diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..6f6a91b --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "dependencies/cli-parser"] + path = dependencies/cli-parser + url = https://githacks.org/_xeroxz/cli-parser.git diff --git a/dependencies/cli-parser b/dependencies/cli-parser new file mode 160000 index 0000000..1aedaf8 --- /dev/null +++ b/dependencies/cli-parser @@ -0,0 +1 @@ +Subproject commit 1aedaf8bb7f383f54b7cd498767611535526da85 diff --git a/dependencies/fcml/fcml.dll b/dependencies/fcml/fcml.dll new file mode 100644 index 0000000..4f9d23d Binary files /dev/null and b/dependencies/fcml/fcml.dll differ diff --git a/dependencies/fcml/fcml.lib b/dependencies/fcml/fcml.lib new file mode 100644 index 0000000..63bcad7 Binary files /dev/null and b/dependencies/fcml/fcml.lib differ diff --git a/dependencies/fcml/include/fcml_assembler.h b/dependencies/fcml/include/fcml_assembler.h new file mode 100644 index 0000000..3018c86 --- /dev/null +++ b/dependencies/fcml/include/fcml_assembler.h @@ -0,0 +1,227 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_assembler.h + * Structures and functions declarations related to one-line FCML assembler. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ASSEMBLER_H_ +#define FCML_ASSEMBLER_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" +#include "fcml_errors.h" +#include "fcml_common.h" +#include "fcml_dialect.h" +#include "fcml_optimizers.h" +#include "fcml_choosers.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Abstract assembler representation. */ +typedef struct fcml_st_assembler fcml_st_assembler; + +/** + * Assembler runtime configuration. + */ +typedef struct fcml_st_assembler_conf { + /** Set to true in order to force assembler to increment IP address by + * length of the assembled instruction. */ + fcml_bool increment_ip; + /** True if optional error and warning messages should be collected + * during processing. */ + fcml_bool enable_error_messages; + /** If there are SIB and "ModR/M only" encodings available, choose + * the SIB based one. */ + fcml_bool choose_sib_encoding; + /** If memory address can be encoded as relative or absolute value choose + * the absolute addressing. It works in 64 bit mode only. */ + fcml_bool choose_abs_encoding; + /** Sometimes REX prefix is useless so it is just omitted in the final + * machine code. By setting this flag to true you can force this prefix +to be added anyway. */ + fcml_bool force_rex_prefix; + /** Every 2 byte VEX/XOP prefix can be encoded using three byte form. + * Setting this flag to true forces it. */ + fcml_bool force_three_byte_VEX; + /** Optimizer implementation that should be used by assembler. Setting it + * to NULL causes assembler to use default one. */ + fcml_fnp_asm_optimizer optimizer; + /** This field is passed to the chosen optimizer. It can be used to + * configure its behavior. */ + fcml_uint16_t optimizer_flags; + /** instruction chooser implementation that should be used by assembler + * to choose most appropriate instruction encoding. Setting this value to + * NULL cause assembler to use default instruction chooser. */ + fcml_fnp_asm_instruction_chooser chooser; +} fcml_st_assembler_conf; + +/** + * Encoded instruction. + * Every instruction might be encoded to more than one binary form. + * This chain holds all forms assembler was able to assemble instruction to. + */ +typedef struct fcml_st_assembled_instruction { + /** Next assembled instruction in the chain. */ + struct fcml_st_assembled_instruction *next; + /** Warning messages related to assembled instruction.*/ + fcml_st_ceh_error_container warnings; + /** Instruction machine code.*/ + fcml_uint8_t *code; + /** Instruction code length in bytes.*/ + fcml_usize code_length; +#ifdef FCML_DEBUG + fcml_uint8_t __def_index; +#endif +} fcml_st_assembled_instruction; + +/** Assembler result. */ +typedef struct fcml_st_assembler_result { + /** Error and warning messages from assembler.*/ + fcml_st_ceh_error_container errors; + /** Chain of assembled instructions. */ + fcml_st_assembled_instruction *instructions; + /** Instruction chosen by used instruction chooser; otherwise NULL.*/ + fcml_st_assembled_instruction *chosen_instruction; + /** Number of encoded instruction forms. */ + fcml_usize number_of_instructions; +} fcml_st_assembler_result; + +/** Assembler runtime context. */ +typedef struct fcml_st_assembler_context { + /** Assembler instance that should be used to assemble instructions. */ + fcml_st_assembler *assembler; + /** Assembler behavior can be configured here.*/ + fcml_st_assembler_conf configuration; + /** Instruction entry point configuration. */ + fcml_st_entry_point entry_point; +} fcml_st_assembler_context; + +/** + * Initializes assembler for given dialect. + * Initializes assembler instance for given dialect (Intel, AT&T). Assembler + * initialized in such a way is dialect dependent and supports GIM with the + * syntax supported by it. Every assembler instance has to be freed using + * fcml_fn_assembler_free() function as soon as it is not needed anymore. + * + * @param dialect Dialect instance. + * @param[out] assembler Initialized assembler instance. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @see fcml_fn_assembler_free + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_assembler_init( + const fcml_st_dialect *dialect, fcml_st_assembler **assembler); + +/** + * Assembles one instruction encoded in the generic instruction model. + * Instruction is proceeded using configuration and assembler provided + * in given fcml_st_assembler_context instance. Assembled code as well + * as potential errors or warnings are accessible via provided reusable + * result holder instance. Result holder has to be allocated by the + * user and appropriately prepared using fcml_fn_assembler_result_prepare() + * function. As long as the instruction context and the result holder + * are not shared across multiple function calls assembling process is + * thread safe. + * + * @param context Assembler context (Assembler, Entry Point, Configuration). + * @param instruction Instruction encoded as generic instruction model + * (Dialect dependent). + * @param result Result holder (Remember to prepare it appropriately). + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @see fcml_fn_assembler_result_prepare fcml_fn_assembler_init + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_assemble( + fcml_st_assembler_context *context, + const fcml_st_instruction *instruction, + fcml_st_assembler_result *result); + +/** + * Prepares reusable result holder for assembler. + * Every instance of fcml_st_assembler_result structure is reusable from + * the assembler's point of view, so it has to be prepared in the right way + * in order to allow assembler to reuse it correctly. It is up to the library + * user to allocate space for the holder itself. This function is only + * responsible for cleaning the structure correctly and preparing it for the + * first assembling process. Notice that assembler has to clean the result + * holder at the beginning so you can not pass an uninitialized memory block + * because it can even cause a crash due to illegal memory access. + * + * @param result Result holder instance to be prepared. + */ +LIB_EXPORT void LIB_CALL fcml_fn_assembler_result_prepare( + fcml_st_assembler_result *result); + +/** + * Cleans result holder. + * Frees all memory blocks allocated by the assembler and held inside the + * result holder (Instructions, errors etc.). Notice that result holder itself + * is not freed and can be even safety reused after call to this function. In + * fact this function is also called internally by the assembler in order to + * clean result holder before reusing it. + * @param result Result holder to clean. + */ +LIB_EXPORT void LIB_CALL fcml_fn_assembler_result_free( + fcml_st_assembler_result *result); + +/** + * Frees assembled instruction. + * Take into account that it does not free whole chain recursively but only + * the one instruction you have provided. + * @param instruction Instruction to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_assembler_instruction_free( + fcml_st_assembled_instruction *instruction); + +/** + * Detaches given instruction from the instructions chain. + * Removes given assembled instruction from the provided chain in order + * to prevent premature freeing of memory while assembler cleans result holder + * reusing it. Detached instructions are not automatically deallocated by + * fcml_fn_assemble() or fcml_fn_assembler_result_free() functions, so + * it is up to you to free it using fcml_fn_assembler_instruction_free() + * function when it is not needed anymore. Function may be useful + * when you need to store assembled instructions across multiple calls + * to the assembler if you reuse the same result holder. If there is only one + * instruction in the chain its pointer will be set to NULL after detaching it. + * @param chain Pointer to the instructions chain pointer. + * @param instruction Instruction to be detached from the chain. + * + */ +LIB_EXPORT void LIB_CALL fcml_fn_assembler_instruction_detach( + fcml_st_assembled_instruction **chain, + fcml_st_assembled_instruction *instruction); + +/** + * Frees assembler instance. + * Every assembler instance manages some resources internally and as such it has + * to be deallocated as soon as it is not needed anymore. + * @param assembler Assembler to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_assembler_free(fcml_st_assembler *assembler); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_ASSEMBLER_H_ */ diff --git a/dependencies/fcml/include/fcml_assembler.hpp b/dependencies/fcml/include/fcml_assembler.hpp new file mode 100644 index 0000000..4fc57dd --- /dev/null +++ b/dependencies/fcml/include/fcml_assembler.hpp @@ -0,0 +1,946 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_assembler.hpp + * C++ wrapper for FCML assembler. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ASSEMBLER_HPP_ +#define FCML_ASSEMBLER_HPP_ + +#include +#include + +#include "fcml_assembler.h" + +#include "fcml_common.hpp" +#include "fcml_errors.hpp" +#include "fcml_dialect.hpp" + +namespace fcml { + +/** + * Assembling failed. + * @since 1.1.0 + */ +class AssemblingFailedException: public ErrorContainerAwareException { +public: + AssemblingFailedException(const fcml_cstring msg, + ErrorContainer errorContainer = ErrorContainer(), + fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR) : + ErrorContainerAwareException(msg, errorContainer, error) { + } +}; + +/** Describes an assembled instruction. + * @since 1.1.0 + */ +class AssembledInstruction { +public: + + /** + * Creates an assembled instruction basing on given code buffer and errors. + * + * @param buffer Pointer to the machine code buffer. + * @param len Number of machine code bytes. + * @param errorContainer Potential warnings related to the + * assembled instruction. + * @since 1.1.0 + * + */ + AssembledInstruction(const fcml_uint8_t *buffer, fcml_usize len, + const ErrorContainer &errorContainer) { + set(buffer, len, errorContainer); + } + + /** + * Copy constructor. + * @since 1.1.0 + */ + AssembledInstruction(const AssembledInstruction &cpy) { + set(cpy._code, cpy._codeLength, cpy._warningContainer); + } + + /** + * Copies one instruction into another. + * + * @param cpy The source instruction. + * @return A reference to the destination instruction. + * @since 1.1.0 + */ + AssembledInstruction& operator=(const AssembledInstruction &cpy) { + if (&cpy != this) { + if (this->_code) { + delete[] this->_code; + } + set(cpy._code, cpy._codeLength, cpy._warningContainer); + } + return *this; + } + + /** + * @since 1.1.0 + */ + virtual ~AssembledInstruction() { + if (_code) { + delete[] _code; + _code = NULL; + } + } + +public: + + /** + * Gets pointer to machine code buffer. + * + * @return Pointer to machine code buffer. + * @since 1.1.0 + */ + const fcml_uint8_t* getCode() const { + return _code; + } + + /** + * Gets number of bytes in the buffer. + * + * @return Number of bytes in the buffer. + * @since 1.1.0 + */ + fcml_usize getCodeLength() const { + return _codeLength; + } + + /** + * Gets reference to the errors container. + * + * @return A reference to the errors container. + * @since 1.1.0 + */ + const ErrorContainer& getWarningContainer() const { + return _warningContainer; + } + +private: + + /** + * Fills the assembled instruction with new data. + * + * @param buffer The code buffer. + * @param len The code buffer lenght. + * @param warnings The warnings container. + * @since 1.1.0 + */ + void set(const fcml_uint8_t *buffer, fcml_usize len, + const ErrorContainer warnigns) { + _warningContainer = warnigns; + if (len > 0) { + _code = new fcml_uint8_t[len]; + for (fcml_usize i = 0; i < len; i++) { + _code[i] = buffer[i]; + } + } else { + _code = NULL; + } + _codeLength = len; + } + +private: + + /** Warnings related to this instruction. */ + ErrorContainer _warningContainer; + + /** Pointer to the instruction machine code. */ + fcml_uint8_t *_code; + + /** Number of machine code bytes in the array above. */ + fcml_usize _codeLength; + +}; + +class Assembler; + +/** Assembler result. */ +class AssemblerResult { +public: + + /** + * @since 1.1.0 + */ + AssemblerResult() : + _chosenInstructionIndex(-1) { + } + +public: + + /** + * Gets instruction chosen by the assembler as the preferred one. + * + * @return Preferred instruction. + * @since 1.1.0 + */ + const AssembledInstruction* getChosenInstruction() const { + if (_chosenInstructionIndex == -1) { + return NULL; + } + return &(_assembledInstructions[_chosenInstructionIndex]); + } + + /** + * Gets errors container. + * + * @return Errors container. + * @since 1.1.0 + */ + const ErrorContainer& getErrorContainer() const { + return _errorContainer; + } + + /** + * Gets number of instructions alternatives available in the result. + * + * @return Number of available instructions. + * @since 1.1.0 + */ + fcml_usize getSize() const { + return static_cast(_assembledInstructions.size()); + } + + /** + * Gets pointer to the chosen instruction. + * + * @return Pointer to the chosen instruction. + * @since 1.1.0 + */ + operator const AssembledInstruction*() const { + if (_chosenInstructionIndex == -1) { + return NULL; + } + return &(_assembledInstructions[_chosenInstructionIndex]); + } + + /** + * Gets an assembled instruction reference by its index. + * + * @return The assembled instruction for given index. + * @throw BadArgumentException Array index out of bound. + * @since 1.1.0 + */ + const AssembledInstruction& operator[](fcml_usize index) const { + if (index > _assembledInstructions.size()) { + throw BadArgumentException(FCML_TEXT("Array index out of bound."), + FCML_CEH_GEC_VALUE_OUT_OF_RANGE); + } + return _assembledInstructions[index]; + } + + /** + * Copies machine code of the chosen instruction to the output stream. + * + * @param[out] out Output stream. + * @param result Assembler result. + * @return Output stream from the parameter. + * @since 1.1.0 + */ + friend std::basic_ostream& operator<<( + std::basic_ostream &out, + const AssemblerResult &result) { + const AssembledInstruction *assembled = result.getChosenInstruction(); + if (assembled) { + // If chosen instruction is not available, do not + // stream anything. It's not so common, because + // instructions choosers are obliged to chose something. + if (assembled->getCode() && assembled->getCodeLength() > 0) { + out.write(assembled->getCode(), assembled->getCodeLength()); + } + } + return out; + } + + /** + * Clears assembler result by removing all assembled instructions, + * errors and reseting the chosen instruction. + * @since 1.1.0 + */ + void clear() { + _errorContainer.clean(); + _assembledInstructions.clear(); + _chosenInstructionIndex = -1; + } + +protected: + + friend Assembler; + + void setErrorContainer(const ErrorContainer &errorContainer) { + _errorContainer = errorContainer; + } + + std::vector& getAssembledInstructions() { + return _assembledInstructions; + } + + void setChoosenInstructionIndex(fcml_int index) { + _chosenInstructionIndex = index; + } + +private: + + /** Assembling errors. */ + ErrorContainer _errorContainer; + /** All assembled instructions are going here. */ + std::vector _assembledInstructions; + /** Index for the chosen instruction. */ + fcml_int _chosenInstructionIndex; + +}; + +/** Assembler configuration. + * For more information about the flags, see fcml_st_assembler_conf + * structure documentation. + * @since 1.1.0 + */ +class AssemblerConf { +public: + + /** + * @since 1.1.0 + */ + AssemblerConf() : + _throwExceptionOnError(true), + _incrementIp(true), + _enableErrorMessages(true), + _chooseSibEncoding(false), + _chooseAbsEncoding(false), + _forceRexPrefix(false), + _forceThreeByteVEX(false), + _noBranchPrediction(false), + _optimizer(NULL), + _optimizerFlags(0), + _chooser(NULL) { + } + +public: + + /** + * @since 1.1.0 + */ + bool isChooseAbsEncoding() const { + return _chooseAbsEncoding; + } + + /** + * @since 1.1.0 + */ + void setChooseAbsEncoding(bool chooseAbsEncoding) { + _chooseAbsEncoding = chooseAbsEncoding; + } + + /** + * @since 1.1.0 + */ + fcml_fnp_asm_instruction_chooser getChooser() const { + return _chooser; + } + + /** + * @since 1.1.0 + */ + void setChooser(fcml_fnp_asm_instruction_chooser chooser) { + _chooser = chooser; + } + + /** + * @since 1.1.0 + */ + bool isChooseSibEncoding() const { + return _chooseSibEncoding; + } + + /** + * @since 1.1.0 + */ + void setChooseSibEncoding(bool chooseSibEncoding) { + _chooseSibEncoding = chooseSibEncoding; + } + + /** + * @since 1.1.0 + */ + bool isEnableErrorMessages() const { + return _enableErrorMessages; + } + + /** + * @since 1.1.0 + */ + void setEnableErrorMessages(bool enableErrorMessages) { + _enableErrorMessages = enableErrorMessages; + } + + /** + * @since 1.1.0 + */ + bool isForceRexPrefix() const { + return _forceRexPrefix; + } + + /** + * @since 1.1.0 + */ + void setForceRexPrefix(bool forceRexPrefix) { + _forceRexPrefix = forceRexPrefix; + } + + /** + * @since 1.1.0 + */ + bool isForceThreeByteVex() const { + return _forceThreeByteVEX; + } + + /** + * @since 1.1.0 + */ + void setForceThreeByteVex(bool forceThreeByteVex) { + _forceThreeByteVEX = forceThreeByteVex; + } + + /** + * @since 1.1.0 + */ + bool isIncrementIp() const { + return _incrementIp; + } + + /** + * @since 1.1.0 + */ + void setIncrementIp(bool incrementIp) { + _incrementIp = incrementIp; + } + + /** + * @since 1.1.0 + */ + fcml_fnp_asm_optimizer getOptimizer() const { + return _optimizer; + } + + /** + * @since 1.1.0 + */ + void setOptimizer(fcml_fnp_asm_optimizer optimizer) { + _optimizer = optimizer; + } + + /** + * @since 1.1.0 + */ + fcml_uint16_t getOptimizerFlags() const { + return _optimizerFlags; + } + + /** + * @since 1.1.0 + */ + void setOptimizerFlags(fcml_uint16_t optimizerFlags) { + _optimizerFlags = optimizerFlags; + } + + /** + * Returns true if exception should be thrown when assembling fails. + * + * @return True if exception is the preferred way of error handling + * in case of failure. + * @since 1.1.0 + */ + bool isThrowExceptionOnError() const { + return _throwExceptionOnError; + } + + /** + * Sets the way how the error handling is done. + * + * @param throwExceptionOnError True if exception should be thrown + * in case of failure. + * @since 1.1.0 + */ + void setThrowExceptionOnError(bool throwExceptionOnError) { + _throwExceptionOnError = throwExceptionOnError; + } + +private: + bool _throwExceptionOnError; + bool _incrementIp; + bool _enableErrorMessages; + bool _chooseSibEncoding; + bool _chooseAbsEncoding; + bool _forceRexPrefix; + bool _forceThreeByteVEX; + bool _noBranchPrediction; + fcml_fnp_asm_optimizer _optimizer; + fcml_uint16_t _optimizerFlags; + fcml_fnp_asm_instruction_chooser _chooser; +}; + +/** Assembler context. + * + * It is a counterpart to the fcml_st_assembler_context structure. + * @since 1.1.0 + */ +class AssemblerContext { + +public: + + /** + * @since 1.1.0 + */ + AssemblerContext() { + } + + /** + * Creates an entry point instance for given operating mode + * and optional instruction pointer. + * + * @param operatingMode The processor operating mode. + * @param ip The instruction pointer. + * @since 1.1.0 + */ + AssemblerContext(EntryPoint::OperatingMode operatingMode, fcml_ip ip = 0) : + _entryPoint(operatingMode, ip) { + } + +public: + + /** + * Gets constant assembler configuration associated with the context. + * + * @return Assembler configuration. + * @since 1.1.0 + */ + const AssemblerConf& getConfig() const { + return _config; + } + + /** + * Gets assembler configuration associated with the context. + * + * @return Assembler configuration. + * @since 1.1.0 + */ + AssemblerConf& getConfig() { + return _config; + } + + /** + * Copies given configuration to the instance associated with the context. + * Deep copy is performed, so passed object not need to be maintained as + * long as the context is used. + * + * @param config Configuration that is copied to the context. + * @since 1.1.0 + */ + void setConfig(const AssemblerConf &config) { + _config = config; + } + + /** + * Gets reference to the constant entry point instance + * associated with the context. + * + * @return Reference to the constant entry point. + * @since 1.1.0 + */ + const EntryPoint& getEntryPoint() const { + return _entryPoint; + } + + /** + * Gets reference to the entry point instance associated with the context. + * + * @return Reference to the entry point. + * @since 1.1.0 + */ + EntryPoint& getEntryPoint() { + return _entryPoint; + } + /** + * Copies given entry point to the instance associated with the context. + * Deep copy is performed, so passed object not need to be maintained as + * long as the context is used. + * + * @param entryPoint The entry point. + * @since 1.1.0 + */ + void setEntryPoint(const EntryPoint &entryPoint) { + _entryPoint = entryPoint; + } + + /** + * Sets instruction pointer directly into the entry point. + * + * @param ip The new IP. + * @since 1.1.0 + */ + void setIP(fcml_ip ip) { + _entryPoint.setIP(ip); + } + + /** + * Increments entry point by given number of bytes. + * + * @param ip Number of bytes the instruction pointer + * has to be incremented by. + * @since 1.1.0 + */ + void incrementIP(fcml_ip ip) { + _entryPoint.incrementIP(ip); + } + + /** + * Sets processor operating mode directly into the entry point. + * + * @param operatingMode Processor operating mode to be set. + * @since 1.1.0 + */ + void setOperatingMode(EntryPoint::OperatingMode operatingMode) { + _entryPoint.setOpMode(operatingMode); + } + + /** + * Sets a new address size attribute for the entry point. + * + * @param addressSizeAttribute The address size attribute. + * @since 1.1.0 + */ + void setAddressSizeAttribute(fcml_usize addressSizeAttribute) { + _entryPoint.setAddressSizeAttribute(addressSizeAttribute); + } + + /** + * Sets a new operand size attribute for the entry point. + * + * @param operandSizeAttribute The operand size attribute. + * @since 1.1.0 + */ + void setOperandSizeAttribute(fcml_usize operandSizeAttribute) { + _entryPoint.setOperandSizeAttribute(operandSizeAttribute); + } + +private: + + /** Entry point associated with the context. */ + EntryPoint _entryPoint; + /** Assembler configuration associated with the context. */ + AssemblerConf _config; + +}; + +/** Converts objects to their structures counterparts. + * @since 1.1.0 + * @remarks Internal API, not intended to be used outside. + */ +class AssemblerTypeConverter { +public: + + static void convert(const fcml_st_assembler_context &src, + AssemblerContext &dest) { + // Converts assembler configuration and entry point. + // Both of them have dedicated conversion methods. + convert(src.configuration, dest.getConfig()); + TypeConverter::convert(src.entry_point, dest.getEntryPoint()); + } + + static void convert(const AssemblerContext &src, + fcml_st_assembler_context &dest) { + // Converts assembler configuration and entry point. Both of them + // have dedicated conversion methods. + convert(src.getConfig(), dest.configuration); + TypeConverter::convert(src.getEntryPoint(), dest.entry_point); + } + + static void convert(const fcml_st_assembler_conf &src, + AssemblerConf &dest) { + dest.setChooseAbsEncoding(FCML_TO_CPP_BOOL(src.choose_abs_encoding)); + dest.setChooseSibEncoding(FCML_TO_CPP_BOOL(src.choose_sib_encoding)); + dest.setChooser(src.chooser); + dest.setEnableErrorMessages( + FCML_TO_CPP_BOOL(src.enable_error_messages)); + dest.setForceRexPrefix(FCML_TO_CPP_BOOL(src.force_rex_prefix)); + dest.setForceThreeByteVex(FCML_TO_CPP_BOOL(src.force_three_byte_VEX)); + dest.setIncrementIp(FCML_TO_CPP_BOOL(src.increment_ip)); + dest.setOptimizer(src.optimizer); + dest.setOptimizerFlags(src.optimizer_flags); + } + + static void convert(const AssemblerConf &src, + fcml_st_assembler_conf &dest) { + dest.choose_abs_encoding = src.isChooseAbsEncoding(); + dest.choose_sib_encoding = src.isChooseSibEncoding(); + dest.chooser = src.getChooser(); + dest.enable_error_messages = src.isEnableErrorMessages(); + dest.force_rex_prefix = src.isForceRexPrefix(); + dest.force_three_byte_VEX = src.isForceThreeByteVex(); + dest.increment_ip = src.isIncrementIp(); + dest.optimizer = src.getOptimizer(); + dest.optimizer_flags = src.getOptimizerFlags(); + } + +}; + +/** + * An assembler wrapper. + * As you can see the assembler instance is managed internally + * and is not exposed outside. + * @since 1.1.0 + * @remarks This class is thread-safe. + */ +class Assembler: public NonCopyable, protected DialectAware { +public: + + /** + * Creates an assembler instance for given dialect. + * + * @param dialect The dialect for the assembler instance. + * @throw InitException Cannot initialize the assembler. + * @since 1.1.0 + */ + Assembler(Dialect &dialect) : + _dialect(dialect) { + fcml_ceh_error error = ::fcml_fn_assembler_init(extractDialect(dialect), + &_assembler); + if (error) { + throw InitException(FCML_TEXT("Cannot initialize the assembler."), + error); + } + } + + /** + * @since 1.1.0 + */ + virtual ~Assembler() { + if (_assembler) { + ::fcml_fn_assembler_free(_assembler); + _assembler = NULL; + } + } + +public: + + /** + * Assembles given generic instruction model. + * + * @param ctx The assembler context. + * @param instruction The generic instruction model to be assembled. + * @param[out] result Assembler result. + * @throw AssemblingFailedException Thrown if assembling fails + * and AssemblerConf.isThrowExceptionOnError returns true. + * @return Error code. + * @since 1.1.0 + */ + fcml_ceh_error assemble(AssemblerContext &ctx, + const Instruction &instruction, AssemblerResult &result) { + + // Prepare assembler context. + fcml_st_assembler_context context; + AssemblerTypeConverter::convert(ctx, context); + + context.assembler = _assembler; + + // Prepare instruction. + fcml_st_instruction inst; + TypeConverter::convert(instruction, inst); + + // Prepare assembler result. + fcml_st_assembler_result res; + ::fcml_fn_assembler_result_prepare(&res); + + fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR; + + try { + + result.clear(); + + error = ::fcml_fn_assemble(&context, &inst, &res); + + // Free instruction mnemonic. + TypeConverter::free(inst); + + // Failed or not, convert assembler errors. + ErrorContainer errorContainer; + ErrorTypeConverter::convert(res.errors, errorContainer); + + // Prepares assembler result. + result.setErrorContainer(errorContainer); + + if (error && ctx.getConfig().isThrowExceptionOnError()) { + ::fcml_fn_assembler_result_free(&res); + throw AssemblingFailedException(FCML_TEXT("Assembling failed."), + errorContainer, error); + } + + if (!error) { + + std::vector &assembledInstructions = + result.getAssembledInstructions(); + + assembledInstructions.clear(); + + if (res.number_of_instructions > 0) { + ErrorContainer instructionWarnings; + fcml_int i = 0; + fcml_st_assembled_instruction *next_instruction = + res.instructions; + while (next_instruction) { + fcml_st_ceh_error_container &instruction_warnings = + next_instruction->warnings; + ErrorTypeConverter::convert(instruction_warnings, + instructionWarnings); + AssembledInstruction assembledInstruction( + next_instruction->code, + next_instruction->code_length, + instructionWarnings); + assembledInstructions.push_back(assembledInstruction); + if (next_instruction == res.chosen_instruction) { + result.setChoosenInstructionIndex(i); + } + next_instruction = next_instruction->next; + i++; + } + } + + // Convert it back to the context because it might have been + // modified during assembling process (IP incrementing etc). + TypeConverter::convert(context.entry_point, + ctx.getEntryPoint()); + + } + + ::fcml_fn_assembler_result_free(&res); + + } catch (std::exception &exc) { + // If anything failed, free assembler results. + TypeConverter::free(inst); + ::fcml_fn_assembler_result_free(&res); + throw exc; + } + + return error; + } + + /** + * Gets dialect associated with the assembler. + * @return The dialect instance associated with the assembler. + * @since 1.1.0 + */ + Dialect& getDialect() const { + return _dialect; + } + +private: + + // A dialect used by the assembler. + Dialect &_dialect; + + // An initialized assembler instance. + fcml_st_assembler *_assembler; + +}; + +/** Iterates over machine code bytes from assembled instructions. + * @since 1.1.0 + */ +class CodeIterator: public Iterator { +public: + + /** + * Creates a code iterator instance. + * @param assembledInstructions Assembled instructions. + * @since 1.1.0 + */ + CodeIterator(std::vector &assembledInstructions) : + _buffer(NULL), _len(0), _pos(0), _iterator( + assembledInstructions.begin()), _assembledInstructions( + assembledInstructions) { + } + + /** + * @since 1.1.0 + */ + virtual ~CodeIterator() { + } + + /** + * Gets true if there is an another element in the iterator. + * + * @return True if there is another byte in the iterator. + * @since 1.1.0 + */ + bool hasNext() { + if (_buffer && _pos >= _len) { + _buffer = NULL; + } + if (!_buffer) { + if (_iterator == _assembledInstructions.end()) { + return false; + } + AssembledInstruction ¤t = *_iterator++; + _buffer = current.getCode(); + _len = current.getCodeLength(); + _pos = 0; + } + return true; + } + + /** + * Gets the next element from the iterator. + * + * @return Next machine code byte. + * @throw IllegalStateException If iterator is empty. + * @since 1.1.0 + */ + fcml_uint8_t next() { + if ((!_buffer || _pos >= _len) && !hasNext()) { + throw IllegalStateException( + FCML_TEXT("No more elements in the iterator.")); + } + return _buffer[_pos++]; + } + +private: + + /** Code of the current instruction iterator points to. */ + const fcml_uint8_t *_buffer; + /** Code length in bytes. */ + fcml_usize _len; + /** Position in the code buffer */ + fcml_usize _pos; + /** Assembled instructions iterator. */ + std::vector::iterator _iterator; + /** Vector with assembled instructions. */ + std::vector &_assembledInstructions; + +}; + +} + +#endif //FCML_ASSEMBLER_HPP_ diff --git a/dependencies/fcml/include/fcml_choosers.h b/dependencies/fcml/include/fcml_choosers.h new file mode 100644 index 0000000..24469b0 --- /dev/null +++ b/dependencies/fcml/include/fcml_choosers.h @@ -0,0 +1,87 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_choosers.h + * + * API for instruction choosers. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_CHOOSER_H_ +#define FCML_CHOOSER_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" +#include "fcml_common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Returns next instructions from the iterator. + * Instruction chooser uses this function to get next instruction from the chain. + * @param instruction Current instruction. + */ +typedef fcml_ptr (*fcml_fnp_chooser_next)(fcml_ptr instruction); + +/** Gets instruction code from current abstract instruction pointer. + * Gets instruction pointer and fills given instruction code + * holder with the binary code of the instruction. + * @param instruction Instruction pointer. + * @param instruction_code Holder for the instruction code. + */ +typedef void (*fcml_fnp_chooser_extract)(fcml_ptr instruction, + fcml_st_instruction_code *instruction_code); + +/** Instruction chooser context used to communicate with environment. */ +typedef struct fcml_st_chooser_context { + /** First instruction in the chain. */ + fcml_ptr instruction; + /** Gets next instruction code from iterator. */ + fcml_fnp_chooser_next next; + /** Extracts instruction code from abstract instruction pointer.*/ + fcml_fnp_chooser_extract extract; +} fcml_st_chooser_context; + +/** Instruction chooser function pointer declaration. + * @param chooser_context Instruction chooser context. + */ +typedef fcml_ptr (LIB_CALL *fcml_fnp_asm_instruction_chooser)( + fcml_st_chooser_context *chooser_context); + +/** Default instruction chooser which chooses the shortest instruction available. + * @param chooser_context Instruction chooser context. + */ +fcml_ptr LIB_EXPORT LIB_CALL fcml_fn_asm_default_instruction_chooser( + fcml_st_chooser_context *chooser_context); + +/** NULL chooser which do not chose anything. + * @param chooser_context Instruction chooser context. + */ +fcml_ptr LIB_EXPORT LIB_CALL fcml_fn_asm_no_instruction_chooser( + fcml_st_chooser_context *chooser_context); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_CHOOSER_H_ */ diff --git a/dependencies/fcml/include/fcml_common.h b/dependencies/fcml/include/fcml_common.h new file mode 100644 index 0000000..bd3d6a0 --- /dev/null +++ b/dependencies/fcml/include/fcml_common.h @@ -0,0 +1,832 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_common.h + * Definitions of common structures used by FCML components. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_INT_COMMON_H_ +#define FCML_INT_COMMON_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" +#include "fcml_instructions.h" + +/** Maximal number of the instruction operands. */ +#define FCML_OPERANDS_COUNT 5 +/** Maximal number of bytes instruction can use. */ +#define FCML_INSTRUCTION_SIZE 15 +/** Number of opcode bytes. */ +#define FCML_OPCODES_NUM 3 + +/** + * @defgroup PREFIX_GROUP Explicit prefixes + * List of prefixes that can be explicitly defined for instruction. + * @{ + */ + +/** LOCK prefix (0xF0)*/ +#define FCML_PREFIX_LOCK 0x0001 +/** REPNE prefix (0xF2) */ +#define FCML_PREFIX_REPNE 0x0002 +/** REPNZ prefix (0xF2) */ +#define FCML_PREFIX_REPNZ FCML_PREFIX_REPNE +/** REP prefix (0xF3) */ +#define FCML_PREFIX_REP 0x0004 +/** REPE prefix (0xF3) */ +#define FCML_PREFIX_REPE FCML_PREFIX_REP +/** REPZ prefix (0xF3) */ +#define FCML_PREFIX_REPZ FCML_PREFIX_REP +/** XACQUIRE prefix (0xF2) */ +#define FCML_PREFIX_XACQUIRE 0x0008 +/** XRELEASE prefix (0xF3) */ +#define FCML_PREFIX_XRELEASE 0x0010 +/** branch hint (0x2E) (SSE2 extension)*/ +#define FCML_PREFIX_BRANCH_HINT 0x0020 +/** nobranch hint (0x3E) (SSE2 extension)*/ +#define FCML_PREFIX_NOBRANCH_HINT 0x0040 + +/** @} */ + +/** + * Supported processor operating modes. + */ +typedef enum fcml_en_operating_mode { + /** Real-addressing mode, virtual 8086 mode. */ + FCML_OM_16_BIT = 1, + /** Protected/Compatibility mode when 'D' segment descriptor + * flag is set to 1. */ + FCML_OM_32_BIT, + /** 64-bit mode. ('L' flag of segment descriptor set to 1.) */ + FCML_OM_64_BIT, +} fcml_en_operating_mode; + +/* Simple types. */ + +/** Type used for storing instruction and operand hint masks. */ +typedef fcml_uint16_t fcml_hints; + +/** + * Type for explicit instruction prefixes bit mask. + */ +typedef fcml_uint16_t fcml_prefixes; + +/** + * General instruction pointer holder. + */ +typedef fcml_int64_t fcml_ip; + +/* Register numbers.*/ + +/** + * @defgroup REGISTERS_GROUP Registers. + * All supported x64_64 registers are defined here. + * @{ + */ + +#define FCML_REG_AL 0 +#define FCML_REG_AX 0 +#define FCML_REG_EAX 0 +#define FCML_REG_RAX 0 +#define FCML_REG_MM0 0 +#define FCML_REG_XMM0 0 +#define FCML_REG_YMM0 0 +#define FCML_REG_ZMM0 0 + +#define FCML_REG_CL 1 +#define FCML_REG_CX 1 +#define FCML_REG_ECX 1 +#define FCML_REG_RCX 1 +#define FCML_REG_MM1 1 +#define FCML_REG_XMM1 1 +#define FCML_REG_YMM1 1 +#define FCML_REG_ZMM1 1 + +#define FCML_REG_DL 2 +#define FCML_REG_DX 2 +#define FCML_REG_EDX 2 +#define FCML_REG_RDX 2 +#define FCML_REG_MM2 2 +#define FCML_REG_XMM2 2 +#define FCML_REG_YMM2 2 +#define FCML_REG_ZMM2 2 + +#define FCML_REG_BL 3 +#define FCML_REG_BX 3 +#define FCML_REG_EBX 3 +#define FCML_REG_RBX 3 +#define FCML_REG_MM3 3 +#define FCML_REG_XMM3 3 +#define FCML_REG_YMM3 3 +#define FCML_REG_ZMM3 3 + +#define FCML_REG_AH 4 +#define FCML_REG_SP 4 +#define FCML_REG_SPL 4 +#define FCML_REG_ESP 4 +#define FCML_REG_RSP 4 +#define FCML_REG_MM4 4 +#define FCML_REG_XMM4 4 +#define FCML_REG_YMM4 4 +#define FCML_REG_ZMM4 4 + +#define FCML_REG_CH 5 +#define FCML_REG_BP 5 +#define FCML_REG_BPL 5 +#define FCML_REG_EBP 5 +#define FCML_REG_RBP 5 +#define FCML_REG_MM5 5 +#define FCML_REG_XMM5 5 +#define FCML_REG_YMM5 5 +#define FCML_REG_ZMM5 5 + +#define FCML_REG_DH 6 +#define FCML_REG_SI 6 +#define FCML_REG_SIL 6 +#define FCML_REG_ESI 6 +#define FCML_REG_RSI 6 +#define FCML_REG_MM6 6 +#define FCML_REG_XMM6 6 +#define FCML_REG_YMM6 6 +#define FCML_REG_ZMM6 6 + +#define FCML_REG_BH 7 +#define FCML_REG_DI 7 +#define FCML_REG_DIL 7 +#define FCML_REG_EDI 7 +#define FCML_REG_RDI 7 +#define FCML_REG_MM7 7 +#define FCML_REG_XMM7 7 +#define FCML_REG_YMM7 7 +#define FCML_REG_ZMM7 7 + +#define FCML_REG_R8L 8 +#define FCML_REG_R8W 8 +#define FCML_REG_R8D 8 +#define FCML_REG_R8 8 +#define FCML_REG_XMM8 8 +#define FCML_REG_YMM8 8 +#define FCML_REG_ZMM8 8 + +#define FCML_REG_R9L 9 +#define FCML_REG_R9W 9 +#define FCML_REG_R9D 9 +#define FCML_REG_R9 9 +#define FCML_REG_XMM9 9 +#define FCML_REG_YMM9 9 +#define FCML_REG_ZMM9 9 + +#define FCML_REG_R10L 10 +#define FCML_REG_R10W 10 +#define FCML_REG_R10D 10 +#define FCML_REG_R10 10 +#define FCML_REG_XMM10 10 +#define FCML_REG_YMM10 10 +#define FCML_REG_ZMM10 10 + +#define FCML_REG_R11L 11 +#define FCML_REG_R11W 11 +#define FCML_REG_R11D 11 +#define FCML_REG_R11 11 +#define FCML_REG_XMM11 11 +#define FCML_REG_YMM11 11 +#define FCML_REG_ZMM11 11 + +#define FCML_REG_R12L 12 +#define FCML_REG_R12W 12 +#define FCML_REG_R12D 12 +#define FCML_REG_R12 12 +#define FCML_REG_XMM12 12 +#define FCML_REG_YMM12 12 +#define FCML_REG_ZMM12 12 + +#define FCML_REG_R13L 13 +#define FCML_REG_R13W 13 +#define FCML_REG_R13D 13 +#define FCML_REG_R13 13 +#define FCML_REG_XMM13 13 +#define FCML_REG_YMM13 13 +#define FCML_REG_ZMM13 13 + +#define FCML_REG_R14L 14 +#define FCML_REG_R14W 14 +#define FCML_REG_R14D 14 +#define FCML_REG_R14 14 +#define FCML_REG_XMM14 14 +#define FCML_REG_YMM14 14 +#define FCML_REG_ZMM14 14 + +#define FCML_REG_R15L 15 +#define FCML_REG_R15W 15 +#define FCML_REG_R15D 15 +#define FCML_REG_R15 15 +#define FCML_REG_XMM15 15 +#define FCML_REG_YMM15 15 +#define FCML_REG_ZMM15 15 + +#define FCML_REG_XMM16 16 +#define FCML_REG_YMM16 16 +#define FCML_REG_ZMM16 16 + +#define FCML_REG_XMM17 17 +#define FCML_REG_YMM17 17 +#define FCML_REG_ZMM17 17 + +#define FCML_REG_XMM18 18 +#define FCML_REG_YMM18 18 +#define FCML_REG_ZMM18 18 + +#define FCML_REG_XMM19 19 +#define FCML_REG_YMM19 19 +#define FCML_REG_ZMM19 19 + +#define FCML_REG_XMM20 20 +#define FCML_REG_YMM20 20 +#define FCML_REG_ZMM20 20 + +#define FCML_REG_XMM21 21 +#define FCML_REG_YMM21 21 +#define FCML_REG_ZMM21 21 + +#define FCML_REG_XMM22 22 +#define FCML_REG_YMM22 22 +#define FCML_REG_ZMM22 22 + +#define FCML_REG_XMM23 23 +#define FCML_REG_YMM23 23 +#define FCML_REG_ZMM23 23 + +#define FCML_REG_XMM24 24 +#define FCML_REG_YMM24 24 +#define FCML_REG_ZMM24 24 + +#define FCML_REG_XMM25 25 +#define FCML_REG_YMM25 25 +#define FCML_REG_ZMM25 25 + +#define FCML_REG_XMM26 26 +#define FCML_REG_YMM26 26 +#define FCML_REG_ZMM26 26 + +#define FCML_REG_XMM27 27 +#define FCML_REG_YMM27 27 +#define FCML_REG_ZMM27 27 + +#define FCML_REG_XMM28 28 +#define FCML_REG_YMM28 28 +#define FCML_REG_ZMM28 28 + +#define FCML_REG_XMM29 29 +#define FCML_REG_YMM29 29 +#define FCML_REG_ZMM29 29 + +#define FCML_REG_XMM30 30 +#define FCML_REG_YMM30 30 +#define FCML_REG_ZMM30 30 + +#define FCML_REG_XMM31 31 +#define FCML_REG_YMM31 31 +#define FCML_REG_ZMM31 31 + +/* Segment registers. */ + +#define FCML_REG_ES 0 +#define FCML_REG_CS 1 +#define FCML_REG_SS 2 +#define FCML_REG_DS 3 +#define FCML_REG_FS 4 +#define FCML_REG_GS 5 + +/* FPU registers */ + +#define FCML_REG_ST0 0 +#define FCML_REG_ST1 1 +#define FCML_REG_ST2 2 +#define FCML_REG_ST3 3 +#define FCML_REG_ST4 4 +#define FCML_REG_ST5 5 +#define FCML_REG_ST6 6 +#define FCML_REG_ST7 7 + +/* Control registers. */ + +#define FCML_REG_CR0 0 +#define FCML_REG_CR2 2 +#define FCML_REG_CR3 3 +#define FCML_REG_CR4 4 +#define FCML_REG_CR8 8 + +/* Debug register. */ + +#define FCML_REG_DR0 0 +#define FCML_REG_DR1 1 +#define FCML_REG_DR2 2 +#define FCML_REG_DR3 3 +#define FCML_REG_DR4 4 +#define FCML_REG_DR5 5 +#define FCML_REG_DR6 6 +#define FCML_REG_DR7 7 + +/* Opmask registers. */ + +#define FCML_REG_K0 0 +#define FCML_REG_K1 1 +#define FCML_REG_K2 2 +#define FCML_REG_K3 3 +#define FCML_REG_K4 4 +#define FCML_REG_K5 5 +#define FCML_REG_K6 6 +#define FCML_REG_K7 7 + +/** @} */ + +/** + * @defgroup DATA_SIZE_GROUP Constants used to describe data size. + * @{instrunction->hints + */ + +#define FCML_DS_UNDEF 0 +#define FCML_DS_8 8 +#define FCML_DS_16 16 +#define FCML_DS_32 32 +#define FCML_DS_64 64 +#define FCML_DS_128 128 +#define FCML_DS_256 256 +#define FCML_DS_512 512 + +/** @} */ + +/* Size operators. */ + +#define FCML_OS_UNDEFINED 0 +#define FCML_OS_BYTE 8 +#define FCML_OS_WORD 16 +#define FCML_OS_DWORD 32 +#define FCML_OS_FWORD 48 +#define FCML_OS_QWORD 64 +#define FCML_OS_MWORD 64 +#define FCML_OS_TBYTE 80 +#define FCML_OS_OWORD 128 +#define FCML_OS_XWORD 128 +#define FCML_OS_YWORD 256 +#define FCML_OS_ZWORD 512 + +/* SIMD tuple types. */ + +/* Instructions affected by embedded broadcast */ +#define FCML_TT_NONE 0 +#define FCML_TT_FV 1 +#define FCML_TT_HV 2 + +/* Instructions not affected by embedded broadcast */ +#define FCML_TT_FVM 3 /* Full Mem */ +#define FCML_TT_T1S 4 +#define FCML_TT_T1F 5 +#define FCML_TT_T2 6 +#define FCML_TT_T4 7 +#define FCML_TT_T8 8 +#define FCML_TT_HVM 9 +#define FCML_TT_QVM 10 +#define FCML_TT_OVM 11 +#define FCML_TT_M128 12 +#define FCML_TT_DUP 13 +#define FCML_TT_T1x4 14 /* Tuple1_4X */ + +/* Embedded rounding mode. */ + +#define FCML_ER_RN_SAE 0 +#define FCML_ER_RD_SAE 1 +#define FCML_ER_RU_SAE 2 +#define FCML_ER_RZ_SAE 3 + +/** + * Register type. + * Every register is represented as an integer value and it's + * register type. This enumeration provides all supported register types. + */ +typedef enum fcml_en_register { + /** Undefined register type. */ + FCML_REG_UNDEFINED = 0, + /** General purpose register. */ + FCML_REG_GPR, + /** SIMD (SSE, MMX) register. */ + FCML_REG_SIMD, + /** FPU register. */ + FCML_REG_FPU, + /** Segment register */ + FCML_REG_SEG, + /** Control register. */ + FCML_REG_CR, + /** Debug register */ + FCML_REG_DR, + /** Instruction pointer register. Used for relative RIP addressing. */ + FCML_REG_IP, + /** Operand mask register. */ + FCML_REG_OPMASK +} fcml_en_register; + +/** + * Structure describes x86_64 register. + */ +typedef struct fcml_st_register { + /** Register type. */ + fcml_en_register type; + /** Register size in bits. */ + fcml_usize size; + /** Register itself as a positive integer. @see REGISTERS_GROUP */ + fcml_uint8_t reg; + /** In case of SPL,BPL,SIL,DIL GPR registers has to be set to true. */ + fcml_bool x64_exp; +} fcml_st_register; + +/********************************* + * Conditions. + *********************************/ + +/** Number of supported condition types. */ +#define FCML_NUMBER_OF_CONDITIONS 8 + +/** + * Condition type. + * Every conditional instruction has an appropriate condition type set. + * Following enumeration defines all supported types. + */ +typedef enum fcml_en_condition_type { + /** 0 Overflow*/ + FCML_CONDITION_O = 0, + /** 1 Below*/ + FCML_CONDITION_B, + /** 2 Equal*/ + FCML_CONDITION_E, + /** 3 Below or equal*/ + FCML_CONDITION_BE, + /** 4 Sign*/ + FCML_CONDITION_S, + /** 5 Parity*/ + FCML_CONDITION_P, + /** 6 Less than*/ + FCML_CONDITION_L, + /** 7 Less than or equal to*/ + FCML_CONDITION_LE +} fcml_en_condition_type; + +/** + * Defines instruction's condition. + */ +typedef struct fcml_st_condition { + /* Condition type.*/ + fcml_en_condition_type condition_type; + /* True if condition should be negated.*/ + fcml_bool is_negation; +} fcml_st_condition; + +/********************************* + * Size attributes flags. + *********************************/ + +/** + * @defgroup SUPPORTED_SIZE_GROUP These values can be used in order to + * prepare a mask of supported sizes. Used mainly by optimizers where + * instructions can be assembled using different attribute sizes. + * @{ + */ + +#define FCML_EN_ASF_ANY 0x00 +#define FCML_EN_ASF_16 0x01 +#define FCML_EN_ASF_32 0x02 +#define FCML_EN_ASF_64 0x04 +#define FCML_EN_ASF_ALL FCML_EN_ASF_16 | FCML_EN_ASF_32 | FCML_EN_ASF_64 + +/** @} */ + +/** + * Nullable wrapper for mask of size flags. + */ +typedef struct fcml_st_nullable_size_flags { + /** True if mask is set. */ + fcml_bool is_set; + /** Mask of supported size values. */ + fcml_flags flags; +} fcml_st_nullable_size_flags; + +/********************************* + * Operands. + *********************************/ + +/** + * Operand access mode. + */ +typedef enum fcml_en_access_mode { + /** Undefined mode. */ + FCML_AM_ACCESS_MODE_UNDEFINED = 0, + /** Operand is read by instruction. */ + FCML_AM_READ = 0x01, + /** Operand is set by instruction */ + FCML_AM_WRITE = 0x02, + /** Operand is read but can be also set. */ + FCML_AM_READ_WRITE = FCML_AM_READ | FCML_AM_WRITE +} fcml_en_access_mode; + +/** + * Representation of far pointer operand. + */ +typedef struct fcml_st_far_pointer { + /** 16-bit Code segment. */ + fcml_uint16_t segment; + /** Size of the offset. */ + fcml_usize offset_size; + /** 16-bit offset. */ + fcml_int16_t offset16; + /** 32-bit offset. */ + fcml_int32_t offset32; +} fcml_st_far_pointer; + +/********************************************/ +/** Memory addressing using ModR/M field **/ +/********************************************/ + +/** + * Addressing form. + * Distinguish between two types of addressing forms: effective addressing + * and explicit absolute offset. + */ +typedef enum fcml_en_address_form { + /** Default value set if memory addressing hasn't been configured. */ + FCML_AF_UNDEFINED, + /** Absolute offset (address). */ + FCML_AF_OFFSET, + /** Effective address combined from address components like base register, + * index registers, factor, displacement etc... */ + FCML_AF_COMBINED +} fcml_en_effective_address_form; + +/** + * Absolute offset. + */ +typedef struct fcml_st_offset { + /** Offset size 16,32 or 64 bits. */ + fcml_usize size; + /** True if offset should be treated as signed value. */ + fcml_bool is_signed; + /** Place for 16-bit absolute offset. */ + fcml_int16_t off16; + /** Place for 32-bit absolute offset. */ + fcml_int32_t off32; + /** Place for 64-bit absolute offset. */ + fcml_int64_t off64; +} fcml_st_offset; + +/** + * Effective address. + */ +typedef struct fcml_st_effective_address { + /** GPR base register. @see fcml_st_register. */ + fcml_st_register base; + /** GPR index register. @see fcml_st_register. */ + fcml_st_register index; + /** Scale factor 1,2,4 or 8. */ + fcml_uint8_t scale_factor; + /** Displacement value. @see fcml_st_integer. */ + fcml_st_integer displacement; +} fcml_st_effective_address; + +/** + * Describes segment register. + */ +typedef struct fcml_st_segment_selector { + /** Used segment register. @see fcml_st_register*/ + fcml_st_register segment_selector; + /** Set to true if given segment register is a default one in given + * context. This value is set by disassembler. + */ + fcml_bool is_default_reg; +} fcml_st_segment_selector; + +/** + * Generic memory addressing operator. + */ +typedef struct fcml_st_address { + /** Size of data accessed in memory.*/ + fcml_usize size_operator; + /** Memory addressing format: absolute offset/effective address. + * @see fcml_en_effective_address_form + */ + fcml_en_effective_address_form address_form; + /** Segment register.*/ + fcml_st_segment_selector segment_selector; + /** Memory address for FCML_AF_COMBINED form.*/ + fcml_st_effective_address effective_address; + /** Memory address for FCML_AF_OFFSET form.*/ + fcml_st_offset offset; +} fcml_st_address; + +/** + * Rounding mode. + */ +typedef enum fcml_en_embeeded_rounding_control { + FCML_ERC_RNE, FCML_ERC_RD, FCML_ERC_RU, FCML_ERC_RZ +} fcml_en_embeeded_rounding_control; + +/** + * Container for operand decorators. + * @since 1.2.0 + */ +typedef struct fcml_st_operand_decorators { + /** Broadcasting: 2, 4, 8, 16, 32, 64. */ + fcml_nuint8_t bcast; + /** Zeroing masking. */ + fcml_bool z; + /** The 64-bit k registers are: k0 through k7. */ + fcml_st_register operand_mask_reg; + /** Embedded rounding control. */ + fcml_nuint8_t er; + /** Indicates support for SAE (Suppress All Exceptions). */ + fcml_bool sae; +} fcml_st_operand_decorators; + +/** + * Supported operand types. + */ +typedef enum fcml_en_operand_type { + /** Operand not used. */ + FCML_OT_NONE, + /** Immediate integer value. */ + FCML_OT_IMMEDIATE, + /** Direct far pointer. */ + FCML_OT_FAR_POINTER, + /** Memory address. */ + FCML_OT_ADDRESS, + /** Processor register. */ + FCML_OT_REGISTER, + /** + * Not an operand in a strict sense, + * only a container for attributes. + */ + FCML_OT_VIRTUAL +} fcml_en_operand_type; + +/** + * Operand hints. + * Hints dedicated for instruction operands. + */ +typedef enum fcml_en_operand_hints { + /** + * Undefined. + */ + FCML_OP_HINT_UNDEFIEND = 0x0000, + /** + * SIMD operand. All operands which uses SIMD registers (mmx, xmm, ymm) + * have this flag set. It is for instance used by Intel syntax renderer + * for data size operators (mmword ptr, xmmword ptr, ymmword ptr). + */ + FCML_OP_HINT_MULTIMEDIA_INSTRUCTION = 0x0001, + /** + * Relative address. Flags set for all branches which use jumps + * calculated by displacement relative to the IP of the next instructions. + */ + FCML_OP_HINT_DISPLACEMENT_RELATIVE_ADDRESS = 0x0002, + /** + * Pseudo opcode. Hint set for last operand (Intel syntax) which contains + * comparison predicate of the following instructions: CMPSD, VCMPSD, CMPSS, + * VCMPSS, VPCOMB, VPCOMW, VPCOMD, VPCOMQ, VPCOMUB, VPCOMUW, + * VPCOMUD, VPCOMUQ. + */ + FCML_OP_HINT_PSEUDO_OPCODE = 0x0004, + /** + * Offset should be encoded as absolute address. + */ + FCML_OP_HINT_ABSOLUTE_ADDRESSING = 0x0008, + /** + * Offset should be encoded as relative address. + */ + FCML_OP_HINT_RELATIVE_ADDRESSING = 0x0010, + /** + * Encode ModR/M with optional SIB byte if possible. + **/ + FCML_OP_HINT_SIB_ENCODING = 0x0020 +} fcml_en_operand_hints; + +/** Instruction operand. + * Structure represents one instruction operand. + */ +typedef struct fcml_st_operand { + /** Operand type */ + fcml_en_operand_type type; + /** Optional operand level hints. */ + fcml_hints hints; + /** Immediate value operand. */ + fcml_st_integer immediate; + /** Far pointer operand. */ + fcml_st_far_pointer far_pointer; + /** Effective address or absolute offset. */ + fcml_st_address address; + /** Register operand. */ + fcml_st_register reg; + /** Operand decorators. */ + fcml_st_operand_decorators decorators; +} fcml_st_operand; + +/********************************* + * Instruction definition. + *********************************/ + +/** + * Instruction level hints. + * Set of the hints that can be only defined on the + * level of the whole instruction. They can not be used + * with operands. + */ +typedef enum fcml_en_instruction_hints { + /** No hints defined. */ + FCML_HINT_NO_HINTS, + /** Hints instruction to use FAR pointer to address the memory. */ + FCML_HINT_FAR_POINTER = 0x0001, + /** Hints instruction to use NEAR pointer to address the memory. */ + FCML_HINT_NEAR_POINTER = 0x0002, + /** This hint is used only by assembler in order to force it to generate + * three byte VEX/XOP prefix even if prefix fields fits into two bytes. */ + FCML_HINT_LONG_FORM_POINTER = 0x0004, + /** Hints instruction to use INDIRECT pointer to address the memory. */ + FCML_HINT_INDIRECT_POINTER = 0x0008, + /** Hints instruction to use DIRECT memory addressing. */ + FCML_HINT_DIRECT_POINTER = 0x0010 +} fcml_en_instruction_hints; + +/** + * Generic instruction model. + * Generic instruction model (GIM) is a common structure used to describe + * instruction in a common way used by FCML assembler and disassembler. + */ +typedef struct fcml_st_instruction { + /** Describes explicit instruction prefixes. @ref PREFIX_GROUP "List + * of explicit prefixes." */ + fcml_prefixes prefixes; + /** Holds instruction level hints. */ + fcml_hints hints; + /** Dialect-dependent instruction mnemonic. + * @see fcml_en_instruction_hints */ + fcml_char *mnemonic; + /** True for conditional instructions. */ + fcml_bool is_conditional; + /** Describes condition used by assembled/disassembled + * conditional instruction. */ + fcml_st_condition condition; + /** Fixed size array of instruction operands. */ + fcml_st_operand operands[FCML_OPERANDS_COUNT]; + /** Number of operands defined for instruction. */ + fcml_int operands_count; +} fcml_st_instruction; + +/********************************* + * Instruction definition. + *********************************/ + +/** + * An encoded instruction. + */ +typedef struct fcml_st_instruction_code { + /** Pointer to the instruction code. */ + fcml_uint8_t *code; + /** Instruction code length. */ + fcml_usize code_length; +} fcml_st_instruction_code; + +/**************************** + * Instruction entry point. + ****************************/ + +/** + * Describes address of an instruction code. + */ +typedef struct fcml_st_entry_point { + /** Processor operating mode 16/32/64-bit.*/ + fcml_en_operating_mode op_mode; + /** Default address size attribute (See 'D' flag of segment descriptor.)*/ + fcml_usize address_size_attribute; + /** Default operand size attribute (See 'D' flag of segment descriptor.)*/ + fcml_usize operand_size_attribute; + /** Instruction pointer EIP/RIP. Take into account that even in 16 bit + * mode EIP register is used.*/ + fcml_ip ip; +} fcml_st_entry_point; + +#endif /* FCML_INT_COMMON_H_ */ diff --git a/dependencies/fcml/include/fcml_common.hpp b/dependencies/fcml/include/fcml_common.hpp new file mode 100644 index 0000000..ba801a6 --- /dev/null +++ b/dependencies/fcml/include/fcml_common.hpp @@ -0,0 +1,9142 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_common.hpp + * C++ wrappers common classes. + * + * @copyright Copyright (C) 2010-2017 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_COMMON_HPP_ +#define FCML_COMMON_HPP_ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "fcml_types.h" +#include "fcml_common.h" +#include "fcml_common_utils.h" +#include "fcml_errors.h" + +namespace fcml { + +#define FCML_TO_CPP_BOOL( x ) ( (x) ? true : false ) + +/** + * By using this type definition here, it will be definitely much + * easier to support UNICODE in future releases. + * @since 1.1.0 + */ +typedef std::basic_string fcml_cstring; + +/** + * String output stream. + * @since 1.1.0 + */ +typedef std::basic_ostringstream fcml_costream; + +/** + * Exposes API responsible for environment specific operations, even if standard CPP library is used + * to implement them. + * + * @since 1.1.0 + * @remarks Internal API, not intended to be used outside. + */ +class Env { +public: + /** + * @throw std::bad_alloc + * @since 1.1.0 + */ + static fcml_string strDup( const fcml_string str ) { + if ( !str ) { + return NULL; + } +#if defined(FCML_MSCC) + fcml_string newStr = _strdup( str ); +#else + fcml_string newStr = strdup( str ); +#endif + if ( !newStr ) { + throw std::bad_alloc(); + } + return newStr; + } + static void strFree( fcml_string str ) { + free( str ); + } +}; + +/** + * A base iterator interface. + * @since 1.1.0 + */ +template +class Iterator { +public: + + Iterator() {} + + virtual ~Iterator() {} + + /** + * Gets true if there is an another element in the iterator. + */ + virtual bool hasNext() = 0; + + /** + * Gets a next element from the iterator. + */ + virtual T next() = 0; +}; + +/** Wrapper for nullable value types. + * @since 1.1.0 + */ +template +class Nullable { +public: + + Nullable( const T& value, bool is_not_null = true ) : + _value( value ), _is_not_null( is_not_null ) { + } + + Nullable() : + _is_not_null( false ) { + } + + bool isNotNull() const { + return _is_not_null; + } + + void setNotNull(bool isNull) { + _is_not_null = isNull; + } + + T getValue() const { + return _value; + } + + T& getValue() { + return _value; + } + + void setValue(const T& value) { + this->_value = value; + } + +public: + + /** + * Checks if two nullable values are equal. + * + * @param nullable The source nullable value. + * @return True if they are equal; otherwise false. + * @since 1.2.0 + */ + bool operator==(const Nullable &nullable) const { + return _value == nullable._value && + _is_not_null == nullable._is_not_null; + } + + /** + * Checks if two nullable values are not equal. + * + * @param nullable The source nullable value. + * @return True if they are not equal; otherwise false. + * @since 1.2.0 + */ + bool operator!=(const Nullable &nullable) const { + return !(nullable == *this); + } + +private: + /** Value. */ + T _value; + /** Information if value is set or not. */ + bool _is_not_null; +}; + +/** + * Base exception for all exceptions exposed by FCML library. + * @since 1.1.0 + */ +class BaseException { +public: + BaseException( fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) { + this->_error = error; + } + BaseException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) { + this->_msg = msg; + this->_error = error; + } + BaseException( const BaseException &cpy ) { + this->_msg = cpy._msg; + this->_error = cpy._error; + } + virtual ~BaseException() { + } + BaseException& operator=( const BaseException &exc ) { + if ( &exc != this ) { + this->_msg = exc._msg; + this->_error = exc._error; + } + return *this; + } +public: + const fcml_cstring getMsg() const { + return _msg; + } + const fcml_ceh_error& getError() const { + return _error; + } +private: + void* operator new( size_t size ) { + return ::operator new( size ); + } +private: + /** Error message. */ + fcml_cstring _msg; + /** Error code */ + fcml_ceh_error _error; +}; + +/** + * Component can not be initialized correctly. + * @since 1.1.0 + */ +class InitException: public BaseException { +public: + InitException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) : + BaseException( msg, error ) { + } +}; + +/** + * Bad arguments. + * @since 1.1.0 + */ +class BadArgumentException: public BaseException { +public: + BadArgumentException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) : + BaseException( msg, error ) { + } +}; + +/** + * Illegal state exception. + * @since 1.1.0 + */ +class IllegalStateException: public BaseException { +public: + IllegalStateException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) : + BaseException( msg, error ) { + } +}; + +/** + * Illegal argument exception. + * @since 1.1.0 + */ +class IllegalArgumentException: public BaseException { +public: + IllegalArgumentException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) : + BaseException( msg, error ) { + } +}; + +/** + * Operation is not supported. + * @since 1.1.0 + */ +class OperationNotSupportedException: public BaseException { +public: + OperationNotSupportedException( const fcml_cstring &msg ) : + BaseException( msg ) { + } + OperationNotSupportedException() { + } +}; + +/** + * Object which shouldn't be copied can inherit from this class. + * @since 1.1.0 + */ +class NonCopyable { +protected: + NonCopyable() { + } +private: + /** + * @throw OperationNotSupportedException + */ + NonCopyable( const NonCopyable &cpy ) { + throw OperationNotSupportedException(); + } + /** + * @throw OperationNotSupportedException + */ + NonCopyable& operator=( const NonCopyable &exc ) { + throw OperationNotSupportedException(); + } +}; + +/** Wraps instruction prefix and prepares factory methods for the hints. + * The static method "create" is used here just to avoid the constructor overloading + * what can be a bit problematic because fcml_prefix is an ordinal integer type. + * @since 1.1.0 + */ +class InstructionPrefix { +private: + /** + * Creates an instance of the instruction prefix for the given FCML prefix. + * @param prefix The native FCML prefix. + * @return Instruction prefix instance. + */ + static InstructionPrefix create( fcml_prefixes prefix ) { + InstructionPrefix instructionPrefix; + instructionPrefix._prefix = prefix; + return instructionPrefix; + } +public: + /** + * Creates instruction prefix: LOCK. + * @return Created instruction prefix. + */ + static const InstructionPrefix LOCK() { + return create(FCML_PREFIX_LOCK); + } + /** + * Creates instruction prefix: REPNE. + * @return Created instruction prefix. + */ + static const InstructionPrefix REPNE() { + return create(FCML_PREFIX_REPNE); + } + /** + * Creates instruction prefix: REPNZ. + * @return Created instruction prefix. + */ + static const InstructionPrefix REPNZ() { + return create(FCML_PREFIX_REPNZ); + } + /** + * Creates instruction prefix: REP. + * @return Created instruction prefix. + */ + static const InstructionPrefix REP() { + return create(FCML_PREFIX_REP); + } + /** + * Creates instruction prefix: REPE. + * @return Created instruction prefix. + */ + static const InstructionPrefix REPE() { + return create(FCML_PREFIX_REPE); + } + /** + * Creates instruction prefix: REPZ. + * @return Created instruction prefix. + */ + static const InstructionPrefix REPZ() { + return create(FCML_PREFIX_REPZ); + } + /** + * Creates instruction prefix: XACQUIRE. + * @return Created instruction prefix. + */ + static const InstructionPrefix XACQUIRE() { + return create(FCML_PREFIX_XACQUIRE); + } + /** + * Creates instruction prefix: XRELEASE. + * @return Created instruction prefix. + */ + static const InstructionPrefix XRELEASE() { + return create(FCML_PREFIX_XRELEASE); + } + /** + * Creates instruction prefix: BRANCH_HINT. + * @return Created instruction prefix. + */ + static const InstructionPrefix BRANCH_HINT() { + return create(FCML_PREFIX_BRANCH_HINT); + } + /** + * Creates instruction prefix: NOBRANCH_HINT. + * @return Created instruction prefix. + */ + static const InstructionPrefix NOBRANCH_HINT() { + return create(FCML_PREFIX_NOBRANCH_HINT); + } +public: + fcml_prefixes _prefix; +}; + +/** Wraps instruction hint and exposes factory methods for instruction hints. + * @since 1.1.0 + */ +struct InstructionHint { +private: + /** + * Creates an instruction level hints for given native FCML hints. + * @param hints The hints set. + */ + InstructionHint(fcml_en_instruction_hints hints) : + _hint(hints) { + } +public: + /** + * Creates instruction hint: NO_HINTS. + * @return Instruction hint. + */ + static const InstructionHint NO_HINTS() { + return InstructionHint(FCML_HINT_NO_HINTS); + } + /** + * Creates instruction hint: NEAR_POINTER. + * @return Instruction hint. + */ + static const InstructionHint NEAR_POINTER() { + return InstructionHint(FCML_HINT_NEAR_POINTER); + } + /** + * Creates instruction hint: FAR_POINTER. + * @return Instruction hint. + */ + static const InstructionHint FAR_POINTER() { + return InstructionHint(FCML_HINT_FAR_POINTER); + } + /** + * Creates instruction hint: LONG_FORM_POINTER. + * @return Instruction hint. + */ + static const InstructionHint LONG_FORM_POINTER() { + return InstructionHint(FCML_HINT_LONG_FORM_POINTER); + } + /** + * Creates instruction hint: INDIRECT_POINTER. + * @return Instruction hint. + */ + static const InstructionHint INDIRECT_POINTER() { + return InstructionHint(FCML_HINT_INDIRECT_POINTER); + } + /** + * Creates instruction hint: DIRECT_POINTER. + * @return Instruction hint. + */ + static const InstructionHint DIRECT_POINTER() { + return InstructionHint(FCML_HINT_DIRECT_POINTER); + } +public: + fcml_en_instruction_hints _hint; +}; + +/** Wraps operand hint and exposes factory methods for instruction hints. + * @since 1.1.0 + */ +struct OperandHint { +private: + OperandHint(fcml_en_operand_hints hint) : + _hint(hint) { + } +public: + /** + * Creates operand level hint: UNDEFIEND. + * @return Operand level hint. + */ + static const OperandHint UNDEFIEND() { + return OperandHint(FCML_OP_HINT_UNDEFIEND); + } + /** + * Creates operand level hint: MULTIMEDIA_INSTRUCTION. + * @return Operand level hint. + */ + static const OperandHint MULTIMEDIA() { + return OperandHint(FCML_OP_HINT_MULTIMEDIA_INSTRUCTION); + } + /** + * Creates operand level hint: DISPLACEMENT_RELATIVE_ADDRESS. + * @return Operand level hint. + */ + static const OperandHint DISPLACEMENT_RELATIVE_ADDRESS() { + return OperandHint(FCML_OP_HINT_DISPLACEMENT_RELATIVE_ADDRESS); + } + /** + * Creates operand level hint: PSEUDO_OPCODE. + * @return Operand level hint. + */ + static const OperandHint PSEUDO_OPCODE() { + return OperandHint(FCML_OP_HINT_PSEUDO_OPCODE); + } + /** + * Creates operand level hint: ABSOLUTE_ADDRESSING. + * @return Operand level hint. + */ + static const OperandHint ABSOLUTE_ADDRESSING() { + return OperandHint(FCML_OP_HINT_ABSOLUTE_ADDRESSING); + } + /** + * Creates operand level hint: RELATIVE_ADDRESSING. + * @return Operand level hint. + */ + static const OperandHint RELATIVE_ADDRESSING() { + return OperandHint(FCML_OP_HINT_RELATIVE_ADDRESSING); + } + /** + * Creates operand level hint: SIB_ENCODING. + * @return Operand level hint. + */ + static const OperandHint SIB_ENCODING() { + return OperandHint(FCML_OP_HINT_SIB_ENCODING); + } +public: + fcml_en_operand_hints _hint; +}; + +/** + * Holds instruction pointer, processor operating mode and memory segment flags. + * @since 1.1.0 + */ +class EntryPoint { +public: + + /** + * Supported operating modes. + * @since 1.1.0 + */ + enum OperatingMode { + OM_16_BIT = FCML_OM_16_BIT, + OM_32_BIT = FCML_OM_32_BIT, + OM_64_BIT = FCML_OM_64_BIT + }; + + /** + * Creates an empty entry point instance. + * @since 1.1.0 + */ + EntryPoint() : + _opMode(OM_32_BIT), + _addressSizeAttribute(FCML_DS_32), + _operandSizeAttribute(FCML_DS_32), + _ip(0) { + } + + /** + * Creates an entry point instance for given processor operating mode, instruction pointer and optionally size attributes. + * @param opMode The processor operating mode. + * @param ip The instruction pointer. + * @param addressSizeAttribute The optional address size attribute. + * @param operandSizeAttribute The optional operand size attribute. + * @since 1.1.0 + */ + EntryPoint(OperatingMode opMode, fcml_ip ip = 0, fcml_usize addressSizeAttribute = FCML_DS_UNDEF, fcml_usize operandSizeAttribute = FCML_DS_UNDEF ) : + _opMode(opMode), + _addressSizeAttribute(addressSizeAttribute), + _operandSizeAttribute(operandSizeAttribute), + _ip(ip) { + } + + virtual ~EntryPoint() { + } + +public: + + /** + * Checks if two entry points are equal. + * + * @param ep The source entry point. + * @return True if they are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const EntryPoint &ep ) const { + return _opMode == ep._opMode && + _ip == ep._ip && + _operandSizeAttribute == ep._operandSizeAttribute && + _addressSizeAttribute == ep._addressSizeAttribute; + } + + /** + * Checks if two entry points are not equal. + * + * @param ep The source entry point. + * @return True if they are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const EntryPoint &ep ) const { + return !(ep == *this); + } + +public: + + /** + * Gets address size attribute held by the entry point. + * + * @return Address size attribute. + * @since 1.1.0 + */ + fcml_usize getAddressSizeAttribute() const { + return _addressSizeAttribute; + } + + /** + * Sets a new address size attribute for the entry point. + * + * @param addressSizeAttribute The address size attribute. + * @since 1.1.0 + */ + void setAddressSizeAttribute( fcml_usize addressSizeAttribute ) { + _addressSizeAttribute = addressSizeAttribute; + } + + /** + * Gets operand size attribute held by the entry point. + * + * @return Operand size attribute. + * @since 1.1.0 + */ + fcml_usize getOperandSizeAttribute() const { + return _operandSizeAttribute; + } + + /** + * Sets a new operand size attribute for the entry point. + * + * @param operandSizeAttribute The operand size attribute. + * @since 1.1.0 + */ + void setOperandSizeAttribute( fcml_usize operandSizeAttribute ) { + _operandSizeAttribute = operandSizeAttribute; + } + + /** + * Gets instruction pointer held by the entry point. + * + * @return Instruction pointer. + * @since 1.1.0 + */ + fcml_ip getIP() const { + return _ip; + } + + /** + * Sets a new instruction pointer for the entry point. + * + * @param ip The new instruction pointer. + * @since 1.1.0 + */ + void setIP( fcml_ip ip ) { + _ip = ip; + } + + /** + * Gets processor operating mode. + * + * @return Processor operating mode. + * @since 1.1.0 + */ + OperatingMode getOpMode() const { + return _opMode; + } + + /** + * Sets a new processor operating mode for the entry point. + * + * @param opMode The new processor operating mode. + * @since 1.1.0 + */ + void setOpMode( OperatingMode opMode ) { + _opMode = opMode; + } + + /** + * Increments the instruction pointer by given number of bytes. + * + * @param ip Number for bytes the instruction pointer should be incremented by. + * @since 1.1.0 + */ + void incrementIP( fcml_ip ip ) { + _ip += ip; + } + +private: + /** Processor operating mode */ + OperatingMode _opMode; + /** Size of the address size attribute. */ + fcml_usize _addressSizeAttribute; + /** Size of the operand size attribute. */ + fcml_usize _operandSizeAttribute; + /** Instruction pointer. Content of the EIP/RIP register. */ + fcml_ip _ip; +}; + +/** + * Represents integer value. + * @since 1.1.0 + */ +class Integer { +public: + + /** @since 1.1.0 */ + Integer() : + _size( FCML_DS_64 ), _isSigned( FCML_FALSE ), _vint8( 0 ), _vint16( 0 ), _vint32( 0 ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_int8_t value ) : + _size( FCML_DS_8 ), _isSigned( FCML_TRUE ), _vint8( value ), _vint16( 0 ), _vint32( 0 ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_int16_t value ) : + _size( FCML_DS_16 ), _isSigned( FCML_TRUE ), _vint8( 0 ), _vint16( value ), _vint32( 0 ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_int32_t value ) : + _size( FCML_DS_32 ), _isSigned( FCML_TRUE ), _vint8( 0 ), _vint16( 0 ), _vint32( value ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_int64_t value ) : + _size( FCML_DS_64 ), _isSigned( FCML_TRUE ), _vint8( 0 ), _vint16( 0 ), _vint32( 0 ), _vint64( value ) { + } + + /** @since 1.1.0 */ + Integer( fcml_uint8_t value ) : + _size( FCML_DS_8 ), _isSigned( FCML_FALSE ), _vint8( static_cast( value ) ), _vint16( 0 ), _vint32( 0 ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_uint16_t value ) : + _size( FCML_DS_16 ), _isSigned( FCML_FALSE ), _vint8( 0 ), _vint16( static_cast( value ) ), _vint32( 0 ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_uint32_t value ) : + _size( FCML_DS_32 ), _isSigned( FCML_FALSE ), _vint8( 0 ), _vint16( 0 ), _vint32( static_cast( value ) ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_uint64_t value ) : + _size( FCML_DS_64 ), _isSigned( FCML_FALSE ), _vint8( 0 ), _vint16( 0 ), _vint32( 0 ), _vint64( static_cast( value ) ) { + } + + /** @since 1.1.0 */ + virtual ~Integer() { + } + +public: + + /** @since 1.1.0 */ + fcml_int16_t getInt16() const { + return _vint16; + } + + /** @since 1.1.0 */ + Integer& setInt16( fcml_int16_t int16 ) { + _vint16 = int16; + return *this; + } + + /** @since 1.1.0 */ + fcml_int32_t getInt32() const { + return _vint32; + } + + /** @since 1.1.0 */ + Integer& setInt32( fcml_int32_t int32 ) { + _vint32 = int32; + return *this; + } + + /** @since 1.1.0 */ + fcml_int64_t getInt64() const { + return _vint64; + } + + /** @since 1.1.0 */ + Integer& setInt64( fcml_int64_t int64 ) { + _vint64 = int64; + return *this; + } + + /** @since 1.1.0 */ + fcml_int8_t getInt8() const { + return _vint8; + } + + /** @since 1.1.0 */ + Integer& setInt8( fcml_int8_t int8 ) { + _vint8 = int8; + return *this; + } + + /** @since 1.1.0 */ + fcml_bool isSigned() const { + return _isSigned; + } + + /** @since 1.1.0 */ + Integer& setSigned( fcml_bool isSigned ) { + _isSigned = isSigned; + return *this; + } + + /** @since 1.1.0 */ + fcml_usize getSize() const { + return _size; + } + + /** @since 1.1.0 */ + Integer& setSize( fcml_usize size ) { + _size = size; + return *this; + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_uint8_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_int8_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_uint16_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_int16_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_uint32_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_int32_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_uint64_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_int64_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const Integer &value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_uint8_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_int8_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_uint16_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_int16_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_uint32_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_int32_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_uint64_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_int64_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const Integer &value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong data size. + */ + operator fcml_int8_t() const { + fcml_int8_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong indeger size. + */ + operator fcml_uint8_t() const { + fcml_uint8_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong integer size. + */ + operator fcml_int16_t() const { + fcml_int16_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong integer size. + */ + operator fcml_uint16_t() const { + fcml_uint16_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong integer size. + */ + operator fcml_int32_t() const { + fcml_int32_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong integer size. + */ + operator fcml_uint32_t() const { + fcml_uint32_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong integer size. + */ + operator fcml_int64_t() const { + fcml_int64_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong integer size. + */ + operator fcml_uint64_t() const { + fcml_uint64_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * Addition assignment. + * @since 1.1.0 + */ + Integer& operator +=( const Integer &arg ) { + plus( *this, arg ); + return ( *this ); + } + + /** + * Multiplication assignment. + * @since 1.1.0 + */ + Integer& operator *=( const Integer &arg ) { + mul( *this, arg ); + return ( *this ); + } + + /** + * Division assignment. + * @since 1.1.0 + */ + Integer& operator /=( const Integer &arg ) { + div( *this, arg ); + return ( *this ); + } + + /** + * Subtraction assignment. + * @since 1.1.0 + */ + Integer& operator -=( const Integer &arg ) { + minus( *this, arg ); + return ( *this ); + } + + /** + * Addition operator. + * @since 1.1.0 + */ + Integer operator+( const Integer &src ) const { + const Integer &thisRef = *this; + Integer result( thisRef ); + plus( result, src ); + return result; + } + + /** + * Subtraction operator. + * @since 1.1.0 + */ + Integer operator-( const Integer &src ) const { + const Integer &thisRef = *this; + Integer result( thisRef ); + minus( result, src ); + return result; + } + + /** + * Multiplication operator. + * @since 1.1.0 + */ + Integer operator*( const Integer &src ) const { + const Integer &thisRef = *this; + Integer result( thisRef ); + mul( result, src ); + return result; + } + + /** + * Division operator. + * @since 1.1.0 + */ + Integer operator/( const Integer &src ) const { + const Integer &thisRef = *this; + Integer result( thisRef ); + div( result, src ); + return result; + } + +public: + + /** + * Factory method which creates an instance fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer int8( fcml_int8_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an instance fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer uint8( fcml_uint8_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an instance fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer int16( fcml_int16_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an instance fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer uint16( fcml_uint16_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an insatnce fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer int32( fcml_int32_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an insatnce fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer uint32( fcml_uint32_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an insatnce fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer int64( fcml_int64_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an insatnce fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer uint64( fcml_uint64_t value ) { + return Integer( value ); + } + +private: + + /** + * @remark An internal API. + * @since 1.1.0 + */ + void minus( Integer &result, const Integer &src ) const { + callMathExpression( &doMinus, &doUMinus, result, src ); + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + void mul( Integer &result, const Integer &src ) const { + callMathExpression( &doMul, &doUMul, result, src ); + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + void div( Integer &result, const Integer &src ) const { + callMathExpression( &doDiv, &doUDiv, result, src ); + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + void plus( Integer &result, const Integer &src ) const { + callMathExpression( &doPlus, &doUPlus, result, src ); + } + +private: + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_int64_t doPlus( fcml_int64_t thisValue, fcml_int64_t thatValue ) { + return thisValue + thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_int64_t doMinus( fcml_int64_t thisValue, fcml_int64_t thatValue ) { + return thisValue - thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_int64_t doMul( fcml_int64_t thisValue, fcml_int64_t thatValue ) { + return thisValue * thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_int64_t doDiv( fcml_int64_t thisValue, fcml_int64_t thatValue ) { + return thisValue / thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_uint64_t doUPlus( fcml_uint64_t thisValue, fcml_uint64_t thatValue ) { + return thisValue + thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_uint64_t doUMinus( fcml_uint64_t thisValue, fcml_uint64_t thatValue ) { + return thisValue - thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_uint64_t doUMul( fcml_uint64_t thisValue, fcml_uint64_t thatValue ) { + return thisValue * thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_uint64_t doUDiv( fcml_uint64_t thisValue, fcml_uint64_t thatValue ) { + return thisValue / thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + void callMathExpression( fcml_int64_t (*signedExpressionFn)( fcml_int64_t thisValue, fcml_int64_t thatValue ), + fcml_uint64_t (*unsignedExpressionFn)( fcml_uint64_t thisValue, fcml_uint64_t thatValue ), + Integer &result, const Integer &src ) const { + + if( _isSigned ) { + + fcml_int64_t thisValue; + fcml_int64_t thatValue; + + // Prepare "that". It has to be converted to the same sign. + switch( src._size ) { + case FCML_DS_8: + thatValue = src._isSigned ? src._vint8 : static_cast( src._vint8 ); + break; + case FCML_DS_16: + thatValue = src._isSigned ? src._vint16 : static_cast( src._vint16 ); + break; + case FCML_DS_32: + thatValue = src._isSigned ? src._vint32 : static_cast( src._vint32 ); + break; + case FCML_DS_64: + thatValue = src._isSigned ? src._vint64 : static_cast( src._vint64 ); + break; + } + + // Now "this". + switch( result._size ) { + case FCML_DS_8: + thisValue = result._isSigned ? result._vint8 : static_cast(result._vint8 ); + thisValue = (*signedExpressionFn)( thisValue, thatValue ); + result._vint8 = static_cast( thisValue ); + break; + case FCML_DS_16: + thisValue = result._isSigned ? result._vint16 : static_cast( result._vint16 ); + thisValue = (*signedExpressionFn)( thisValue, thatValue ); + result._vint16 = static_cast( thisValue ); + break; + case FCML_DS_32: + thisValue = result._isSigned ? result._vint32 : static_cast( result._vint32 ); + thisValue = (*signedExpressionFn)( thisValue, thatValue ); + result._vint32 = static_cast( thisValue ); + break; + case FCML_DS_64: + thisValue = result._isSigned ? result._vint64 : static_cast( result._vint64 ); + thisValue = (*signedExpressionFn)( thisValue, thatValue ); + result._vint64 = thisValue; + break; + } + + } else { + + fcml_uint64_t thisValue; + fcml_uint64_t thatValue; + + // Prepare "that". It has to be converted to the same sign. + switch( src._size ) { + case FCML_DS_8: + thatValue = src._isSigned ? src._vint8 : static_cast( src._vint8 ); + break; + case FCML_DS_16: + thatValue = src._isSigned ? src._vint16 : static_cast( src._vint16 ); + break; + case FCML_DS_32: + thatValue = src._isSigned ? src._vint32 : static_cast( src._vint32 ); + break; + case FCML_DS_64: + thatValue = src._isSigned ? src._vint64 : static_cast( src._vint64 ); + break; + } + + // Now "this". + switch( result._size ) { + case FCML_DS_8: + thisValue = result._isSigned ? result._vint8 : static_cast( result._vint8 ); + thisValue = (*unsignedExpressionFn)( thisValue, thatValue ); + result._vint8 = static_cast( thisValue ); + break; + case FCML_DS_16: + thisValue = result._isSigned ? result._vint16 : static_cast( result._vint16 ); + thisValue = (*unsignedExpressionFn)( thisValue, thatValue ); + result._vint16 = static_cast( thisValue ); + break; + case FCML_DS_32: + thisValue = result._isSigned ? result._vint32 : static_cast( result._vint32 ); + thisValue = (*unsignedExpressionFn)( thisValue, thatValue ); + result._vint32 = static_cast( thisValue ); + break; + case FCML_DS_64: + thisValue = result._isSigned ? result._vint64 : static_cast( result._vint64 ); + thisValue = (*unsignedExpressionFn)( thisValue, thatValue ); + result._vint64 = thisValue; + break; + } + } + + } + +private: + fcml_usize _size; + fcml_bool _isSigned; + fcml_int8_t _vint8; + fcml_int16_t _vint16; + fcml_int32_t _vint32; + fcml_int64_t _vint64; +}; + +/** + * x86 - 64 register representation. + * @since 1.1.0 + */ +class Register { +public: + + // TODO: Do we need this REG_ prefix here? + /** Register types. + * @since 1.1.0 + */ + enum RegisterType { + /** Undefined register type. */ + REG_UNDEFINED = FCML_REG_UNDEFINED, + /** General purpose register. */ + REG_GPR = FCML_REG_GPR, + /** SIMD (SSE, MMX) register. */ + REG_SIMD = FCML_REG_SIMD, + /** FPU register. */ + REG_FPU = FCML_REG_FPU, + /** Segment register */ + REG_SEG = FCML_REG_SEG, + /** Control register. */ + REG_CR = FCML_REG_CR, + /** Debug register */ + REG_DR = FCML_REG_DR, + /** Instruction pointer register. Used for relative RIP addressing. */ + REG_IP = FCML_REG_IP, + /** Opmask register + * @since 1.2.0 + */ + REG_OPMASK = FCML_REG_OPMASK + }; + + /** + * Creates an empty register instance. + * @since 1.1.0 + */ + Register() : + _type(REG_UNDEFINED), + _size(0), + _reg(0), + _x64_exp(FCML_FALSE) { + } + + /** + * Creates a register instance for given register structure. + * @param reg The source register as the FCML structure. + * @since 1.1.0 + */ + Register( const fcml_st_register ® ) : + _type(static_cast( reg.type )), + _size(reg.size), + _reg(reg.reg), + _x64_exp(reg.x64_exp? true : false) { + } + + /** + * Creates a register instance for given parameters. + * @param reg The FCML register number. + * @param size The register size. + * @param type The register type. + * @param x64_exp True if it's a 8-bit general purpose register for REX aware instruction. See manual. + * @since 1.1.0 + */ + Register( fcml_uint8_t reg, fcml_usize size, RegisterType type = REG_GPR, fcml_bool x64_exp = FCML_FALSE ) : + _type(type), + _size(size), + _reg(reg), + _x64_exp(x64_exp?true:false) { + } + + /** + * @since 1.1.0 + */ + virtual ~Register() { + } + +public: + + /** + * Gets the register number. + * @return The register number. + * @since 1.1.0 + */ + fcml_uint8_t getReg() const { + return _reg; + } + + /** + * Sets the register number. + * @param reg The register number. + * @since 1.1.0 + */ + void setReg( fcml_uint8_t reg ) { + _reg = reg; + } + + /** + * Gets the register size. + * @return The register size. + * @since 1.1.0 + */ + fcml_usize getSize() const { + return _size; + } + + /** + * Sets the register size. + * @param size The register size. + * @since 1.1.0 + */ + void setSize( fcml_usize size ) { + _size = size; + } + + /** + * Gets the register type. + * @return The register type. + * @since 1.1.0 + */ + RegisterType getType() const { + return _type; + } + + /** + * Sets the register type. + * @param type The register type. + * @since 1.1.0 + */ + void setType( RegisterType type ) { + _type = type; + } + + /** + * Gets true if it's a 8-bit general purpose register for REX aware instruction. See manual. + * @return True if it's a 8-bit general purpose register for REX aware instruction. See manual.. + * @since 1.1.0 + */ + bool getX64Exp() const { + return _x64_exp; + } + + /** + * Sets x64exp flag, see manual. + * @param x64Exp The flag value. + * @since 1.1.0 + */ + void setX64Exp( bool x64Exp ) { + _x64_exp = x64Exp; + } + +public: + + /** + * Compares registers. + * @param reg The source register. + * @return True if registers are equal. + * @since 1.1.0 + */ + bool operator==( const Register ® ) const { + return _reg == reg._reg && _type == reg._type && _size == reg._size && _x64_exp == reg._x64_exp; + } + + /** + * Compares registers. + * @param reg The source register. + * @return True if registers are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const Register ® ) const { + return !( reg == *this ); + } + +public: + + /** + * Factory method for an undefined register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register UNDEF() { + Register reg( 0, 0, Register::REG_UNDEFINED, FCML_FALSE ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register AL() { + Register reg( ::fcml_reg_AL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register AX() { + Register reg( ::fcml_reg_AX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register EAX() { + Register reg( ::fcml_reg_EAX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RAX() { + Register reg( ::fcml_reg_RAX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM0() { + Register reg( ::fcml_reg_MM0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM0() { + Register reg( ::fcml_reg_XMM0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM0() { + Register reg( ::fcml_reg_YMM0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM0() { + Register reg( ::fcml_reg_ZMM0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CL() { + Register reg( ::fcml_reg_CL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CX() { + Register reg( ::fcml_reg_CX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ECX() { + Register reg( ::fcml_reg_ECX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RCX() { + Register reg( ::fcml_reg_RCX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM1() { + Register reg( ::fcml_reg_MM1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM1() { + Register reg( ::fcml_reg_XMM1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM1() { + Register reg( ::fcml_reg_YMM1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM1() { + Register reg( ::fcml_reg_ZMM1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DL() { + Register reg( ::fcml_reg_DL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DX() { + Register reg( ::fcml_reg_DX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register EDX() { + Register reg( ::fcml_reg_EDX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RDX() { + Register reg( ::fcml_reg_RDX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM2() { + Register reg( ::fcml_reg_MM2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM2() { + Register reg( ::fcml_reg_XMM2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM2() { + Register reg( ::fcml_reg_YMM2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM2() { + Register reg( ::fcml_reg_ZMM2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register BL() { + Register reg( ::fcml_reg_BL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register BX() { + Register reg( ::fcml_reg_BX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register EBX() { + Register reg( ::fcml_reg_EBX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RBX() { + Register reg( ::fcml_reg_RBX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM3() { + Register reg( ::fcml_reg_MM3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM3() { + Register reg( ::fcml_reg_XMM3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM3() { + Register reg( ::fcml_reg_YMM3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM3() { + Register reg( ::fcml_reg_ZMM3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register AH() { + Register reg( ::fcml_reg_AH ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register SPL() { + Register reg( ::fcml_reg_SPL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register SP() { + Register reg( ::fcml_reg_SP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ESP() { + Register reg( ::fcml_reg_ESP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RSP() { + Register reg( ::fcml_reg_RSP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM4() { + Register reg( ::fcml_reg_MM4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM4() { + Register reg( ::fcml_reg_XMM4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM4() { + Register reg( ::fcml_reg_YMM4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM4() { + Register reg( ::fcml_reg_ZMM4 ); + return reg; + } + + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CH() { + Register reg( ::fcml_reg_CH ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register BPL() { + Register reg( ::fcml_reg_BPL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register BP() { + Register reg( ::fcml_reg_BP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register EBP() { + Register reg( ::fcml_reg_EBP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RBP() { + Register reg( ::fcml_reg_RBP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM5() { + Register reg( ::fcml_reg_MM5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM5() { + Register reg( ::fcml_reg_XMM5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM5() { + Register reg( ::fcml_reg_YMM5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM5() { + Register reg( ::fcml_reg_ZMM5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DH() { + Register reg( ::fcml_reg_DH ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register SIL() { + Register reg( ::fcml_reg_SIL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register SI() { + Register reg( ::fcml_reg_SI ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ESI() { + Register reg( ::fcml_reg_ESI ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RSI() { + Register reg( ::fcml_reg_RSI ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM6() { + Register reg( ::fcml_reg_MM6 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM6() { + Register reg( ::fcml_reg_XMM6 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM6() { + Register reg( ::fcml_reg_YMM6 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM6() { + Register reg( ::fcml_reg_ZMM6 ); + return reg; + } + + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register BH() { + Register reg( ::fcml_reg_BH ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DIL() { + Register reg( ::fcml_reg_DIL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DI() { + Register reg( ::fcml_reg_DI ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register EDI() { + Register reg( ::fcml_reg_EDI ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RDI() { + Register reg( ::fcml_reg_RDI ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM7() { + Register reg( ::fcml_reg_MM7 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM7() { + Register reg( ::fcml_reg_XMM7 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM7() { + Register reg( ::fcml_reg_YMM7 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM7() { + Register reg( ::fcml_reg_ZMM7 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R8L() { + Register reg( ::fcml_reg_R8L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R8W() { + Register reg( ::fcml_reg_R8W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R8D() { + Register reg( ::fcml_reg_R8D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R8() { + Register reg( ::fcml_reg_R8 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM8() { + Register reg( ::fcml_reg_XMM8 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM8() { + Register reg( ::fcml_reg_YMM8 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM8() { + Register reg( ::fcml_reg_ZMM8 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R9L() { + Register reg( ::fcml_reg_R9L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R9W() { + Register reg( ::fcml_reg_R9W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R9D() { + Register reg( ::fcml_reg_R9D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R9() { + Register reg( ::fcml_reg_R9 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM9() { + Register reg( ::fcml_reg_XMM9 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM9() { + Register reg( ::fcml_reg_YMM9 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM9() { + Register reg( ::fcml_reg_ZMM9 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R10L() { + Register reg( ::fcml_reg_R10L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R10W() { + Register reg( ::fcml_reg_R10W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R10D() { + Register reg( ::fcml_reg_R10D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R10() { + Register reg( ::fcml_reg_R10 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM10() { + Register reg( ::fcml_reg_XMM10 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM10() { + Register reg( ::fcml_reg_YMM10 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM10() { + Register reg( ::fcml_reg_ZMM10 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R11L() { + Register reg( ::fcml_reg_R11L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R11W() { + Register reg( ::fcml_reg_R11W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R11D() { + Register reg( ::fcml_reg_R11D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R11() { + Register reg( ::fcml_reg_R11 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM11() { + Register reg( ::fcml_reg_XMM11 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM11() { + Register reg( ::fcml_reg_YMM11 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM11() { + Register reg( ::fcml_reg_ZMM11 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R12L() { + Register reg( ::fcml_reg_R12L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R12W() { + Register reg( ::fcml_reg_R12W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R12D() { + Register reg( ::fcml_reg_R12D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R12() { + Register reg( ::fcml_reg_R12 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM12() { + Register reg( ::fcml_reg_XMM12 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM12() { + Register reg( ::fcml_reg_YMM12 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM12() { + Register reg( ::fcml_reg_ZMM12 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R13L() { + Register reg( ::fcml_reg_R13L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R13W() { + Register reg( ::fcml_reg_R13W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R13D() { + Register reg( ::fcml_reg_R13D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R13() { + Register reg( ::fcml_reg_R13 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM13() { + Register reg( ::fcml_reg_XMM13 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM13() { + Register reg( ::fcml_reg_YMM13 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM13() { + Register reg( ::fcml_reg_ZMM13 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R14L() { + Register reg( ::fcml_reg_R14L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R14W() { + Register reg( ::fcml_reg_R14W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R14D() { + Register reg( ::fcml_reg_R14D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R14() { + Register reg( ::fcml_reg_R14 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM14() { + Register reg( ::fcml_reg_XMM14 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM14() { + Register reg( ::fcml_reg_YMM14 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM14() { + Register reg( ::fcml_reg_ZMM14 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R15L() { + Register reg( ::fcml_reg_R15L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R15W() { + Register reg( ::fcml_reg_R15W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R15D() { + Register reg( ::fcml_reg_R15D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R15() { + Register reg( ::fcml_reg_R15 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM15() { + Register reg( ::fcml_reg_XMM15 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM15() { + Register reg( ::fcml_reg_YMM15 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM15() { + Register reg( ::fcml_reg_ZMM15 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM16() { + Register reg( ::fcml_reg_XMM16 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM16() { + Register reg( ::fcml_reg_YMM16 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM16() { + Register reg( ::fcml_reg_ZMM16 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM17() { + Register reg( ::fcml_reg_XMM17 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM17() { + Register reg( ::fcml_reg_YMM17 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM17() { + Register reg( ::fcml_reg_ZMM17 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM18() { + Register reg( ::fcml_reg_XMM18 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM18() { + Register reg( ::fcml_reg_YMM18 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM18() { + Register reg( ::fcml_reg_ZMM18 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM19() { + Register reg( ::fcml_reg_XMM19 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM19() { + Register reg( ::fcml_reg_YMM19 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM19() { + Register reg( ::fcml_reg_ZMM19 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM20() { + Register reg( ::fcml_reg_XMM20 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM20() { + Register reg( ::fcml_reg_YMM20 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM20() { + Register reg( ::fcml_reg_ZMM20 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM21() { + Register reg( ::fcml_reg_XMM21 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM21() { + Register reg( ::fcml_reg_YMM21 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM21() { + Register reg( ::fcml_reg_ZMM21 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM22() { + Register reg( ::fcml_reg_XMM22 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM22() { + Register reg( ::fcml_reg_YMM22 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM22() { + Register reg( ::fcml_reg_ZMM22 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM23() { + Register reg( ::fcml_reg_XMM23 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM23() { + Register reg( ::fcml_reg_YMM23 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM23() { + Register reg( ::fcml_reg_ZMM23 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM24() { + Register reg( ::fcml_reg_XMM24 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM24() { + Register reg( ::fcml_reg_YMM24 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM24() { + Register reg( ::fcml_reg_ZMM24 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM25() { + Register reg( ::fcml_reg_XMM25 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM25() { + Register reg( ::fcml_reg_YMM25 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM25() { + Register reg( ::fcml_reg_ZMM25 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM26() { + Register reg( ::fcml_reg_XMM26 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM26() { + Register reg( ::fcml_reg_YMM26 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM26() { + Register reg( ::fcml_reg_ZMM26 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM27() { + Register reg( ::fcml_reg_XMM27 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM27() { + Register reg( ::fcml_reg_YMM27 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM27() { + Register reg( ::fcml_reg_ZMM27 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM28() { + Register reg( ::fcml_reg_XMM28 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM28() { + Register reg( ::fcml_reg_YMM28 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM28() { + Register reg( ::fcml_reg_ZMM28 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM29() { + Register reg( ::fcml_reg_XMM29 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM29() { + Register reg( ::fcml_reg_YMM29 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM29() { + Register reg( ::fcml_reg_ZMM29 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM30() { + Register reg( ::fcml_reg_XMM30 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM30() { + Register reg( ::fcml_reg_YMM30 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM30() { + Register reg( ::fcml_reg_ZMM30 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM31() { + Register reg( ::fcml_reg_XMM31 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM31() { + Register reg( ::fcml_reg_YMM31 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM31() { + Register reg( ::fcml_reg_ZMM31 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ES() { + Register reg( ::fcml_reg_ES ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CS() { + Register reg( ::fcml_reg_CS ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register SS() { + Register reg( ::fcml_reg_SS ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DS() { + Register reg( ::fcml_reg_DS ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register FS() { + Register reg( ::fcml_reg_FS ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register GS() { + Register reg( ::fcml_reg_GS ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST0() { + Register reg( ::fcml_reg_ST0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST1() { + Register reg( ::fcml_reg_ST1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST2() { + Register reg( ::fcml_reg_ST2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST3() { + Register reg( ::fcml_reg_ST3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST4() { + Register reg( ::fcml_reg_ST4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST5() { + Register reg( ::fcml_reg_ST5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST6() { + Register reg( ::fcml_reg_ST6 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST7() { + Register reg( ::fcml_reg_ST7 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CR0() { + Register reg( ::fcml_reg_CR0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CR2() { + Register reg( ::fcml_reg_CR2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CR3() { + Register reg( ::fcml_reg_CR3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CR4() { + Register reg( ::fcml_reg_CR4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CR8() { + Register reg( ::fcml_reg_CR8 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR0() { + Register reg( ::fcml_reg_DR0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR1() { + Register reg( ::fcml_reg_DR1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR2() { + Register reg( ::fcml_reg_DR2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR3() { + Register reg( ::fcml_reg_DR3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR4() { + Register reg( ::fcml_reg_DR4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR5() { + Register reg( ::fcml_reg_DR5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR6() { + Register reg( ::fcml_reg_DR6 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR7() { + Register reg( ::fcml_reg_DR7 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register IP() { + Register reg( ::fcml_reg_IP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register EIP() { + Register reg( ::fcml_reg_EIP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RIP() { + Register reg( ::fcml_reg_RIP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K0() { + Register reg( ::fcml_reg_K0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K1() { + Register reg( ::fcml_reg_K1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K2() { + Register reg( ::fcml_reg_K2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K3() { + Register reg( ::fcml_reg_K3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K4() { + Register reg( ::fcml_reg_K4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K5() { + Register reg( ::fcml_reg_K5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K6() { + Register reg( ::fcml_reg_K6 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K7() { + Register reg( ::fcml_reg_K7 ); + return reg; + } + +private: + + /** Register type. */ + RegisterType _type; + /** Register size in bits. */ + fcml_usize _size; + /** Register itself as a positive integer. @see REGISTERS_GROUP */ + fcml_uint8_t _reg; + /** In case of SPL,BPL,SIL,DIL GPR registers has to be set to true. */ + bool _x64_exp; + +}; + +/** + * Describes far pointer. + * @since 1.1.0 + */ +class FarPointer { + +public: + + /** + * Creates an far pointer instance. + * @since 1.1.0 + */ + FarPointer() : + _segment(0), + _offset_size(0), + _offset16(0), + _offset32(0) { + } + + /** + * Creates an far pointer instance. + * @param segment A segment selector. + * @param offset16 A 16-bit offset in the given segment. + * @since 1.1.0 + */ + FarPointer( fcml_uint16_t segment, fcml_int16_t offset16 ) : + _segment(segment), + _offset_size(FCML_DS_16), + _offset16(offset16), + _offset32(0) { + } + /** + * Creates an far pointer instance. + * @param segment A segment selector. + * @param offset32 A 32-bit offset in the given segment. + * @since 1.1.0 + */ + FarPointer( fcml_uint16_t segment, fcml_int32_t offset32 ) : + _segment(segment), + _offset_size(FCML_DS_32), + _offset16(0), + _offset32(offset32) { + } + + virtual ~FarPointer() { + } + +public: + + /** + * Compares two far pointers. + * @param fp The far pointer to be compared with the current one. + * @return True if they are equal. + * @since 1.1.0 + */ + bool operator==( const FarPointer &fp ) const { + fcml_int32_t thisOffset; + switch( _offset_size ) { + case FCML_DS_32: + thisOffset = _offset32; + break; + case FCML_DS_16: + thisOffset = _offset16; + break; + } + fcml_int32_t thatOffset; + switch( fp._offset_size ) { + case FCML_DS_32: + thatOffset = fp._offset32; + break; + case FCML_DS_16: + thatOffset = fp._offset16; + break; + } + return thisOffset == thatOffset; + } + + /** + * Compares two far pointers. + * @param fp The far pointer to be compared with the current one. + * @return True if they are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const FarPointer &fp) const { + return !(fp == *this); + } + +public: + + /** + * Creates FarPointer instance for 16 bit segment and 16-bit offset. + * + * @param segment Segment selector. + * @param offset 16-bit address. + * @return FarPointer instance. + * @since 1.1.0 + */ + static FarPointer off16( fcml_uint16_t segment, fcml_int16_t offset ) { + return FarPointer(segment, offset); + } + + /** + * Creates FarPointer instance for 16 bit segment and 32-bit offset. + * + * @param segment Segment selector. + * @param offset 32-bit address. + * @return FarPointer instance. + */ + static FarPointer off32( fcml_uint16_t segment, fcml_int32_t offset ) { + return FarPointer(segment, offset); + } + +public: + + /** + * Gets offset size. + * + * @return Offset size. + * @since 1.1.0 + */ + fcml_usize getOffsetSize() const { + return _offset_size; + } + + /** + * Sets offset size. + * + * @param offsetSize The new offset size to be set. + * @since 1.1.0 + */ + void setOffsetSize( fcml_usize offsetSize ) { + _offset_size = offsetSize; + } + + /** + * Gets the 16-bit offset. + * + * @return 16-bit offset. + * @since 1.1.0 + */ + fcml_int16_t getOffset16() const { + return _offset16; + } + + /** + * Sets 16-bit offset. + * + * @param offset16 Sets 16-bit offset. + * @since 1.1.0 + */ + void setOffset16( fcml_int16_t offset16 ) { + _offset16 = offset16; + } + + /** + * Gets 32-bit offset. + * + * @return 32-bit offset. + * @since 1.1.0 + */ + fcml_int32_t getOffset32() const { + return _offset32; + } + + /** + * Sets 32-bit offset. + * + * @param offset32 Sets 32-bit offset. + * @since 1.1.0 + */ + void setOffset32( fcml_int32_t offset32 ) { + _offset32 = offset32; + } + + /** + * Gets segment selector. + * + * @return 16-bit segment selector. + * @since 1.1.0 + */ + fcml_uint16_t getSegment() const { + return _segment; + } + + /** + * Sets segment selector. + * + * @param segment Segment selector. + * @since 1.1.0 + */ + void setSegment( fcml_uint16_t segment ) { + _segment = segment; + } + +private: + + /** 16-bit Code segment. */ + fcml_uint16_t _segment; + /** Size of the offset. */ + fcml_usize _offset_size; + /** 16-bit offset. */ + fcml_int16_t _offset16; + /** 32-bit offset. */ + fcml_int32_t _offset32; + +}; + +/** + * Describes segment register. + * @since 1.1.0 + */ +class SegmentSelector { +public: + + /** + * Creates an empty segment selector instance. + * @since 1.1.0 + */ + SegmentSelector() : + _segmentSelector(), + _isDefaultReg(false) { + } + + /** + * Creates a segment selector instance for given parameters. + * @param segmentSelector A segment register. + * @param isDefaultReg Information if the register is the default one. + * @since 1.1.0 + */ + SegmentSelector( const Register &segmentSelector, bool isDefaultReg = FCML_TRUE ) : + _segmentSelector(segmentSelector), + _isDefaultReg(isDefaultReg) { + } + + virtual ~SegmentSelector() { + } + +public: + + /** + * Checks if two segment selector are equal. + * @param segmentSelector The source segment selector. + * @return True if they are equal. + * @since 1.1.0 + */ + bool operator==( const SegmentSelector &segmentSelector ) const { + // It really doesn't matter if it is the default segment register in a given context. + return segmentSelector._segmentSelector == _segmentSelector; + } + + /** + * Checks if two segment selector are not equal. + * @param segmentSelector The source segment selector. + * @return True if they are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const SegmentSelector &segmentSelector ) const { + return !(*this == segmentSelector); + } + + /** + * Casting operator. + * @return The segment register. + * @since 1.1.0 + */ + operator Register() const { + return _segmentSelector; + } + + /** + * Copies one segment selector to another. + * @param reg The source segment selector. + * @return The destination segment selector. + * @since 1.1.0 + */ + SegmentSelector& operator=( const SegmentSelector ® ) { + if( ® != this ) { + _isDefaultReg = reg._isDefaultReg; + _segmentSelector = reg._segmentSelector; + } + return *this; + } + +public: + + /** + * Creates segment selector for the given register. + * + * @param segmentSelector Segment register. + * @param isDefaultReg True if the register is the default one in the given context. + * @return Prepared segment selector. + * @since 1.1.0 + */ + static SegmentSelector seg( const Register &segmentSelector, bool isDefaultReg ) { + return SegmentSelector( segmentSelector, isDefaultReg ); + } + +public: + + /** + * Returns true if a register stored in the segment selector is the default one + * in the context the segment selector is used. + * + * @return True if register is the default one. + * @since 1.1.0 + */ + bool isDefaultReg() const { + return _isDefaultReg; + } + + /** + * Sets "default" flag for the segment selector. + * + * @param isDefaultReg True if the register is the default one in the given context. + * @since 1.1.0 + */ + void setDefaultReg( bool isDefaultReg ) { + _isDefaultReg = isDefaultReg; + } + + /** + * Gets constant segment register associated with the selector. + * + * @return Constant segment register. + * @since 1.1.0 + */ + const Register& getSegmentSelector() const { + return _segmentSelector; + } + + /** + * Gets segment register associated with the selector. + * + * @return Segment register. + * @since 1.1.0 + */ + Register& getSegmentSelector() { + return _segmentSelector; + } + + /** + * Sets segment register for the selector. + * + * @param segmentSelector Segment register. + * @since 1.1.0 + */ + void setSegmentSelector( const Register& segmentSelector ) { + _segmentSelector = segmentSelector; + } + +private: + /** Segment register. */ + Register _segmentSelector; + /** True if this is a default segment register. */ + bool _isDefaultReg; +}; + +/** + * Describes effective address. + * + * It's a counterpart to the fcml_st_effective_address structure. + * @since 1.1.0 + */ +class EffectiveAddress { +public: + + /** + * Creates an empry effective address. + * @since 1.1.0 + */ + EffectiveAddress() : + _scaleFactor(0){ + } + + /** + * Creates an effective address instance with the displacement only. + * @param displacement The displacement value. + * @since 1.1.0 + */ + EffectiveAddress( const Integer &displacement ) : + _scaleFactor(0), + _displacement(displacement) { + } + + /** + * Creates an effective address instance with the base register only. + * @param base The base register. + * @since 1.1.0 + */ + EffectiveAddress( const Register &base ) : + _base(base), + _scaleFactor(0) { + } + + /** + * Creates an effective address instance with the base register and displacement only. + * @param base The base register. + * @param displacement The displacement value. + * @since 1.1.0 + */ + EffectiveAddress( const Register &base, const Integer &displacement ) : + _base(base), + _scaleFactor(0), + _displacement(displacement) { + } + + /** + * Creates an effective address instance with the index register, scale factor and displacement. + * @param index The index register. + * @param scaleFactor The scale factor value. + * @param displacement The displacement. + * @since 1.1.0 + */ + EffectiveAddress( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) : + _index(index), + _scaleFactor(scaleFactor), + _displacement(displacement) { + } + + /** + * Creates an effective address instance with the base register and index register. + * @param base The base register. + * @param index The index register. + * @since 1.1.0 + */ + EffectiveAddress( const Register &base, const Register &index ) : + _base(base), + _index(index), + _scaleFactor(0) { + } + + /** + * Creates an effective address instance with the base register, index register and scale factor set. + * @param base The base register. + * @param index THe index register. + * @param scaleFactor The scale factor. + * @since 1.1.0 + */ + EffectiveAddress( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) : + _base(base), + _index(index), + _scaleFactor(scaleFactor) { + } + + /** + * Creates an effective address instance with the base register, index register, scale factor and displacement set. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor value. + * @param displacement The displacement. + * @since 1.1.0 + */ + EffectiveAddress( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) : + _base(base), + _index(index), + _scaleFactor(scaleFactor), + _displacement(displacement) { + } + + /** + * @since 1.1.0 + */ + virtual ~EffectiveAddress() { + } + +public: + + /** + * Checks whether two effective addresses are equal or not. + * @param address The source address to be compared. + * @return True if they are equal. + * @since 1.1.0 + */ + bool operator==( const EffectiveAddress &address ) const { + if( &address == this ) { + return true; + } + return _base == address._base && + _index == address._index && + _scaleFactor == address._scaleFactor && + _displacement == address._displacement; + } + + /** + * Checks whether two effective addresses are equal or not. + * @param address The source address to be compared. + * @return True if they are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const EffectiveAddress &address ) const { + return !(address == *this); + } + +public: + + /** + * Factory method which creates an effective address instance with the displacement only. + * @param displacement The displacement value. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Integer &displacement ) { + return EffectiveAddress( displacement ); + } + + /** + * Factory method which creates an effective address instance with the base register only. + * @param base The base register. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Register &base ) { + return EffectiveAddress( base ); + } + + /** + * Factory method which creates an effective address instance with the base register and displacement. + * @param base The base register. + * @param displacement The displacement value. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Register &base, const Integer &displacement ) { + return EffectiveAddress( base, displacement ); + } + + /** + * Factory method which creates an effective address instance with the index register, scale factor and displacement. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return EffectiveAddress( index, scaleFactor, displacement ); + } + + /** + * Factory method which creates an effective address instance with the base register and index register. + * @param base The base register. + * @param index The index register. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Register &base, const Register &index ) { + return EffectiveAddress( base, index, 0 ); + } + + /** + * Factory method which creates an effective address instance with the base register, index register and scale factor. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + return EffectiveAddress( base, index, scaleFactor ); + } + + /** + * Factory method which creates an effective address instance with the base register, index register, scale factor and displacement. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return EffectiveAddress( base, index, scaleFactor, displacement ); + } + +public: + + /** + * Gets the constant base register associated with the effective address. + * + * @return The constant base register. + * @since 1.1.0 + */ + const Register& getBase() const { + return _base; + } + + /** + * Gets the base register associated with the effective address. + * + * @return The base register. + * @since 1.1.0 + */ + Register& getBase() { + return _base; + } + + /** + * Sets a new base register for the effective address. + * + * @param base The new base register to be set. + * @return Effective address itself. + * @since 1.1.0 + */ + EffectiveAddress& setBase( const Register &base ) { + _base = base; + return *this; + } + + /** + * Gets the constant displacement associated with the effective address. + * + * @return The constant displacement. + * @since 1.1.0 + */ + const Integer& getDisplacement() const { + return _displacement; + } + + /** + * Gets the displacement associated with the effective address. + * + * @return The displacement. + * @since 1.1.0 + */ + Integer& getDisplacement() { + return _displacement; + } + + /** + * Sets a new displacement value for the effective address. + * + * @param displacement The new displacement for effective address. + * @return The effective address itself. + * @since 1.1.0 + */ + EffectiveAddress& setDisplacement( const Integer &displacement ) { + _displacement = displacement; + return *this; + } + + /** + * Gets the constant index register associated with the effective address. + * + * @return The index register. + * @since 1.1.0 + */ + const Register& getIndex() const { + return _index; + } + + /** + * Gets the index register associated with the effective address. + * + * @return The index register. + * @since 1.1.0 + */ + Register& getIndex() { + return _index; + } + + /** + * Sets a new index register for the effective address. + * + * @param index The new index register for the effective address. + * @return The effective address itself. + * @since 1.1.0 + */ + EffectiveAddress& setIndex( const Register &index ) { + _index = index; + return *this; + } + + /** + * Gets a scale factor value associated with the effective address. + * + * @return The scale factor. + * @since 1.1.0 + */ + fcml_uint8_t getScaleFactor() const { + return _scaleFactor; + } + + /** + * Sets a new scale factor for the effective address. + * + * @param scaleFactor The new scale factor value. + * @return Effective address itself. + * @since 1.1.0 + */ + EffectiveAddress& setScaleFactor( fcml_uint8_t scaleFactor ) { + _scaleFactor = scaleFactor; + return *this; + } + +private: + /** Base register. */ + Register _base; + /** Index register. */ + Register _index; + /** Scale factor. */ + fcml_uint8_t _scaleFactor; + /** Displacement. */ + Integer _displacement; +}; + +/** Address operand. + * + * It's a counterpart to the fcml_st_address structure. + * @since 1.1.0 + */ +class Address { + +public: + + /** Addressing type, see fcml_en_address_form enumerator. + * @since 1.1.0 + */ + enum AddressForm { + /** Default value set if memory addressing hasn't been configured. */ + AF_UNDEFINED = FCML_AF_UNDEFINED, + /** Absolute offset (address). */ + AF_OFFSET = FCML_AF_OFFSET, + /** Effective address combined from address components like base register, index registers, factor, displacement etc... */ + AF_COMBINED = FCML_AF_COMBINED + }; + + /** + * Creates an empty address. + * @since 1.1.0 + */ + Address() : + _size_operator( FCML_DS_UNDEF ), + _address_form( AF_UNDEFINED ) { + } + + /** + * Creates an address instance with an offset and optional size operator set. + * + * @param offset Offset to be set for the address. + * @param sizeOperator The optional size operator, set to FCML_DS_UNDEF by default. + * @since 1.1.0 + */ + Address( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) : + _size_operator( sizeOperator ), + _address_form( AF_OFFSET ), + _offset( offset ) { + } + + /** + * Creates an address instance with an effective address and optional size operator set. + * + * @param effectiveAddress The effective address to be set for the address. + * @param sizeOperator The optional size operator, set to FCML_DS_UNDEF by default. + * @since 1.1.0 + */ + Address( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) : + _size_operator( sizeOperator ), + _address_form( AF_COMBINED ), + _effective_address( effectiveAddress ) { + } + + /** + * Creates an address instance with an effective address, segment selector and optional size operator set. + * + * @param effectiveAddress The effective address to be set for the address. + * @param segmentSelector The segment selector. + * @param sizeOperator The optional size operator, set to FCML_DS_UNDEF by default. + * @since 1.1.0 + */ + Address( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) : + _size_operator( sizeOperator ), + _address_form( AF_COMBINED ), + _segment_selector( segmentSelector ), + _effective_address( effectiveAddress ) { + } + + /** @since 1.1.0 */ + virtual ~Address() { + } + +public: + + /** + * Factory method which creates an effective address instance with the displacement only. + * @param displacement The displacement value. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address instance with the base register only. + * @param base The base register. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Register &base, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( base ), sizeOperator ); + } + + /** + * Factory method which creates an effective address instance with the base register and displacement. + * @param base The base register. + * @param displacement The displacement value. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Register &base, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( base, displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address instance with the index register, scale factor and displacement. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( index, scaleFactor, displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address instance with the base register and index register. + * @param base The base register. + * @param index The index register. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Register &base, const Register &index, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( base, index, 0 ), sizeOperator ); + } + + /** + * Factory method which creates an effective address instance with the base register, index register and scale factor. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Register &base, const Register &index, fcml_uint8_t scaleFactor, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( base, index, scaleFactor ), sizeOperator ); + } + + /** + * Factory method which creates an effective address instance with the base register, index register, scale factor and displacement. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( base, index, scaleFactor, displacement ), sizeOperator ); + } + + +public: + + /** + * Checks if two addresses are equal or not. + * @param address The address to be compared with the current one. + * @return True if they are equal. + * @since 1.1.0 + */ + bool operator==( const Address &address ) const { + if( &address == this ) { + return true; + } + return _size_operator == address._size_operator && + _address_form == address._address_form && + _segment_selector == address._segment_selector && + _effective_address == address._effective_address && + _offset == address._offset; + } + + /** + * Checks if two addresses are equal or not. + * @param address The address to be compared with the current one. + * @return True if they are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const Address &address ) const { + return !(address == *this ); + } + +public: + + /** + * Factor method which creates an instance of the address for an effective address, segment selector and optional size operator. + * + * @param effectiveAddress The effective address to be set for the address. + * @param segmentSelector The segment selector. + * @param sizeOperator The optional size operator, set to FCML_DS_UNDEF by default. + * @return The created address instance. + * @since 1.1.0 + */ + static Address effective( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return Address( effectiveAddress, segmentSelector, sizeOperator ); + } + + /** + * Factor method which creates an address instance with an effective address and optional size operator set. + * + * @param effectiveAddress The effective address to be set for the address. + * @param sizeOperator The optional size operator, set to FCML_DS_UNDEF by default. + * @return The created address instance. + * @since 1.1.0 + */ + static Address effective( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return Address( effectiveAddress, sizeOperator ); + } + + /** + * Factor method which creates an address instance with an offset and optional size operator set. + * + * @param offset The offset to be set for the address. + * @param sizeOperator The optional size operator, set to FCML_DS_UNDEF by default. + * @return The created address instance. + * @since 1.1.0 + */ + static Address offset( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return Address( offset, sizeOperator ); + } + +public: + + /** + * Returns true if address holds effective address. + * + * @return Returns true if address holds effective address. + * @since 1.1.0 + */ + bool isEffectiveAddress() const { + return _address_form == AF_COMBINED; + } + + /** + * Returns true if address holds an offset only. + * + * @return Returns true if address holds an offset only. + * @since 1.1.0 + */ + bool isOffset() const { + return _address_form == AF_OFFSET; + } + + /** + * Gets an address form. See fcml_en_address_form for more details. + * + * @return The address form. + * @since 1.1.0 + */ + AddressForm getAddressForm() const { + return _address_form; + } + + /** + * Sets a new address form for the effective address. + * + * @param addressForm The address form to be set for the effective address. + * + * @return Address itself. + * @since 1.1.0 + */ + Address& setAddressForm( AddressForm addressForm ) { + _address_form = addressForm; + return *this; + } + + /** + * Gets reference to the constant effective address associated with the address. + * + * @return The constant effective address. + * @since 1.1.0 + */ + const EffectiveAddress& getEffectiveAddress() const { + return _effective_address; + } + + /** + * Gets reference to the effective address associated with the address. + * + * @return The effective address. + * @since 1.1.0 + */ + EffectiveAddress& getEffectiveAddress() { + return _effective_address; + } + + /** + * Sets a new effective address for the address. + * + * @param effectiveAddress The new address to be set for the effective address. + * @return The address itself. + * @since 1.1.0 + */ + Address& setEffectiveAddress( const EffectiveAddress& effectiveAddress ) { + _effective_address = effectiveAddress; + return *this; + } + + /** + * Gets the constant offset associated with the address. + * + * @return The offset associated with the address. + * @since 1.1.0 + */ + const Integer& getOffset() const { + return _offset; + } + + /** + * Gets the offset associated with the address. + * + * @return The offset associated with the address. + * @since 1.1.0 + */ + Integer& getOffset() { + return _offset; + } + + /** + * Sets a new offset for the address. + * + * @param offset The enw offset to be set for the address. + * @return The address itself. + * @since 1.1.0 + */ + Address& setOffset( const Integer &offset ) { + this->_offset = offset; + return *this; + } + + /** + * Gets the constant segment selector associated with the address. + * + * @return The segment selector associated with the address. + * @since 1.1.0 + */ + const SegmentSelector& getSegmentSelector() const { + return _segment_selector; + } + + /** + * Gets the segment selector associated with the address. + * + * @return The segment selector associated with the address. + * @since 1.1.0 + */ + SegmentSelector& getSegmentSelector() { + return _segment_selector; + } + + /** + * Sets a new segment selector for the address. + * + * @param segmentSelector The new segment selector for the address. + * @return The address itself. + * @since 1.1.0 + */ + Address& setSegmentSelector( const SegmentSelector &segmentSelector ) { + _segment_selector = segmentSelector; + return *this; + } + + /** + * Gets the size operator associated with the address. + * + * @return The size operator. + * @since 1.1.0 + */ + fcml_usize getSizeOperator() const { + return _size_operator; + } + + /** + * Sets a new size operator for the address. + * + * @param sizeOperator The size operator. + * @since 1.1.0 + */ + Address& setSizeOperator( fcml_usize sizeOperator ) { + _size_operator = sizeOperator; + return *this; + } + +private: + + /** Size of data accessed in memory.*/ + fcml_usize _size_operator; + /** Memory addressing format: absolute offset/effective address. @see fcml_en_effective_address_form*/ + AddressForm _address_form; + /** Segment register.*/ + SegmentSelector _segment_selector; + /** Memory address for FCML_AF_COMBINED form.*/ + EffectiveAddress _effective_address; + /** Memory address for FCML_AF_OFFSET form.*/ + Integer _offset; + +}; + +/** Holds operand decorators. + * @since 1.2.0 + */ +class Decorators { +public: + + /** + * Rounding mode. + */ + enum EmbeededRoundingControl { + FCML_ERC_RNE = 0, + FCML_ERC_RD, + FCML_ERC_RU, + FCML_ERC_RZ + }; + + /** + * Creates an empty operand decorators container. + * @since 1.2.0 + */ + Decorators() : _z(FCML_FALSE), _operandMaskReg(Register::UNDEF()), + _sae(FCML_FALSE) { + } + + /** + * Sets a new AVX-512 {z} decorator. + * + * @param z {z} decorator. + * @return Decorators. + * @since 1.2.0 + */ + Decorators& setZ(fcml_bool z) { + _z = z; + return *this; + } + + /** + * Sets a new AVX-512 {bcast} decorator. + * + * @param bcast Decorator value. + * @return Decorators.. + * @since 1.2.0 + */ + Decorators& setBcast(const Nullable &bcast) { + _bcast = bcast; + return *this; + } + + /** + * Sets AVX-512 opmask register for {k} decorator. + * + * @param opmaskReg Opmask register. + * @since 1.2.0 + */ + Decorators& setOpmaskReg( const Register& opmaskReg ) { + _operandMaskReg = opmaskReg; + return *this; + } + + /** + * Sets AVX-512 {er} decorator. + * + * @param er {er} decorator. + * @since 1.2.0 + */ + Decorators& setEr(const Nullable &er) { + _er = er; + return *this; + } + + /** + * Sets AVX-512 {sae} decorator. + * + * @param sae {sae} decorator. + * @since 1.2.0 + */ + Decorators& setSae(const fcml_bool sae) { + _sae = sae; + return *this; + } + + /** + * Gets AVX-512 {z} operator. + * + * @return {z} operator. + * @since 1.2.0 + */ + fcml_bool isZ() const { + return _z; + } + + /** + * Gets AVX-512 {bcast} decorator. + * + * @return Value of {bcast} decorator. + * @since 1.2.0 + */ + const Nullable& getBcast() const { + return _bcast; + } + + /** + * Gets constant AVX-512 opmask register for {k} decorator. + * + * @return Opmask register. + * @since 1.2.0 + */ + const Register& getOpmaskReg() const { + return _operandMaskReg; + } + + /** + * Gets AVX-512 opmask register for {k} decorator. + * + * @return Opmask register. + * @since 1.2.0 + */ + Register& getOpmaskReg() { + return _operandMaskReg; + } + + /** + * Gets AVX-512 {er} decorator. + * + * @return Value of {er} decorator. + * @since 1.2.0 + */ + const Nullable& getEr() const { + return _er; + } + + /** + * Gets AVX-512 {sae} decorator. + * + * @return True if {sae} is set. + * @since 1.2.0 + */ + fcml_bool isSae() const { + return _sae; + } + +public: + + /** + * Checks if two decorators containers are equal or not. + * @param decorators Decorators. + * @return True if they are equal. + * @since 1.2.0 + */ + bool operator==(const Decorators &decorators) const { + if(&decorators == this) { + return true; + } + return _z == decorators._z && + _bcast == decorators._bcast && + _operandMaskReg == decorators._operandMaskReg && + _er == decorators._er && + _sae == decorators._sae; + } + + /** + * Checks if two decorators are equal or not. + * @param decorators Decorators. + * @return True if they are NOT equal. + * @since 1.2.0 + */ + bool operator!=(const Decorators &decorators) const { + return !(decorators == *this); + } + +private: + /** Broadcasting: 2, 4, 8, 16, 32, 64. */ + Nullable _bcast; + /** Zeroing masking. */ + fcml_bool _z; + /** The 64-bit k registers are: k0 through k7. */ + Register _operandMaskReg; + /** Embedded rounding control. */ + Nullable _er; + /** Indicates support for SAE (Suppress All Exceptions). */ + fcml_bool _sae; +}; + +/** Instruction operand. + * @since 1.1.0 + */ +class Operand { +public: + + /** See fcml_en_operand_type structure for more details. + * @since 1.1.0 + */ + enum OperandType { + /** Operand not used. */ + OT_NONE = FCML_OT_NONE, + /** Immediate integer value. */ + OT_IMMEDIATE = FCML_OT_IMMEDIATE, + /** Direct far pointer. */ + OT_FAR_POINTER = FCML_OT_FAR_POINTER, + /** Memory address. */ + OT_ADDRESS = FCML_OT_ADDRESS, + /** Processor register. */ + OT_REGISTER = FCML_OT_REGISTER, + /** Virtual operand */ + OT_VIRTUAL = FCML_OT_VIRTUAL + }; + + /** + * Creates an undefined operand. + * @since 1.1.0 + */ + Operand() : + _hints( FCML_OP_HINT_UNDEFIEND ), + _operandType( OT_NONE ) { + } + + /** + * Creates an immediate value operand for given integer. + * + * @param imm The immediate value as integer. + * @param hints Optional operand level hints. + * @since 1.1.0 + */ + Operand( const Integer &imm, fcml_hints hints = FCML_OP_HINT_UNDEFIEND ) : + _hints( hints ), + _operandType(OT_IMMEDIATE ), + _immediate( imm ) { + } + + /** + * Creates a far pointer operand for given far pointer. + * + * @param pointer The far pointer for the operand. + * @param hints Optional operand level hints. + * @since 1.1.0 + */ + Operand( const FarPointer &pointer, fcml_hints hints = FCML_OP_HINT_UNDEFIEND ) : + _hints( hints ), + _operandType( OT_FAR_POINTER ), + _farPointer( pointer ) { + } + + /** + * Creates an address operand for given address. + * + * @param address The address for the created operand. + * @param hints Optional operand level hints. + * @since 1.1.0 + */ + Operand( const Address &address, fcml_hints hints = FCML_OP_HINT_UNDEFIEND ) : + _hints( hints ), + _operandType( OT_ADDRESS ), + _address( address ) { + } + + /** + * Creates a new register operand for given register. + * + * @param reg The register for the new operand being created. + * @param hints Optional operand level hints. + * @since 1.1.0 + */ + Operand( const Register ®, fcml_hints hints = FCML_OP_HINT_UNDEFIEND ) : + _hints( hints ), + _operandType( OT_REGISTER ), + _register( reg ) { + } + +public: + + /** + * Checks if two operands are equal or not. + * + * @param op The operand to be compared with the current one. + * @return True if the operands are equal. + * @since 1.1.0 + */ + bool operator==( const Operand &op ) const { + if( &op == this ) { + return true; + } + bool equal = false; + switch( _operandType ) { + case OT_ADDRESS: + equal = _address == op._address; + break; + case OT_FAR_POINTER: + equal = _farPointer == op._farPointer; + break; + case OT_IMMEDIATE: + equal = _immediate == op._immediate; + break; + case OT_REGISTER: + equal = _register == op._register; + break; + case OT_VIRTUAL: + equal = true; + break; + case OT_NONE: + equal = true; + break; + } + return equal && op._hints == _hints && op._decorators == _decorators; + } + + /** + * Checks if two operands are equal or not. + * + * @param op The operand to be compared with the current one. + * @return True if the operands are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const Operand &op ) const { + return !(op == *this); + } + +public: + + /** + * Converts operand to the undefined one. + * @since 1.1.0 + */ + void undef() { + _operandType = OT_NONE; + } + + /** + * Sets given immediate value for the operand and makes it to be an immediate operand. + * + * @param imm The immediate value. + * @since 1.1.0 + */ + void imm( const Integer &imm ) { + _operandType = OT_IMMEDIATE; + _immediate = imm; + } + + /** + * Converts operand to the far pointer and sets the segment selector and offset for it. + * + * @param seg The segment selector. + * @param addr Offset. + * @since 1.1.0 + */ + void far_ptr( fcml_uint16_t seg, fcml_int16_t addr ) { + _operandType = OT_FAR_POINTER; + _farPointer = FarPointer( seg, addr ); + } + + /** + * Prepares far pointer operand for given components. + * + * @param seg The segment selector. + * @param addr The offset. + * @since 1.1.0 + */ + void far_ptr( fcml_uint16_t seg, fcml_int32_t addr ) { + _operandType = OT_FAR_POINTER; + _farPointer = FarPointer( seg, addr ); + } + + /** + * Prepares far pointer operand for given far pointer. + * + * @param pointer Far pointer to be set for the operand. + * @since 1.1.0 + */ + void far_ptr( const FarPointer &pointer ) { + _operandType = OT_FAR_POINTER; + _farPointer = pointer; + } + + /** + * Prepares address operand for given address. + * + * @param address The address to be set for the operand. + * @since 1.1.0 + */ + void addr( const Address &address ) { + _operandType = OT_ADDRESS; + _address = address; + } + + /** + * Prepares address operand for given offset. + * + * @param offset The offset to be set for the operand. + * @param sizeOperator The size operator to be set for the address. + * @since 1.1.0 + */ + void off( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + _operandType = OT_ADDRESS; + _address = Address( offset, sizeOperator ); + } + + /** + * Prepares an address operand for given effective address and optional size operator. + * + * @param effectiveAddress The effective address. + * @param sizeOperator The size operator. + * @since 1.1.0 + */ + void addr( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + _operandType = OT_ADDRESS; + _address = Address( effectiveAddress, sizeOperator ); + } + + /** + * Prepares address operator for given parameters. + * + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @param sizeOperator The size operator. + * @since 1.1.0 + */ + void addr( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + _operandType = OT_ADDRESS; + _address = Address( effectiveAddress, segmentSelector, sizeOperator ); + } + + /** + * Prepares operator for the given register. + * + * @param reg The register for the operator. + * @since 1.1.0 + */ + void reg( const Register ® ) { + _operandType = OT_REGISTER; + _register = reg; + } + + /** + * Prepares an register operator for given register compounds. + * + * @param reg A register number. + * @param size A register size. + * @param type A register type. + * @param x64_exp An optional marker for the SPL, BPL, SIL etc. registers. See manual for more information. + * @since 1.1.0 + */ + void reg( fcml_uint8_t reg, fcml_usize size, Register::RegisterType type = Register::REG_GPR, fcml_bool x64_exp = FCML_FALSE ) { + _operandType = OT_REGISTER; + _register = Register( reg, size, type, x64_exp ); + } + +public: + + /** + * Returns true if operand is an immediate value operand. + * + * @return True if operand is an immediate value operand. + * @since 1.1.0 + */ + bool isImm() const { + return _operandType == OT_IMMEDIATE; + } + + /** + * Returns true if operand is a register operand. + * + * @return True if operand is a register operand. + * @since 1.1.0 + */ + bool isReg() const { + return _operandType == OT_REGISTER; + } + + /** + * Returns true if operand is an address operand. + * + * @return True if operand is an address operand. + * @since 1.1.0 + */ + bool isAddr() const { + return _operandType == OT_ADDRESS; + } + + /** + * Returns true if operand is a far pointer operand. + * + * @return True if operand is a far pointer operand. + * @since 1.1.0 + */ + bool isFar() const { + return _operandType == OT_FAR_POINTER; + } + + /** + * Gets reference to the constant address associated with the operand. + * + * @return The reference to the address. + * @since 1.1.0 + */ + const Address& getAddress() const { + return _address; + } + + /** + * Gets reference to the address associated with the operand. + * + * @return The reference to the address. + * @since 1.1.0 + */ + Address& getAddress() { + return _address; + } + + /** + * Sets a new address for the operand. + * + * @param address The new address. + * @return The operand itself. + * @since 1.1.0 + */ + Operand& setAddress( const Address &address ) { + _address = address; + return *this; + } + + /** + * Gets a reference to the constant far pointer instance associated with the address. + * + * @return The far pointer instance associated with the address. + * @since 1.1.0 + */ + const FarPointer& getFarPointer() const { + return _farPointer; + } + + /** + * Gets a reference to the far pointer instance associated with the address. + * + * @return The far pointer instance associated with the address. + * @since 1.1.0 + */ + FarPointer& getFarPointer() { + return _farPointer; + } + + /** + * Sets a new far pointer for the operand. + * + * @param farPointer The new far pointer instance. + * @return The operand itself. + * @since 1.1.0 + */ + Operand& setFarPointer( const FarPointer &farPointer ) { + _farPointer = farPointer; + return *this; + } + + /** + * Gets a reference to the constant immediate value associated with the operand. + * + * @return The immediate value. + * @since 1.1.0 + */ + const Integer& getImmediate() const { + return _immediate; + } + + /** + * Gets a reference to the immediate value associated with the operand. + * + * @return The immediate value. + * @since 1.1.0 + */ + Integer& getImmediate() { + return _immediate; + } + + /** + * Sets a new immediate value for the address. + * + * @param immediate The new immediate value. + * @return The operand itself. + * @since 1.1.0 + */ + Operand& setImmediate( const Integer &immediate ) { + _immediate = immediate; + return *this; + } + + /** + * Gets operand type. + * + * @return The operand type. + * @since 1.1.0 + */ + OperandType getOperandType() const { + return _operandType; + } + + /** + * Sets a new operand type. + * + * @param operandType The new operand type. + * @return The operand itself. + * @since 1.1.0 + */ + Operand& setOperandType( OperandType operandType ) { + _operandType = operandType; + return *this; + } + + /** + * Returns a reference to the constant register associated with the operand. + * + * @return The reference to the register associated with the operand. + * @since 1.1.0 + */ + const Register& getRegister() const { + return _register; + } + + /** + * Returns a reference to the register associated with the operand. + * + * @return The reference to the register associated with the operand. + * @since 1.1.0 + */ + Register& getRegister() { + return _register; + } + + /** + * Sets a new register for the operand. + * + * @param reg The new register. + * @return The operand itself. + * @since 1.1.0 + */ + Operand& setRegister( const Register ® ) { + this->_register = reg; + return *this; + } + + /** + * Gets hits associated with the operand. + * + * @return The hits associated with the operand. + * @since 1.1.0 + */ + fcml_hints getHints() const { + return _hints; + } + + /** + * Sets new operand level hits for the operand. + * + * @param hints The new hits to be set. + * @return The operand itself. + * @since 1.1.0 + */ + Operand& setHints( fcml_hints hints ) { + _hints = hints; + return *this; + } + + /** + * Gets constant decorators associated with the operand. + * + * @return The decorators associated with the operand. + * @since 1.2.0 + */ + const Decorators& getDecorators() const { + return _decorators; + } + + /** + * Gets decorators associated with the operand. + * + * @return The decorators associated with the operand. + * @since 1.2.0 + */ + Decorators& getDecorators() { + return _decorators; + } + + /** + * Sets new operand decorators for the operand. + * + * @param decorators The new decorators to be set. + * @return The operand itself. + * @since 1.2.0 + */ + Operand& setDecorators(const Decorators& decorators) { + _decorators = decorators; + return *this; + } + + // Hints + + /** + * Returns information if the operand is multimedia one or not. For more details about the + * multimedia operand head over to the manual pages. + * + * @return true if it's a multimedia operand. + * @since 1.1.0 + */ + bool isMultimedia() const { + return _hints & FCML_OP_HINT_MULTIMEDIA_INSTRUCTION; + } + + /** + * Returns true if it's an displacement relative address. + * + * @return True if it's an displacement relative address. + * @since 1.1.0 + */ + bool isDisRelativeAddress() const { + return ( _hints & FCML_OP_HINT_DISPLACEMENT_RELATIVE_ADDRESS ) ? true : false; + } + + /** + * Returns true if it's pseudo opcode operand. More information + * about pseudo opcodes in the manual. + * + * @return True if it's pseudo opcode operand. + * @since 1.1.0 + */ + bool isPseudoOpcode() const { + return ( _hints & FCML_OP_HINT_PSEUDO_OPCODE ) ? true : false; + } + + /** + * Returns true if it's an absolute offset being set in the operand. + * + * @return True in case of absolute addressing being used. + * @since 1.1.0 + */ + bool isAbsoluteAddressing() const { + return ( _hints & FCML_OP_HINT_ABSOLUTE_ADDRESSING ) ? true : false; + } + + /** + * Returns true is relative addressing is used. + * + * @return True in case of relative addressing. + * @since 1.1.0 + */ + bool isRelativeAddressing() const { + return ( _hints & FCML_OP_HINT_RELATIVE_ADDRESSING ) ? true : false; + } + + /** + * Returns true if the SIB byte is used. + * + * @return True if the SIB byte is used. + * @since 1.1.0 + */ + bool isSIBEncoding() const { + return ( _hints & FCML_OP_HINT_SIB_ENCODING ) ? true : false; + } + +public: + + /** + * A casting operator. + * @since 1.1.0 + */ + operator const Integer&() const { + return _immediate; + } + + /** + * A casting operator. + * @since 1.1.0 + */ + operator const FarPointer&() const { + return _farPointer; + } + + /** + * A casting operator. + * @since 1.1.0 + */ + operator const Address&() const { + return _address; + } + + /** + * A casting operator. + * @since 1.1.0 + */ + operator const Register&() const { + return _register; + } + +private: + + /** Operand hints */ + fcml_hints _hints; + /** Operand type */ + OperandType _operandType; + /** Describes immediate operand */ + Integer _immediate; + /** Describes far pointer. */ + FarPointer _farPointer; + /** Describes address. */ + Address _address; + /** Describes register. */ + Register _register; + /** Operand decorators. + * since 1.2.0 + */ + Decorators _decorators; + +}; + +/** Operand builder. + * A builder that exposes various factory methods that can be used to create + * several types of the instruction operands. These methods are very simple + * so no API documentation has been provided for now. Just take a look at + * the source code. + * + * @since 1.1.0 + */ +class OB { +public: + + /** + * Factory method which builds an empty operand. + * @return The empty operand. + * @since 1.1.0 + */ + static Operand undef() { + return Operand(); + } + + /** + * Factory method which builds an immediate operand. + * @return The immediate operand. + * @since 1.1.0 + */ + static Operand imm( const Integer &imm ) { + return Operand( imm ); + } + + /** + * Factory method which builds a far pointer operand. + * @param seg A segment selector. + * @param addr An 16-bit offset value. + * @return The far pointer operand. + * @since 1.1.0 + */ + static Operand far_ptr( fcml_uint16_t seg, fcml_int16_t addr ) { + return Operand( FarPointer( seg, addr ) ); + } + + /** + * Factory method which builds a far pointer operand. + * @param seg A segment selector. + * @param addr An 32-bit offset value. + * @return The far pointer operand. + * @since 1.1.0 + */ + static Operand far_ptr( fcml_uint16_t seg, fcml_int32_t addr ) { + return Operand( FarPointer( seg, addr ) ); + } + + /** + * Factory method which builds a far pointer operand. + * @param pointer A far pointer instance. + * @return The far pointer operand. + * @since 1.1.0 + */ + static Operand far_ptr( const FarPointer &pointer ) { + return Operand( pointer ); + } + + /** + * Factory method which builds an address operand. + * @param address An address instance. + * @return The address operand. + * @since 1.1.0 + */ + static Operand addr( const Address &address ) { + return Operand( address ); + } + + /** + * Factory method which builds an address operand. + * @param offset An offset instance. + * @param sizeOperator An optional size operator. + * @return The address operand. + * @since 1.1.0 + */ + static Operand off( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return Operand( Address( offset, sizeOperator ) ); + } + + /** + * Factory method which builds an offset based address operand with byte size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + static Operand offb( const Integer &offset ) { + return Operand( Address( offset, FCML_DS_8 ) ); + } + + /** + * Factory method which builds an offset based address operand with word size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + static Operand offw( const Integer &offset ) { + return Operand( Address( offset, FCML_DS_16 ) ); + } + + /** + * Factory method which builds an offset based address operand with double word size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + static Operand offd( const Integer &offset ) { + return Operand( Address( offset, FCML_DS_32 ) ); + } + + /** + * Factory method which builds an offset based address operand with quadro word size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + static Operand offq( const Integer &offset ) { + return Operand( Address( offset, FCML_DS_64 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and optional size operator. + * @param effectiveAddress The effective address. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addr( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return Operand( Address( effectiveAddress, sizeOperator ) ); + } + + /** + * Factory method which creates address type operand for given effective address and byte size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrb( const EffectiveAddress &effectiveAddress ) { + return Operand( Address( effectiveAddress, FCML_DS_8 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and word size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrw( const EffectiveAddress &effectiveAddress ) { + return Operand( Address( effectiveAddress, FCML_DS_16 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and double word size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrd( const EffectiveAddress &effectiveAddress ) { + return Operand( Address( effectiveAddress, FCML_DS_32 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and quadro word size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrq( const EffectiveAddress &effectiveAddress ) { + return Operand( Address( effectiveAddress, FCML_DS_64 ) ); + } + + /** + * Factory method which creates address type operand for given segment selector, effective address and optional size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addr( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return Operand( Address( effectiveAddress, segmentSelector, sizeOperator ) ); + } + + /** + * Factory method which creates address type operand for given effective address and byte size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrb( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + return Operand( Address( effectiveAddress, segmentSelector, FCML_DS_8 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and word size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrw( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + return Operand( Address( effectiveAddress, segmentSelector, FCML_DS_16 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and double word size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrd( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + return Operand( Address( effectiveAddress, segmentSelector, FCML_DS_32 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and quadro word size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrq( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + return Operand( Address( effectiveAddress, segmentSelector, FCML_DS_64 ) ); + } + + /** + * Factory method which creates an register based operator for given register. + * @param reg The register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand reg( const Register ® ) { + return Operand( reg ); + } + + /** + * Factory method which creates an register based operator for given parameters. + * @param reg The FCML register number. + * @param size The register size. + * @param type The register type. + * @param x64_exp See manual for more information. + * @return The created operator. + * @since 1.1.0 + */ + static Operand reg( fcml_uint8_t reg, fcml_usize size, Register::RegisterType type = Register::REG_GPR, fcml_bool x64_exp = FCML_FALSE ) { + return Operand( Register( reg, size, type, x64_exp ) ); + } + + /** + * Factory method which creates an effective address based operator for a displacement and optional size operator. + * @param displacement The displacement value. + * @param sizeOperator The size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for a displacement and byte size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Integer &displacement ) { + return addr( EffectiveAddress( displacement ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for a displacement and word size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Integer &displacement ) { + return addr( EffectiveAddress( displacement ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for a displacement and double word size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Integer &displacement ) { + return addr( EffectiveAddress( displacement ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for a displacement and quadro byte size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Integer &displacement ) { + return addr( EffectiveAddress( displacement ), FCML_DS_64 ); + } + + /** + * Factory method which creates an effective address based operator for a base register and optional size operator. + * @param base The base register. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Register &base, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( base ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for a base register and byte size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Register &base ) { + return addr( EffectiveAddress( base ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for a base register and word size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Register &base ) { + return addr( EffectiveAddress( base ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for a base register and double word size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Register &base ) { + return addr( EffectiveAddress( base ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for a base register and quadro word size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Register &base ) { + return addr( EffectiveAddress( base ), FCML_DS_64 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, displacement and optional size operator. + * @param base The base register. + * @param displacement The displacement value. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Register &base, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( base, displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for a base register, displacement and byte size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Register &base, const Integer &displacement ) { + return addr( EffectiveAddress( base, displacement ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, displacement and word size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Register &base, const Integer &displacement ) { + return addr( EffectiveAddress( base, displacement ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, displacement and double word size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Register &base, const Integer &displacement ) { + return addr( EffectiveAddress( base, displacement ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, displacement and quadro word size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Register &base, const Integer &displacement ) { + return addr( EffectiveAddress( base, displacement ), FCML_DS_64 ); + } + + /** + * Factory method which creates an effective address based operator for an index register, scaleFactor, displacement and optional size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( index, scaleFactor, displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for an index register, scaleFactor, displacement and byte size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for an index register, scaleFactor, displacement and word size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for an index register, scaleFactor, displacement and double word size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for an index register, scaleFactor, displacement and quadro word size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_64 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register and optional size operator. + * @param base The base register. + * @param index The index register. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Register &base, const Register &index, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( base, index ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register and byte size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Register &base, const Register &index ) { + return addr( EffectiveAddress( base, index ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register and word size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Register &base, const Register &index ) { + return addr( EffectiveAddress( base, index ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register and double word size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Register &base, const Register &index ) { + return addr( EffectiveAddress( base, index ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register and quadro word size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Register &base, const Register &index ) { + return addr( EffectiveAddress( base, index ), FCML_DS_64 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and optional size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Register &base, const Register &index, fcml_uint8_t scaleFactor, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( base, index, scaleFactor ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and byte size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + return addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + return addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and double word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + return addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and quadro word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + return addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_64 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and optional size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( base, index, scaleFactor, displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and byte size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and double word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and quardo word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_64 ); + } + +}; + +/** Instruction condition. + * + * It's counterpart to the fcml_st_condition structure. + * + * @since 1.1.0 + */ +class Condition { + +public: + + /** See fcml_st_condition for more details. + * @since 1.1.0 + */ + enum ConditionType { + /** 0 Overflow*/ + CONDITION_O = FCML_CONDITION_O, + /** 1 Below*/ + CONDITION_B = FCML_CONDITION_B, + /** 2 Equal*/ + CONDITION_E = FCML_CONDITION_E, + /** 3 Below or equal*/ + CONDITION_BE = FCML_CONDITION_BE, + /** 4 Sign*/ + CONDITION_S = FCML_CONDITION_S, + /** 5 Parity*/ + CONDITION_P = FCML_CONDITION_P, + /** 6 Less than*/ + CONDITION_L = FCML_CONDITION_L, + /** 7 Less than or equal to*/ + CONDITION_LE = FCML_CONDITION_LE + }; + + /** + * Creates an empty condition. + * @since 1.1.0 + */ + Condition() : + _conditionType(CONDITION_O), + _isNegation(false) { + } + + /** + * Creates a condition for given parameters. + * + * @param type A condition type. + * @param negation True in order to negate condition. + * @since 1.1.0 + */ + Condition( ConditionType type, bool negation = false ) : + _conditionType( type ), + _isNegation( negation ) { + } + +public: + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isO() const { + return check( CONDITION_O ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition O() { + const Condition condition( CONDITION_O ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNO() const { + return check( CONDITION_O, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NO() { + const Condition condition( CONDITION_O ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isB() const { + return check( CONDITION_B ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition B() { + const Condition condition( CONDITION_B ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNB() const { + return check( CONDITION_B, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NB() { + const Condition condition( CONDITION_B, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNAE() const { + return check( CONDITION_B ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NAE() { + const Condition condition( CONDITION_B ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isAE() const { + return check( CONDITION_B, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition AE() { + const Condition condition( CONDITION_B, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isC() const { + return check( CONDITION_B ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition C() { + const Condition condition( CONDITION_B ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNC() const { + return check( CONDITION_B, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NC() { + const Condition condition( CONDITION_B, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isE() const { + return check( CONDITION_E ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition E() { + const Condition condition( CONDITION_E ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isZ() const { + return check( CONDITION_E ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition Z() { + const Condition condition( CONDITION_E ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNE() const { + return check( CONDITION_E, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NE() { + const Condition condition( CONDITION_E, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNZ() const { + return check( CONDITION_E, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NZ() { + const Condition condition( CONDITION_E, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isBE() const { + return check( CONDITION_BE ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition BE() { + const Condition condition( CONDITION_BE ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNA() const { + return check( CONDITION_BE ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NA() { + const Condition condition( CONDITION_BE ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNBE() const { + return check( CONDITION_BE, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NBE() { + const Condition condition( CONDITION_BE, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isA() const { + return check( CONDITION_BE, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition A() { + const Condition condition( CONDITION_BE, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isS() const { + return check( CONDITION_S ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition S() { + const Condition condition( CONDITION_S ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNS() const { + return check( CONDITION_S, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NS() { + const Condition condition( CONDITION_S, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isP() const { + return check( CONDITION_P ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition P() { + const Condition condition( CONDITION_P ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isPE() const { + return check( CONDITION_P ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition PE() { + const Condition condition( CONDITION_P ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNP() const { + return check( CONDITION_P, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NP() { + const Condition condition( CONDITION_P, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isPO() const { + return check( CONDITION_P, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition PO() { + const Condition condition( CONDITION_P, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isL() const { + return check( CONDITION_L ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition L() { + const Condition condition( CONDITION_L ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNGE() const { + return check( CONDITION_L ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NGE() { + const Condition condition( CONDITION_L ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNL() const { + return check( CONDITION_L, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NL() { + const Condition condition( CONDITION_L, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isGE() const { + return check( CONDITION_L, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition GE() { + const Condition condition( CONDITION_L, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isLE() const { + return check( CONDITION_LE ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition LE() { + const Condition condition( CONDITION_LE ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNG() const { + return check( CONDITION_LE ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NG() { + const Condition condition( CONDITION_LE ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNLE() const { + return check( CONDITION_LE, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NLE() { + const Condition condition( CONDITION_LE, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isG() const { + return check( CONDITION_LE, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition G() { + const Condition condition( CONDITION_LE, true ); + return condition; + } + +public: + + /** + * Checks if two condition are equal. + * + * @param cond The condition to be compared to the current one. + * @return True if they are equal. + * @since 1.1.0 + */ + bool operator==( const Condition &cond ) const { + return cond._conditionType == _conditionType && cond._isNegation == _isNegation; + } + + /** + * Checks if two condition are equal. + * + * @param cond The condition to be compared to the current one. + * @return True if they are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const Condition &cond ) const { + return !(*this == cond); + } + +public: + + /** + * Gets a type of the condition. + * + * @return The type of the condition. + * @since 1.1.0 + */ + ConditionType getConditionType() const { + return _conditionType; + } + + /** + * Sets condition type. + * + * @param conditionType The condition type to be set. + * @since 1.1.0 + */ + Condition& setConditionType( ConditionType conditionType ) { + _conditionType = conditionType; + return *this; + } + + /** + * Returns true if condition is negated. + * + * @return True if condition is negated. + * @since 1.1.0 + */ + bool isNegation() const { + return _isNegation; + } + + /** + * Sets negation flag for the condition. + * + * @param isNegation The negation flag. + * @since 1.1.0 + */ + Condition& setNegation( bool isNegation ) { + _isNegation = isNegation; + return *this; + } + +private: + + /** + * Checks if the condition is of given type and negation flag. + * + * @param type The condition type. + * @param negation The negation flag. + * @return True if the condition has the same type and negation set. + * @since 1.1.0 + */ + bool check( ConditionType type, bool negation = false ) const { + return _conditionType == type && _isNegation == negation; + } + +private: + + /* Condition type.*/ + ConditionType _conditionType; + /* True if condition should be negated.*/ + bool _isNegation; + +}; + +/** Describes an instruction. + * + * It's counterpart to the fcml_st_instruction structure. + * @since 1.1.0 + */ +class Instruction { +public: + + /** + * Creates an empty instruction. + * @since 1.1.0 + */ + Instruction() : + _prefixes(0), + _hints(FCML_HINT_NO_HINTS), + _isConditional(false), + _operandsCount(0) { + } + + /** + * Creates an empty instruction for given mnemonic. + * + * @param mnemonic The mnemonic for the newly created instruction. + * @since 1.1.0 + */ + Instruction( const fcml_cstring &mnemonic ) : + _prefixes(0), + _hints(FCML_HINT_NO_HINTS), + _mnemonic(mnemonic), + _isConditional(false), + _operandsCount(0) { + } + +public: + + /** + * Adds a new operand to the instruction. + * + * @param operand The operand to be added to the instruction. + * @throw IllegalStateException No more operands allowed. + * @since 1.1.0 + */ + void add( const Operand &operand ) { + if( _operandsCount == FCML_OPERANDS_COUNT ) { + throw IllegalStateException( FCML_TEXT( "No more operands allowed." ) ); + } + _operands[_operandsCount++] = operand; + } + + /** + * Sets a new oeprand for the instruction at given index. + * + * @param operand The operand to be set. + * @param index The index operand should be set at. + * @throw IllegalStateException Operand's number exceeds maximal number of operands allowed. + * @since 1.1.0 + */ + void setOperand( const Operand &operand, fcml_int index ) { + if( index >= FCML_OPERANDS_COUNT ) { + throw IllegalStateException( FCML_TEXT( "Operand's number exceeds maximal number of operands allowed." ) ); + } + _operands[index] = operand; + } + + /** + * Gets reference to the constant operand at given index. + * + * @param index The operand index. + * @return The operand available at given index. + * @since 1.1.0 + */ + const Operand & operator[]( fcml_int index ) const { + checkArrayAccess(index); + return _operands[index]; + } + + /** + * Gets reference to the operand at given index. + * + * @param index The operand index. + * @return The operand available at given index. + * @since 1.1.0 + */ + Operand & operator[]( fcml_int index ) { + checkArrayAccess(index); + return _operands[index]; + } + + /** + * Cleans the instruction by removing all operands from it. + * @since 1.1.0 + */ + void clean() { + for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) { + // Clean the operand. + _operands[i] = Operand(); + } + _operandsCount = 0; + } + +public: + + /** + * Gets a pointer to the constant condition associated with the instruction. + * + * @return A reference to the condition. + * @since 1.1.0 + */ + const Condition& getCondition() const { + return _condition; + } + + /** + * Gets a pointer to the condition associated with the instruction. + * + * @return A reference to the condition. + * @since 1.1.0 + */ + Condition& getCondition() { + return _condition; + } + + /** + * Sets a new condition for the instruction. + * + * @param condition The condition to be set for the instruction. + * @return The instruction itself. + * @since 1.1.0 + */ + Instruction& setCondition( const Condition &condition ) { + _condition = condition; + return *this; + } + + /** + * Gets instruction level hits associated with the instruction. + * + * @return The instruction level hits associated with the instruction. + * @since 1.1.0 + */ + fcml_hints getHints() const { + return _hints; + } + + /** + * Sets new instruction hints. + * + * @param hints The hints to be set. + * @return The instruction itself. + * @since 1.1.0 + */ + Instruction& setHints( fcml_hints hints ) { + _hints = hints; + return *this; + } + + /** + * Gets true if it's a conditional instruction. + * + * @return True in case of the conditional instruction. + * @since 1.1.0 + */ + bool isConditional() const { + return _isConditional; + } + + /** + * Sets conditional flag for the instruction. + * + * @param isConditional Set to true in order to mark instruction as conditional one. + * @return The instruction itself. + * @since 1.1.0 + */ + Instruction& setConditional( bool isConditional ) { + _isConditional = isConditional; + return *this; + } + + /** + * Gets the mnemonic associated with the instruction. + * + * @return The mnemonic associated with the instruction. + * @since 1.1.0 + */ + const fcml_cstring& getMnemonic() const { + return _mnemonic; + } + + /** + * Sets a new mnemonic for the instruction. + * + * @param mnemonic The new mnemonic. + * @return The instruction itself. + * @since 1.1.0 + */ + Instruction& setMnemonic( const fcml_cstring &mnemonic ) { + _mnemonic = mnemonic; + return *this; + } + + /** + * Gets number of operands associated with the instruction. + * + * @return The number of operands in the instruction. + * @since 1.1.0 + */ + fcml_int getOperandsCount() const { + return _operandsCount; + } + + /** + * Sets number of operands available in the instruction. + * + * @param operandsCount Number of operands. + * @return The number of instructions. + * @since 1.1.0 + */ + Instruction& setOperandsCount( fcml_int operandsCount ) { + _operandsCount = operandsCount; + return *this; + } + + /** + * Gets prefixes associated with the instruction. + * + * @return The prefixes. + * @since 1.1.0 + */ + fcml_prefixes getPrefixes() const { + return _prefixes; + } + + /** + * Sets a new set of prefixes for the instruction. + * + * @param prefixes The set of prefixes to be set for the instruction. + * @return The instruction itself. + * @since 1.1.0 + */ + Instruction& setPrefixes( fcml_prefixes prefixes ) { + _prefixes = prefixes; + return *this; + } + +public: + + // Helper methods to identify prefixes and hints. + + /** + * Returns true if lock prefix is set. + * @return True if lock prefix is set. + * @since 1.1.0 + */ + bool isLock() const { + return ( _prefixes & FCML_PREFIX_LOCK ) ? true : false; + } + + /** + * Returns true if repne prefix is set. + * @return True if repne prefix is set. + * @since 1.1.0 + */ + bool isRepne() const { + return ( _prefixes & FCML_PREFIX_REPNE ) ? true : false; + } + + /** + * Returns true if lock repnz is set. + * @return True if lock repnz is set. + * @since 1.1.0 + */ + bool isRepnz() const { + return ( _prefixes & FCML_PREFIX_REPNZ ) ? true : false; + } + + /** + * Returns true if rep prefix is set. + * @return True if rep prefix is set. + * @since 1.1.0 + */ + bool isRep() const { + return ( _prefixes & FCML_PREFIX_REP ) ? true : false; + } + + /** + * Returns true if repe prefix is set. + * @return True if repe prefix is set. + * @since 1.1.0 + */ + bool isRepe() const { + return ( _prefixes & FCML_PREFIX_REPE ) ? true : false; + } + + /** + * Returns true if repz prefix is set. + * @return True if repz prefix is set. + * @since 1.1.0 + */ + bool isRepz() const { + return ( _prefixes & FCML_PREFIX_REPZ ) ? true : false; + } + + /** + * Returns true if xacquire prefix is set. + * @return True if xacquire prefix is set. + * @since 1.1.0 + */ + bool isXAcquire() const { + return ( _prefixes & FCML_PREFIX_XACQUIRE ) ? true : false; + } + + /** + * Returns true if xrelease prefix is set. + * @return True if xrelease prefix is set. + * @since 1.1.0 + */ + bool isXRelease() const { + return ( _prefixes & FCML_PREFIX_XRELEASE ) ? true : false; + } + + /** + * Returns true if branch_hint prefix is set. + * @return True if branch_hint prefix is set. + * @since 1.1.0 + */ + bool isBranchHint() const { + return ( _prefixes & FCML_PREFIX_BRANCH_HINT ) ? true : false; + } + + /** + * Returns true if no_branch_hint prefix is set. + * @return True if no_branch_hint prefix is set. + * @since 1.1.0 + */ + bool isNoBranchHint() const { + return ( _prefixes & FCML_PREFIX_NOBRANCH_HINT ) ? true : false; + } + + /** + * Returns true if far pointer hint is set. + * @return True if far pointer hint is set. + * @since 1.1.0 + */ + bool isFarPointer() const { + return ( _hints & FCML_HINT_FAR_POINTER ) ? true : false; + } + + /** + * Returns true if near pointer hint is set. + * @return True if near pointer hint is set. + * @since 1.1.0 + */ + bool isNearPointer() const { + return ( _hints & FCML_HINT_NEAR_POINTER ) ? true : false; + } + + /** + * Returns true if long form pointer hint is set. See manual for more information about this hint. + * @return True if long form pointer hint is set. + * @since 1.1.0 + */ + bool isLongFormPointer() const { + return ( _hints & FCML_HINT_LONG_FORM_POINTER ) ? true : false; + } + + /** + * Returns true if indirect pointer hint is set. + * @return True if indirect pointer hint is set. + * @since 1.1.0 + */ + bool isIndirectPointer() const { + return ( _hints & FCML_HINT_INDIRECT_POINTER ) ? true : false; + } + + /** + * Returns true if direct pointer hint is set. + * @return True if direct pointer hint is set. + * @since 1.1.0 + */ + bool isDirectPointer() const { + return ( _hints & FCML_HINT_DIRECT_POINTER ) ? true : false; + } + +private: + + /** + * Throws if given operand index is wrong. + * @throw BadArgumentException Index exceeds the allowed number of operands. + * @remarks An internal API, not intended to be used outside. + */ + void checkArrayAccess( fcml_int index) const { + if( index < 0 || index >= FCML_OPERANDS_COUNT ) { + throw BadArgumentException( FCML_TEXT( "Index exceeds the allowed number of operands." ) ); + } + } + +private: + + /** Describes explicit instruction prefixes. @ref PREFIX_GROUP "List of explicit prefixes." */ + fcml_prefixes _prefixes; + /** Holds instruction level hints. */ + fcml_hints _hints; + /** Dialect-dependent instruction mnemonic. @see fcml_en_instruction_hints */ + fcml_cstring _mnemonic; + /** True for conditional instructions. */ + bool _isConditional; + /** Describes condition used by assembled/disassembled conditional instruction. */ + Condition _condition; + /** Fixed size array of instruction operands. */ + Operand _operands[FCML_OPERANDS_COUNT]; + /** Number of operands defined for instruction. */ + fcml_int _operandsCount; + +}; + +/** An instruction builder. + * + * A classic builder that can be used to prepare instruction in a + * more convenient way than doing it manually using setters. + * + * @since 1.1.0 + */ +class IB { + +public: + + /** Creates builder for the given mnemonic. + * + * @param mnemonic Mnemonic for the instruction being created. + * @since 1.1.0 + */ + IB( const fcml_cstring &mnemonic ) : + _hints(FCML_HINT_NO_HINTS), + _prefixes(0), + _mnemonic(mnemonic), + _operandsCount(0) { + } + + /** + * Creates builder for the given mnemonic and prefixes. + * + * @param prefixes The prefixes for the new instruction. + * @param mnemonic Mnemonic for the instruction being created. + * @since 1.1.0 + */ + IB( fcml_prefixes prefixes, const fcml_cstring &mnemonic ) : + _hints(FCML_HINT_NO_HINTS), + _prefixes(prefixes), + _mnemonic(mnemonic), + _operandsCount(0) { + } + + /** + * Creates an instruction builder for given mnemonic and hints. + * + * @param mnemonic The instruction mnemonic. + * @param hints The instruction hints. + * @since 1.1.0 + */ + IB( const fcml_cstring &mnemonic, fcml_hints hints) : + _hints(hints), + _prefixes(0), + _mnemonic(mnemonic), + _operandsCount(0) { + } + + /** + * Creates an instruction builder for given prefixes, mnemonic and hints. + * + * @param prefixes The instruction prefixes. + * @param mnemonic The instruction mnemonic. + * @param hints The instruction hints. + * @since 1.1.0 + */ + IB( fcml_prefixes prefixes, const fcml_cstring &mnemonic, fcml_hints hints ) : + _hints(hints), + _prefixes(prefixes), + _mnemonic(mnemonic), + _operandsCount(0) { + } + + /** + * Converts builder to the instruction instance. + * @since 1.1.0 + * @return The built instruction. + */ + operator Instruction() const { + return build(); + } + + /** + * Builds an instruction instance for the current state of the builder. + * + * @return The built instruction instance. + * @since 1.1.0 + */ + Instruction build() const { + Instruction instruction(_mnemonic); + instruction.setHints(_hints); + instruction.setPrefixes(_prefixes); + instruction.setOperandsCount(_operandsCount); + for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) { + instruction.setOperand( _operands[i], i ); + } + return instruction; + } + + /** + * Sets a next operand for the instruction. + * + * @param operand The next operand to be added to the instruction. + * @throw IllegalStateException No more operands allowed. + * @since 1.1.0 + */ + void op( const Operand &operand ) { + if( _operandsCount == FCML_OPERANDS_COUNT ) { + throw IllegalStateException( FCML_TEXT( "No more operands allowed." ) ); + } + _operands[_operandsCount++] = operand; + } + + /** + * Factory method that can be used to create instruction builder. + * + * @param mnemonic The mnemonic for the instruction builder. + * @return Instruction builder instance. + * @since 1.1.0 + */ + static IB inst( const fcml_cstring &mnemonic ) { + return IB(mnemonic); + } + + // Hints. + + /** + * Creates a hint instance described by the name of the method. Such a hint can be then used + * together with shift operator overridden by the builder in order to set an appropriate hint + * for the instruction being built. + * @return The hint indicator for the builder. + * @since 1.1.0 + */ + static const InstructionHint FAR_PTR() { + return InstructionHint::FAR_POINTER(); + } + + /** + * Sets a hint described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate hint set. + * @since 1.1.0 + */ + IB& farPtr() { + _hints |= FCML_HINT_FAR_POINTER; + return *this; + } + + /** + * Creates a hint instance described by the name of the method. Such a hint can be then used + * together with shift operator overridden by the builder in order to set an appropriate hint + * for the instruction being built. + * @return The hint indicator for the builder. + * @since 1.1.0 + */ + static const InstructionHint NEAR_PTR() { + return InstructionHint::NEAR_POINTER(); + } + + /** + * Sets a hint described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate hint set. + * @since 1.1.0 + */ + IB& nearPtr() { + _hints |= FCML_HINT_NEAR_POINTER; + return *this; + } + + /** + * Creates a hint instance described by the name of the method. Such a hint can be then used + * together with shift operator overridden by the builder in order to set an appropriate hint + * for the instruction being built. + * @return The hint indicator for the builder. + * @since 1.1.0 + */ + static const InstructionHint LONG_FORM_PTR() { + return InstructionHint::LONG_FORM_POINTER(); + } + + /** + * Sets a hint described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate hint set. + * @since 1.1.0 + */ + IB& longFormPtr() { + _hints |= FCML_HINT_LONG_FORM_POINTER; + return *this; + } + + /** + * Creates a hint instance described by the name of the method. Such a hint can be then used + * together with shift operator overridden by the builder in order to set an appropriate hint + * for the instruction being built. + * @return The hint indicator for the builder. + * @since 1.1.0 + */ + static const InstructionHint INDIRECT_PTR() { + return InstructionHint::INDIRECT_POINTER(); + } + + /** + * Sets a hint described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate hint set. + * @since 1.1.0 + */ + IB& indirectPtr() { + _hints |= FCML_HINT_INDIRECT_POINTER; + return *this; + } + + /** + * Creates a hint instance described by the name of the method. Such a hint can be then used + * together with shift operator overridden by the builder in order to set an appropriate hint + * for the instruction being built. + * @return The hint indicator for the builder. + * @since 1.1.0 + */ + static const InstructionHint DIRECT_PTR() { + return InstructionHint::DIRECT_POINTER(); + } + + /** + * Sets a hint described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate hint set. + * @since 1.1.0 + */ + IB& directPtr() { + _hints |= FCML_HINT_DIRECT_POINTER; + return *this; + } + + // Prefixes. + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix LOCK() { + return InstructionPrefix::LOCK(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& lock() { + _prefixes |= FCML_PREFIX_LOCK; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix REPNE() { + return InstructionPrefix::REPNE(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& repne() { + _prefixes |= FCML_PREFIX_REPNE; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix REPNZ() { + return InstructionPrefix::REPNZ(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& repnz() { + _prefixes |= FCML_PREFIX_REPNZ; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix REP() { + return InstructionPrefix::REP(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& rep() { + _prefixes |= FCML_PREFIX_REP; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix REPE() { + return InstructionPrefix::REPE(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& repe() { + _prefixes |= FCML_PREFIX_REPE; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix REPZ() { + return InstructionPrefix::REPZ(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& repz() { + _prefixes |= FCML_PREFIX_REPZ; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix XACQUIRE() { + return InstructionPrefix::XACQUIRE(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& xacquire() { + _prefixes |= FCML_PREFIX_XACQUIRE; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix XRELEASE() { + return InstructionPrefix::XRELEASE(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& xrelease() { + _prefixes |= FCML_PREFIX_XRELEASE; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix BRANCH() { + return InstructionPrefix::BRANCH_HINT(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& branchHint() { + _prefixes |= FCML_PREFIX_BRANCH_HINT; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix NO_BRANCH() { + return InstructionPrefix::NOBRANCH_HINT(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& nobranchHint() { + _prefixes |= FCML_PREFIX_NOBRANCH_HINT; + return *this; + } + + /** + * Gets multimedia hint for the operand. + * @return The multimedia hint. + */ + static const OperandHint OP_MULTIMEDIA_HINT() { + return OperandHint::MULTIMEDIA(); + } + + /** + * Gets relative address hint for the operand. + * @return The multimedia hint. + */ + static const OperandHint OP_RELATIVE_ADDRESSING() { + return OperandHint::RELATIVE_ADDRESSING(); + } + + /** + * Gets absolute hint for the operand. + * @return The multimedia hint. + */ + static const OperandHint OP_ABSOLUTE_ADDRESSING() { + return OperandHint::ABSOLUTE_ADDRESSING(); + } + + /** + * Gets SIB encoding hint for the operand. + * @return The SIB encoding hint. + */ + static const OperandHint OP_SIB_ENCODING() { + return OperandHint::SIB_ENCODING(); + } + + /** + * Marks the lastly added operand as a multimedia one. + * @return The instruction builder itself. + */ + IB& operandMultimediaHint() { + set( OP_MULTIMEDIA_HINT() ); + return *this; + } + + /** + * Marks the lastly added address operand as a relative one. + * @return The instruction builder itself. + */ + IB& operandRelativeHint() { + set( OP_MULTIMEDIA_HINT() ); + return *this; + } + + /** + * Marks the lastly added address operand as a absolute one. + * @return The instruction builder itself. + */ + IB& operandAbsoluteHint() { + set( OP_MULTIMEDIA_HINT() ); + return *this; + } + + /** + * Sets preferred encoding to SIB for the lastly added ModR/M operand. + * @return The instruction builder itself. + */ + IB& operandSIBEncodingHint() { + set( OP_MULTIMEDIA_HINT() ); + return *this; + } + + // Operands. + + /** + * Adds an immediate operand. + * @return The immediate operand. + * @since 1.1.0 + */ + IB& imm( const Integer &imm ) { + sanityCheck(); + _operands[_operandsCount++].imm(imm); + return *this; + } + + /** + * Adds a far pointer operand. + * @param seg A segment selector. + * @param addr An 16-bit offset value. + * @return The far pointer operand. + * @since 1.1.0 + */ + IB& far_ptr( fcml_uint16_t seg, fcml_int16_t addr ) { + sanityCheck(); + _operands[_operandsCount++].far_ptr(seg, addr); + return *this; + } + + /** + * Adds a far pointer operand. + * @param seg A segment selector. + * @param addr An 32-bit offset value. + * @return The far pointer operand. + * @since 1.1.0 + */ + IB& far_ptr( fcml_uint16_t seg, fcml_int32_t addr ) { + sanityCheck(); + _operands[_operandsCount++].far_ptr(seg, addr); + return *this; + } + + /** + * Adds a far pointer operand. + * @param pointer A far pointer instance. + * @return The far pointer operand. + * @since 1.1.0 + */ + IB& far_ptr( const FarPointer &pointer ) { + sanityCheck(); + _operands[_operandsCount++].far_ptr( pointer ); + return *this; + } + + /** + * Adds an address operand. + * @param address An address instance. + * @return The address operand. + * @since 1.1.0 + */ + IB& addr( const Address &address ) { + sanityCheck(); + _operands[_operandsCount++].addr(address); + return *this; + } + + /** + * Adds an offset operand. + * @param offset An offset instance. + * @param sizeOperator An optional size operator. + * @return The address operand. + * @since 1.1.0 + */ + IB& off( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + sanityCheck(); + _operands[_operandsCount++].off( offset, sizeOperator ); + return *this; + } + + /** + * Adds an offset based address operand with byte size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + IB& offb( const Integer &offset ) { + sanityCheck(); + _operands[_operandsCount++].off( offset, FCML_DS_8 ); + return *this; + } + + /** + * Adds an offset based address operand with word size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + IB& offw( const Integer &offset ) { + sanityCheck(); + _operands[_operandsCount++].off( offset, FCML_DS_16 ); + return *this; + } + + /** + * Adds an offset based address operand with double word size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + IB& offd( const Integer &offset ) { + sanityCheck(); + _operands[_operandsCount++].off( offset, FCML_DS_32 ); + return *this; + } + + /** + * Adds an offset based address operand with quadro word size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + IB& offq( const Integer &offset ) { + sanityCheck(); + _operands[_operandsCount++].off( offset, FCML_DS_64 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and optional size operator. + * @param effectiveAddress The effective address. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& addr( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, sizeOperator ); + return *this; + } + + /** + * Adds an address type operand for given effective address and byte size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrb( const EffectiveAddress &effectiveAddress ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, FCML_DS_8 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and word size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrw( const EffectiveAddress &effectiveAddress ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, FCML_DS_16 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and double word size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrd( const EffectiveAddress &effectiveAddress ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, FCML_DS_32 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and quadro word size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrq( const EffectiveAddress &effectiveAddress ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, FCML_DS_64 ); + return *this; + } + + /** + * Adds an address type operand for given segment selector, effective address and optional size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& addr( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, sizeOperator ); + return *this; + } + + /** + * Adds an address type operand for given effective address and byte size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrb( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, FCML_DS_8 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and byte size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrw( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, FCML_DS_8 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and double word size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrd( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, FCML_DS_8 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and quadro word size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrq( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, FCML_DS_8 ); + return *this; + } + + /** + * Adds an an register based operator for given register. + * @param reg The register. + * @return The created operator. + * @since 1.1.0 + */ + IB& reg( const Register ® ) { + sanityCheck(); + _operands[_operandsCount++].reg( reg ); + return *this; + } + + /** + * Adds an an register based operator for given parameters. + * @param reg The FCML register number. + * @param size The register size. + * @param type The register type. + * @param x64_exp See manual for more information. + * @return The created operator. + * @since 1.1.0 + */ + IB& reg( fcml_uint8_t reg, fcml_usize size, Register::RegisterType type = Register::REG_GPR, fcml_bool x64_exp = FCML_FALSE ) { + sanityCheck(); + _operands[_operandsCount++].reg( Register( reg, size, type, x64_exp ) ); + return *this; + } + + /** + * Adds an an effective address based operator for a displacement and optional size operator. + * @param displacement The displacement value. + * @param sizeOperator The size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress(displacement), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for a displacement and byte size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Integer &displacement ) { + next().addr( EffectiveAddress(displacement), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for a displacement and word size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Integer &displacement ) { + next().addr( EffectiveAddress(displacement), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for a displacement and double word size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Integer &displacement ) { + next().addr( EffectiveAddress(displacement), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for a displacement and quadro byte size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Integer &displacement ) { + next().addr( EffectiveAddress(displacement), FCML_DS_64 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register and optional size operator. + * @param base The base register. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Register &base, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress(base), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register and byte size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Register &base ) { + next().addr( EffectiveAddress(base), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register and word size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Register &base ) { + next().addr( EffectiveAddress(base), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register and double word size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Register &base ) { + next().addr( EffectiveAddress(base), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register and quadro word size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Register &base ) { + next().addr( EffectiveAddress(base), FCML_DS_64 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, displacement and optional size operator. + * @param base The base register. + * @param displacement The displacement value. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Register &base, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress( base, displacement ), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, displacement and byte size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Register &base, const Integer &displacement ) { + next().addr( EffectiveAddress( base, displacement ), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, displacement and word size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Register &base, const Integer &displacement ) { + next().addr( EffectiveAddress( base, displacement ), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, displacement and double word size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Register &base, const Integer &displacement ) { + next().addr( EffectiveAddress( base, displacement ), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, displacement and quadro word size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Register &base, const Integer &displacement ) { + next().addr( EffectiveAddress( base, displacement ), FCML_DS_64 ); + return *this; + } + + /** + * Adds an an effective address based operator for an index register, scaleFactor, displacement and optional size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress( index, scaleFactor, displacement ), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for an index register, scaleFactor, displacement and byte size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for an index register, scaleFactor, displacement and word size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for an index register, scaleFactor, displacement and double word size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for an index register, scaleFactor, displacement and quadro word size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_64 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register and optional size operator. + * @param base The base register. + * @param index The index register. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Register &base, const Register &index, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress( base, index ), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register and byte size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Register &base, const Register &index ) { + next().addr( EffectiveAddress( base, index ), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register and word size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Register &base, const Register &index ) { + next().addr( EffectiveAddress( base, index ), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register and double word size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Register &base, const Register &index ) { + next().addr( EffectiveAddress( base, index ), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register and quadro word size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Register &base, const Register &index ) { + next().addr( EffectiveAddress( base, index ), FCML_DS_64 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and optional size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Register &base, const Register &index, fcml_uint8_t scaleFactor, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress( base, index, scaleFactor ), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and byte size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + next().addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + next().addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and double word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + next().addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and quadro word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + next().addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_64 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and optional size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and byte size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and double word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and quardo word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_64 ); + return *this; + } + + /** + * Adds an operand to the instruction being built. + * @param operand The operand to be added. + * @return The instruction builder with the new operand added to it. + * @since 1.1.0 + */ + IB& operator <<(const Operand &operand) { + next() = operand; + return *this; + } + + /** + * Adds a prefix to the instruction being built. + * @param prefix The prefix to be added. + * @return The instruction builder with the new prefix set for it. + * @since 1.1.0 + */ + IB& operator <<(const InstructionPrefix &prefix) { + return set(prefix); + } + + /** + * Adds an instruction level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + IB& operator <<(const InstructionHint &hint) { + return set( hint ); + } + + /** + * Adds an operand level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + IB& operator <<(const OperandHint &hint) { + return set( hint ); + } + + /** + * Adds a prefix to the instruction being built. + * @param prefix The prefix to be added. + * @return The instruction builder with the new prefix set for it. + * @since 1.1.0 + */ + IB& set( const InstructionPrefix &prefix ) { + _prefixes |= prefix._prefix; + return *this; + } + + /** + * Adds an instruction level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + IB& set( const InstructionHint &hint ) { + _hints |= hint._hint; + return *this; + } + + /** + * Adds an operand level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + IB& set( const OperandHint &hint ) { + if( _operandsCount == 0 ) { + throw IllegalStateException( FCML_TEXT( "There are no operands yet for the current instruction.." ) ); + } + _operands[_operandsCount-1].setHints( _operands[_operandsCount-1].getHints() | hint._hint ); + return *this; + } + +private: + + /** + * Gets the next instruction operand. + * @return A reference to the next instruction operand. + * @since 1.1.0 + */ + Operand& next() { + sanityCheck(); + return _operands[_operandsCount++]; + } + + /** + * Throws exception if there is no more space for new operands in the builder. + * @throw IllegalStateException Operand's number exceeds maximal number of operands allowed. + * @since 1.1.0 + */ + void sanityCheck() const { + if( _operandsCount == FCML_OPERANDS_COUNT ) { + throw IllegalStateException( FCML_TEXT( "Operand's number exceeds maximal number of operands allowed." ) ); + } + } + +private: + + /** Instruction hints. */ + fcml_hints _hints; + /** Instruction prefixes.*/ + fcml_prefixes _prefixes; + /** Instruction mnemonic. */ + fcml_cstring _mnemonic; + /** Number of operands available in the builder. */ + fcml_int _operandsCount; + /** Operands for the built instruction. */ + Operand _operands[FCML_OPERANDS_COUNT]; + +}; + +/** Two way conversion for common types. + * @since 1.1.0 + * @remarks Internal API, not intended to be used outside. + */ +class TypeConverter { +public: + + static void convert( const fcml_st_entry_point &src, EntryPoint &dest ) { + dest.setIP( src.ip ); + dest.setOpMode( static_cast( src.op_mode ) ); + dest.setAddressSizeAttribute( src.address_size_attribute ); + dest.setOperandSizeAttribute( src.operand_size_attribute ); + } + + static void convert( const EntryPoint &src, fcml_st_entry_point &dest ) { + dest.ip = src.getIP(); + dest.op_mode = static_cast( src.getOpMode() ); + dest.address_size_attribute = src.getAddressSizeAttribute(); + dest.operand_size_attribute = src.getOperandSizeAttribute(); + } + + static void convert( const fcml_st_integer &src, Integer &dest ) { + dest.setInt8( src.int8 ); + dest.setInt16( src.int16 ); + dest.setInt32( src.int32 ); + dest.setInt64( src.int64 ); + dest.setSigned( src.is_signed ); + dest.setSize( src.size ); + } + + static void convert( const Integer &src, fcml_st_integer &dest ) { + dest.int8 = src.getInt8(); + dest.int16 = src.getInt16(); + dest.int32 = src.getInt32(); + dest.int64 = src.getInt64(); + dest.is_signed = src.isSigned(); + dest.size = src.getSize(); + } + + static void convert( const fcml_st_offset &src, Integer &dest ) { + dest.setInt16( src.off16 ); + dest.setInt32( src.off32 ); + dest.setInt64( src.off64 ); + dest.setSigned( src.is_signed ); + dest.setSize( src.size ); + } + + static void convert( const Integer &src, fcml_st_offset &dest ) { + dest.off16 = src.getSize() == FCML_DS_8 ? src.getInt8() : src.getInt16(); + dest.off32 = src.getInt32(); + dest.off64 = src.getInt64(); + dest.is_signed = src.isSigned(); + dest.size = src.getSize(); + } + + static void convert( const fcml_st_register &src, Register &dest ) { + dest.setReg( src.reg ); + dest.setSize( src.size ); + dest.setType( static_cast( src.type ) ); + dest.setX64Exp( src.x64_exp ? true : false ); + } + + static void convert( const Register &src, fcml_st_register &dest ) { + dest.reg = src.getReg(); + dest.size = src.getSize(); + dest.type = static_cast( src.getType() ); + dest.x64_exp = src.getX64Exp(); + } + + static void convert( const fcml_st_far_pointer &src, FarPointer &dest ) { + dest.setOffset16( src.offset16 ); + dest.setOffset32( src.offset32 ); + dest.setOffsetSize( src.offset_size ); + dest.setSegment( src.segment ); + } + + static void convert( const FarPointer &src, fcml_st_far_pointer &dest ) { + dest.offset16 = src.getOffset16(); + dest.offset32 = src.getOffset32(); + dest.offset_size = src.getOffsetSize(); + dest.segment = src.getSegment(); + } + + static void convert( const fcml_st_segment_selector &src, SegmentSelector &dest ) { + dest.setDefaultReg( src.is_default_reg ? true : false ); + convert( src.segment_selector, dest.getSegmentSelector() ); + } + + static void convert( const SegmentSelector &src, fcml_st_segment_selector &dest ) { + dest.is_default_reg = src.isDefaultReg(); + convert( src.getSegmentSelector(), dest.segment_selector ); + } + + static void convert( const fcml_st_effective_address &src, EffectiveAddress &dest ) { + convert( src.base, dest.getBase() ); + convert( src.index, dest.getIndex() ); + convert( src.displacement, dest.getDisplacement() ); + dest.setScaleFactor(src.scale_factor); + } + + static void convert( const EffectiveAddress &src, fcml_st_effective_address &dest ) { + convert( src.getBase(), dest.base ); + convert( src.getIndex(), dest.index ); + convert( src.getDisplacement(), dest.displacement ); + dest.scale_factor = src.getScaleFactor(); + } + + static void convert( const fcml_st_address &src, Address &dest ) { + dest.setAddressForm( static_cast( src.address_form ) ); + dest.setSizeOperator( src.size_operator ); + convert( src.segment_selector, dest.getSegmentSelector() ); + convert( src.effective_address, dest.getEffectiveAddress() ); + convert( src.offset, dest.getOffset() ); + } + + static void convert( const Address &src, fcml_st_address &dest ) { + dest.address_form = static_cast( src.getAddressForm() ); + dest.size_operator = src.getSizeOperator(); + convert( src.getSegmentSelector(), dest.segment_selector ); + convert( src.getEffectiveAddress(), dest.effective_address ); + convert( src.getOffset(), dest.offset ); + } + + static void convert(const fcml_st_operand &src, Operand &dest) { + dest.setHints(src.hints); + dest.setOperandType(static_cast(src.type)); + convert(src.address, dest.getAddress()); + convert(src.far_pointer, dest.getFarPointer()); + convert(src.immediate, dest.getImmediate()); + convert(src.reg, dest.getRegister()); + convert(src.decorators, dest.getDecorators()); + } + + static void convert(const Operand &src, fcml_st_operand &dest) { + dest.hints = src.getHints(); + dest.type = static_cast(src.getOperandType()); + convert(src.getAddress(), dest.address); + convert(src.getFarPointer(), dest.far_pointer); + convert(src.getImmediate(), dest.immediate); + convert(src.getRegister(), dest.reg); + convert(src.getDecorators(), dest.decorators); + } + + static void convert(const fcml_st_operand_decorators &src, + Decorators &dest) { + Nullable bcast; + bcast.setNotNull(FCML_TO_CPP_BOOL(src.bcast.is_not_null)); + bcast.setValue(src.bcast.value); + dest.setBcast(bcast); + Nullable er; + er.setNotNull(FCML_TO_CPP_BOOL(src.er.is_not_null)); + er.setValue(static_cast(src.er.value)); + dest.setEr(er); + dest.setZ(src.z); + dest.setSae(src.sae); + convert(src.operand_mask_reg, dest.getOpmaskReg()); + } + + static void convert(const Decorators &src, fcml_st_operand_decorators &dest) { + dest.bcast.is_not_null = src.getBcast().isNotNull(); + dest.bcast.value = src.getBcast().getValue(); + dest.er.is_not_null = src.getEr().isNotNull(); + dest.er.value = static_cast(src.getEr().getValue()); + dest.z = src.isZ(); + dest.sae = src.isSae(); + convert(src.getOpmaskReg(), dest.operand_mask_reg); + } + + static void convert( const fcml_st_condition &src, Condition &dest ) { + dest.setConditionType( static_cast( src.condition_type ) ); + dest.setNegation( src.is_negation ? true : false ); + } + + static void convert( const Condition &src, fcml_st_condition &dest ) { + dest.condition_type = static_cast( src.getConditionType() ); + dest.is_negation = src.isNegation(); + } + + static void convert( const fcml_st_instruction &src, Instruction &dest ) { + dest.setMnemonic( src.mnemonic ); + convert( src.condition, dest.getCondition() ); + dest.setHints( src.hints ); + dest.setPrefixes( src.prefixes ); + dest.setConditional( src.is_conditional ? true : false ); + for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) { + convert( src.operands[i], dest[i] ); + } + dest.setOperandsCount(src.operands_count); + } + + static void convert( const Instruction &src, fcml_st_instruction &dest ) { + // Bear in mind that you are responsible for freeing mnemonic duplicated here. + dest.mnemonic = Env::strDup( src.getMnemonic().c_str() ); + convert( src.getCondition(), dest.condition ); + dest.hints = src.getHints(); + dest.prefixes = src.getPrefixes(); + dest.is_conditional = src.isConditional(); + for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) { + convert( src[i], dest.operands[i] ); + } + dest.operands_count = src.getOperandsCount(); + } + + static void free( fcml_st_instruction &instruction ) { + if( instruction.mnemonic ) { + Env::strFree( instruction.mnemonic ); + instruction.mnemonic = NULL; + } + } +}; + +} + +#endif //FCML_COMMON_HPP_ diff --git a/dependencies/fcml/include/fcml_common_utils.h b/dependencies/fcml/include/fcml_common_utils.h new file mode 100644 index 0000000..29363ea --- /dev/null +++ b/dependencies/fcml/include/fcml_common_utils.h @@ -0,0 +1,660 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_common_utils.h + * + * Common general purpose utility functions. + * + * @copyright Copyright (C) 2010-2017 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_COMMON_UTILS_H_ +#define FCML_COMMON_UTILS_H_ + +#include "fcml_lib_export.h" + +#include "fcml_common.h" +#include "fcml_assembler.h" +#include "fcml_disassembler.h" +#include "fcml_instructions.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup REG_STRUCTURES_GROUP Registers + * Declarations of structures describing all available registers. + * @{ + */ + +extern LIB_EXPORT fcml_st_register fcml_reg_AL; +extern LIB_EXPORT fcml_st_register fcml_reg_AX; +extern LIB_EXPORT fcml_st_register fcml_reg_EAX; +extern LIB_EXPORT fcml_st_register fcml_reg_RAX; +extern LIB_EXPORT fcml_st_register fcml_reg_MM0; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM0; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM0; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM0; + +extern LIB_EXPORT fcml_st_register fcml_reg_CL; +extern LIB_EXPORT fcml_st_register fcml_reg_CX; +extern LIB_EXPORT fcml_st_register fcml_reg_ECX; +extern LIB_EXPORT fcml_st_register fcml_reg_RCX; +extern LIB_EXPORT fcml_st_register fcml_reg_MM1; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM1; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM1; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM1; + +extern LIB_EXPORT fcml_st_register fcml_reg_DL; +extern LIB_EXPORT fcml_st_register fcml_reg_DX; +extern LIB_EXPORT fcml_st_register fcml_reg_EDX; +extern LIB_EXPORT fcml_st_register fcml_reg_RDX; +extern LIB_EXPORT fcml_st_register fcml_reg_MM2; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM2; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM2; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM2; + +extern LIB_EXPORT fcml_st_register fcml_reg_BL; +extern LIB_EXPORT fcml_st_register fcml_reg_BX; +extern LIB_EXPORT fcml_st_register fcml_reg_EBX; +extern LIB_EXPORT fcml_st_register fcml_reg_RBX; +extern LIB_EXPORT fcml_st_register fcml_reg_MM3; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM3; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM3; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM3; + +extern LIB_EXPORT fcml_st_register fcml_reg_AH; +extern LIB_EXPORT fcml_st_register fcml_reg_SPL; +extern LIB_EXPORT fcml_st_register fcml_reg_SP; +extern LIB_EXPORT fcml_st_register fcml_reg_ESP; +extern LIB_EXPORT fcml_st_register fcml_reg_RSP; +extern LIB_EXPORT fcml_st_register fcml_reg_MM4; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM4; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM4; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM4; + +extern LIB_EXPORT fcml_st_register fcml_reg_CH; +extern LIB_EXPORT fcml_st_register fcml_reg_BPL; +extern LIB_EXPORT fcml_st_register fcml_reg_BP; +extern LIB_EXPORT fcml_st_register fcml_reg_EBP; +extern LIB_EXPORT fcml_st_register fcml_reg_RBP; +extern LIB_EXPORT fcml_st_register fcml_reg_MM5; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM5; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM5; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM5; + +extern LIB_EXPORT fcml_st_register fcml_reg_DH; +extern LIB_EXPORT fcml_st_register fcml_reg_SIL; +extern LIB_EXPORT fcml_st_register fcml_reg_SI; +extern LIB_EXPORT fcml_st_register fcml_reg_ESI; +extern LIB_EXPORT fcml_st_register fcml_reg_RSI; +extern LIB_EXPORT fcml_st_register fcml_reg_MM6; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM6; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM6; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM6; + +extern LIB_EXPORT fcml_st_register fcml_reg_BH; +extern LIB_EXPORT fcml_st_register fcml_reg_DIL; +extern LIB_EXPORT fcml_st_register fcml_reg_DI; +extern LIB_EXPORT fcml_st_register fcml_reg_EDI; +extern LIB_EXPORT fcml_st_register fcml_reg_RDI; +extern LIB_EXPORT fcml_st_register fcml_reg_MM7; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM7; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM7; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM7; + +extern LIB_EXPORT fcml_st_register fcml_reg_R8L; +extern LIB_EXPORT fcml_st_register fcml_reg_R8W; +extern LIB_EXPORT fcml_st_register fcml_reg_R8D; +extern LIB_EXPORT fcml_st_register fcml_reg_R8; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM8; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM8; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM8; + +extern LIB_EXPORT fcml_st_register fcml_reg_R9L; +extern LIB_EXPORT fcml_st_register fcml_reg_R9W; +extern LIB_EXPORT fcml_st_register fcml_reg_R9D; +extern LIB_EXPORT fcml_st_register fcml_reg_R9; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM9; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM9; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM9; + +extern LIB_EXPORT fcml_st_register fcml_reg_R10L; +extern LIB_EXPORT fcml_st_register fcml_reg_R10W; +extern LIB_EXPORT fcml_st_register fcml_reg_R10D; +extern LIB_EXPORT fcml_st_register fcml_reg_R10; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM10; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM10; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM10; + +extern LIB_EXPORT fcml_st_register fcml_reg_R11L; +extern LIB_EXPORT fcml_st_register fcml_reg_R11W; +extern LIB_EXPORT fcml_st_register fcml_reg_R11D; +extern LIB_EXPORT fcml_st_register fcml_reg_R11; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM11; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM11; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM11; + +extern LIB_EXPORT fcml_st_register fcml_reg_R12L; +extern LIB_EXPORT fcml_st_register fcml_reg_R12W; +extern LIB_EXPORT fcml_st_register fcml_reg_R12D; +extern LIB_EXPORT fcml_st_register fcml_reg_R12; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM12; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM12; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM12; + +extern LIB_EXPORT fcml_st_register fcml_reg_R13L; +extern LIB_EXPORT fcml_st_register fcml_reg_R13W; +extern LIB_EXPORT fcml_st_register fcml_reg_R13D; +extern LIB_EXPORT fcml_st_register fcml_reg_R13; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM13; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM13; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM13; + +extern LIB_EXPORT fcml_st_register fcml_reg_R14L; +extern LIB_EXPORT fcml_st_register fcml_reg_R14W; +extern LIB_EXPORT fcml_st_register fcml_reg_R14D; +extern LIB_EXPORT fcml_st_register fcml_reg_R14; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM14; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM14; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM14; + +extern LIB_EXPORT fcml_st_register fcml_reg_R15L; +extern LIB_EXPORT fcml_st_register fcml_reg_R15W; +extern LIB_EXPORT fcml_st_register fcml_reg_R15D; +extern LIB_EXPORT fcml_st_register fcml_reg_R15; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM15; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM15; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM15; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM16; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM16; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM16; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM17; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM17; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM17; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM18; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM18; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM18; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM19; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM19; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM19; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM20; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM20; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM20; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM21; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM21; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM21; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM22; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM22; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM22; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM23; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM23; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM23; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM24; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM24; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM24; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM25; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM25; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM25; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM26; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM26; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM26; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM27; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM27; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM27; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM28; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM28; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM28; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM29; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM29; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM29; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM30; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM30; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM30; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM31; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM31; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM31; + +extern LIB_EXPORT fcml_st_register fcml_reg_ES; +extern LIB_EXPORT fcml_st_register fcml_reg_CS; +extern LIB_EXPORT fcml_st_register fcml_reg_SS; +extern LIB_EXPORT fcml_st_register fcml_reg_DS; +extern LIB_EXPORT fcml_st_register fcml_reg_FS; +extern LIB_EXPORT fcml_st_register fcml_reg_GS; + +extern LIB_EXPORT fcml_st_register fcml_reg_ST0; +extern LIB_EXPORT fcml_st_register fcml_reg_ST1; +extern LIB_EXPORT fcml_st_register fcml_reg_ST2; +extern LIB_EXPORT fcml_st_register fcml_reg_ST3; +extern LIB_EXPORT fcml_st_register fcml_reg_ST4; +extern LIB_EXPORT fcml_st_register fcml_reg_ST5; +extern LIB_EXPORT fcml_st_register fcml_reg_ST6; +extern LIB_EXPORT fcml_st_register fcml_reg_ST7; + +extern LIB_EXPORT fcml_st_register fcml_reg_CR0; +extern LIB_EXPORT fcml_st_register fcml_reg_CR2; +extern LIB_EXPORT fcml_st_register fcml_reg_CR3; +extern LIB_EXPORT fcml_st_register fcml_reg_CR4; +extern LIB_EXPORT fcml_st_register fcml_reg_CR8; + +extern LIB_EXPORT fcml_st_register fcml_reg_DR0; +extern LIB_EXPORT fcml_st_register fcml_reg_DR1; +extern LIB_EXPORT fcml_st_register fcml_reg_DR2; +extern LIB_EXPORT fcml_st_register fcml_reg_DR3; +extern LIB_EXPORT fcml_st_register fcml_reg_DR4; +extern LIB_EXPORT fcml_st_register fcml_reg_DR5; +extern LIB_EXPORT fcml_st_register fcml_reg_DR6; +extern LIB_EXPORT fcml_st_register fcml_reg_DR7; + +extern LIB_EXPORT fcml_st_register fcml_reg_K0; +extern LIB_EXPORT fcml_st_register fcml_reg_K1; +extern LIB_EXPORT fcml_st_register fcml_reg_K2; +extern LIB_EXPORT fcml_st_register fcml_reg_K3; +extern LIB_EXPORT fcml_st_register fcml_reg_K4; +extern LIB_EXPORT fcml_st_register fcml_reg_K5; +extern LIB_EXPORT fcml_st_register fcml_reg_K6; +extern LIB_EXPORT fcml_st_register fcml_reg_K7; + +extern LIB_EXPORT fcml_st_register fcml_reg_IP; +extern LIB_EXPORT fcml_st_register fcml_reg_EIP; +extern LIB_EXPORT fcml_st_register fcml_reg_RIP; + +/** @} */ + +/** Prepares register operand for given register. + * @param reg Register for instruction operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_reg( + fcml_st_register *reg); + +/* IMM.*/ + +/** Prepares immediate operand for unsigned int8. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_unsigned_imm_8( + fcml_uint8_t value); +/** Prepares immediate operand for signed int8. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_signed_imm_8( + fcml_int8_t value); +/** Prepares immediate operand for unsigned int16. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_unsigned_imm_16( + fcml_uint16_t value); +/** Prepares immediate operand for signed int16. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_signed_imm_16( + fcml_int16_t value); +/** Prepares immediate operand for unsigned int32. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_unsigned_imm_32( + fcml_uint32_t value); +/** Prepares immediate operand for signed int32. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_signed_imm_32( + fcml_int32_t value); +/** Prepares immediate operand for unsigned int64. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_unsigned_imm_64( + fcml_uint64_t value); +/** Prepares immediate operand for signed int64. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_signed_imm_64( + fcml_int64_t value); + +/* Memory addressing.*/ + +/** Prepares far pointer operand for given segment and offset. + * @param seg 16-bit code segment. + * @param offset 16-bit code offset. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_far_pointer_offset16( + fcml_int16_t seg, fcml_int16_t offset); +/** Prepares far pointer operand for given segment and offset. + * @param seg 16-bit code segment. + * @param offset 32-bit code offset. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_far_pointer_offset32( + fcml_int16_t seg, fcml_int32_t offset); +/** Prepares memory addressing operand for 16-bit absolute offset. + * @param offset 16-bit absolute offset. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_offset_16( + fcml_int16_t offset, fcml_usize size_operator); +/** Prepares memory addressing operand for 32-bit absolute offset. + * @param offset 32-bit absolute offset. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_offset_32( + fcml_int32_t offset, fcml_usize size_operator); +/** Prepares memory addressing operand for 64-bit absolute offset. Function + * sets operand level hint: FCML_OP_HINT_ABSOLUTE_ADDRESSING. + * @param offset 64-bit absolute offset. + * @param size_operator Size operator. + * @return Prepared operand. + * @see RIP addressing. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_offset_abs_64( + fcml_int64_t offset, fcml_usize size_operator); +/** Prepares memory addressing operand for 64-bit absolute offset. Function + * sets operand level hint: FCML_OP_HINT_RELATIVE_ADDRESSING. + * @param offset 64-bit absolute offset. + * @param size_operator Size operator. + * @return Prepared operand. + * @see RIP addressing. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_offset_rel_64( + fcml_int64_t offset, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 16-bit displacement. + * @param disp 16-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_disp_16( + fcml_int16_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 32-bit displacement. + * @param disp 32-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_disp_32( + fcml_int32_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 64-bit displacement. + * @param disp 64-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_disp_64( + fcml_int64_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 8-bit displacement + * and base register. + * @param base Base register. + * @param disp 8-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_b_disp_8( + fcml_st_register *base, fcml_int8_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 16-bit displacement + * and base register. + * @param base Base register. + * @param disp 16-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_b_disp_16( + fcml_st_register *base, fcml_int16_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 32-bit displacement + * and base register. + * @param base Base register. + * @param disp 32-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_b_disp_32( + fcml_st_register *base, fcml_int32_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 64-bit displacement + * and base register. + * @param base Base register. + * @param disp 64-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_b_disp_64( + fcml_st_register *base, fcml_int64_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 8-bit displacement, + * scale factor and index register. + * @param index Index register. + * @param scale_factor Scale factor. + * @param disp 8-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_is_disp_8( + fcml_st_register *index, fcml_uint8_t scale_factor, fcml_int8_t disp, + fcml_usize size_operator); +/** Prepares effective memory addressing operand for 16-bit displacement, + * scale factor and index register. + * @param index Index register. + * @param scale_factor Scale factor. + * @param disp 16-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_is_disp_32( + fcml_st_register *index, fcml_uint8_t scale_factor, fcml_int32_t disp, + fcml_usize size_operator); +/** Prepares effective memory addressing operand for 32-bit displacement, + * scale factor and index register. + * @param index Index register. + * @param scale_factor Scale factor. + * @param disp 32-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_is_disp_64( + fcml_st_register *index, fcml_uint8_t scale_factor, fcml_int64_t disp, + fcml_usize size_operator); +/** Prepares effective memory addressing operand for 8-bit displacement, + * base register, scale factor and index register. + * @param base Base register. + * @param index Index register. + * @param scale_factor Scale factor. + * @param disp 8-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_bis_disp_8( + fcml_st_register *base, fcml_st_register *index, + fcml_uint8_t scale_factor, fcml_int8_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 16-bit displacement, + * base register, scale factor and index register. + * @param base Base register. + * @param index Index register. + * @param scale_factor Scale factor. + * @param disp 16-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_bis_disp_32( + fcml_st_register *base, fcml_st_register *index, + fcml_uint8_t scale_factor, fcml_int32_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 32-bit displacement, + * base register, scale factor and index register. + * @param base Base register. + * @param index Index register. + * @param scale_factor Scale factor. + * @param disp 32-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_bis_disp_64( + fcml_st_register *base, fcml_st_register *index, + fcml_uint8_t scale_factor, fcml_int64_t disp, fcml_usize size_operator); + +/** Adds hints to the operand. + * @param operand Operand for hints. + * @param hints Hints mask. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_add_operand_hints( + fcml_st_operand operand, fcml_hints hints); + +/** Clones given instruction. + * Allocates new instance of instruction and makes a deep copy of + * all fields. Remember that cloned instructions have to be freed + * using fcml_fn_cu_free_instruction() function. Do not try to free + * it on your own because it might be allocated on different + * dedicated memory heap. + * @param instruction Instruction to be cloned. + * @return Cloned instruction. + */ +LIB_EXPORT fcml_st_instruction* LIB_CALL fcml_fn_cu_clone_instruction( + fcml_st_instruction *instruction); + +/** Frees given instruction. + * Frees instruction allocated by fcml_fn_cu_clone_instruction() function. + * @param instruction Instruction to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_cu_free_instruction( + fcml_st_instruction *instruction); + +/** Gets operand of given type or NULL if there is no such operand. + * If more than one operand of given type exist, the first one is returned. + * @param instruction Finds an operand of the given type for for + * given instruction. + * @param operand_type Operand type. + * @return Pointer to the operand of given type. + */ +LIB_EXPORT fcml_st_operand* fcml_fn_cu_find_operand( + fcml_st_instruction *instruction, fcml_en_operand_type operand_type); + +/* Some shortcuts for those who prefer to use macros instead of functions.*/ + +#define FCML_IMM8_S( x ) fcml_fn_cu_operand_signed_imm_8( x ) +#define FCML_IMM8( x ) fcml_fn_cu_operand_unsigned_imm_8( x ) +#define FCML_IMM16_S( x ) fcml_fn_cu_operand_signed_imm_16( x ) +#define FCML_IMM16( x ) fcml_fn_cu_operand_unsigned_imm_16( x ) +#define FCML_IMM32_S( x ) fcml_fn_cu_operand_signed_imm_32( x ) +#define FCML_IMM32( x ) fcml_fn_cu_operand_unsigned_imm_32( x ) +#define FCML_IMM64_S( x ) fcml_fn_cu_operand_signed_imm_64( x ) +#define FCML_IMM64( x ) fcml_fn_cu_operand_unsigned_imm_64( x ) + +#ifdef FCML_USE_SHORT_REG +#define FCML_REG( x ) fcml_fn_cu_operand_reg( &fcml_reg_##x ) +#else +#define FCML_REG( x ) fcml_fn_cu_operand_reg( &x ) +#endif + +#define FCML_FAR_POINTER_16( seg, offset ) \ + fcml_fn_cu_operand_addr_far_pointer_offset16( seg, offset ) +#define FCML_FAR_POINTER_32( seg, offset ) \ + fcml_fn_cu_operand_addr_far_pointer_offset32( seg, offset ) +#define FCML_OFFSET_16( offset ) \ + fcml_fn_cu_operand_addr_offset_16( offset ) +#define FCML_OFFSET_32( offset ) \ + fcml_fn_cu_operand_addr_offset_32( offset ) +#define FCML_OFFSET_ABS_64( offset ) \ + fcml_fn_cu_operand_addr_offset_abs_64( offset ) +#define FCML_OFFSET_REL_64( offset ) \ + fcml_fn_cu_operand_addr_offset_rel_64( offset ) +#define FCML_DISP_16( offset ) \ + fcml_fn_cu_operand_addr_disp_16( offset ) +#define FCML_DISP_32( offset ) \ + fcml_fn_cu_operand_addr_disp_32( offset ) +#define FCML_DISP_64( offset ) \ + fcml_fn_cu_operand_addr_disp_64( offset ) + +#ifdef FCML_USE_SHORT_REG +#define FCML_B_DISP_8(base, offset) \ +fcml_fn_cu_operand_addr_b_disp_8( &fcml_reg_##base, offset ) +#define FCML_B_DISP_16(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_16( &fcml_reg_##base, offset ) +#define FCML_B_DISP_32(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_32( &fcml_reg_##base, offset ) +#define FCML_B_DISP_64(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_64( &fcml_reg_##base, offset ) +#define FCML_IS_DISP_8(index, scale, offset) \ + fcml_fn_cu_operand_addr_is_disp_8( &fcml_reg_##index, scale, offset ) +#define FCML_IS_DISP_16(index, scale, offset) \ + fcml_fn_cu_operand_addr_is_disp_32( &fcml_reg_##index, scale, offset ) +#define FCML_IS_DISP_32(index, scale, offset) \ + fcml_fn_cu_operand_addr_is_disp_64( &fcml_reg_##index, scale, offset ) +#define FCML_BIS_DISP_8(base, index, scale, offset) \ + fcml_fn_cu_operand_addr_bis_disp_8( &fcml_reg_##base, &fcml_reg_##index, \ + scale, offset ) +#define FCML_BIS_DISP_16(base, index, scale, offset) \ + fcml_fn_cu_operand_addr_bis_disp_32( &fcml_reg_##base, &fcml_reg_##index, \ + scale, offset ) +#define FCML_BIS_DISP_32(base, index, scale, offset) \ + fcml_fn_cu_operand_addr_bis_disp_64( &fcml_reg_##base, &fcml_reg_##index, \ + scale, offset ) +#else +#define FCML_B_DISP_8(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_8( &base, offset ) +#define FCML_B_DISP_16(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_16( &base, offset ) +#define FCML_B_DISP_32(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_32( &base, offset ) +#define FCML_B_DISP_64(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_64( &base, offset ) +#define FCML_IS_DISP_8(index, scale, offset) \ + fcml_fn_cu_operand_addr_is_disp_8( &index, scale, offset ) +#define FCML_IS_DISP_16(index, scale, offset) \ + fcml_fn_cu_operand_addr_is_disp_32( &index, scale, offset ) +#define FCML_IS_DISP_32(index, scale, offset) \ + fcml_fn_cu_operand_addr_is_disp_64( &index, scale, offset ) +#define FCML_BIS_DISP_8(base, index, scale, offset) \ + fcml_fn_cu_operand_addr_bis_disp_8( &base, &index, scale, offset ) +#define FCML_BIS_DISP_16(base, index, scale, offset) \ + fcml_fn_cu_operand_addr_bis_disp_32( &base, &index, scale, offset ) +#define FCML_BIS_DISP_32(base, index, scale, offset) \ + fcml_fn_cu_operand_addr_bis_disp_64( &base, &index, scale, offset ) +#endif + +#define FCML_IS_INSTRUCTION_GROUP(result, group) \ + ( result.instruction_details.instruction_group & ( group ) ) +#define FCML_IS_INSTRUCTION_CODE(result, _ins) \ + ( result.instruction_details.instruction == _ins ) + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_COMMON_UTILS_H_ */ diff --git a/dependencies/fcml/include/fcml_dialect.h b/dependencies/fcml/include/fcml_dialect.h new file mode 100644 index 0000000..75571c5 --- /dev/null +++ b/dependencies/fcml/include/fcml_dialect.h @@ -0,0 +1,53 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_dialect.h + * Structures and functions related to dialects. + * Functions and structures used for developing new dialects are not exposed + * as public API. If you are interested in implementing another dialect + * you have to use internal headers. + * + * @copyright Copyright (C) 2010-2019 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_DIALECT_H_ +#define FCML_DIALECT_H_ + +#include "fcml_lib_export.h" + +/** Assembler dialect.*/ +typedef struct fcml_st_dialect fcml_st_dialect; + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Frees dialect instance. + * Frees all resources occupied by the dialect instance. + * @param dialect Dialect to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_dialect_free( fcml_st_dialect *dialect ); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_DIALECT_H_ */ diff --git a/dependencies/fcml/include/fcml_dialect.hpp b/dependencies/fcml/include/fcml_dialect.hpp new file mode 100644 index 0000000..1bea71c --- /dev/null +++ b/dependencies/fcml/include/fcml_dialect.hpp @@ -0,0 +1,129 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_dialect.hpp + * C++ wrapper for the base dialect. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_DIALECT_HPP_ +#define FCML_DIALECT_HPP_ + +#include "fcml_common.hpp" + +#include "fcml_dialect.h" + +namespace fcml { + +/** + * An abstract dialect. It's a base class for all supported dialects. + * @since 1.1.0 + * @remarks This class is thread-safe. + */ +class Dialect: public NonCopyable { +protected: + + /** + * Default constructor. + * @since 1.1.0 + */ + Dialect() { + _dialect = NULL; + } + + /** + * Virtual destructor. + * @since 1.1.0 + */ + virtual ~Dialect() { + if (_dialect) { + ::fcml_fn_dialect_free(_dialect); + _dialect = NULL; + } + } + +protected: + + friend class DialectAware; + + /** + * Gets the wrapped FCML dialect. + * + * @return The wrapped FCML dialect. + * @since 1.1.0 + */ + fcml_st_dialect* getDialect() const { + return _dialect; + } + + /** + * Sets a new dialect for the wrapper. + * + * @param dialect The new dialect for the wrapper. + * @since 1.1.0 + */ + void setDialect(fcml_st_dialect *dialect) { + this->_dialect = dialect; + } + +private: + + /** Wrapped dialect */ + fcml_st_dialect *_dialect; + +}; + +/** Inherit from this class in order to get access to the native FCML + * dialect structure. + * @since 1.1.0 + */ +class DialectAware { +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + DialectAware() { + } + + /** + * Virtual destructor. + * @since 1.1.0 + */ + virtual ~DialectAware() { + } + + /** + * Extracts the native FCML dialect from the dialect object. + * + * @param dialect The wrapper. + * @return The wrapped FCML dialect. + * @since 1.1.0 + */ + fcml_st_dialect* extractDialect(const Dialect &dialect) const { + return dialect.getDialect(); + } +}; + +} + +#endif /* FCML_DIALECT_HPP_ */ diff --git a/dependencies/fcml/include/fcml_disassembler.h b/dependencies/fcml/include/fcml_disassembler.h new file mode 100644 index 0000000..00da9e9 --- /dev/null +++ b/dependencies/fcml/include/fcml_disassembler.h @@ -0,0 +1,356 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_disassembler.h + * Structures and functions declarations related to FCML disassembler. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_DISASSEMBLER_H_ +#define FCML_DISASSEMBLER_H_ + +#include "fcml_lib_export.h" + +#include "fcml_instructions.h" +#include "fcml_types.h" +#include "fcml_errors.h" +#include "fcml_common.h" +#include "fcml_dialect.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Maximal number of instruction prefixes. */ +#define FCML_DASM_PREFIXES_COUNT 12 + +/** First group of conditional suffixes (See FCML manual). */ +#define FCML_DASM_CONDITIONAL_GROUP_1 0x00 +/** Second group of conditional suffixes (See FCML manual). */ +#define FCML_DASM_CONDITIONAL_GROUP_2 0x01 + +/** This structure and type declaration represents an abstract disassembler. */ +typedef struct fcml_st_disassembler fcml_st_disassembler; + +/** Disassembler configuration. */ +typedef struct fcml_st_disassembler_conf { + /** Set to true in order to make disassembler to increment IP address by + * length of the disassembled instruction. */ + fcml_bool increment_ip; + /** True if optional error and warning messages should be collected + * during processing. */ + fcml_bool enable_error_messages; + /** True if suffixes for carry flag has to be used by disassembler.*/ + fcml_bool carry_flag_conditional_suffix; + /** There are two groups of suffixes for conditional instructions, you + * can choose which one should be used. */ + fcml_uint8_t conditional_group; + /** Set to true in order to use short forms. + * For instance 'cmpsb' will be used instead of + * 'cmps byte ptr [si],byte ptr [di]' + */ + fcml_bool short_forms; + /** True if displacement should be sign extended to effective + * address size; otherwise false. */ + fcml_bool extend_disp_to_asa; + /** If set to true assembler will return FCML_CEH_GEC_UNKNOWN_INSTRUCTION + * error code if instruction is not known. + */ + fcml_bool fail_if_unknown_instruction; +} fcml_st_disassembler_conf; + +/** Disassembler context. */ +typedef struct fcml_st_disassembler_context { + /** Disassembler used to decode instructions. */ + fcml_st_disassembler *disassembler; + /** Disassembler configuration. */ + fcml_st_disassembler_conf configuration; + /** Instruction entry point configuration. */ + fcml_st_entry_point entry_point; + /** Pointer to the encoded instruction. */ + fcml_ptr code; + /** Size of the code in the buffer above. */ + fcml_usize code_length; +} fcml_st_disassembler_context; + +/* Prefixes */ + +/** Available types of instruction prefixes. For more information see + * Intel/AMD Architecture Manual. */ +typedef enum fcml_en_prefix_types { + FCML_PT_GROUP_UNKNOWN = 0, + FCML_PT_GROUP_1 = 1, + FCML_PT_GROUP_2, + FCML_PT_GROUP_3, + FCML_PT_GROUP_4, + FCML_PT_REX, + FCML_PT_VEX, + FCML_PT_XOP, + FCML_PT_EVEX +} fcml_en_prefix_types; + +/** Describes one decoded prefix. */ +typedef struct fcml_st_instruction_prefix { + /** Prefix itself as raw byte. */ + fcml_uint8_t prefix; + /** Type of the prefix. */ + fcml_en_prefix_types prefix_type; + /** FCML_TRUE if prefix is treated as mandatory one. */ + fcml_bool mandatory_prefix; + /** Place for additional bytes of VEX/EVEX/XOP prefix. + * since 1.2.0 + */ + fcml_uint8_t avx_bytes[3]; +} fcml_st_instruction_prefix; + +/** + * Contains some additional information about all decoded + * instruction prefixes. + */ +typedef struct fcml_st_prefixes_details { + /** Array with decoded prefixes. */ + fcml_st_instruction_prefix prefixes[FCML_DASM_PREFIXES_COUNT]; + /** Number of decoded prefixes. */ + fcml_int prefixes_count; + /** Number of bytes used by all decoded prefixes. */ + fcml_int prefixes_bytes_count; + /** FCML_TRUE if branch prefix exists. */ + fcml_bool is_branch; + /** FCML_TRUE if nobranch prefix exists. */ + fcml_bool is_nobranch; + /** FCML_TRUE if lock explicit prefix exists. */ + fcml_bool is_lock; + /** FCML_TRUE if rep explicit prefix exists. */ + fcml_bool is_rep; + /** FCML_TRUE if repne explicit prefix exists. */ + fcml_bool is_repne; + /** FCML_TRUE if xrelease explicit prefix exists. */ + fcml_bool is_xrelease; + /** FCML_TRUE if xacquire explicit prefix exists. */ + fcml_bool is_xacquire; + /** FCML_TRUE if VEX prefix exists. */ + fcml_bool is_vex; + /** FCML TRUE if EVEX prefix exists. */ + fcml_bool is_evex; + /** FCML_TRUE if XOP prefix exists. */ + fcml_bool is_xop; + /** True if it is an AVX instruction (VEX/XOP/EVEX). */ + fcml_bool is_avx; + /** FCML_TRUE if REX prefix exists. */ + fcml_bool is_rex; + /** First byte of AVX prefix. */ + fcml_uint8_t avx_first_byte; + /** R field of REX,XOP or VEX prefix. */ + fcml_uint8_t R; + /** EVEX R’ High-16 register specifier modifier. */ + fcml_uint8_t R_prim; + /** X field of REX,XOP or VEX prefix. */ + fcml_uint8_t X; + /** B field of REX,XOP or VEX prefix. */ + fcml_uint8_t B; + /** b field of EVEX prefix. */ + fcml_uint8_t b; + /** W field of REX,XOP or VEX/EVEX prefix. */ + fcml_uint8_t W; + /** L field of XOP or VEX prefix. */ + fcml_uint8_t L; + /** L’ field of EVEX prefix. */ + fcml_uint8_t L_prim; + /** m-mmmm field of XOP or VEX prefix. */ + fcml_uint8_t mmmm; + /** vvvv field of XOP or VEX prefix. */ + fcml_uint8_t vvvv; + /** pp field of XOP or VEX/EVEX prefix. */ + fcml_uint8_t pp; + /** z field of EVEX prefix */ + fcml_uint8_t z; + /** V’ field of EVEX prefix. */ + fcml_uint8_t V_prim; + /** Embedded opmask register specifier. */ + fcml_uint8_t aaa; +} fcml_st_prefixes_details; + +/** Some additional disassembler specific information about decoded operands. */ +typedef struct fcml_st_operand_details { + /** Instruction operand access mode READ, WRITE or both. */ + fcml_en_access_mode access_mode; +} fcml_st_operand_details; + +/** + * Displacement in raw form. + */ +typedef struct fcml_st_raw_displacement { + /** Displacement as encoded in disp8/disp16/disp32/disp8*N. */ + fcml_st_integer displacement; + /** Scaling factor N in EVEX specific compressed disp8*N. */ + fcml_nuint32_t N; +} fcml_st_raw_displacement; + +/** Some basic information about decoded ModR/M and SIB bytes. */ +typedef struct fcml_st_decoded_modrm_details { + /** ModR/M byte if exists.*/ + fcml_uint8_t modrm; + /** SIB byte if exists.*/ + fcml_nuint8_t sib; + /** True if RIP encoding is used by decoded instruction. This flag is + * used only in 64 bit mode. */ + fcml_bool is_rip; + /** True if ModR/M exists. */ + fcml_bool is_modrm; + /** Raw displacement */ + fcml_st_raw_displacement displacement; +} fcml_st_decoded_modrm_details; + +/** Additional instruction details provided by disassembler. */ +typedef struct fcml_st_instruction_details { + /** True if this is a shortcut. + * A good example of such instruction is 'cmpsb' as opposed to + * 'cmps byte ptr [si],byte ptr [di]'. It is very important to take this + * information into consideration when instruction models are analyzed + * because there is no operands in the GIM for shortcuts. + */ + fcml_bool is_shortcut; + /** True if given instruction is a short form of pseudo-ops instructions. + * See 'vcmpunordsd' for instance. */ + fcml_bool is_pseudo_op; + /** Code of the disassembled instruction. */ + fcml_uint8_t instruction_code[FCML_INSTRUCTION_SIZE]; + /** Instruction size in bytes. */ + fcml_usize instruction_size; + /** Some additional information about decoded instruction prefixes. */ + fcml_st_prefixes_details prefixes_details; + /** All disassembler specific information about operands going there. */ + fcml_st_operand_details operand_details[FCML_OPERANDS_COUNT]; + /** Details about decoded ModR/M and SIB bytes. */ + fcml_st_decoded_modrm_details modrm_details; + /** Opcode field 's'. + * This is set only for informational purpose only and you should not + * use it for any critical functionality. + */ + fcml_bool opcode_field_s_bit; + /** Opcode field 'w'. + * This is set only for informational purpose only and you should not + * use it for any critical functionality. + */ + fcml_bool opcode_field_w_bit; + /** Instruction code/number. @see fcml_instructions.h header file. */ + fcml_en_instruction instruction; + /** Pseudo operation code. */ + fcml_en_pseudo_operations pseudo_op; + /** Code of the instruction form/addressing mode of the instruction + * above. */ + fcml_uint16_t addr_mode; + /** Instruction group. */ + fcml_uint64_t instruction_group; + /** avx-512 tuple type */ + fcml_uint8_t tuple_type; +} fcml_st_instruction_details; + +/** Reusable disassembler result holder. */ +typedef struct fcml_st_disassembler_result { + /** All errors and warnings messages going here. */ + fcml_st_ceh_error_container errors; + /** Additional disassembler specific information about decoded + * instruction. */ + fcml_st_instruction_details instruction_details; + /** Decoded instruction in its generic form.*/ + fcml_st_instruction instruction; +} fcml_st_disassembler_result; + +/** + * Initializes disassembler instance. + * Initializes disassembler instance for given dialect. Disassembler + * initialized in such a way is dialect dependent and generates generic + * instruction models compliant to the syntax supported by the dialect + * (Intel, AT&T). Every disassembler instance has to be freed using + * fcml_fn_disassembler_free() function as soon as it is not needed anymore. + * + * @param dialect Dialect for newly created disassembler. + * @param[out] disassembler Initialized disassembler instance. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @see fcml_fn_disassembler_free + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_disassembler_init( + const fcml_st_dialect *dialect, fcml_st_disassembler **disassembler); + +/** + * Disassembles one instruction from provided code buffer. + * Disassembles the first instruction available in the provided code buffer + * using disassembler instance, configuration and entry point accessible through + * the disassembler context. Disassembled instruction model as well as potential + * errors are returned in reusable result holder given in the second parameter. + * Result holder has to be allocated by the user and appropriately prepared + * using fcml_fn_disassembler_result_prepare() function. As long as the + * instruction context and the result holder are not shared across multiple + * function calls disassembling process is thread safe. + * + * @param context Disassembler context. + * @param result Appropriately prepared result holder. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @see fcml_fn_disassembler_result_free + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_disassemble( + fcml_st_disassembler_context *context, + fcml_st_disassembler_result *result); + +/** + * Prepares reusable result holder for disassembler. + * Every instance of fcml_st_disassembler_result structure is reusable from + * the disassembler's point of view, so it has to be prepared in the right + * way in order to allow disassembler to reuse it correctly. It is up to the + * library user to allocate space for the holder itself. This function is only + * responsible for cleaning the structure correctly and preparing it for first + * disassembling process. Notice that disassembler has to clean the result + * holder at the beginning so you can not pass an uninitialized memory + * block because it can even cause a crash due to illegal memory access. + * + * @param result Result holder instance to be prepared. + * @see fcml_fn_disassembler_result_free + */ +LIB_EXPORT void LIB_CALL fcml_fn_disassembler_result_prepare( + fcml_st_disassembler_result *result); + +/** + * Cleans result holder. + * Frees all memory blocks allocated by the disassembler and held inside + * the result holder (Instructions, errors etc.). Notice that result holder + * itself is not freed and can be even safety reused after calling this + * function. In fact this function is also called internally by assembler in + * order to clean result holder before reusing it. + * + * @param result Result holder to clean. + */ +LIB_EXPORT void LIB_CALL fcml_fn_disassembler_result_free( + fcml_st_disassembler_result *result); + +/** + * Frees disassembler instance. + * Every disassembler instance manages some resources internally and as + * such it has to be deallocated as soon as it is not needed anymore. + * @param disassembler Disassembler to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_disassembler_free( + fcml_st_disassembler *disassembler); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_DISASSEMBLER_H_ */ diff --git a/dependencies/fcml/include/fcml_disassembler.hpp b/dependencies/fcml/include/fcml_disassembler.hpp new file mode 100644 index 0000000..4660e5c --- /dev/null +++ b/dependencies/fcml/include/fcml_disassembler.hpp @@ -0,0 +1,2329 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_disassembler.hpp + * C++ wrapper for the FCML disassembler. + * + * @copyright Copyright (C) 2010-2017 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_DISASSEMBLER_HPP_ +#define FCML_DISASSEMBLER_HPP_ + +#include + +#include "fcml_disassembler.h" + +#include "fcml_common.hpp" +#include "fcml_errors.hpp" +#include "fcml_dialect.hpp" + +namespace fcml { + +/** + * Component can not be initialized correctly. + * @since 1.1.0 + */ +class DisassemblingFailedException: public ErrorContainerAwareException { +public: + DisassemblingFailedException(const fcml_cstring &msg, + const ErrorContainer &errorContainer, + fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR) : + ErrorContainerAwareException(msg, errorContainer, error) { + } +}; + +/** Disassembler configuration. + * + * It's counterpart to the fcml_st_disassembler_conf structure. + * @since 1.1.0 + */ +class DisassemblerConf { +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + DisassemblerConf() : + _throwExceptionOnError(true), + _incrementIP(true), + _enableErrorMessages(true), + _carryFlagConditionalSuffix(false), + _conditionalGroup(false), + _shortForms(false), + _extendDispToASA(false), + _failIfUnknownInstruction(false) { + } + + /** @since 1.1.0 */ + bool isCarryFlagConditionalSuffix() const { + return _carryFlagConditionalSuffix; + } + + /** @since 1.1.0 */ + void setCarryFlagConditionalSuffix(bool carryFlagConditionalSuffix) { + _carryFlagConditionalSuffix = carryFlagConditionalSuffix; + } + + /** @since 1.1.0 */ + fcml_uint8_t getConditionalGroup() const { + return _conditionalGroup; + } + + /** @since 1.1.0 */ + void setConditionalGroup(fcml_uint8_t conditionalGroup) { + _conditionalGroup = conditionalGroup; + } + + /** @since 1.1.0 */ + bool isEnableErrorMessages() const { + return _enableErrorMessages; + } + + /** @since 1.1.0 */ + void setEnableErrorMessages(bool enableErrorMessages) { + _enableErrorMessages = enableErrorMessages; + } + + /** @since 1.1.0 */ + bool isExtendDispToAsa() const { + return _extendDispToASA; + } + + /** @since 1.1.0 */ + void setExtendDispToAsa(bool extendDispToAsa) { + _extendDispToASA = extendDispToAsa; + } + + /** @since 1.1.0 */ + bool isFailIfUnknownInstruction() const { + return _failIfUnknownInstruction; + } + + /** @since 1.1.0 */ + void setFailIfUnknownInstruction(bool failIfUnknownInstruction) { + _failIfUnknownInstruction = failIfUnknownInstruction; + } + + /** @since 1.1.0 */ + bool isIncrementIp() const { + return _incrementIP; + } + + /** @since 1.1.0 */ + void setIncrementIp(bool incrementIp) { + _incrementIP = incrementIp; + } + + /** @since 1.1.0 */ + bool isShortForms() const { + return _shortForms; + } + + /** @since 1.1.0 */ + void setShortForms(bool shortForms) { + _shortForms = shortForms; + } + + /** + * Returns true if exception should be thrown when disassembling fails. + * + * @return True if exception is the preferred way of error + * handling in case of failure. + * @since 1.1.0 + */ + bool isThrowExceptionOnError() const { + return _throwExceptionOnError; + } + + /** + * Sets the way how the error handling is done. + * + * @param throwExceptionOnError True if exception should be thrown + * in case of failure. + * @since 1.1.0 + */ + void setThrowExceptionOnError(bool throwExceptionOnError) { + _throwExceptionOnError = throwExceptionOnError; + } + +private: + bool _throwExceptionOnError; + bool _incrementIP; + bool _enableErrorMessages; + bool _carryFlagConditionalSuffix; + fcml_uint8_t _conditionalGroup; + bool _shortForms; + bool _extendDispToASA; + bool _failIfUnknownInstruction; + +}; + +/** Disassembler context. + * @since 1.1.0 + */ +class DisassemblerContext { +public: + + /** + * Creates empty disassembler context. + * @since 1.1.0 + */ + DisassemblerContext() : + _code(NULL), _codeLength(0) { + } + + /** + * Creates disassembler context for given piece of machine code. + * + * @param code A buffer with the machine code. + * @param codeLength Size of the buffer in bytes. + * @since 1.1.0 + */ + DisassemblerContext(fcml_ptr code, fcml_usize codeLength) : + _code(code), _codeLength(codeLength) { + } + +public: + + /** + * Gets pointer to the machine code buffer. + * + * @return A pointer to the machine code. + * @since 1.1.0 + */ + fcml_ptr getCode() const { + return _code; + } + + /** + * Sets a new buffer with machine code for the context. + * + * @param code The new code buffer. + * @since 1.1.0 + */ + void setCode(fcml_ptr code) { + _code = code; + } + + /** + * Gets length of the buffer in bytes. + * + * @return Size of the buffer. + * @since 1.1.0 + */ + fcml_usize getCodeLength() const { + return _codeLength; + } + + /** + * Sets length of the code buffer in bytes. + * + * @param codeLength Size of the code. + * @since 1.1.0 + */ + void setCodeLength(fcml_usize codeLength) { + _codeLength = codeLength; + } + + /** + * Gets a reference to the configuration object associated with the context. + * + * @return The disassembler configuration. + * @since 1.1.0 + */ + const DisassemblerConf& getDisassemblerConf() const { + return _disassemblerConf; + } + + /** + * Gets a reference to the configuration object associated with the context. + * + * @return The disassembler configuration. + * @since 1.1.0 + */ + DisassemblerConf& getDisassemblerConf() { + return _disassemblerConf; + } + + /** + * Sets a new disassembler configuration for the context. + * + * @param disassemblerConf The new disassembler configuration. + * @since 1.1.0 + */ + void setDisassemblerConf(DisassemblerConf disassemblerConf) { + _disassemblerConf = disassemblerConf; + } + + /** + * Gets reference to the constant entry point instance + * associated with the context. + * + * @return Reference to the constant entry point. + * @since 1.1.0 + */ + const EntryPoint& getEntryPoint() const { + return _entryPoint; + } + + /** + * Gets reference to the entry point instance associated with the context. + * + * @return Reference to the entry point. + * @since 1.1.0 + */ + EntryPoint& getEntryPoint() { + return _entryPoint; + } + /** + * Copies given entry point to the instance associated with the context. + * Deep copy is performed, so passed object not need to be maintained as + * long as the context is used. + * + * @param entryPoint The entry point which is copied to the context. + * @since 1.1.0 + */ + void setEntryPoint(const EntryPoint &entryPoint) { + _entryPoint = entryPoint; + } + + /** + * Sets instruction pointer directly into the entry point. + * + * @param ip The new IP. + * @since 1.1.0 + */ + void setIP(fcml_ip ip) { + _entryPoint.setIP(ip); + } + + /** + * Increments entry point by given number of bytes. + * + * @param ip Number of bytes the instruction pointer has to be + * incremented by. + * @since 1.1.0 + */ + void incrementIP(fcml_ip ip) { + _entryPoint.incrementIP(ip); + } + + /** + * Sets processor operating mode directly into the entry point. + * + * @param operatingMode Processor operating mode to be set. + * @since 1.1.0 + */ + void setOperatingMode(EntryPoint::OperatingMode operatingMode) { + _entryPoint.setOpMode(operatingMode); + } + + /** + * Sets a new address size attribute for the entry point. + * + * @param addressSizeAttribute The address size attribute. + * @since 1.1.0 + */ + void setAddressSizeAttribute(fcml_usize addressSizeAttribute) { + _entryPoint.setAddressSizeAttribute(addressSizeAttribute); + } + + /** + * Sets a new operand size attribute for the entry point. + * + * @param operandSizeAttribute The operand size attribute. + * @since 1.1.0 + */ + void setOperandSizeAttribute(fcml_usize operandSizeAttribute) { + _entryPoint.setOperandSizeAttribute(operandSizeAttribute); + } + +private: + /** Disassembler configuration. */ + DisassemblerConf _disassemblerConf; + /** Entry point. */ + EntryPoint _entryPoint; + /** Code buffer. */ + fcml_ptr _code; + /** Code length. */ + fcml_usize _codeLength; +}; + +/** Instruction prefix. + * @since 1.1.0 + */ +class InstructionPrefixDetails { +public: + + /** Type of the instruction prefix. + * @since 1.1.0 + */ + enum PrefixType { + PT_GROUP_UNKNOWN = FCML_PT_GROUP_UNKNOWN, + PT_GROUP_1 = FCML_PT_GROUP_1, + PT_GROUP_2 = FCML_PT_GROUP_2, + PT_GROUP_3 = FCML_PT_GROUP_3, + PT_GROUP_4 = FCML_PT_GROUP_4, + PT_REX = FCML_PT_REX, + PT_VEX = FCML_PT_VEX, + PT_XOP = FCML_PT_XOP, + PT_EVEX = FCML_PT_EVEX + }; + + /** + * Returns true if it's a mandatory prefix. + * + * @return True if it's a mandatory prefix. + * @since 1.1.0 + */ + bool isMandatoryPrefix() const { + return _mandatoryPrefix; + } + + /** + * Sets mandatory prefix flag for the prefix. + * + * @param mandatoryPrefix Set to true in order to make the + * prefix mandatory one. + * @since 1.1.0 + */ + void setMandatoryPrefix(bool mandatoryPrefix) { + _mandatoryPrefix = mandatoryPrefix; + } + + /** + * Gets the prefix byte. + * + * @return The prefix byte. + * @since 1.1.0 + */ + fcml_uint8_t getPrefix() const { + return _prefix; + } + + /** + * Sets the prefix byte. + * + * @param prefix The prefix byte. + * @since 1.1.0 + */ + void setPrefix(fcml_uint8_t prefix) { + _prefix = prefix; + } + + /** + * Gets the prefix type. + * + * @return The prefix byte. + * @since 1.1.0 + */ + PrefixType getPrefixType() const { + return _prefixType; + } + + /** + * Sets a new prefix type. + * + * @param prefixType The prefix byte to be set. + * @since 1.1.0 + */ + void setPrefixType(PrefixType prefixType) { + _prefixType = prefixType; + } + + /** + * Gets the second and third bytes of the XOP/VEX prefix. + * + * @return A pointer to the VEX/XOP bytes. + * @since 1.2.0 + */ + const fcml_uint8_t* getAvxBytes() const { + return _AvxBytes; + } + + /** + * Gets the second and third bytes of the XOP/VEX prefix. + * + * @return A pointer to the VEX/XOP bytes. + * @since 1.2.0 + */ + fcml_uint8_t* getAvxBytes() { + return _AvxBytes; + } + +private: + /** The first byte of the prefix. */ + fcml_uint8_t _prefix; + /** Tye type of the prefix. */ + PrefixType _prefixType; + /** True if the prefix is a mandatory one. */ + bool _mandatoryPrefix; + /** The second and third byte of the AVX prefix. + * since 1.2.0 + */ + fcml_uint8_t _AvxBytes[3]; +}; + +/** Prefixes details. + * @since 1.1.0 + */ +class PrefixesDetails { +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + PrefixesDetails() : + _prefixesCount(0), + _prefixesBytesCount(0), + _isBranch(false), + _isNobranch(false), + _isLock(false), + _isRep(false), + _isRepne(false), + _isXrelease(false), + _isXacquire(false), + _isVex(false), + _isEvex(false), + _isXop(false), + _isAvx(false), + _isRex(false), + _AvxPrefixFirstByte(false), + _R(0), + _RPrim(0), + _X(0), + _B(0), + _W(0), + _L(0), + _LPrim(0), + _mmmm(0), + _vvvv(0), + _VPrim(0), + _pp(0), + _aaa(0), + _b(false), + _z(false) { + } + + /** + * Gets reference to the instruction prefix at given index. + * @param index Number of the prefix. + * @return The instruction prefix for given index. + * @throw IllegalArgumentException Index out of bound. + * @since 1.1.0 + */ + const InstructionPrefixDetails& operator[](fcml_usize index) const { + if (index >= FCML_DASM_PREFIXES_COUNT) { + throw IllegalArgumentException(FCML_TEXT("Index out of bound.")); + } + return _prefixes[index]; + } + + /** + * Gets reference to the instruction prefix at given index. + * @param index Number of the prefix. + * @return The instruction prefix for given index. + * @throw IllegalArgumentException Index out of bound. + * @since 1.1.0 + */ + InstructionPrefixDetails& operator[](fcml_usize index) { + if (index >= FCML_DASM_PREFIXES_COUNT) { + throw IllegalArgumentException(FCML_TEXT("Index out of bound.")); + } + return _prefixes[index]; + } + + /** + * Gets b flag. + * + * @return The B flag. + * @since 1.1.0 + */ + fcml_uint8_t getB() const { + return _B; + } + + /** + * Sets B flag. + * + * @param b The B flag. + * @since 1.1.0 + */ + void setB(fcml_uint8_t B) { + _B = B; + } + + /** + * Gets true if branch prefix is available. + * + * @return True if branch prefix is available. + * @since 1.1.0 + */ + bool isBranch() const { + return _isBranch; + } + + /** + * Sets branch prefix availability. + * + * @param isBranch True if branch prefix is available. + * @since 1.1.0 + */ + void setBranch(bool isBranch) { + _isBranch = isBranch; + } + + /** + * Gets true if lock prefix is available. + * + * @return True if lock prefix is available. + * @since 1.1.0 + */ + bool isLock() const { + return _isLock; + } + + /** + * Sets lock prefix availability. + * + * @param isLock True if lock prefix is available. + * @since 1.1.0 + */ + void setLock(bool isLock) { + _isLock = isLock; + } + + /** + * Gets true if no-branch prefix is available. + * + * @return True if no-branch prefix is available. + * @since 1.1.0 + */ + bool isNobranch() const { + return _isNobranch; + } + + /** + * Sets no-branch prefix availability. + * + * @param isNobranch True if no-branch prefix is available. + * @since 1.1.0 + */ + void setNobranch(bool isNobranch) { + _isNobranch = isNobranch; + } + + /** + * Gets true if Rep prefix is available. + * + * @return True if Rep prefix is available. + * @since 1.1.0 + */ + bool isRep() const { + return _isRep; + } + + /** + * Sets Rep prefix availability. + * + * @param isRep True if Rep prefix is available. + * @since 1.1.0 + */ + void setRep(bool isRep) { + _isRep = isRep; + } + + /** + * Gets true if Repne prefix is available. + * + * @return True if Repne prefix is available. + * @since 1.1.0 + */ + bool isRepne() const { + return _isRepne; + } + + /** + * Sets Repne prefix availability. + * + * @param isRepne True if branch prefix is available. + * @since 1.1.0 + */ + void setRepne(bool isRepne) { + _isRepne = isRepne; + } + + /** + * Gets true if Rex prefix is available. + * + * @return True if Rex prefix is available. + * @since 1.1.0 + */ + bool isRex() const { + return _isRex; + } + + /** + * Sets REX prefix availability. + * + * @param isRex True if REX prefix is available. + * @since 1.1.0 + */ + void setRex(bool isRex) { + _isRex = isRex; + } + + /** + * Gets true if Vex prefix is available. + * + * @return True if Vex prefix is available. + * @since 1.1.0 + */ + bool isVex() const { + return _isVex; + } + + /** + * Sets VEX prefix availability. + * + * @param isVex True if VEX prefix is available. + * @since 1.1.0 + */ + void setVex(bool isVex) { + _isVex = isVex; + } + + /** + * Sets EVEX prefix availability. + * + * @param isEvex True if EVEX prefix is available. + * @since 1.2.0 + */ + void setEvex(bool isEvex) { + _isEvex = isEvex; + } + + /** + * Gets true if EVEX prefix is available. + * + * @return True if EVEX prefix is available. + * @since 1.2.0 + */ + bool isEvex() const { + return _isEvex; + } + + /** + * Gets true if xacquire prefix is available. + * + * @return True if xacquire prefix is available. + * @since 1.1.0 + */ + bool isXacquire() const { + return _isXacquire; + } + + /** + * Sets xacquire prefix availability. + * + * @param isXacquire True if xacquire prefix is available. + * @since 1.1.0 + */ + void setXacquire(bool isXacquire) { + _isXacquire = isXacquire; + } + + /** + * Gets true if XOP prefix is available. + * + * @return True if XOP prefix is available. + * @since 1.1.0 + */ + bool isXop() const { + return _isXop; + } + + /** + * Sets XOP prefix availability. + * + * @param isXop True if XOP prefix is available. + * @since 1.1.0 + */ + void setXop(bool isXop) { + _isXop = isXop; + } + + /** + * Gets true if any AVX prefix is available. + * + * @return True if any AVX prefix is available. + * @since 1.2.0 + */ + bool isAvx() const { + return _isAvx; + } + + /** + * Sets XOP prefix availability. + * + * @param isXop True if XOP prefix is available. + * @since 1.2.0 + */ + void setAvx(bool isAvx) { + _isAvx = isAvx; + } + + /** + * Gets true if xrelease prefix is available. + * + * @return True if xrelease prefix is available. + * @since 1.1.0 + */ + bool isXrelease() const { + return _isXrelease; + } + + /** + * Sets xrelease prefix availability. + * + * @param isXrelease True if xrelease prefix is available. + * @since 1.1.0 + */ + void setXrelease(bool isXrelease) { + _isXrelease = isXrelease; + } + + /** + * Gets L flag. + * + * @return The L flag. + * @since 1.1.0 + */ + fcml_uint8_t getL() const { + return _L; + } + + /** + * Sets L flag. + * + * @param l The L flag. + * @since 1.1.0 + */ + void setL(fcml_uint8_t L) { + _L = L; + } + + /** + * Gets L' flag. + * + * @return The L' flag. + * @since 1.2.0 + */ + fcml_uint8_t getLPrim() const { + return _LPrim; + } + + /** + * Sets L' flag. + * + * @param l The L' flag. + * @since 1.2.0 + */ + void setLPrim(fcml_uint8_t lPrim) { + _LPrim = lPrim; + } + + /** + * Gets MMMM field. + * + * @return MMMM field. + * @since 1.1.0 + */ + fcml_uint8_t getMmmm() const { + return _mmmm; + } + + /** + * Sets MMMM field. + * + * @param mmmm MMMM field. + * @since 1.1.0 + */ + void setMmmm(fcml_uint8_t mmmm) { + _mmmm = mmmm; + } + + /** + * Gets PP field. + * + * @return The PP field. + * @since 1.1.0 + */ + fcml_uint8_t getPp() const { + return _pp; + } + + /** + * Sets PP field. + * + * @param pp PP field. + * @since 1.1.0 + */ + void setPp(fcml_uint8_t pp) { + _pp = pp; + } + + /** + * Gets a reference to the prefix of the given index. + * + * @param index Index for the prefix. + * @return The prefix at given index. + * @throw BadArgumentException Array index out of bound. + * @since 1.1.0 + */ + const InstructionPrefixDetails& getPrefixes(fcml_usize index) const { + if (index > FCML_DASM_PREFIXES_COUNT) { + throw BadArgumentException(FCML_TEXT("Array index out of bound."), + FCML_CEH_GEC_VALUE_OUT_OF_RANGE); + } + return _prefixes[index]; + } + + /** + * Gets a reference to the prefix of the given index. + * + * @param index Index for the prefix. + * @return The prefix at given index. + * @throw BadArgumentException Array index out of bound. + * @since 1.1.0 + */ + InstructionPrefixDetails& getPrefixes(fcml_usize index) { + if (index > FCML_DASM_PREFIXES_COUNT) { + throw BadArgumentException(FCML_TEXT("Array index out of bound."), + FCML_CEH_GEC_VALUE_OUT_OF_RANGE); + } + return _prefixes[index]; + } + + /** + * Gets number of bytes interpreted to be prefixes. + * + * @return Number of prefixes bytes. + * @since 1.1.0 + */ + fcml_int getPrefixesBytesCount() const { + return _prefixesBytesCount; + } + + /** + * Sets number of prefixes bytes available for the instruction. + * + * @param prefixesBytesCount Number of the prefixes bytes. + * @since 1.1.0 + */ + void setPrefixesBytesCount(fcml_int prefixesBytesCount) { + _prefixesBytesCount = prefixesBytesCount; + } + + /** + * Gets number of prefixes available for the instruction. + * + * @return Number of the prefixes for the instruction. + * @since 1.1.0 + */ + fcml_int getPrefixesCount() const { + return _prefixesCount; + } + + /** + * Sets number of prefixes available for the instruction. + * + * @param prefixesCount Number of the available prefixes. + * @since 1.1.0 + */ + void setPrefixesCount(fcml_int prefixesCount) { + _prefixesCount = prefixesCount; + } + + /** + * Gets R flag. + * + * @return The R flag. + * @since 1.1.0 + */ + fcml_uint8_t getR() const { + return _R; + } + + /** + * Sets R flag. + * + * @param r The R flag. + * @since 1.1.0 + */ + void setR(fcml_uint8_t r) { + _R = r; + } + + /** + * Gets R' flag. + * + * @return The R' flag. + * @since 1.2.0 + */ + fcml_uint8_t getRPrim() const { + return _RPrim; + } + + /** + * Sets R' flag. + * + * @param rPrim The R' flag. + * @since 1.2.0 + */ + void setRPrim(fcml_uint8_t rPrim) { + _RPrim = rPrim; + } + + /** + * Gets the first byte of the AVX prefix. + * + * @return The first byte of the AVX prefix. + * @since 1.2.0 + */ + fcml_uint8_t getAvxFirstByte() const { + return _AvxPrefixFirstByte; + } + + /** + * Sets a first byte of the XOP/VEX prefix. + * + * @param avxFirstByte The first AVX prefix byte. + * @since 1.2.0 + */ + void setAvxFirstByte(fcml_uint8_t avxFirstByte) { + _AvxPrefixFirstByte = avxFirstByte; + } + + /** + * Gets VVVV field of the XOP/VEX prefix. + * + * @return VVVV field of the XOP/VEX prefix. + * @since 1.1.0 + */ + fcml_uint8_t getVvvv() const { + return _vvvv; + } + + /** + * Sets VVVV field of the XOP/VEX prefix. + * + * @param vvvv The VVVV field. + * @since 1.1.0 + */ + void setVvvv(fcml_uint8_t vvvv) { + _vvvv = vvvv; + } + + /** + * Gets 'aaa' field of the EVEX prefix. + * + * @return aaa field of the EVEX prefix. + * @since 1.2.0 + */ + fcml_uint8_t getAaa() const { + return _aaa; + } + + /** + * Sets 'aaa' field of the EVEX prefix. + * + * @param aaa The 'aaa' field. + * @since 1.1.0 + */ + void setAaa(fcml_uint8_t aaa) { + _aaa = aaa; + } + + /** + * Gets V' flag. + * + * @return The V' flag. + * @since 1.2.0 + */ + fcml_uint8_t getVPrim() const { + return _VPrim; + } + + /** + * Sets V' flag. + * + * @param vPrim The V' flag. + * @since 1.2.0 + */ + void setVPrim(fcml_uint8_t vPrim) { + _VPrim = vPrim; + } + + /** + * Gets W flag. + * + * @return The W flag. + * @since 1.1.0 + */ + fcml_uint8_t getW() const { + return _W; + } + + /** + * Sets W flag. + * + * @param w The W flag. + * @since 1.1.0 + */ + void setW(fcml_uint8_t W) { + _W = W; + } + + /** + * Gets X flag. + * + * @return The X flag. + * @since 1.1.0 + */ + fcml_uint8_t getX() const { + return _X; + } + + /** + * Sets X flag. + * + * @param x The X flag. + * @since 1.1.0 + */ + void setX(fcml_uint8_t X) { + _X = X; + } + + /** + * Gets EVEX.b bit. + * + * @return The EVEX.b bit. + * @since 1.2.0 + */ + bool getBcast() const { + return _b; + } + + /** + * Sets EVEX.b bit. + * + * @param b The EVEX.b bit. + * @since 1.2.0 + */ + void setBcast(bool b) { + _b = b; + } + + /** + * Gets EVEX.z bit. + * + * @return The EVEX.z bit. + * @since 1.2.0 + */ + bool getZ() const { + return _z; + } + + /** + * Sets EVEX.z bit. + * + * @param z The EVEX.z bit. + * @since 1.2.0 + */ + void setZ(bool z) { + _z = z; + } + +private: + /** Array with decoded prefixes. */ + InstructionPrefixDetails _prefixes[FCML_DASM_PREFIXES_COUNT]; + /** Number of decoded prefixes. */ + fcml_int _prefixesCount; + /** Number of bytes used by all decoded prefixes. */ + fcml_int _prefixesBytesCount; + /** FCML_TRUE if branch prefix exists. */ + bool _isBranch; + /** FCML_TRUE if nobranch prefix exists. */ + bool _isNobranch; + /** FCML_TRUE if lock explicit prefix exists. */ + bool _isLock; + /** FCML_TRUE if rep explicit prefix exists. */ + bool _isRep; + /** FCML_TRUE if repne explicit prefix exists. */ + bool _isRepne; + /** FCML_TRUE if xrelease explicit prefix exists. */ + bool _isXrelease; + /** FCML_TRUE if xacquire explicit prefix exists. */ + bool _isXacquire; + /** FCML_TRUE if VEX prefix exists. */ + bool _isVex; + /** FCML_TRUE if EVEX prefix exists. + * since 1.2.0 + */ + bool _isEvex; + /** FCML_TRUE if XOP prefix exists. */ + bool _isXop; + /** FCML_TRUE if any AVX prefix exists. + * @since 1.2.0 + */ + bool _isAvx; + /** FCML_TRUE if REX prefix exists. */ + bool _isRex; + /** Various fields encoded inside decoded prefixes. + * since 1.2.0 + */ + fcml_uint8_t _AvxPrefixFirstByte; + /** R field of REX,XOP,VEX or EVEX prefix. */ + fcml_uint8_t _R; + /** R' field of EVEX prefix. + * since 1.2.0 + */ + fcml_uint8_t _RPrim; + /** X field of REX,XOP,VEX or EVEX prefix. */ + fcml_uint8_t _X; + /** B field of REX,XOP,VEX or EVEX prefix. */ + fcml_uint8_t _B; + /** W field of REX,XOP,VEX or EVEX prefix. */ + fcml_uint8_t _W; + /** L field of XOP, VEX or EVEX prefix. */ + fcml_uint8_t _L; + /** L' field of EVEX prefix. + * since 1.2.0 + */ + fcml_uint8_t _LPrim; + /** m-mmmm field of XOP or VEX prefix. */ + fcml_uint8_t _mmmm; + /** vvvv field of XOP or VEX prefix. */ + fcml_uint8_t _vvvv; + /** V' field of EVEX prefix. + * since 1.2.0 + */ + fcml_uint8_t _VPrim; + /** pp field of XOP or VEX prefix. */ + fcml_uint8_t _pp; + /** aaa field of EVEX prefix. + * since 1.2.0 + */ + fcml_uint8_t _aaa; + /** EVEX.b bit. + * since 1.2.0 + */ + bool _b; + /** EVEX.z bit. + * since 1.2.0 + */ + bool _z; +}; + +/** Operand details. + * @since 1.1.0 + */ +class OperandDetails { +public: + + /** @since 1.1.0 */ + enum AccessMode { + /** Undefined mode. */ + AM_ACCESS_MODE_UNDEFINED = FCML_AM_ACCESS_MODE_UNDEFINED, + /** Operand is read by instruction. */ + AM_READ = FCML_AM_READ, + /** Operand is set by instruction */ + AM_WRITE = FCML_AM_WRITE, + /** Operand is read but can be also set. */ + AM_READ_WRITE = AM_READ | AM_WRITE + }; + + /** + * Creates default operand details with an undefined access mode. + * @since 1.1.0 + */ + OperandDetails() : + _accessMode(AM_ACCESS_MODE_UNDEFINED) { + } + + /** + * Creates operand details for given access mode. + * + * @param accessMode Access mode. + * @since 1.1.0 + */ + OperandDetails(AccessMode accessMode) : + _accessMode(accessMode) { + } + + /** + * Gets access mode for the operand. + * + * @return Access mode. + * @since 1.1.0 + */ + AccessMode getAccessMode() const { + return _accessMode; + } + + /** + * Sets an access mode for the operand. + * + * @param accessMode The access mode for the operand. + * @since 1.1.0 + */ + void setAccessMode(AccessMode accessMode) { + _accessMode = accessMode; + } + +private: + /** Operan's access mode. */ + AccessMode _accessMode; +}; + +/** ModRM details. + * @since 1.1.0 + */ +class DecodedModRMDetails { +public: + + /** + * Creates an empty ModR/M details. + * @since 1.1.0 + */ + DecodedModRMDetails() : + _isRip(false) { + } + + /** + * Gets true if RIP byte is available. + * + * @return True if RIP byte is available. + * @since 1.1.0 + */ + bool isRip() const { + return _isRip; + } + + /** + * Sets RIP byte availability. + * + * @param isRip True if RIP byte is available. + * @since 1.1.0 + */ + void setRip(bool isRip) { + _isRip = isRip; + } + + /** + * Gets ModR/M nullable byte. + * + * @return ModR/M nullable byte. + * @since 1.1.0 + */ + const Nullable& getModRM() const { + return _modRM; + } + + /** + * Gets ModR/M nullable byte. + * + * @return ModR/M nullable byte. + * @since 1.1.0 + */ + Nullable& getModRM() { + return _modRM; + } + + /** + * Sets ModR/M nullable byte. + * + * @param modRM ModR/M nullable byte. + * @since 1.1.0 + */ + void setModRM(const Nullable &modRM) { + _modRM = modRM; + } + + /** + * Gets SIB nullable byte. + * + * @return SIB nullable byte. + * @since 1.1.0 + */ + const Nullable& getSib() const { + return _sib; + } + + /** + * Gets SIB nullable byte. + * + * @return SIB nullable byte. + * @since 1.1.0 + */ + Nullable& getSib() { + return _sib; + } + + /** + * Sets SIB nullable byte. + * + * @param sib The SIB nullable byte. + * @since 1.1.0 + */ + void setSib(const Nullable &sib) { + _sib = sib; + } + + /** + * Gets constant N (see AVX-512 compressed disp8). + * + * @return N as nullable value. + * @since 1.2.0 + */ + const Nullable& getN() const { + return _N; + } + + /** + * Gets N (see compressed AVX-512 disp8). + * + * @return N nullable value. + * @since 1.2.0 + */ + Nullable& getN() { + return _N; + } + + /** + * Sets N (see compressed AVX-512 disp8). + * + * @param N N nullable value. + * @since 1.2.0 + */ + void setN(const Nullable &N) { + _N = N; + } + + /** + * Gets constant raw displacement. + * + * @return Displacement. + * @since 1.2.0 + */ + const Integer& getDisplacement() const { + return _displacement; + } + + /** + * Gets raw displacement. + * + * @return Displacement. + * @since 1.2.0 + */ + Integer& getDisplacement() { + return _displacement; + } + + /** + * Sets displacement. + * + * @param displacement Displacement. + * @since 1.2.0 + */ + void setDisplacement(const Integer &displacement) { + _displacement = displacement; + } + +private: + /** ModR/M byte if exists.*/ + Nullable _modRM; + /** SIB byte if exists.*/ + Nullable _sib; + /** True if RIP encoding is used by decoded instruction. This flag is + * used only in 64 bit mode. */ + bool _isRip; + /** Raw displacement. + * since 1.2.0 + */ + Integer _displacement; + /* N from AVX-512 compressed disp8. + * since 1.2.0 + */ + Nullable _N; +}; + +/** Additional details about an instruction. + * @since 1.1.0 + */ +class InstructionDetails { +public: + + /** + * Gets address mode/instruction form. This information is used + * internally and is rather useless in day to day usage, but if + * you are interested in it do not hesitate to take a look at + * the manual. + * + * @return Instruction form. + * @since 1.1.0 + */ + fcml_uint16_t getAddrMode() const { + return _addrMode; + } + + /** + * Sets instruction form. + * + * @param addrMode Addressing mode. + * @since 1.1.0 + */ + void setAddrMode(fcml_uint16_t addrMode) { + _addrMode = addrMode; + } + + /** + * Gets instruction code. See fcml_en_instruction for more details. + * + * @return Instruction code. + * @since 1.1.0 + */ + fcml_en_instruction getInstruction() const { + return _instruction; + } + + /** + * Gets a new instruction code for the instruction. + * + * @param instruction The new instruction code. + * @since 1.1.0 + */ + void setInstruction(fcml_en_instruction instruction) { + _instruction = instruction; + } + + /** + * Gets a pointer to the instruction code. See fcml_en_instruction + * for more details. + * + * @return The pointer to the instruction code. + * @since 1.1.0 + */ + const fcml_uint8_t* getInstructionCode() const { + return _instructionCode; + } + + /** + * Gets a pointer to the instruction code. See fcml_en_instruction + * for more details. + * + * @return The pointer to the instruction code. + * @since 1.1.0 + */ + fcml_uint8_t* getInstructionCode() { + return _instructionCode; + } + + /** + * Gets instruction group. See fcml_instructions.h for all + * available groups. + * + * @return The instruction group. + * @since 1.1.0 + */ + fcml_uint64_t getInstructionGroup() const { + return _instructionGroup; + } + + /** + * Sets an instruction group. See fcml_instructions.h for all + * available groups. + * + * @param instructionGroup The instruction group. + * @since 1.1.0 + */ + void setInstructionGroup(fcml_uint64_t instructionGroup) { + _instructionGroup = instructionGroup; + } + + /** + * Instruction size in bytes. + * + * @return Size of the instruction in bytes. + * @since 1.1.0 + */ + fcml_usize getInstructionSize() const { + return _instructionSize; + } + + /** + * Sets the instruction size in bytes. + * + * @param instructionSize The instruction size. + * @since 1.1.0 + */ + void setInstructionSize(fcml_usize instructionSize) { + _instructionSize = instructionSize; + } + + /** + * Gets true if it's a shortcut instruction. + * + * @return True if it's a shortcut instruction. + * @since 1.1.0 + */ + bool isShortcut() const { + return _isShortcut; + } + + /** + * Marks the instruction as a shortcut. + * + * @param isShortcut True if it's a shortcut instruction. + * @since 1.1.0 + */ + void setShortcut(bool isShortcut) { + _isShortcut = isShortcut; + } + + /** + * Gets ModR/M instruction details. + * + * @return ModR/M details. + * @since 1.1.0 + */ + const DecodedModRMDetails& getModRmDetails() const { + return _modRMDetails; + } + + /** + * Gets ModR/M instruction details. + * + * @return ModR/M details. + * @since 1.1.0 + */ + DecodedModRMDetails& getModRmDetails() { + return _modRMDetails; + } + + /** + * Sets a new instruction details for the instruction. + * + * @param modRmDetails The new instruction details. + * @since 1.1.0 + */ + void setModRmDetails(const DecodedModRMDetails &modRmDetails) { + _modRMDetails = modRmDetails; + } + + /** + * Gets opcode field 'S'. + * + * @return 'S' opcode field. + * @since 1.1.0 + */ + bool isOpcodeFieldSBit() const { + return _opcodeFieldSBit; + } + + /** + * Sets 'S' field of the opcode byte. + * + * @param opcodeFieldSBit 'S' opcode byte field. + * @since 1.1.0 + */ + void setOpcodeFieldSBit(bool opcodeFieldSBit) { + _opcodeFieldSBit = opcodeFieldSBit; + } + + /** + * Gets opcode field 'W'. + * + * @return 'W' opcode field. + * @since 1.1.0 + */ + bool isOpcodeFieldWBit() const { + return _opcodeFieldWBit; + } + + /** + * Sets 'W' field of the opcode byte. + * + * @param opcodeFieldWBit 'W' opcode byte field. + * @since 1.1.0 + */ + void setOpcodeFieldWBit(bool opcodeFieldWBit) { + _opcodeFieldWBit = opcodeFieldWBit; + } + + /** + * Gets the operand details for given index. + * + * @param index Index of the instruction details. + * @return The operand details for the given index. + * @throw BadArgumentException Array index out of bound. + * @since 1.1.0 + */ + const OperandDetails& getOperandDetails(fcml_usize index) const { + if (index > FCML_OPERANDS_COUNT) { + throw BadArgumentException(FCML_TEXT("Array index out of bound."), + FCML_CEH_GEC_VALUE_OUT_OF_RANGE); + } + return _operandDetails[index]; + } + + /** + * Gets the operand details for given index. + * + * @param index Index of the instruction details. + * @return The operand details for the given index. + * @throw BadArgumentException Array index out of bound. + * @since 1.1.0 + */ + OperandDetails& getOperandDetails(fcml_usize index) { + if (index > FCML_OPERANDS_COUNT) { + throw BadArgumentException(FCML_TEXT("Array index out of bound."), + FCML_CEH_GEC_VALUE_OUT_OF_RANGE); + } + return _operandDetails[index]; + } + + /** + * Gets instruction prefixes details. + * + * @return The instruction prefix details. + * @since 1.1.0 + */ + const PrefixesDetails& getPrefixesDetails() const { + return _prefixesDetails; + } + + /** + * Gets instruction prefixes details. + * + * @return The instruction prefix details. + * @since 1.1.0 + */ + PrefixesDetails& getPrefixesDetails() { + return _prefixesDetails; + } + + /** + * Sets a new instruction prefixes details. + * + * @param prefixesDetails The new prefixes details. + * @since 1.1.0 + */ + void setPrefixesDetails(const PrefixesDetails &prefixesDetails) { + _prefixesDetails = prefixesDetails; + } + + /** + * Gets pseudo operation code. + * + * @return The pseudo operation associated with the instruction. + * @since 1.1.0 + */ + fcml_en_pseudo_operations getPseudoOp() const { + return _pseudoOp; + } + + /** + * Sets pseudo operation for the instruction. + * + * @param pseudoOp The pseudo operation. + * @since 1.1.0 + */ + void setPseudoOp(fcml_en_pseudo_operations pseudoOp) { + _pseudoOp = pseudoOp; + } + + /** + * Gets true is it's a pseudo operation. + * + * @return True if the instruction is a pseudo operation. + * @since 1.1.0 + */ + bool isPseudoOp() const { + return _isPseudoOp; + } + + /** + * Sets pseudo operation flag. + * + * @param isPseudoOp True if the instruction is a pseudo operation. + * @since 1.1.0 + */ + void setIsPseudoOp(bool isPseudoOp) { + _isPseudoOp = isPseudoOp; + } + + /** + * Gets avx-512 tuple type. + * @since 1.2.0 + */ + fcml_uint8_t getTupleType() const { + return _tupleType; + } + + /** + * Sets avx-512 tuple type. + * + * @param isPseudoOp True if the instruction is a pseudo operation. + * @since 1.2.0 + */ + void setTupleType(fcml_uint8_t tupleType) { + _tupleType = tupleType; + } + +private: + + /** + * True if this is a shortcut. + * A good example of such instruction is 'cmpsb' as opposed to 'cmps + * byte ptr [si],byte ptr [di]'. It is very important to take this + * information into consideration when instruction models are analyzed + * because there is no operands in the GIM for shortcuts. + */ + bool _isShortcut; + /** + * True if given instruction is a short form of pseudo-ops instructions. + * See 'vcmpunordsd' for instance. + */ + bool _isPseudoOp; + /** + * Code of the disassembled instruction. + */ + fcml_uint8_t _instructionCode[FCML_INSTRUCTION_SIZE]; + /** + * Instruction size in bytes. + */ + fcml_usize _instructionSize; + /** + * Some additional information about decoded instruction prefixes. + */ + PrefixesDetails _prefixesDetails; + /** + * All disassembler specific information about operands going there. + */ + OperandDetails _operandDetails[FCML_OPERANDS_COUNT]; + /** + * Details about decoded ModR/M and SIB bytes. + */ + DecodedModRMDetails _modRMDetails; + /** Opcode field 's'. + * This is set only for informational purpose only and you should not use + * it for any critical functionality. + */ + bool _opcodeFieldSBit; + /** Opcode field 'w'. + * This is set only for informational purpose only and you should not + * use it for any critical functionality. + */ + bool _opcodeFieldWBit; + /** + * Instruction code/number. @see fcml_instructions.h header file. + */ + fcml_en_instruction _instruction; + /** + * Pseudo operation code. + */ + fcml_en_pseudo_operations _pseudoOp; + /** + * Code of the instruction form/addressing mode of the instruction above. + */ + fcml_uint16_t _addrMode; + /** + * Instruction group. + */ + fcml_uint64_t _instructionGroup; + /** + * Tuple type used by avx-512 instructions to calculate disp8. + */ + fcml_uint8_t _tupleType; +}; + +/** Disassembler result. + * + * It's a counterpart to the fcml_st_disassembler_result structure. + * @since 1.1.0 + */ +class DisassemblerResult { + +public: + + /** + * Gets errors container with errors related to the failed + * disassembling process. + * + * @return The error container. + * @since 1.1.0 + */ + const ErrorContainer& getErrorContainer() const { + return _errorContainer; + } + + /** + * Gets errors container with errors related to the failed + * disassembling process. + * + * @return The error container. + * @since 1.1.0 + */ + const Instruction& getInstruction() const { + return _instruction; + } + + /** + * Gets instruction details associated with the instruction. + * + * @return The instruction details. + * @since 1.1.0 + */ + const InstructionDetails& getInstructionDetails() const { + return _instructionDetails; + } + + /** + * Cleans the disassembling result. + * @since 1.1.0 + */ + void clean() { + _errorContainer.clean(); + _instructionDetails = InstructionDetails(); + _instruction = Instruction(); + } + +protected: + + friend class Disassembler; + friend class DisassemblerTypeConverter; + + /** + * Gets mutable instruction details. + * @return Instruction details. + * @since 1.1.0 + */ + InstructionDetails& getInstructionDetailsInternal() { + return _instructionDetails; + } + + /** + * Sets new instruction details for the disassembler. + * @param instructionDetails The instruction details. + * @since 1.1.0 + */ + void setInstructionDetails(const InstructionDetails &instructionDetails) { + _instructionDetails = instructionDetails; + } + + /** + * Gets mutable instruction. + * @return The mutable instruction. + * @since 1.1.0 + */ + Instruction& getInstructionInternal() { + return _instruction; + } + + /** + * Sets a new instruction for the result. + * @param instruction The instruction to be copied to the result. + * @since 1.1.0 + */ + void setInstruction(const Instruction &instruction) { + _instruction = instruction; + } + + /** + * Sets error container. + * @param errorContainer The error container. + * @since 1.1.0 + */ + void setErrorContainer(const ErrorContainer &errorContainer) { + _errorContainer = errorContainer; + } + +private: + + /** Errors container */ + ErrorContainer _errorContainer; + /** Instruction details. */ + InstructionDetails _instructionDetails; + /** The disassembled instruction. */ + Instruction _instruction; + +}; + +/** + * Converts objects to their structures counterparts. + * @since 1.1.0 + * @remarks Internal API, not intended to be used outside. + */ +class DisassemblerTypeConverter { + +public: + + static void convert(const DisassemblerContext &src, + fcml_st_disassembler_context &dest) { + dest.code = src.getCode(); + dest.code_length = src.getCodeLength(); + TypeConverter::convert(src.getEntryPoint(), dest.entry_point); + convert(src.getDisassemblerConf(), dest.configuration); + } + + static void convert(const DisassemblerConf &src, + fcml_st_disassembler_conf &dest) { + dest.conditional_group = src.getConditionalGroup(); + dest.carry_flag_conditional_suffix = src.isCarryFlagConditionalSuffix(); + dest.enable_error_messages = src.isEnableErrorMessages(); + dest.extend_disp_to_asa = src.isExtendDispToAsa(); + dest.fail_if_unknown_instruction = src.isFailIfUnknownInstruction(); + dest.increment_ip = src.isIncrementIp(); + dest.short_forms = src.isShortForms(); + } + + static void convert(const fcml_st_decoded_modrm_details &src, + DecodedModRMDetails &dest) { + dest.setRip(FCML_TO_CPP_BOOL(src.is_rip)); + Nullable &modRM = dest.getModRM(); + modRM.setNotNull(FCML_TO_CPP_BOOL(src.is_modrm)); + modRM.setValue(src.modrm); + Nullable &sib = dest.getSib(); + sib.setNotNull(FCML_TO_CPP_BOOL(src.sib.is_not_null)); + sib.setValue(src.sib.value); + TypeConverter::convert(src.displacement.displacement, + dest.getDisplacement()); + Nullable N; + N.setNotNull(FCML_TO_CPP_BOOL(src.displacement.N.is_not_null)); + N.setValue(src.displacement.N.value); + dest.setN(N); + } + + static void convert(const DecodedModRMDetails &src, + fcml_st_decoded_modrm_details &dest) { + dest.is_modrm = src.getModRM().isNotNull(); + dest.is_rip = src.isRip(); + dest.modrm = src.getModRM().getValue(); + fcml_nuint8_t &sib = dest.sib; + sib.is_not_null = src.getSib().isNotNull(); + sib.value = src.getSib().getValue(); + TypeConverter::convert(src.getDisplacement(), + dest.displacement.displacement); + dest.displacement.N.is_not_null = src.getN().isNotNull(); + dest.displacement.N.value = src.getN().getValue(); + } + + static void convert(const fcml_st_operand_details &src, + OperandDetails &dest) { + dest.setAccessMode( + static_cast(src.access_mode)); + } + + static void convert(const OperandDetails &src, + fcml_st_operand_details &dest) { + dest.access_mode = + static_cast(src.getAccessMode()); + } + + static void convert(const fcml_st_instruction_prefix &src, + InstructionPrefixDetails &dest) { + dest.setMandatoryPrefix(FCML_TO_CPP_BOOL(src.mandatory_prefix)); + dest.setPrefix(src.prefix); + dest.setPrefixType( + static_cast(src.prefix_type)); + ::memcpy(dest.getAvxBytes(), src.avx_bytes, sizeof(src.avx_bytes)); + } + + static void convert(const InstructionPrefixDetails &src, + fcml_st_instruction_prefix &dest) { + dest.mandatory_prefix = src.isMandatoryPrefix(); + dest.prefix = src.getPrefix(); + dest.prefix_type = + static_cast(src.getPrefixType()); + ::memcpy(dest.avx_bytes, src.getAvxBytes(), sizeof(dest.avx_bytes)); + } + + static void convert(const fcml_st_prefixes_details src, + PrefixesDetails &dest) { + for (int i = 0; i < FCML_DASM_PREFIXES_COUNT; i++) { + convert(src.prefixes[i], dest.getPrefixes(i)); + } + dest.setPrefixesCount(src.prefixes_count); + dest.setPrefixesBytesCount(src.prefixes_bytes_count); + dest.setBranch(FCML_TO_CPP_BOOL(src.is_branch)); + dest.setNobranch(FCML_TO_CPP_BOOL(src.is_nobranch)); + dest.setLock(FCML_TO_CPP_BOOL(src.is_lock)); + dest.setRep(FCML_TO_CPP_BOOL(src.is_rep)); + dest.setRepne(FCML_TO_CPP_BOOL(src.is_repne)); + dest.setXrelease(FCML_TO_CPP_BOOL(src.is_xrelease)); + dest.setXacquire(FCML_TO_CPP_BOOL(src.is_xacquire)); + dest.setVex(FCML_TO_CPP_BOOL(src.is_vex)); + dest.setEvex(FCML_TO_CPP_BOOL(src.is_evex)); + dest.setXop(FCML_TO_CPP_BOOL(src.is_xop)); + dest.setAvx(FCML_TO_CPP_BOOL(src.is_avx)); + dest.setRex(FCML_TO_CPP_BOOL(src.is_rex)); + dest.setAvxFirstByte(src.avx_first_byte); + dest.setR(src.R); + dest.setRPrim(src.R_prim); + dest.setX(src.X); + dest.setB(src.B); + dest.setW(src.W); + dest.setL(src.L); + dest.setLPrim(src.L_prim); + dest.setMmmm(src.mmmm); + dest.setVvvv(src.vvvv); + dest.setVPrim(src.V_prim); + dest.setPp(src.pp); + dest.setAaa(src.aaa); + dest.setBcast(src.b); + dest.setZ(src.z); + } + + static void convert(const PrefixesDetails src, + fcml_st_prefixes_details &dest) { + for (int i = 0; i < FCML_DASM_PREFIXES_COUNT; i++) { + convert(src.getPrefixes(i), dest.prefixes[i]); + } + dest.prefixes_count = src.getPrefixesCount(); + dest.prefixes_bytes_count = src.getPrefixesBytesCount(); + dest.is_branch = src.isBranch(); + dest.is_nobranch = src.isNobranch(); + dest.is_lock = src.isLock(); + dest.is_rep = src.isRep(); + dest.is_repne = src.isRepne(); + dest.is_xrelease = src.isXrelease(); + dest.is_xacquire = src.isXacquire(); + dest.is_vex = src.isVex(); + dest.is_xop = src.isXop(); + dest.is_avx = src.isAvx(); + dest.is_evex = src.isEvex(); + dest.is_rex = src.isRex(); + dest.avx_first_byte = src.getAvxFirstByte(); + dest.R = src.getR(); + dest.R_prim = src.getRPrim(); + dest.X = src.getX(); + dest.B = src.getB(); + dest.W = src.getW(); + dest.L = src.getL(); + dest.L_prim = src.getLPrim(); + dest.mmmm = src.getMmmm(); + dest.vvvv = src.getVvvv(); + dest.V_prim = src.getVPrim(); + dest.pp = src.getPp(); + dest.aaa = src.getAaa(); + dest.b = src.getBcast(); + dest.z = src.getZ() ? 1 : 0; + } + + static void convert(const fcml_st_instruction_details &src, + InstructionDetails &dest) { + dest.setTupleType(src.tuple_type); + dest.setAddrMode(src.addr_mode); + dest.setInstruction(src.instruction); + dest.setInstructionGroup(src.instruction_group); + dest.setInstructionSize(src.instruction_size); + dest.setOpcodeFieldSBit(FCML_TO_CPP_BOOL(src.opcode_field_s_bit)); + dest.setOpcodeFieldWBit(FCML_TO_CPP_BOOL(src.opcode_field_w_bit)); + dest.setIsPseudoOp(FCML_TO_CPP_BOOL(src.is_pseudo_op)); + dest.setPseudoOp(src.pseudo_op); + dest.setShortcut(FCML_TO_CPP_BOOL(src.is_shortcut)); + convert(src.modrm_details, dest.getModRmDetails()); + for (int i = 0; i < FCML_OPERANDS_COUNT; i++) { + convert(src.operand_details[i], dest.getOperandDetails(i)); + } + fcml_uint8_t *code = dest.getInstructionCode(); + for (int i = 0; i < FCML_INSTRUCTION_SIZE; i++) { + code[i] = src.instruction_code[i]; + } + convert(src.prefixes_details, dest.getPrefixesDetails()); + } + + static void convert(const InstructionDetails &src, + fcml_st_instruction_details &dest) { + dest.tuple_type = src.getTupleType(); + dest.addr_mode = src.getAddrMode(); + dest.instruction = src.getInstruction(); + dest.instruction_group = src.getInstructionGroup(); + dest.instruction_size = src.getInstructionSize(); + dest.opcode_field_s_bit = src.isOpcodeFieldSBit(); + dest.opcode_field_w_bit = src.isOpcodeFieldWBit(); + dest.is_pseudo_op = src.isPseudoOp(); + dest.pseudo_op = src.getPseudoOp(); + dest.is_shortcut = src.isShortcut(); + convert(src.getModRmDetails(), dest.modrm_details); + for (int i = 0; i < FCML_OPERANDS_COUNT; i++) { + convert(src.getOperandDetails(i), dest.operand_details[i]); + } + for (int i = 0; i < FCML_INSTRUCTION_SIZE; i++) { + dest.instruction_code[i] = src.getInstructionCode()[i]; + } + convert(src.getPrefixesDetails(), dest.prefixes_details); + } + + static void convert(const fcml_st_disassembler_result &src, + DisassemblerResult &dest) { + TypeConverter::convert(src.instruction, dest.getInstructionInternal()); + convert(src.instruction_details, dest.getInstructionDetailsInternal()); + } + + static void convert(const DisassemblerResult &src, + fcml_st_disassembler_result &dest) { + TypeConverter::convert(src.getInstruction(), dest.instruction); + convert(src.getInstructionDetails(), dest.instruction_details); + } + + static void free(fcml_st_disassembler_result &src) { + TypeConverter::free(src.instruction); + } + +}; + +/** Disassembler wrapper. + * @since 1.1.0 + */ +class Disassembler: public NonCopyable, protected DialectAware { +public: + + /** + * Creates a disassembler instance for the given dialect. + * + * @param dialect The dialect for the disassembler. + * @throw InitException Cannot initialize the disassembler. + * @since 1.1.0 + */ + Disassembler(Dialect &dialect) : + _dialect(dialect) { + fcml_ceh_error error = ::fcml_fn_disassembler_init( + extractDialect(dialect), &_disassembler); + if (error) { + throw InitException( + FCML_TEXT("Cannot initialize the disassembler."), error); + } + } + + /** + * Destructor. + * @since 1.1.0 + */ + virtual ~Disassembler() { + if (_disassembler) { + ::fcml_fn_disassembler_free(_disassembler); + _disassembler = NULL; + } + } + +public: + + /** + * Disassembled the next instruction from the context. + * + * @param ctx Context describing the next instruction to disassemble. + * @param[out] disassemblerResult Disassembler result. + * @throw DisassemblingFailedException Disassemblation failed. + * @return Error code. + * @since 1.1.0 + */ + fcml_ceh_error disassemble(DisassemblerContext &ctx, + DisassemblerResult &disassemblerResult) { + + fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR; + + fcml_st_disassembler_context context; + DisassemblerTypeConverter::convert(ctx, context); + + context.disassembler = _disassembler; + + /* Prepare assembler result. */ + fcml_st_disassembler_result disassembler_result; + ::fcml_fn_disassembler_result_prepare(&disassembler_result); + + try { + + disassemblerResult.clean(); + + error = ::fcml_fn_disassemble(&context, &disassembler_result); + + ErrorContainer errorContainer; + ErrorTypeConverter::convert(disassembler_result.errors, + errorContainer); + + disassemblerResult.setErrorContainer(errorContainer); + + if (error && ctx.getDisassemblerConf().isThrowExceptionOnError()) { + ::fcml_fn_disassembler_result_free(&disassembler_result); + throw DisassemblingFailedException( + FCML_TEXT("Assembling failed."), errorContainer, error); + } + + if (!error) { + + // Convert result. + DisassemblerTypeConverter::convert(disassembler_result, + disassemblerResult); + + ctx.getEntryPoint().setIP(context.entry_point.ip); + ctx.setCode(context.code); + ctx.setCodeLength(context.code_length); + + } + + ::fcml_fn_disassembler_result_free(&disassembler_result); + + } catch (std::exception &exc) { + // If anything failed, free assembler results. + ::fcml_fn_disassembler_result_free(&disassembler_result); + throw exc; + } + + return error; + } + + /** + * Gets dialect associated with the disassembler. + * @return The dialect instance associated with the disassembler. + * @since 1.1.0 + */ + Dialect& getDialect() const { + return _dialect; + } + +private: + + /** The dialect associated with the disassembler. */ + Dialect &_dialect; + /** The disassembler instance. */ + fcml_st_disassembler *_disassembler; + +}; + +} + +#endif //FCML_DISASSEMBLER_HPP_ + diff --git a/dependencies/fcml/include/fcml_env.h b/dependencies/fcml/include/fcml_env.h new file mode 100644 index 0000000..7813884 --- /dev/null +++ b/dependencies/fcml/include/fcml_env.h @@ -0,0 +1,96 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_env.h + * API for environment configuration. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ENV_H_ +#define FCML_ENV_H_ + +#include "fcml_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Memory allocator handler function pointer declaration. + * Memory allocation handlers are used to allocate requested memory in + * environment specific way. + * @param size Size of the memory to allocate. + * @return The allocated memory block or NULL in case of out of memory. + */ +typedef fcml_ptr (*fcml_fp_env_memory_alloc_handler)(fcml_usize size); + +/** Memory reallocator handler function pointer declaration. + * Memory reallocation handlers are used to reallocate requested memory in + * environment specific way. + * @param ptr The memory block to be reallocated. + * @param size Size of the memory to allocate. + * @return The reallocated memory block or NULL in case of out of memory. + */ +typedef fcml_ptr (*fcml_fp_env_memory_realloc_handler)(fcml_ptr ptr, + fcml_usize size); + +/** Memory deallocator handler function pointer declaration. + * Memory deallocation handlers are used to free requested memory blocks in + * environment specific way. + * @param memory_block The memory block to free. + */ +typedef void (*fcml_fp_env_memory_free_handler)(fcml_ptr memory_block); + +/** + * Registers the new dedicated handler responsible for allocating + * memory for the sake of internal FCML implementation. + * @param handler New memory allocation handler. + * @return The replaced memory handler. + */ +LIB_EXPORT fcml_fp_env_memory_alloc_handler LIB_CALL + fcml_fn_env_register_memory_alloc_handler( + fcml_fp_env_memory_alloc_handler handler); + +/** + * Registers the new dedicated handler responsible for reallocating + * memory for the sake + * of internal FCML implementation. + * @param handler New memory reallocation handler. + * @return The replaced memory handler. + */ +LIB_EXPORT fcml_fp_env_memory_realloc_handler LIB_CALL + fcml_fn_env_register_memory_realloc_handler( + fcml_fp_env_memory_realloc_handler handler); + +/** + * Registers the new dedicated handler responsible for deallocating the + * memory for the sake + * of internal FCML implementation. + * @param handler New memory deallocation handler. + * @return The replaced memory handler. + */ +LIB_EXPORT fcml_fp_env_memory_free_handler LIB_CALL + fcml_fn_env_register_memory_free_handler( + fcml_fp_env_memory_free_handler handler); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_ENV_H_ */ diff --git a/dependencies/fcml/include/fcml_errors.h b/dependencies/fcml/include/fcml_errors.h new file mode 100644 index 0000000..3e5fb26 --- /dev/null +++ b/dependencies/fcml/include/fcml_errors.h @@ -0,0 +1,187 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_errors.h + * Global error handling related declarations. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ASM_ERRORS_H_ +#define FCML_ASM_ERRORS_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" + +/** + * @defgroup ERRORS_GROUP Global error codes + * Describes all available global error codes. + * @{ + */ + +/** All global error codes are placed here. */ +enum fcml_en_ceh_error_globals { + /** Operation succeed. */ + FCML_CEH_GEC_NO_ERROR = 0, + /** There is not enough memory to complete operation. */ + FCML_CEH_GEC_OUT_OF_MEMORY = 1, + /** Invalid function arguments. */ + FCML_CEH_GEC_INVALID_INPUT = 2, + /** An internal error occurred. Enable tracing in order to get more + * detailed information. */ + FCML_CEH_GEC_INTERNAL_ERROR = 3, + /** Component hasn't been initialized yet. */ + FCML_CEH_GEC_NOT_INITIALIZED = 4, + /** Incomplete instruction. */ + FCML_CEH_GEC_EOF = 5, + /** Used mainly in case of integers and offsets. */ + FCML_CEH_GEC_VALUE_OUT_OF_RANGE = 6, + /** Chosen operation is not supported in case of given configuration. */ + FCML_CEH_GEC_FEATURE_NOT_SUPPORTED = 7, + /** Unsupported operating mode. For instance encoded instruction needs 16 + * bit operating mode, but we are in 64 bit mode. */ + FCML_CEH_GEC_INVALID_OPERATING_MODE = 8, + /** Chosen addressing form can not be encoded as for example ModR/M field. */ + FCML_CEH_GEC_INVALID_ADDRESSING_FORM = 9, + /** Unsupported instruction form (Instruction may be supported, but not + * with given set of operands). */ + FCML_CEH_GEC_INVALID_INSTRUCTION_FORM = 10, + /** Instruction do not support one of the defined operands. */ + FCML_CEH_GEC_INVALID_OPPERAND = 11, + /** Unknown mnemonic. */ + FCML_CEH_GEC_UNKNOWN_MNEMONIC = 12, + /** Operand size (Operand size attribute) is not allowed in given context. */ + FCML_CEH_GEC_INVALID_OPPERAND_SIZE = 13, + /** Address size (Address size attribute) is not allowed in given context. */ + FCML_CEH_GEC_INVALID_ADDRESS_SIZE = 14, + /** User chosen unsupported addressing form */ + FCML_CEH_GEC_UNKNOWN_INSTRUCTION = 15, + /** Assembler can return this error code if there is not allowed prefix + * defined for given instruction. */ + FCML_CEH_GEC_INVALID_PREFIX = 16, + /** Wrong register type. */ + FCML_CEH_GEC_INVALID_REGISTER_TYPE = 17, + /** Wrong register. */ + FCML_CEH_GEC_INVALID_REGISTER = 18, + /** Error returned by parsers when there is undefined symbol used. */ + FCML_CEH_GEC_UNDEFINED_SYMBOL = 19, + /** Labels are not supported. */ + FCML_CEH_GEC_UNSUPPORTED_LABEL_DECLARATION = 20, + /** Required operand decorator is missing. */ + FCML_CEH_GEC_MISSING_DECORATOR = 21, + /** Given operand decorator is not supported by operand. */ + FCML_CEH_GEC_NOT_SUPPORTED_DECORATOR = 22, + /** Gap between operands found. */ + FCML_CEH_GEC_INVALID_INSTRUCTION_MODEL = 23, + /* Decorator is invalid. For example wrong register type is used in + * opmask decorator. */ + FCML_CEH_GEC_INVALID_OPERAND_DECORATOR = 24 +}; + +/** @} */ + +/** + * @defgroup MESSAGE_ERRORS_GROUP Error codes for textual messages + * Describes all available error codes dedicated to textual errors. + * @{ + */ + +/** Error codes dedicated to textual messages. + * In some cases they are a bit more detailed than corresponding + * global error codes returned in case of errors. Remember that global + * error codes also can be used in place of error codes for textual + * messages. It is why they use different code ranges. + */ +enum fcml_en_ceh_message_errors { + /** Segment register can not be overridden. */ + FCML_CEH_MEC_ERROR_ILLEGAL_SEG_REG_OVERRIDE = 1000, + /** To many operands passed to parser. */ + FCML_CEH_MEC_ERROR_TO_MANY_OPERANDS = 1001, + /** Unsupported pseudo-op value. */ + FCML_CEH_MEC_ERROR_INVALID_PSEUDO_OPCODE_VALUE = 1002, + /** HLE prefix is not allowed in given context. */ + FCML_CEH_MEC_ERROR_HLE_PREFIX_NOT_ALLOWED = 1003, + /** There is more than one HLE prefix. */ + FCML_CEH_MEC_ERROR_HLE_MORE_THAN_ONE_PREFIX = 1004, + /** Expression attempts to divide by 0 */ + FCML_CEH_MEC_ERROR_DIVISION_BY_0 = 1005, + /** Wrong value type used in given context. For example float used + * in place of integer. */ + FCML_CEH_MEC_ERROR_WRONG_VALUE_FORMAT = 1006, + /** Value out of range, for example 32 bit value used as + * segment selector. */ + FCML_CEH_MEC_ERROR_VALUE_OUT_OF_RANGE = 1007, + /** Syntax error from parser. */ + FCML_CEH_MEC_ERROR_INVALID_SYNTAX = 1008, + /** Wrong register type used in place of segment register. */ + FCML_CEH_MEC_ERROR_INVALID_REGISTER_TYPE_SEG = 1009, + /** Symbol is already defined in parser's symbol table. */ + FCML_CEH_MEC_ERROR_SYMBOL_ALREADY_DEFINED = 1010, + /** Symbol is undefined. */ + FCML_CEH_MEC_ERROR_UNDEFINED_SYMBOL = 1011, + /** Parsed line exceed maximal allowed length. */ + FCML_CEH_MEC_ERROR_PARSED_LINE_TOO_LONG = 1012, + /** Invalid vector length size. */ + FCML_CEH_MEC_ERROR_INVALID_VECTOR_LENGTH = 1013 +}; + +/** Codes for textual warnings. */ +enum fcml_en_ceh_message_warnings { + /** Value out of range */ + FCML_CEH_MEW_WARN_VALUE_OUT_OF_RANGE = 2000, + /** Invalid addressing mode. */ + FCML_CEH_MEW_WARN_INVALID_ADDRESSING_MODE = 2001 +}; + +/** @} */ + +/** All error codes should be held in variables of this type. */ +typedef fcml_uint16_t fcml_ceh_error; + +/** Error levels. */ +typedef enum fcml_en_ceh_error_level { + /** Warnings are reported when processing does not need to be stopped. */ + FCML_EN_CEH_EL_WARN, + /** Errors are reported when something more important happened and + * processing should be stopped. */ + FCML_EN_CEH_EL_ERROR +} fcml_en_ceh_error_level; + +/** Information about one particular error/warning. */ +typedef struct fcml_st_ceh_error_info { + /** Next error/warning on the list. */ + struct fcml_st_ceh_error_info *next_error; + /** Error message. */ + fcml_string message; + /** Error code */ + fcml_ceh_error code; + /** Error level. */ + fcml_en_ceh_error_level level; +} fcml_st_ceh_error_info; + +/** Container for all collected errors and warnings. */ +typedef struct fcml_st_ceh_error_container { + /** All errors and warnings going here. */ + fcml_st_ceh_error_info *errors; + /** Pointer to the last error/warning on the list. */ + fcml_st_ceh_error_info *last_error; +} fcml_st_ceh_error_container; + +#endif /* FCML_ASM_ERRORS_H_ */ diff --git a/dependencies/fcml/include/fcml_errors.hpp b/dependencies/fcml/include/fcml_errors.hpp new file mode 100644 index 0000000..2057094 --- /dev/null +++ b/dependencies/fcml/include/fcml_errors.hpp @@ -0,0 +1,388 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_errors.hpp + * C++ wrapper for the FCML errors handling. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ERRORS_HPP_ +#define FCML_ERRORS_HPP_ + +#include + +#include "fcml_types.h" +#include "fcml_errors.h" +#include "fcml_common.hpp" + +namespace fcml { + +/** + * Contains an error message together with error level and error code. + * @since 1.1.0 + */ +class ErrorInfo { +public: + + /** Error level. + * @since 1.1.0 + */ + enum ErrorLevel { + EL_ERROR, + EL_WARN + }; + +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + ErrorInfo() : + _code( FCML_CEH_GEC_NO_ERROR ), + _level( EL_ERROR ) { + } + + /** + * Creates an error for given message and optional error code and level. + * @param message The error message. + * @param code The error code. + * @param level The error level. + * @since 1.1.0 + */ + ErrorInfo( const fcml_cstring &message, fcml_ceh_error code = FCML_CEH_GEC_NO_ERROR, ErrorLevel level = EL_ERROR ) : + _message( message ), + _code( code ), + _level( level ) { + } + +public: + + /** + * Gets error code. + * @return The error code. + * @since 1.1.0 + */ + fcml_ceh_error getCode() const { + return _code; + } + + /** + * Sets a new error code. + * @param code The new error code. + * @since 1.1.0 + */ + void setCode(fcml_ceh_error code) { + _code = code; + } + + /** + * Gets error level. + * @return The error level. + * @since 1.1.0 + */ + ErrorLevel getLevel() const { + return _level; + } + + /** + * Sets error level. + * @param level The error level. + * @since 1.1.0 + */ + void setLevel(ErrorLevel level) { + _level = level; + } + + /** + * Gets error message. + * @return The error message. + * @since 1.1.0 + */ + const fcml_cstring& getMessage() const { + return _message; + } + + /** + * Sets error message. + * @param message The error message. + * @since 1.1.0 + */ + void setMessage(const fcml_cstring& message) { + _message = message; + } + +private: + + /** Error message. */ + fcml_cstring _message; + /** Error code */ + fcml_ceh_error _code; + /** Error level. */ + ErrorLevel _level; + +}; + +/** + * Wraps multiple errors into one component. + * @since 1.1.0 + */ +class ErrorContainer { +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + ErrorContainer() : + _isWarn(false), + _isError(false) { + } + + /** + * Gets number of errors in the container. + * @return The number of errors. + * @since 1.1.0 + */ + fcml_usize getSize() const { + return static_cast( _errorInfos.size() ); + } + + /** + * Gets an error at given index. + * @param index The error index. + * @return The error at given index. + * @throw BadArgumentException If index is out of bound. + * @since 1.1.0 + */ + const ErrorInfo& operator[]( fcml_usize index ) const { + checkVectorAccess( index ); + return _errorInfos[index]; + } + + /** + * Gets an error at given index. + * @param index The error index. + * @return The error at given index. + * @since 1.1.0 + */ + ErrorInfo& operator[]( fcml_usize index ) { + checkVectorAccess( index ); + return _errorInfos[index]; + } + + /** + * Adds a new error into the container. + * @param errorInfo The new error to add. + * @since 1.1.0 + */ + void addErrorInfo( const ErrorInfo &errorInfo ) { + _errorInfos.push_back(errorInfo); + switch( errorInfo.getLevel() ) { + case ErrorInfo::EL_ERROR: + _isError = true; + break; + case ErrorInfo::EL_WARN: + _isWarn = true; + break; + } + } + + /** + * Returns true if there is any error in the container. + * @return True if there is any error in the container. + * @since 1.1.0 + */ + bool isError() const { + return _isError; + } + + /** + * Returns true if there is any warning in the container. + * @return True if there is any warning in the container. + * @since 1.1.0 + */ + bool isWarn() const { + return _isWarn; + } + + /** + * Gets true if there is any error or warning in the container. + * @return True if there is any error or warning in the container. + * @since 1.1.0 + */ + bool isEmpty() const { + return _errorInfos.empty(); + } + + /** + * Returns the first error from the container. + * @return The first error. + * @throw IllegalStateException Container is empty. + * @since 1.1.0 + */ + const ErrorInfo& getFirstError() const { + if( isEmpty() ) { + throw IllegalStateException( FCML_TEXT( "Container is empty." ) ); + } + return _errorInfos[0]; + } + + /** + * Returns the first error from the container. + * @return The first error. + * @throw IllegalStateException Container is empty. + * @since 1.1.0 + */ + ErrorInfo& getFirstError() { + if( isEmpty() ) { + throw IllegalStateException( FCML_TEXT( "Container is empty." ) ); + } + return _errorInfos[0]; + } + + /** + * Returns the first error message from the container. + * @return The first error message. + * @since 1.1.0 + */ + fcml_cstring getFirstErrorMessage() const { + fcml_cstring message; + try { + const ErrorInfo &errorInfo = getFirstError(); + message = errorInfo.getMessage(); + } catch( IllegalStateException &exc ) { + } + return message; + } + + /** + * Prepares an error message basing on the first error in the container. + * @param message A prefix for the destination error message. + * @return Error message. + * @since 1.1.0 + */ + fcml_cstring prepareErrorMessage( const fcml_cstring &message ) const { + const fcml_cstring errorMessage = getFirstErrorMessage(); + if( errorMessage.empty() ) { + return message + FCML_TEXT('.'); + } else { + return message + FCML_TEXT(": ") + errorMessage; + } + } + + /** + * Cleans all errors and warnings. + * @since 1.1.0 + */ + void clean() { + _errorInfos.clear(); + _isWarn = false; + _isError = false; + } + +private: + + /** + * Checks bounds of the index. + * @param index The index to check. + * @throw BadArgumentException Index out of bound. + * @since 1.1.0 + */ + void checkVectorAccess( fcml_usize index ) const { + if( index >= _errorInfos.size() ) { + throw BadArgumentException( FCML_TEXT( "Index exceeds the allowed number of error info structures." ) ); + } + } + +private: + /** Error messages. */ + std::vector _errorInfos; + /* Sets if there is any warning in the container. */ + bool _isWarn; + /* Sets if there is any error in the container. */ + bool _isError; +}; + +/** + * Types converter. + * @since 1.1.0 + */ +class ErrorTypeConverter { +public: + + static void convert( const fcml_st_ceh_error_container &src, ErrorContainer &dest ) { + fcml_st_ceh_error_info *error = src.errors; + while( error ) { + ErrorInfo::ErrorLevel level = ( error->level == FCML_EN_CEH_EL_ERROR ) ? ErrorInfo::EL_ERROR : ErrorInfo::EL_WARN; + dest.addErrorInfo( ErrorInfo( error->message, error->code, level ) ); + error = error->next_error; + } + } + +}; + +/** + * Base class for all exceptions that are aware of ErrorContainer. + * @since 1.1.0 + */ +class ErrorContainerAwareException: public BaseException { +public: + + /** + * Creates an error container aware exception instance and sets basic information for it. + * @param msg An error message. + * @param errorContainer An error container for exception. + * @param error An optional FCML error code. + * @since 1.1.0 + */ + ErrorContainerAwareException( const fcml_cstring &msg, const ErrorContainer &errorContainer, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) : + BaseException( msg, error ), _errorContainer( errorContainer ) { + } + + /** + * Gets a reference to an error container associated with the exception. + * @return The error container. + * @since 1.1.0 + */ + const ErrorContainer& getErrorContainer() const { + return _errorContainer; + } + + /** + * Sets a new error container for the exception. + * @param errorContainer The new error container to be set for the exception. + * @since 1.1.0 + */ + void setErrorContainer(const ErrorContainer& errorContainer) { + _errorContainer = errorContainer; + } + +private: + + /** A container for errors. */ + ErrorContainer _errorContainer; + +}; + +} + +#endif // FCML_ERRORS_HPP_ diff --git a/dependencies/fcml/include/fcml_gas_dialect.h b/dependencies/fcml/include/fcml_gas_dialect.h new file mode 100644 index 0000000..a0e0697 --- /dev/null +++ b/dependencies/fcml/include/fcml_gas_dialect.h @@ -0,0 +1,62 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_gas_dialect.h + * AT&T dialect implementation. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ASM_DIALECT_GAS_H_ +#define FCML_ASM_DIALECT_GAS_H_ + +#include "fcml_lib_export.h" + +#include "fcml_errors.h" +#include "fcml_dialect.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Disables "SystemV/386 SVR3.2" compatibility for the non-commutative + * arithmetic floating point operations with two register operands. */ +#define FCML_GAS_DIALECT_CF_SYSV_SVR32_INCOMPATIBLE 0x00000001 + +/** Default combination of configuration flags. */ +#define FCML_GAS_DIALECT_CF_DEFAULT 0 + +/** + * Initializes AT&T dialect. + * Prepares new instance of AT&T dialect for given set of configuration flags. + * Every dialect has to be freed using fcml_fn_dialect_free() function. + * + * @param config_flags Configuration flags dedicated to the dialect. + * @param[out] dialect Prepared dialect instance. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @see fcml_fn_dialect_free + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_dialect_init_gas( + fcml_uint32_t config_flags, fcml_st_dialect **dialect); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_ASM_DIALECT_GAS_H_ */ diff --git a/dependencies/fcml/include/fcml_gas_dialect.hpp b/dependencies/fcml/include/fcml_gas_dialect.hpp new file mode 100644 index 0000000..7080193 --- /dev/null +++ b/dependencies/fcml/include/fcml_gas_dialect.hpp @@ -0,0 +1,66 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_gas_dialect.hpp + * C++ wrapper for the AT&T dialect. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_GAS_DIALECT_HPP_ +#define FCML_GAS_DIALECT_HPP_ + +#include "fcml_dialect.hpp" + +#include "fcml_gas_dialect.h" + +namespace fcml { + +/** Wraps the AT&T dialect. + * @since 1.1.0 + */ +class GASDialect: public Dialect { +public: + /** + * Creates AT&T dialect. + * + * @param flags Optional flags. + * @since 1.1.0 + */ + GASDialect(fcml_uint32_t flags = FCML_GAS_DIALECT_CF_DEFAULT) { + fcml_st_dialect *dialect; + fcml_ceh_error error = ::fcml_fn_dialect_init_gas(flags, &dialect); + if (error) { + throw InitException( + FCML_TEXT("Can not initialize the AT&T dialect."), error); + } + setDialect(dialect); + } + /** + * Virtual destructor. + * @since 1.1.0 + */ + virtual ~GASDialect() { + } +}; + +} + +#endif /* FCML_GAS_DIALECT_HPP_ */ diff --git a/dependencies/fcml/include/fcml_gas_mnemonics.cpp b/dependencies/fcml/include/fcml_gas_mnemonics.cpp new file mode 100644 index 0000000..4623b13 --- /dev/null +++ b/dependencies/fcml/include/fcml_gas_mnemonics.cpp @@ -0,0 +1,1934 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_gas_mnemonics.cpp + * Definitions of AT&T mnemonics for C++. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#include "fcml_gas_mnemonics.hpp" + +namespace fcml { +namespace gas { + +extern const fcml_cstring M_AAA = _FT("aaa"); +extern const fcml_cstring M_AAD = _FT("aad"); +extern const fcml_cstring M_AAM = _FT("aam"); +extern const fcml_cstring M_AAS = _FT("aas"); +extern const fcml_cstring M_ADC = _FT("adc"); +extern const fcml_cstring M_ADCB = _FT("adcb"); +extern const fcml_cstring M_ADCL = _FT("adcl"); +extern const fcml_cstring M_ADCQ = _FT("adcq"); +extern const fcml_cstring M_ADCW = _FT("adcw"); +extern const fcml_cstring M_ADCX = _FT("adcx"); +extern const fcml_cstring M_ADD = _FT("add"); +extern const fcml_cstring M_ADDB = _FT("addb"); +extern const fcml_cstring M_ADDL = _FT("addl"); +extern const fcml_cstring M_ADDPD = _FT("addpd"); +extern const fcml_cstring M_ADDPS = _FT("addps"); +extern const fcml_cstring M_ADDQ = _FT("addq"); +extern const fcml_cstring M_ADDSD = _FT("addsd"); +extern const fcml_cstring M_ADDSS = _FT("addss"); +extern const fcml_cstring M_ADDSUBPD = _FT("addsubpd"); +extern const fcml_cstring M_ADDSUBPS = _FT("addsubps"); +extern const fcml_cstring M_ADDW = _FT("addw"); +extern const fcml_cstring M_ADOX = _FT("adox"); +extern const fcml_cstring M_AESDEC = _FT("aesdec"); +extern const fcml_cstring M_AESDECLAST = _FT("aesdeclast"); +extern const fcml_cstring M_AESENC = _FT("aesenc"); +extern const fcml_cstring M_AESENCLAST = _FT("aesenclast"); +extern const fcml_cstring M_AESIMC = _FT("aesimc"); +extern const fcml_cstring M_AESKEYGENASSIST = _FT("aeskeygenassist"); +extern const fcml_cstring M_AND = _FT("and"); +extern const fcml_cstring M_ANDB = _FT("andb"); +extern const fcml_cstring M_ANDL = _FT("andl"); +extern const fcml_cstring M_ANDN = _FT("andn"); +extern const fcml_cstring M_ANDNPD = _FT("andnpd"); +extern const fcml_cstring M_ANDNPS = _FT("andnps"); +extern const fcml_cstring M_ANDPD = _FT("andpd"); +extern const fcml_cstring M_ANDPS = _FT("andps"); +extern const fcml_cstring M_ANDQ = _FT("andq"); +extern const fcml_cstring M_ANDW = _FT("andw"); +extern const fcml_cstring M_ARPL = _FT("arpl"); +extern const fcml_cstring M_BEXR = _FT("bexr"); +extern const fcml_cstring M_BEXTR = _FT("bextr"); +extern const fcml_cstring M_BLCFILL = _FT("blcfill"); +extern const fcml_cstring M_BLCI = _FT("blci"); +extern const fcml_cstring M_BLCIC = _FT("blcic"); +extern const fcml_cstring M_BLCMSK = _FT("blcmsk"); +extern const fcml_cstring M_BLCS = _FT("blcs"); +extern const fcml_cstring M_BLENDPD = _FT("blendpd"); +extern const fcml_cstring M_BLENDPS = _FT("blendps"); +extern const fcml_cstring M_BLENDVPD = _FT("blendvpd"); +extern const fcml_cstring M_BLENDVPS = _FT("blendvps"); +extern const fcml_cstring M_BLSFILL = _FT("blsfill"); +extern const fcml_cstring M_BLSI = _FT("blsi"); +extern const fcml_cstring M_BLSIC = _FT("blsic"); +extern const fcml_cstring M_BLSMSK = _FT("blsmsk"); +extern const fcml_cstring M_BLSR = _FT("blsr"); +extern const fcml_cstring M_BOUND = _FT("bound"); +extern const fcml_cstring M_BSF = _FT("bsf"); +extern const fcml_cstring M_BSR = _FT("bsr"); +extern const fcml_cstring M_BSWAP = _FT("bswap"); +extern const fcml_cstring M_BT = _FT("bt"); +extern const fcml_cstring M_BTC = _FT("btc"); +extern const fcml_cstring M_BTCL = _FT("btcl"); +extern const fcml_cstring M_BTCQ = _FT("btcq"); +extern const fcml_cstring M_BTCW = _FT("btcw"); +extern const fcml_cstring M_BTL = _FT("btl"); +extern const fcml_cstring M_BTQ = _FT("btq"); +extern const fcml_cstring M_BTR = _FT("btr"); +extern const fcml_cstring M_BTRL = _FT("btrl"); +extern const fcml_cstring M_BTRQ = _FT("btrq"); +extern const fcml_cstring M_BTRW = _FT("btrw"); +extern const fcml_cstring M_BTS = _FT("bts"); +extern const fcml_cstring M_BTSL = _FT("btsl"); +extern const fcml_cstring M_BTSQ = _FT("btsq"); +extern const fcml_cstring M_BTSW = _FT("btsw"); +extern const fcml_cstring M_BTW = _FT("btw"); +extern const fcml_cstring M_BZHI = _FT("bzhi"); +extern const fcml_cstring M_CALL = _FT("call"); +extern const fcml_cstring M_CALLQ = _FT("callq"); +extern const fcml_cstring M_CALLW = _FT("callw"); +extern const fcml_cstring M_CBTW = _FT("cbtw"); +extern const fcml_cstring M_CLAC = _FT("clac"); +extern const fcml_cstring M_CLC = _FT("clc"); +extern const fcml_cstring M_CLD = _FT("cld"); +extern const fcml_cstring M_CLFLUSH = _FT("clflush"); +extern const fcml_cstring M_CLGI = _FT("clgi"); +extern const fcml_cstring M_CLI = _FT("cli"); +extern const fcml_cstring M_CLTD = _FT("cltd"); +extern const fcml_cstring M_CLTQ = _FT("cltq"); +extern const fcml_cstring M_CLTS = _FT("clts"); +extern const fcml_cstring M_CMC = _FT("cmc"); +extern const fcml_cstring M_CMOVA = _FT("cmova"); +extern const fcml_cstring M_CMOVAE = _FT("cmovae"); +extern const fcml_cstring M_CMOVB = _FT("cmovb"); +extern const fcml_cstring M_CMOVBE = _FT("cmovbe"); +extern const fcml_cstring M_CMOVC = _FT("cmovc"); +extern const fcml_cstring M_CMOVENE = _FT("cmovene"); +extern const fcml_cstring M_CMOVG = _FT("cmovg"); +extern const fcml_cstring M_CMOVGE = _FT("cmovge"); +extern const fcml_cstring M_CMOVL = _FT("cmovl"); +extern const fcml_cstring M_CMOVLE = _FT("cmovle"); +extern const fcml_cstring M_CMOVNA = _FT("cmovna"); +extern const fcml_cstring M_CMOVNAE = _FT("cmovnae"); +extern const fcml_cstring M_CMOVNB = _FT("cmovnb"); +extern const fcml_cstring M_CMOVNBE = _FT("cmovnbe"); +extern const fcml_cstring M_CMOVNC = _FT("cmovnc"); +extern const fcml_cstring M_CMOVNG = _FT("cmovng"); +extern const fcml_cstring M_CMOVNGE = _FT("cmovnge"); +extern const fcml_cstring M_CMOVNL = _FT("cmovnl"); +extern const fcml_cstring M_CMOVNLE = _FT("cmovnle"); +extern const fcml_cstring M_CMOVNO = _FT("cmovno"); +extern const fcml_cstring M_CMOVNP = _FT("cmovnp"); +extern const fcml_cstring M_CMOVNS = _FT("cmovns"); +extern const fcml_cstring M_CMOVNZ = _FT("cmovnz"); +extern const fcml_cstring M_CMOVO = _FT("cmovo"); +extern const fcml_cstring M_CMOVP = _FT("cmovp"); +extern const fcml_cstring M_CMOVPE = _FT("cmovpe"); +extern const fcml_cstring M_CMOVPO = _FT("cmovpo"); +extern const fcml_cstring M_CMOVS = _FT("cmovs"); +extern const fcml_cstring M_CMOVZ = _FT("cmovz"); +extern const fcml_cstring M_CMP = _FT("cmp"); +extern const fcml_cstring M_CMPB = _FT("cmpb"); +extern const fcml_cstring M_CMPEQPD = _FT("cmpeqpd"); +extern const fcml_cstring M_CMPEQPS = _FT("cmpeqps"); +extern const fcml_cstring M_CMPEQSD = _FT("cmpeqsd"); +extern const fcml_cstring M_CMPEQSS = _FT("cmpeqss"); +extern const fcml_cstring M_CMPL = _FT("cmpl"); +extern const fcml_cstring M_CMPLEPD = _FT("cmplepd"); +extern const fcml_cstring M_CMPLEPS = _FT("cmpleps"); +extern const fcml_cstring M_CMPLESD = _FT("cmplesd"); +extern const fcml_cstring M_CMPLESS = _FT("cmpless"); +extern const fcml_cstring M_CMPLTPD = _FT("cmpltpd"); +extern const fcml_cstring M_CMPLTPS = _FT("cmpltps"); +extern const fcml_cstring M_CMPLTSD = _FT("cmpltsd"); +extern const fcml_cstring M_CMPLTSS = _FT("cmpltss"); +extern const fcml_cstring M_CMPNEQPD = _FT("cmpneqpd"); +extern const fcml_cstring M_CMPNEQPS = _FT("cmpneqps"); +extern const fcml_cstring M_CMPNEQSD = _FT("cmpneqsd"); +extern const fcml_cstring M_CMPNEQSS = _FT("cmpneqss"); +extern const fcml_cstring M_CMPNLEPD = _FT("cmpnlepd"); +extern const fcml_cstring M_CMPNLEPS = _FT("cmpnleps"); +extern const fcml_cstring M_CMPNLESD = _FT("cmpnlesd"); +extern const fcml_cstring M_CMPNLESS = _FT("cmpnless"); +extern const fcml_cstring M_CMPNLTPD = _FT("cmpnltpd"); +extern const fcml_cstring M_CMPNLTPS = _FT("cmpnltps"); +extern const fcml_cstring M_CMPNLTSD = _FT("cmpnltsd"); +extern const fcml_cstring M_CMPNLTSS = _FT("cmpnltss"); +extern const fcml_cstring M_CMPORDPD = _FT("cmpordpd"); +extern const fcml_cstring M_CMPORDPS = _FT("cmpordps"); +extern const fcml_cstring M_CMPORDSD = _FT("cmpordsd"); +extern const fcml_cstring M_CMPORDSS = _FT("cmpordss"); +extern const fcml_cstring M_CMPPD = _FT("cmppd"); +extern const fcml_cstring M_CMPPS = _FT("cmpps"); +extern const fcml_cstring M_CMPQ = _FT("cmpq"); +extern const fcml_cstring M_CMPSB = _FT("cmpsb"); +extern const fcml_cstring M_CMPSD = _FT("cmpsd"); +extern const fcml_cstring M_CMPSL = _FT("cmpsl"); +extern const fcml_cstring M_CMPSQ = _FT("cmpsq"); +extern const fcml_cstring M_CMPSS = _FT("cmpss"); +extern const fcml_cstring M_CMPSW = _FT("cmpsw"); +extern const fcml_cstring M_CMPUNORDPD = _FT("cmpunordpd"); +extern const fcml_cstring M_CMPUNORDPS = _FT("cmpunordps"); +extern const fcml_cstring M_CMPUNORDSD = _FT("cmpunordsd"); +extern const fcml_cstring M_CMPUNORDSS = _FT("cmpunordss"); +extern const fcml_cstring M_CMPW = _FT("cmpw"); +extern const fcml_cstring M_CMPXCHG = _FT("cmpxchg"); +extern const fcml_cstring M_CMPXCHG16B = _FT("cmpxchg16b"); +extern const fcml_cstring M_CMPXCHG8B = _FT("cmpxchg8b"); +extern const fcml_cstring M_COMISD = _FT("comisd"); +extern const fcml_cstring M_COMISS = _FT("comiss"); +extern const fcml_cstring M_CPUID = _FT("cpuid"); +extern const fcml_cstring M_CQTO = _FT("cqto"); +extern const fcml_cstring M_CRC32B = _FT("crc32b"); +extern const fcml_cstring M_CRC32L = _FT("crc32l"); +extern const fcml_cstring M_CRC32Q = _FT("crc32q"); +extern const fcml_cstring M_CRC32W = _FT("crc32w"); +extern const fcml_cstring M_CVTDQ2PD = _FT("cvtdq2pd"); +extern const fcml_cstring M_CVTDQ2PS = _FT("cvtdq2ps"); +extern const fcml_cstring M_CVTPD2DQ = _FT("cvtpd2dq"); +extern const fcml_cstring M_CVTPD2PI = _FT("cvtpd2pi"); +extern const fcml_cstring M_CVTPD2PS = _FT("cvtpd2ps"); +extern const fcml_cstring M_CVTPI2PD = _FT("cvtpi2pd"); +extern const fcml_cstring M_CVTPI2PS = _FT("cvtpi2ps"); +extern const fcml_cstring M_CVTPS2DQ = _FT("cvtps2dq"); +extern const fcml_cstring M_CVTPS2PD = _FT("cvtps2pd"); +extern const fcml_cstring M_CVTPS2PI = _FT("cvtps2pi"); +extern const fcml_cstring M_CVTSD2SI = _FT("cvtsd2si"); +extern const fcml_cstring M_CVTSD2SS = _FT("cvtsd2ss"); +extern const fcml_cstring M_CVTSI2SDL = _FT("cvtsi2sdl"); +extern const fcml_cstring M_CVTSI2SDQ = _FT("cvtsi2sdq"); +extern const fcml_cstring M_CVTSI2SSL = _FT("cvtsi2ssl"); +extern const fcml_cstring M_CVTSI2SSQ = _FT("cvtsi2ssq"); +extern const fcml_cstring M_CVTSS2SD = _FT("cvtss2sd"); +extern const fcml_cstring M_CVTSS2SI = _FT("cvtss2si"); +extern const fcml_cstring M_CVTTPD2DQ = _FT("cvttpd2dq"); +extern const fcml_cstring M_CVTTPD2PI = _FT("cvttpd2pi"); +extern const fcml_cstring M_CVTTPS2DQ = _FT("cvttps2dq"); +extern const fcml_cstring M_CVTTPS2PI = _FT("cvttps2pi"); +extern const fcml_cstring M_CVTTSD2SI = _FT("cvttsd2si"); +extern const fcml_cstring M_CVTTSS2SI = _FT("cvttss2si"); +extern const fcml_cstring M_CWTD = _FT("cwtd"); +extern const fcml_cstring M_CWTL = _FT("cwtl"); +extern const fcml_cstring M_DAA = _FT("daa"); +extern const fcml_cstring M_DAS = _FT("das"); +extern const fcml_cstring M_DEC = _FT("dec"); +extern const fcml_cstring M_DECB = _FT("decb"); +extern const fcml_cstring M_DECL = _FT("decl"); +extern const fcml_cstring M_DECQ = _FT("decq"); +extern const fcml_cstring M_DECW = _FT("decw"); +extern const fcml_cstring M_DIV = _FT("div"); +extern const fcml_cstring M_DIVB = _FT("divb"); +extern const fcml_cstring M_DIVL = _FT("divl"); +extern const fcml_cstring M_DIVPD = _FT("divpd"); +extern const fcml_cstring M_DIVPS = _FT("divps"); +extern const fcml_cstring M_DIVQ = _FT("divq"); +extern const fcml_cstring M_DIVSD = _FT("divsd"); +extern const fcml_cstring M_DIVSS = _FT("divss"); +extern const fcml_cstring M_DIVW = _FT("divw"); +extern const fcml_cstring M_DPPD = _FT("dppd"); +extern const fcml_cstring M_DPPS = _FT("dpps"); +extern const fcml_cstring M_EMMS = _FT("emms"); +extern const fcml_cstring M_ENTER = _FT("enter"); +extern const fcml_cstring M_ENTERQ = _FT("enterq"); +extern const fcml_cstring M_EXTRACTPS = _FT("extractps"); +extern const fcml_cstring M_EXTRQ = _FT("extrq"); +extern const fcml_cstring M_F2XM1 = _FT("f2xm1"); +extern const fcml_cstring M_FABS = _FT("fabs"); +extern const fcml_cstring M_FADD = _FT("fadd"); +extern const fcml_cstring M_FADDL = _FT("faddl"); +extern const fcml_cstring M_FADDP = _FT("faddp"); +extern const fcml_cstring M_FADDS = _FT("fadds"); +extern const fcml_cstring M_FBLD = _FT("fbld"); +extern const fcml_cstring M_FBSTP = _FT("fbstp"); +extern const fcml_cstring M_FCHS = _FT("fchs"); +extern const fcml_cstring M_FCLEX = _FT("fclex"); +extern const fcml_cstring M_FCMOVB = _FT("fcmovb"); +extern const fcml_cstring M_FCMOVBE = _FT("fcmovbe"); +extern const fcml_cstring M_FCMOVE = _FT("fcmove"); +extern const fcml_cstring M_FCMOVNB = _FT("fcmovnb"); +extern const fcml_cstring M_FCMOVNBE = _FT("fcmovnbe"); +extern const fcml_cstring M_FCMOVNE = _FT("fcmovne"); +extern const fcml_cstring M_FCMOVNU = _FT("fcmovnu"); +extern const fcml_cstring M_FCMOVU = _FT("fcmovu"); +extern const fcml_cstring M_FCOM = _FT("fcom"); +extern const fcml_cstring M_FCOMI = _FT("fcomi"); +extern const fcml_cstring M_FCOMIP = _FT("fcomip"); +extern const fcml_cstring M_FCOML = _FT("fcoml"); +extern const fcml_cstring M_FCOMP = _FT("fcomp"); +extern const fcml_cstring M_FCOMPL = _FT("fcompl"); +extern const fcml_cstring M_FCOMPP = _FT("fcompp"); +extern const fcml_cstring M_FCOMPS = _FT("fcomps"); +extern const fcml_cstring M_FCOMS = _FT("fcoms"); +extern const fcml_cstring M_FCOS = _FT("fcos"); +extern const fcml_cstring M_FDECSTP = _FT("fdecstp"); +extern const fcml_cstring M_FDIV = _FT("fdiv"); +extern const fcml_cstring M_FDIVL = _FT("fdivl"); +extern const fcml_cstring M_FDIVP = _FT("fdivp"); +extern const fcml_cstring M_FDIVR = _FT("fdivr"); +extern const fcml_cstring M_FDIVRL = _FT("fdivrl"); +extern const fcml_cstring M_FDIVRP = _FT("fdivrp"); +extern const fcml_cstring M_FDIVRS = _FT("fdivrs"); +extern const fcml_cstring M_FDIVS = _FT("fdivs"); +extern const fcml_cstring M_FEMMS = _FT("femms"); +extern const fcml_cstring M_FFREE = _FT("ffree"); +extern const fcml_cstring M_FIADD = _FT("fiadd"); +extern const fcml_cstring M_FIADDL = _FT("fiaddl"); +extern const fcml_cstring M_FICOM = _FT("ficom"); +extern const fcml_cstring M_FICOML = _FT("ficoml"); +extern const fcml_cstring M_FICOMP = _FT("ficomp"); +extern const fcml_cstring M_FICOMPL = _FT("ficompl"); +extern const fcml_cstring M_FIDIV = _FT("fidiv"); +extern const fcml_cstring M_FIDIVL = _FT("fidivl"); +extern const fcml_cstring M_FIDIVR = _FT("fidivr"); +extern const fcml_cstring M_FIDIVRL = _FT("fidivrl"); +extern const fcml_cstring M_FILD = _FT("fild"); +extern const fcml_cstring M_FILDL = _FT("fildl"); +extern const fcml_cstring M_FILDLL = _FT("fildll"); +extern const fcml_cstring M_FIMUL = _FT("fimul"); +extern const fcml_cstring M_FIMULL = _FT("fimull"); +extern const fcml_cstring M_FINCSTP = _FT("fincstp"); +extern const fcml_cstring M_FINIT = _FT("finit"); +extern const fcml_cstring M_FIST = _FT("fist"); +extern const fcml_cstring M_FISTL = _FT("fistl"); +extern const fcml_cstring M_FISTP = _FT("fistp"); +extern const fcml_cstring M_FISTPL = _FT("fistpl"); +extern const fcml_cstring M_FISTPLL = _FT("fistpll"); +extern const fcml_cstring M_FISTTP = _FT("fisttp"); +extern const fcml_cstring M_FISTTPL = _FT("fisttpl"); +extern const fcml_cstring M_FISTTPLL = _FT("fisttpll"); +extern const fcml_cstring M_FISUB = _FT("fisub"); +extern const fcml_cstring M_FISUBL = _FT("fisubl"); +extern const fcml_cstring M_FISUBR = _FT("fisubr"); +extern const fcml_cstring M_FISUBRL = _FT("fisubrl"); +extern const fcml_cstring M_FLD = _FT("fld"); +extern const fcml_cstring M_FLD1 = _FT("fld1"); +extern const fcml_cstring M_FLDCW = _FT("fldcw"); +extern const fcml_cstring M_FLDENV = _FT("fldenv"); +extern const fcml_cstring M_FLDENVS = _FT("fldenvs"); +extern const fcml_cstring M_FLDL = _FT("fldl"); +extern const fcml_cstring M_FLDL2E = _FT("fldl2e"); +extern const fcml_cstring M_FLDL2T = _FT("fldl2t"); +extern const fcml_cstring M_FLDLG2 = _FT("fldlg2"); +extern const fcml_cstring M_FLDLN2 = _FT("fldln2"); +extern const fcml_cstring M_FLDPI = _FT("fldpi"); +extern const fcml_cstring M_FLDS = _FT("flds"); +extern const fcml_cstring M_FLDT = _FT("fldt"); +extern const fcml_cstring M_FLDZ = _FT("fldz"); +extern const fcml_cstring M_FMUL = _FT("fmul"); +extern const fcml_cstring M_FMULL = _FT("fmull"); +extern const fcml_cstring M_FMULP = _FT("fmulp"); +extern const fcml_cstring M_FMULS = _FT("fmuls"); +extern const fcml_cstring M_FNCLEX = _FT("fnclex"); +extern const fcml_cstring M_FNINIT = _FT("fninit"); +extern const fcml_cstring M_FNOP = _FT("fnop"); +extern const fcml_cstring M_FNSAVE = _FT("fnsave"); +extern const fcml_cstring M_FNSAVES = _FT("fnsaves"); +extern const fcml_cstring M_FNSTCW = _FT("fnstcw"); +extern const fcml_cstring M_FNSTENV = _FT("fnstenv"); +extern const fcml_cstring M_FNSTENVS = _FT("fnstenvs"); +extern const fcml_cstring M_FNSTSW = _FT("fnstsw"); +extern const fcml_cstring M_FPATAN = _FT("fpatan"); +extern const fcml_cstring M_FPREM = _FT("fprem"); +extern const fcml_cstring M_FPREM1 = _FT("fprem1"); +extern const fcml_cstring M_FPTAN = _FT("fptan"); +extern const fcml_cstring M_FRNDINT = _FT("frndint"); +extern const fcml_cstring M_FRSTOR = _FT("frstor"); +extern const fcml_cstring M_FRSTORS = _FT("frstors"); +extern const fcml_cstring M_FSAVE = _FT("fsave"); +extern const fcml_cstring M_FSAVES = _FT("fsaves"); +extern const fcml_cstring M_FSCALE = _FT("fscale"); +extern const fcml_cstring M_FSIN = _FT("fsin"); +extern const fcml_cstring M_FSINCOS = _FT("fsincos"); +extern const fcml_cstring M_FSQRT = _FT("fsqrt"); +extern const fcml_cstring M_FST = _FT("fst"); +extern const fcml_cstring M_FSTCW = _FT("fstcw"); +extern const fcml_cstring M_FSTENV = _FT("fstenv"); +extern const fcml_cstring M_FSTENVS = _FT("fstenvs"); +extern const fcml_cstring M_FSTL = _FT("fstl"); +extern const fcml_cstring M_FSTP = _FT("fstp"); +extern const fcml_cstring M_FSTPL = _FT("fstpl"); +extern const fcml_cstring M_FSTPS = _FT("fstps"); +extern const fcml_cstring M_FSTPT = _FT("fstpt"); +extern const fcml_cstring M_FSTS = _FT("fsts"); +extern const fcml_cstring M_FSTSW = _FT("fstsw"); +extern const fcml_cstring M_FSUB = _FT("fsub"); +extern const fcml_cstring M_FSUBL = _FT("fsubl"); +extern const fcml_cstring M_FSUBP = _FT("fsubp"); +extern const fcml_cstring M_FSUBR = _FT("fsubr"); +extern const fcml_cstring M_FSUBRL = _FT("fsubrl"); +extern const fcml_cstring M_FSUBRP = _FT("fsubrp"); +extern const fcml_cstring M_FSUBRS = _FT("fsubrs"); +extern const fcml_cstring M_FSUBS = _FT("fsubs"); +extern const fcml_cstring M_FTST = _FT("ftst"); +extern const fcml_cstring M_FUCOM = _FT("fucom"); +extern const fcml_cstring M_FUCOMI = _FT("fucomi"); +extern const fcml_cstring M_FUCOMIP = _FT("fucomip"); +extern const fcml_cstring M_FUCOMP = _FT("fucomp"); +extern const fcml_cstring M_FUCOMPP = _FT("fucompp"); +extern const fcml_cstring M_FWAIT = _FT("fwait"); +extern const fcml_cstring M_FXAM = _FT("fxam"); +extern const fcml_cstring M_FXCH = _FT("fxch"); +extern const fcml_cstring M_FXRSTOR = _FT("fxrstor"); +extern const fcml_cstring M_FXRSTOR64 = _FT("fxrstor64"); +extern const fcml_cstring M_FXSAVE = _FT("fxsave"); +extern const fcml_cstring M_FXSAVE64 = _FT("fxsave64"); +extern const fcml_cstring M_FXTRACT = _FT("fxtract"); +extern const fcml_cstring M_FYL2X = _FT("fyl2x"); +extern const fcml_cstring M_FYL2XP1 = _FT("fyl2xp1"); +extern const fcml_cstring M_GETSEC = _FT("getsec"); +extern const fcml_cstring M_HADDPD = _FT("haddpd"); +extern const fcml_cstring M_HADDPS = _FT("haddps"); +extern const fcml_cstring M_HLT = _FT("hlt"); +extern const fcml_cstring M_HSUBPD = _FT("hsubpd"); +extern const fcml_cstring M_HSUBPS = _FT("hsubps"); +extern const fcml_cstring M_IDIV = _FT("idiv"); +extern const fcml_cstring M_IDIVB = _FT("idivb"); +extern const fcml_cstring M_IDIVL = _FT("idivl"); +extern const fcml_cstring M_IDIVQ = _FT("idivq"); +extern const fcml_cstring M_IDIVW = _FT("idivw"); +extern const fcml_cstring M_IMUL = _FT("imul"); +extern const fcml_cstring M_IMULB = _FT("imulb"); +extern const fcml_cstring M_IMULL = _FT("imull"); +extern const fcml_cstring M_IMULQ = _FT("imulq"); +extern const fcml_cstring M_IMULW = _FT("imulw"); +extern const fcml_cstring M_IN = _FT("in"); +extern const fcml_cstring M_INC = _FT("inc"); +extern const fcml_cstring M_INCB = _FT("incb"); +extern const fcml_cstring M_INCL = _FT("incl"); +extern const fcml_cstring M_INCQ = _FT("incq"); +extern const fcml_cstring M_INCW = _FT("incw"); +extern const fcml_cstring M_INSB = _FT("insb"); +extern const fcml_cstring M_INSERTPS = _FT("insertps"); +extern const fcml_cstring M_INSERTQ = _FT("insertq"); +extern const fcml_cstring M_INSL = _FT("insl"); +extern const fcml_cstring M_INSW = _FT("insw"); +extern const fcml_cstring M_INT = _FT("int"); +extern const fcml_cstring M_INT3 = _FT("int3"); +extern const fcml_cstring M_INTO = _FT("into"); +extern const fcml_cstring M_INVD = _FT("invd"); +extern const fcml_cstring M_INVEPT = _FT("invept"); +extern const fcml_cstring M_INVLPG = _FT("invlpg"); +extern const fcml_cstring M_INVLPGA = _FT("invlpga"); +extern const fcml_cstring M_INVPCID = _FT("invpcid"); +extern const fcml_cstring M_INVVPID = _FT("invvpid"); +extern const fcml_cstring M_IRET = _FT("iret"); +extern const fcml_cstring M_IRETQ = _FT("iretq"); +extern const fcml_cstring M_IRETW = _FT("iretw"); +extern const fcml_cstring M_JA = _FT("ja"); +extern const fcml_cstring M_JAE = _FT("jae"); +extern const fcml_cstring M_JB = _FT("jb"); +extern const fcml_cstring M_JBE = _FT("jbe"); +extern const fcml_cstring M_JC = _FT("jc"); +extern const fcml_cstring M_JCXZ = _FT("jcxz"); +extern const fcml_cstring M_JECXZ = _FT("jecxz"); +extern const fcml_cstring M_JENE = _FT("jene"); +extern const fcml_cstring M_JG = _FT("jg"); +extern const fcml_cstring M_JGE = _FT("jge"); +extern const fcml_cstring M_JL = _FT("jl"); +extern const fcml_cstring M_JLE = _FT("jle"); +extern const fcml_cstring M_JMP = _FT("jmp"); +extern const fcml_cstring M_JMPQ = _FT("jmpq"); +extern const fcml_cstring M_JMPW = _FT("jmpw"); +extern const fcml_cstring M_JNA = _FT("jna"); +extern const fcml_cstring M_JNAE = _FT("jnae"); +extern const fcml_cstring M_JNB = _FT("jnb"); +extern const fcml_cstring M_JNBE = _FT("jnbe"); +extern const fcml_cstring M_JNC = _FT("jnc"); +extern const fcml_cstring M_JNG = _FT("jng"); +extern const fcml_cstring M_JNGE = _FT("jnge"); +extern const fcml_cstring M_JNL = _FT("jnl"); +extern const fcml_cstring M_JNLE = _FT("jnle"); +extern const fcml_cstring M_JNO = _FT("jno"); +extern const fcml_cstring M_JNP = _FT("jnp"); +extern const fcml_cstring M_JNS = _FT("jns"); +extern const fcml_cstring M_JNZ = _FT("jnz"); +extern const fcml_cstring M_JO = _FT("jo"); +extern const fcml_cstring M_JP = _FT("jp"); +extern const fcml_cstring M_JPE = _FT("jpe"); +extern const fcml_cstring M_JPO = _FT("jpo"); +extern const fcml_cstring M_JRCXZ = _FT("jrcxz"); +extern const fcml_cstring M_JS = _FT("js"); +extern const fcml_cstring M_JZ = _FT("jz"); +extern const fcml_cstring M_KADDB = _FT("kaddb"); +extern const fcml_cstring M_KADDD = _FT("kaddd"); +extern const fcml_cstring M_KADDQ = _FT("kaddq"); +extern const fcml_cstring M_KADDW = _FT("kaddw"); +extern const fcml_cstring M_KANDB = _FT("kandb"); +extern const fcml_cstring M_KANDD = _FT("kandd"); +extern const fcml_cstring M_KANDNB = _FT("kandnb"); +extern const fcml_cstring M_KANDND = _FT("kandnd"); +extern const fcml_cstring M_KANDNQ = _FT("kandnq"); +extern const fcml_cstring M_KANDNW = _FT("kandnw"); +extern const fcml_cstring M_KANDQ = _FT("kandq"); +extern const fcml_cstring M_KANDW = _FT("kandw"); +extern const fcml_cstring M_KMOVB = _FT("kmovb"); +extern const fcml_cstring M_KMOVD = _FT("kmovd"); +extern const fcml_cstring M_KMOVQ = _FT("kmovq"); +extern const fcml_cstring M_KMOVW = _FT("kmovw"); +extern const fcml_cstring M_KNOTB = _FT("knotb"); +extern const fcml_cstring M_KNOTD = _FT("knotd"); +extern const fcml_cstring M_KNOTQ = _FT("knotq"); +extern const fcml_cstring M_KNOTW = _FT("knotw"); +extern const fcml_cstring M_KORB = _FT("korb"); +extern const fcml_cstring M_KORD = _FT("kord"); +extern const fcml_cstring M_KORQ = _FT("korq"); +extern const fcml_cstring M_KORTESTB = _FT("kortestb"); +extern const fcml_cstring M_KORTESTD = _FT("kortestd"); +extern const fcml_cstring M_KORTESTQ = _FT("kortestq"); +extern const fcml_cstring M_KORTESTW = _FT("kortestw"); +extern const fcml_cstring M_KORW = _FT("korw"); +extern const fcml_cstring M_KSHIFTLB = _FT("kshiftlb"); +extern const fcml_cstring M_KSHIFTLD = _FT("kshiftld"); +extern const fcml_cstring M_KSHIFTLQ = _FT("kshiftlq"); +extern const fcml_cstring M_KSHIFTLW = _FT("kshiftlw"); +extern const fcml_cstring M_KSHIFTRB = _FT("kshiftrb"); +extern const fcml_cstring M_KSHIFTRD = _FT("kshiftrd"); +extern const fcml_cstring M_KSHIFTRQ = _FT("kshiftrq"); +extern const fcml_cstring M_KSHIFTRW = _FT("kshiftrw"); +extern const fcml_cstring M_KTESTB = _FT("ktestb"); +extern const fcml_cstring M_KTESTD = _FT("ktestd"); +extern const fcml_cstring M_KTESTQ = _FT("ktestq"); +extern const fcml_cstring M_KTESTW = _FT("ktestw"); +extern const fcml_cstring M_KXNORB = _FT("kxnorb"); +extern const fcml_cstring M_KXNORD = _FT("kxnord"); +extern const fcml_cstring M_KXNORQ = _FT("kxnorq"); +extern const fcml_cstring M_KXNORW = _FT("kxnorw"); +extern const fcml_cstring M_KXORB = _FT("kxorb"); +extern const fcml_cstring M_KXORD = _FT("kxord"); +extern const fcml_cstring M_KXORQ = _FT("kxorq"); +extern const fcml_cstring M_KXORW = _FT("kxorw"); +extern const fcml_cstring M_LAHF = _FT("lahf"); +extern const fcml_cstring M_LAR = _FT("lar"); +extern const fcml_cstring M_LCALL = _FT("lcall"); +extern const fcml_cstring M_LCALLQ = _FT("lcallq"); +extern const fcml_cstring M_LCALLW = _FT("lcallw"); +extern const fcml_cstring M_LDDQU = _FT("lddqu"); +extern const fcml_cstring M_LDMXCSR = _FT("ldmxcsr"); +extern const fcml_cstring M_LDS = _FT("lds"); +extern const fcml_cstring M_LEA = _FT("lea"); +extern const fcml_cstring M_LEAVE = _FT("leave"); +extern const fcml_cstring M_LES = _FT("les"); +extern const fcml_cstring M_LFENCE = _FT("lfence"); +extern const fcml_cstring M_LFS = _FT("lfs"); +extern const fcml_cstring M_LGDT = _FT("lgdt"); +extern const fcml_cstring M_LGS = _FT("lgs"); +extern const fcml_cstring M_LIDT = _FT("lidt"); +extern const fcml_cstring M_LJMP = _FT("ljmp"); +extern const fcml_cstring M_LJMPL = _FT("ljmpl"); +extern const fcml_cstring M_LJMPQ = _FT("ljmpq"); +extern const fcml_cstring M_LJMPW = _FT("ljmpw"); +extern const fcml_cstring M_LLDT = _FT("lldt"); +extern const fcml_cstring M_LLWPCB = _FT("llwpcb"); +extern const fcml_cstring M_LMSW = _FT("lmsw"); +extern const fcml_cstring M_LODS = _FT("lods"); +extern const fcml_cstring M_LODSB = _FT("lodsb"); +extern const fcml_cstring M_LODSL = _FT("lodsl"); +extern const fcml_cstring M_LODSQ = _FT("lodsq"); +extern const fcml_cstring M_LODSW = _FT("lodsw"); +extern const fcml_cstring M_LOOP = _FT("loop"); +extern const fcml_cstring M_LOOPE = _FT("loope"); +extern const fcml_cstring M_LOOPNE = _FT("loopne"); +extern const fcml_cstring M_LOOPNZ = _FT("loopnz"); +extern const fcml_cstring M_LOOPZ = _FT("loopz"); +extern const fcml_cstring M_LRET = _FT("lret"); +extern const fcml_cstring M_LRETQ = _FT("lretq"); +extern const fcml_cstring M_LRETW = _FT("lretw"); +extern const fcml_cstring M_LSL = _FT("lsl"); +extern const fcml_cstring M_LSS = _FT("lss"); +extern const fcml_cstring M_LTR = _FT("ltr"); +extern const fcml_cstring M_LWPINS = _FT("lwpins"); +extern const fcml_cstring M_LWPVAL = _FT("lwpval"); +extern const fcml_cstring M_LZCNT = _FT("lzcnt"); +extern const fcml_cstring M_MASKMOVDQU = _FT("maskmovdqu"); +extern const fcml_cstring M_MASKMOVQ = _FT("maskmovq"); +extern const fcml_cstring M_MAXPD = _FT("maxpd"); +extern const fcml_cstring M_MAXPS = _FT("maxps"); +extern const fcml_cstring M_MAXSD = _FT("maxsd"); +extern const fcml_cstring M_MAXSS = _FT("maxss"); +extern const fcml_cstring M_MFENCE = _FT("mfence"); +extern const fcml_cstring M_MINPD = _FT("minpd"); +extern const fcml_cstring M_MINPS = _FT("minps"); +extern const fcml_cstring M_MINSD = _FT("minsd"); +extern const fcml_cstring M_MINSS = _FT("minss"); +extern const fcml_cstring M_MONITOR = _FT("monitor"); +extern const fcml_cstring M_MOV = _FT("mov"); +extern const fcml_cstring M_MOVABS = _FT("movabs"); +extern const fcml_cstring M_MOVAPD = _FT("movapd"); +extern const fcml_cstring M_MOVAPS = _FT("movaps"); +extern const fcml_cstring M_MOVB = _FT("movb"); +extern const fcml_cstring M_MOVBE = _FT("movbe"); +extern const fcml_cstring M_MOVD = _FT("movd"); +extern const fcml_cstring M_MOVDDUP = _FT("movddup"); +extern const fcml_cstring M_MOVDQ2Q = _FT("movdq2q"); +extern const fcml_cstring M_MOVDQA = _FT("movdqa"); +extern const fcml_cstring M_MOVDQU = _FT("movdqu"); +extern const fcml_cstring M_MOVHLPS = _FT("movhlps"); +extern const fcml_cstring M_MOVHPD = _FT("movhpd"); +extern const fcml_cstring M_MOVHPS = _FT("movhps"); +extern const fcml_cstring M_MOVL = _FT("movl"); +extern const fcml_cstring M_MOVLHPS = _FT("movlhps"); +extern const fcml_cstring M_MOVLPD = _FT("movlpd"); +extern const fcml_cstring M_MOVLPS = _FT("movlps"); +extern const fcml_cstring M_MOVMSKPD = _FT("movmskpd"); +extern const fcml_cstring M_MOVMSKPS = _FT("movmskps"); +extern const fcml_cstring M_MOVNTDQ = _FT("movntdq"); +extern const fcml_cstring M_MOVNTDQA = _FT("movntdqa"); +extern const fcml_cstring M_MOVNTI = _FT("movnti"); +extern const fcml_cstring M_MOVNTPD = _FT("movntpd"); +extern const fcml_cstring M_MOVNTPS = _FT("movntps"); +extern const fcml_cstring M_MOVNTQ = _FT("movntq"); +extern const fcml_cstring M_MOVNTSD = _FT("movntsd"); +extern const fcml_cstring M_MOVNTSS = _FT("movntss"); +extern const fcml_cstring M_MOVQ = _FT("movq"); +extern const fcml_cstring M_MOVQ2DQ = _FT("movq2dq"); +extern const fcml_cstring M_MOVS = _FT("movs"); +extern const fcml_cstring M_MOVSB = _FT("movsb"); +extern const fcml_cstring M_MOVSBL = _FT("movsbl"); +extern const fcml_cstring M_MOVSBQ = _FT("movsbq"); +extern const fcml_cstring M_MOVSBW = _FT("movsbw"); +extern const fcml_cstring M_MOVSD = _FT("movsd"); +extern const fcml_cstring M_MOVSHDUP = _FT("movshdup"); +extern const fcml_cstring M_MOVSL = _FT("movsl"); +extern const fcml_cstring M_MOVSLDUP = _FT("movsldup"); +extern const fcml_cstring M_MOVSQ = _FT("movsq"); +extern const fcml_cstring M_MOVSS = _FT("movss"); +extern const fcml_cstring M_MOVSW = _FT("movsw"); +extern const fcml_cstring M_MOVSWL = _FT("movswl"); +extern const fcml_cstring M_MOVSWQ = _FT("movswq"); +extern const fcml_cstring M_MOVSWW = _FT("movsww"); +extern const fcml_cstring M_MOVSXD = _FT("movsxd"); +extern const fcml_cstring M_MOVUPD = _FT("movupd"); +extern const fcml_cstring M_MOVUPS = _FT("movups"); +extern const fcml_cstring M_MOVW = _FT("movw"); +extern const fcml_cstring M_MOVZBL = _FT("movzbl"); +extern const fcml_cstring M_MOVZBQ = _FT("movzbq"); +extern const fcml_cstring M_MOVZBW = _FT("movzbw"); +extern const fcml_cstring M_MOVZWL = _FT("movzwl"); +extern const fcml_cstring M_MOVZWQ = _FT("movzwq"); +extern const fcml_cstring M_MOVZWW = _FT("movzww"); +extern const fcml_cstring M_MPSADBW = _FT("mpsadbw"); +extern const fcml_cstring M_MUL = _FT("mul"); +extern const fcml_cstring M_MULB = _FT("mulb"); +extern const fcml_cstring M_MULL = _FT("mull"); +extern const fcml_cstring M_MULPD = _FT("mulpd"); +extern const fcml_cstring M_MULPS = _FT("mulps"); +extern const fcml_cstring M_MULQ = _FT("mulq"); +extern const fcml_cstring M_MULSD = _FT("mulsd"); +extern const fcml_cstring M_MULSS = _FT("mulss"); +extern const fcml_cstring M_MULW = _FT("mulw"); +extern const fcml_cstring M_MULX = _FT("mulx"); +extern const fcml_cstring M_MWAIT = _FT("mwait"); +extern const fcml_cstring M_NEG = _FT("neg"); +extern const fcml_cstring M_NEGB = _FT("negb"); +extern const fcml_cstring M_NEGL = _FT("negl"); +extern const fcml_cstring M_NEGQ = _FT("negq"); +extern const fcml_cstring M_NEGW = _FT("negw"); +extern const fcml_cstring M_NOP = _FT("nop"); +extern const fcml_cstring M_NOPL = _FT("nopl"); +extern const fcml_cstring M_NOPQ = _FT("nopq"); +extern const fcml_cstring M_NOPW = _FT("nopw"); +extern const fcml_cstring M_NOT = _FT("not"); +extern const fcml_cstring M_NOTB = _FT("notb"); +extern const fcml_cstring M_NOTL = _FT("notl"); +extern const fcml_cstring M_NOTQ = _FT("notq"); +extern const fcml_cstring M_NOTW = _FT("notw"); +extern const fcml_cstring M_OR = _FT("or"); +extern const fcml_cstring M_ORB = _FT("orb"); +extern const fcml_cstring M_ORL = _FT("orl"); +extern const fcml_cstring M_ORPD = _FT("orpd"); +extern const fcml_cstring M_ORPS = _FT("orps"); +extern const fcml_cstring M_ORQ = _FT("orq"); +extern const fcml_cstring M_ORW = _FT("orw"); +extern const fcml_cstring M_OUT = _FT("out"); +extern const fcml_cstring M_OUTSB = _FT("outsb"); +extern const fcml_cstring M_OUTSL = _FT("outsl"); +extern const fcml_cstring M_OUTSW = _FT("outsw"); +extern const fcml_cstring M_PABSB = _FT("pabsb"); +extern const fcml_cstring M_PABSD = _FT("pabsd"); +extern const fcml_cstring M_PABSW = _FT("pabsw"); +extern const fcml_cstring M_PACKSSDW = _FT("packssdw"); +extern const fcml_cstring M_PACKSSWB = _FT("packsswb"); +extern const fcml_cstring M_PACKUSDW = _FT("packusdw"); +extern const fcml_cstring M_PACKUSWB = _FT("packuswb"); +extern const fcml_cstring M_PADDB = _FT("paddb"); +extern const fcml_cstring M_PADDD = _FT("paddd"); +extern const fcml_cstring M_PADDQ = _FT("paddq"); +extern const fcml_cstring M_PADDSB = _FT("paddsb"); +extern const fcml_cstring M_PADDSW = _FT("paddsw"); +extern const fcml_cstring M_PADDUSB = _FT("paddusb"); +extern const fcml_cstring M_PADDUSW = _FT("paddusw"); +extern const fcml_cstring M_PADDW = _FT("paddw"); +extern const fcml_cstring M_PALIGNR = _FT("palignr"); +extern const fcml_cstring M_PAND = _FT("pand"); +extern const fcml_cstring M_PANDN = _FT("pandn"); +extern const fcml_cstring M_PAUSE = _FT("pause"); +extern const fcml_cstring M_PAVGB = _FT("pavgb"); +extern const fcml_cstring M_PAVGUSB = _FT("pavgusb"); +extern const fcml_cstring M_PAVGW = _FT("pavgw"); +extern const fcml_cstring M_PBLENDVB = _FT("pblendvb"); +extern const fcml_cstring M_PBLENDW = _FT("pblendw"); +extern const fcml_cstring M_PCLMULQDQ = _FT("pclmulqdq"); +extern const fcml_cstring M_PCMPEQB = _FT("pcmpeqb"); +extern const fcml_cstring M_PCMPEQD = _FT("pcmpeqd"); +extern const fcml_cstring M_PCMPEQQ = _FT("pcmpeqq"); +extern const fcml_cstring M_PCMPEQW = _FT("pcmpeqw"); +extern const fcml_cstring M_PCMPESTRI = _FT("pcmpestri"); +extern const fcml_cstring M_PCMPESTRM = _FT("pcmpestrm"); +extern const fcml_cstring M_PCMPGTB = _FT("pcmpgtb"); +extern const fcml_cstring M_PCMPGTD = _FT("pcmpgtd"); +extern const fcml_cstring M_PCMPGTQ = _FT("pcmpgtq"); +extern const fcml_cstring M_PCMPGTW = _FT("pcmpgtw"); +extern const fcml_cstring M_PCMPISTRI = _FT("pcmpistri"); +extern const fcml_cstring M_PCMPISTRM = _FT("pcmpistrm"); +extern const fcml_cstring M_PDEP = _FT("pdep"); +extern const fcml_cstring M_PEXT = _FT("pext"); +extern const fcml_cstring M_PEXTRB = _FT("pextrb"); +extern const fcml_cstring M_PEXTRD = _FT("pextrd"); +extern const fcml_cstring M_PEXTRQ = _FT("pextrq"); +extern const fcml_cstring M_PEXTRW = _FT("pextrw"); +extern const fcml_cstring M_PF2ID = _FT("pf2id"); +extern const fcml_cstring M_PF2IW = _FT("pf2iw"); +extern const fcml_cstring M_PFACC = _FT("pfacc"); +extern const fcml_cstring M_PFADD = _FT("pfadd"); +extern const fcml_cstring M_PFCMPEQ = _FT("pfcmpeq"); +extern const fcml_cstring M_PFCMPGE = _FT("pfcmpge"); +extern const fcml_cstring M_PFCMPGT = _FT("pfcmpgt"); +extern const fcml_cstring M_PFMAX = _FT("pfmax"); +extern const fcml_cstring M_PFMIN = _FT("pfmin"); +extern const fcml_cstring M_PFMUL = _FT("pfmul"); +extern const fcml_cstring M_PFNACC = _FT("pfnacc"); +extern const fcml_cstring M_PFPNACC = _FT("pfpnacc"); +extern const fcml_cstring M_PFRCP = _FT("pfrcp"); +extern const fcml_cstring M_PFRCPIT1 = _FT("pfrcpit1"); +extern const fcml_cstring M_PFRCPIT2 = _FT("pfrcpit2"); +extern const fcml_cstring M_PFRSQIT1 = _FT("pfrsqit1"); +extern const fcml_cstring M_PFRSQRT = _FT("pfrsqrt"); +extern const fcml_cstring M_PFSUB = _FT("pfsub"); +extern const fcml_cstring M_PFSUBR = _FT("pfsubr"); +extern const fcml_cstring M_PHADDD = _FT("phaddd"); +extern const fcml_cstring M_PHADDSW = _FT("phaddsw"); +extern const fcml_cstring M_PHADDW = _FT("phaddw"); +extern const fcml_cstring M_PHMINPOSUW = _FT("phminposuw"); +extern const fcml_cstring M_PHSUBD = _FT("phsubd"); +extern const fcml_cstring M_PHSUBSW = _FT("phsubsw"); +extern const fcml_cstring M_PHSUBW = _FT("phsubw"); +extern const fcml_cstring M_PI2FD = _FT("pi2fd"); +extern const fcml_cstring M_PI2FW = _FT("pi2fw"); +extern const fcml_cstring M_PINSRB = _FT("pinsrb"); +extern const fcml_cstring M_PINSRD = _FT("pinsrd"); +extern const fcml_cstring M_PINSRQ = _FT("pinsrq"); +extern const fcml_cstring M_PINSRW = _FT("pinsrw"); +extern const fcml_cstring M_PMADDUBSW = _FT("pmaddubsw"); +extern const fcml_cstring M_PMADDWD = _FT("pmaddwd"); +extern const fcml_cstring M_PMAXSB = _FT("pmaxsb"); +extern const fcml_cstring M_PMAXSD = _FT("pmaxsd"); +extern const fcml_cstring M_PMAXSW = _FT("pmaxsw"); +extern const fcml_cstring M_PMAXUB = _FT("pmaxub"); +extern const fcml_cstring M_PMAXUD = _FT("pmaxud"); +extern const fcml_cstring M_PMAXUW = _FT("pmaxuw"); +extern const fcml_cstring M_PMINSB = _FT("pminsb"); +extern const fcml_cstring M_PMINSD = _FT("pminsd"); +extern const fcml_cstring M_PMINSW = _FT("pminsw"); +extern const fcml_cstring M_PMINUB = _FT("pminub"); +extern const fcml_cstring M_PMINUD = _FT("pminud"); +extern const fcml_cstring M_PMINUW = _FT("pminuw"); +extern const fcml_cstring M_PMOVMSKB = _FT("pmovmskb"); +extern const fcml_cstring M_PMOVSXBD = _FT("pmovsxbd"); +extern const fcml_cstring M_PMOVSXBQ = _FT("pmovsxbq"); +extern const fcml_cstring M_PMOVSXBW = _FT("pmovsxbw"); +extern const fcml_cstring M_PMOVSXDQ = _FT("pmovsxdq"); +extern const fcml_cstring M_PMOVSXWD = _FT("pmovsxwd"); +extern const fcml_cstring M_PMOVSXWQ = _FT("pmovsxwq"); +extern const fcml_cstring M_PMOVZXBD = _FT("pmovzxbd"); +extern const fcml_cstring M_PMOVZXBQ = _FT("pmovzxbq"); +extern const fcml_cstring M_PMOVZXBW = _FT("pmovzxbw"); +extern const fcml_cstring M_PMOVZXDQ = _FT("pmovzxdq"); +extern const fcml_cstring M_PMOVZXWD = _FT("pmovzxwd"); +extern const fcml_cstring M_PMOVZXWQ = _FT("pmovzxwq"); +extern const fcml_cstring M_PMULDQ = _FT("pmuldq"); +extern const fcml_cstring M_PMULHRSW = _FT("pmulhrsw"); +extern const fcml_cstring M_PMULHRW = _FT("pmulhrw"); +extern const fcml_cstring M_PMULHUW = _FT("pmulhuw"); +extern const fcml_cstring M_PMULHW = _FT("pmulhw"); +extern const fcml_cstring M_PMULLD = _FT("pmulld"); +extern const fcml_cstring M_PMULLW = _FT("pmullw"); +extern const fcml_cstring M_PMULUDQ = _FT("pmuludq"); +extern const fcml_cstring M_POP = _FT("pop"); +extern const fcml_cstring M_POPA = _FT("popa"); +extern const fcml_cstring M_POPAW = _FT("popaw"); +extern const fcml_cstring M_POPCNT = _FT("popcnt"); +extern const fcml_cstring M_POPF = _FT("popf"); +extern const fcml_cstring M_POPFQ = _FT("popfq"); +extern const fcml_cstring M_POPFW = _FT("popfw"); +extern const fcml_cstring M_POPL = _FT("popl"); +extern const fcml_cstring M_POPQ = _FT("popq"); +extern const fcml_cstring M_POPW = _FT("popw"); +extern const fcml_cstring M_POR = _FT("por"); +extern const fcml_cstring M_PREFETCH = _FT("prefetch"); +extern const fcml_cstring M_PREFETCHNTA = _FT("prefetchnta"); +extern const fcml_cstring M_PREFETCHT0 = _FT("prefetcht0"); +extern const fcml_cstring M_PREFETCHT1 = _FT("prefetcht1"); +extern const fcml_cstring M_PREFETCHT2 = _FT("prefetcht2"); +extern const fcml_cstring M_PREFETCHW = _FT("prefetchw"); +extern const fcml_cstring M_PREFETCHWT1 = _FT("prefetchwt1"); +extern const fcml_cstring M_PSADBW = _FT("psadbw"); +extern const fcml_cstring M_PSHUFB = _FT("pshufb"); +extern const fcml_cstring M_PSHUFD = _FT("pshufd"); +extern const fcml_cstring M_PSHUFHW = _FT("pshufhw"); +extern const fcml_cstring M_PSHUFLW = _FT("pshuflw"); +extern const fcml_cstring M_PSHUFW = _FT("pshufw"); +extern const fcml_cstring M_PSIGNB = _FT("psignb"); +extern const fcml_cstring M_PSIGND = _FT("psignd"); +extern const fcml_cstring M_PSIGNW = _FT("psignw"); +extern const fcml_cstring M_PSLLD = _FT("pslld"); +extern const fcml_cstring M_PSLLDQ = _FT("pslldq"); +extern const fcml_cstring M_PSLLQ = _FT("psllq"); +extern const fcml_cstring M_PSLLW = _FT("psllw"); +extern const fcml_cstring M_PSRAD = _FT("psrad"); +extern const fcml_cstring M_PSRAW = _FT("psraw"); +extern const fcml_cstring M_PSRLD = _FT("psrld"); +extern const fcml_cstring M_PSRLDQ = _FT("psrldq"); +extern const fcml_cstring M_PSRLQ = _FT("psrlq"); +extern const fcml_cstring M_PSRLW = _FT("psrlw"); +extern const fcml_cstring M_PSUBB = _FT("psubb"); +extern const fcml_cstring M_PSUBD = _FT("psubd"); +extern const fcml_cstring M_PSUBQ = _FT("psubq"); +extern const fcml_cstring M_PSUBSB = _FT("psubsb"); +extern const fcml_cstring M_PSUBSW = _FT("psubsw"); +extern const fcml_cstring M_PSUBUSB = _FT("psubusb"); +extern const fcml_cstring M_PSUBUSW = _FT("psubusw"); +extern const fcml_cstring M_PSUBW = _FT("psubw"); +extern const fcml_cstring M_PSWAPD = _FT("pswapd"); +extern const fcml_cstring M_PTEST = _FT("ptest"); +extern const fcml_cstring M_PUNPCKHBW = _FT("punpckhbw"); +extern const fcml_cstring M_PUNPCKHDQ = _FT("punpckhdq"); +extern const fcml_cstring M_PUNPCKHQDQ = _FT("punpckhqdq"); +extern const fcml_cstring M_PUNPCKHWD = _FT("punpckhwd"); +extern const fcml_cstring M_PUNPCKLBW = _FT("punpcklbw"); +extern const fcml_cstring M_PUNPCKLDQ = _FT("punpckldq"); +extern const fcml_cstring M_PUNPCKLQDQ = _FT("punpcklqdq"); +extern const fcml_cstring M_PUNPCKLWD = _FT("punpcklwd"); +extern const fcml_cstring M_PUSH = _FT("push"); +extern const fcml_cstring M_PUSHA = _FT("pusha"); +extern const fcml_cstring M_PUSHAW = _FT("pushaw"); +extern const fcml_cstring M_PUSHB = _FT("pushb"); +extern const fcml_cstring M_PUSHF = _FT("pushf"); +extern const fcml_cstring M_PUSHFQ = _FT("pushfq"); +extern const fcml_cstring M_PUSHFW = _FT("pushfw"); +extern const fcml_cstring M_PUSHL = _FT("pushl"); +extern const fcml_cstring M_PUSHQ = _FT("pushq"); +extern const fcml_cstring M_PUSHW = _FT("pushw"); +extern const fcml_cstring M_PXOR = _FT("pxor"); +extern const fcml_cstring M_RCL = _FT("rcl"); +extern const fcml_cstring M_RCLB = _FT("rclb"); +extern const fcml_cstring M_RCLL = _FT("rcll"); +extern const fcml_cstring M_RCLQ = _FT("rclq"); +extern const fcml_cstring M_RCLW = _FT("rclw"); +extern const fcml_cstring M_RCPPS = _FT("rcpps"); +extern const fcml_cstring M_RCPSS = _FT("rcpss"); +extern const fcml_cstring M_RCR = _FT("rcr"); +extern const fcml_cstring M_RCRB = _FT("rcrb"); +extern const fcml_cstring M_RCRL = _FT("rcrl"); +extern const fcml_cstring M_RCRQ = _FT("rcrq"); +extern const fcml_cstring M_RCRW = _FT("rcrw"); +extern const fcml_cstring M_RDFSBASE = _FT("rdfsbase"); +extern const fcml_cstring M_RDGSBASE = _FT("rdgsbase"); +extern const fcml_cstring M_RDMSR = _FT("rdmsr"); +extern const fcml_cstring M_RDPMC = _FT("rdpmc"); +extern const fcml_cstring M_RDRAND = _FT("rdrand"); +extern const fcml_cstring M_RDSEED = _FT("rdseed"); +extern const fcml_cstring M_RDTSC = _FT("rdtsc"); +extern const fcml_cstring M_RDTSCP = _FT("rdtscp"); +extern const fcml_cstring M_RET = _FT("ret"); +extern const fcml_cstring M_RETQ = _FT("retq"); +extern const fcml_cstring M_RETW = _FT("retw"); +extern const fcml_cstring M_ROL = _FT("rol"); +extern const fcml_cstring M_ROLB = _FT("rolb"); +extern const fcml_cstring M_ROLL = _FT("roll"); +extern const fcml_cstring M_ROLQ = _FT("rolq"); +extern const fcml_cstring M_ROLW = _FT("rolw"); +extern const fcml_cstring M_ROR = _FT("ror"); +extern const fcml_cstring M_RORB = _FT("rorb"); +extern const fcml_cstring M_RORL = _FT("rorl"); +extern const fcml_cstring M_RORQ = _FT("rorq"); +extern const fcml_cstring M_RORW = _FT("rorw"); +extern const fcml_cstring M_RORX = _FT("rorx"); +extern const fcml_cstring M_ROUNDPD = _FT("roundpd"); +extern const fcml_cstring M_ROUNDPS = _FT("roundps"); +extern const fcml_cstring M_ROUNDSD = _FT("roundsd"); +extern const fcml_cstring M_ROUNDSS = _FT("roundss"); +extern const fcml_cstring M_RSM = _FT("rsm"); +extern const fcml_cstring M_RSQRTPS = _FT("rsqrtps"); +extern const fcml_cstring M_RSQRTSS = _FT("rsqrtss"); +extern const fcml_cstring M_SAHF = _FT("sahf"); +extern const fcml_cstring M_SAL = _FT("sal"); +extern const fcml_cstring M_SALB = _FT("salb"); +extern const fcml_cstring M_SALL = _FT("sall"); +extern const fcml_cstring M_SALQ = _FT("salq"); +extern const fcml_cstring M_SALW = _FT("salw"); +extern const fcml_cstring M_SAR = _FT("sar"); +extern const fcml_cstring M_SARB = _FT("sarb"); +extern const fcml_cstring M_SARL = _FT("sarl"); +extern const fcml_cstring M_SARQ = _FT("sarq"); +extern const fcml_cstring M_SARW = _FT("sarw"); +extern const fcml_cstring M_SARX = _FT("sarx"); +extern const fcml_cstring M_SBB = _FT("sbb"); +extern const fcml_cstring M_SBBB = _FT("sbbb"); +extern const fcml_cstring M_SBBL = _FT("sbbl"); +extern const fcml_cstring M_SBBQ = _FT("sbbq"); +extern const fcml_cstring M_SBBW = _FT("sbbw"); +extern const fcml_cstring M_SCAS = _FT("scas"); +extern const fcml_cstring M_SCASB = _FT("scasb"); +extern const fcml_cstring M_SCASL = _FT("scasl"); +extern const fcml_cstring M_SCASQ = _FT("scasq"); +extern const fcml_cstring M_SCASW = _FT("scasw"); +extern const fcml_cstring M_SETA = _FT("seta"); +extern const fcml_cstring M_SETAE = _FT("setae"); +extern const fcml_cstring M_SETB = _FT("setb"); +extern const fcml_cstring M_SETBE = _FT("setbe"); +extern const fcml_cstring M_SETC = _FT("setc"); +extern const fcml_cstring M_SETENE = _FT("setene"); +extern const fcml_cstring M_SETG = _FT("setg"); +extern const fcml_cstring M_SETGE = _FT("setge"); +extern const fcml_cstring M_SETL = _FT("setl"); +extern const fcml_cstring M_SETLE = _FT("setle"); +extern const fcml_cstring M_SETNA = _FT("setna"); +extern const fcml_cstring M_SETNAE = _FT("setnae"); +extern const fcml_cstring M_SETNB = _FT("setnb"); +extern const fcml_cstring M_SETNBE = _FT("setnbe"); +extern const fcml_cstring M_SETNC = _FT("setnc"); +extern const fcml_cstring M_SETNG = _FT("setng"); +extern const fcml_cstring M_SETNGE = _FT("setnge"); +extern const fcml_cstring M_SETNL = _FT("setnl"); +extern const fcml_cstring M_SETNLE = _FT("setnle"); +extern const fcml_cstring M_SETNO = _FT("setno"); +extern const fcml_cstring M_SETNP = _FT("setnp"); +extern const fcml_cstring M_SETNS = _FT("setns"); +extern const fcml_cstring M_SETNZ = _FT("setnz"); +extern const fcml_cstring M_SETO = _FT("seto"); +extern const fcml_cstring M_SETP = _FT("setp"); +extern const fcml_cstring M_SETPE = _FT("setpe"); +extern const fcml_cstring M_SETPO = _FT("setpo"); +extern const fcml_cstring M_SETS = _FT("sets"); +extern const fcml_cstring M_SETZ = _FT("setz"); +extern const fcml_cstring M_SFENCE = _FT("sfence"); +extern const fcml_cstring M_SGDT = _FT("sgdt"); +extern const fcml_cstring M_SHL = _FT("shl"); +extern const fcml_cstring M_SHLB = _FT("shlb"); +extern const fcml_cstring M_SHLD = _FT("shld"); +extern const fcml_cstring M_SHLL = _FT("shll"); +extern const fcml_cstring M_SHLQ = _FT("shlq"); +extern const fcml_cstring M_SHLW = _FT("shlw"); +extern const fcml_cstring M_SHLX = _FT("shlx"); +extern const fcml_cstring M_SHR = _FT("shr"); +extern const fcml_cstring M_SHRB = _FT("shrb"); +extern const fcml_cstring M_SHRD = _FT("shrd"); +extern const fcml_cstring M_SHRL = _FT("shrl"); +extern const fcml_cstring M_SHRQ = _FT("shrq"); +extern const fcml_cstring M_SHRW = _FT("shrw"); +extern const fcml_cstring M_SHRX = _FT("shrx"); +extern const fcml_cstring M_SHUFPD = _FT("shufpd"); +extern const fcml_cstring M_SHUFPS = _FT("shufps"); +extern const fcml_cstring M_SIDT = _FT("sidt"); +extern const fcml_cstring M_SKINIT = _FT("skinit"); +extern const fcml_cstring M_SLDT = _FT("sldt"); +extern const fcml_cstring M_SLWPCB = _FT("slwpcb"); +extern const fcml_cstring M_SMSW = _FT("smsw"); +extern const fcml_cstring M_SQRTPD = _FT("sqrtpd"); +extern const fcml_cstring M_SQRTPS = _FT("sqrtps"); +extern const fcml_cstring M_SQRTSD = _FT("sqrtsd"); +extern const fcml_cstring M_SQRTSS = _FT("sqrtss"); +extern const fcml_cstring M_STAC = _FT("stac"); +extern const fcml_cstring M_STC = _FT("stc"); +extern const fcml_cstring M_STD = _FT("std"); +extern const fcml_cstring M_STGI = _FT("stgi"); +extern const fcml_cstring M_STI = _FT("sti"); +extern const fcml_cstring M_STMXCSR = _FT("stmxcsr"); +extern const fcml_cstring M_STOS = _FT("stos"); +extern const fcml_cstring M_STOSB = _FT("stosb"); +extern const fcml_cstring M_STOSL = _FT("stosl"); +extern const fcml_cstring M_STOSQ = _FT("stosq"); +extern const fcml_cstring M_STOSW = _FT("stosw"); +extern const fcml_cstring M_STR = _FT("str"); +extern const fcml_cstring M_SUB = _FT("sub"); +extern const fcml_cstring M_SUBB = _FT("subb"); +extern const fcml_cstring M_SUBL = _FT("subl"); +extern const fcml_cstring M_SUBPD = _FT("subpd"); +extern const fcml_cstring M_SUBPS = _FT("subps"); +extern const fcml_cstring M_SUBQ = _FT("subq"); +extern const fcml_cstring M_SUBSD = _FT("subsd"); +extern const fcml_cstring M_SUBSS = _FT("subss"); +extern const fcml_cstring M_SUBW = _FT("subw"); +extern const fcml_cstring M_SWAPGS = _FT("swapgs"); +extern const fcml_cstring M_SYSCALL = _FT("syscall"); +extern const fcml_cstring M_SYSENTER = _FT("sysenter"); +extern const fcml_cstring M_SYSEXIT = _FT("sysexit"); +extern const fcml_cstring M_SYSRET = _FT("sysret"); +extern const fcml_cstring M_T1MSKC = _FT("t1mskc"); +extern const fcml_cstring M_TEST = _FT("test"); +extern const fcml_cstring M_TESTB = _FT("testb"); +extern const fcml_cstring M_TESTL = _FT("testl"); +extern const fcml_cstring M_TESTQ = _FT("testq"); +extern const fcml_cstring M_TESTW = _FT("testw"); +extern const fcml_cstring M_TZCNT = _FT("tzcnt"); +extern const fcml_cstring M_TZMSK = _FT("tzmsk"); +extern const fcml_cstring M_UCOMISD = _FT("ucomisd"); +extern const fcml_cstring M_UCOMISS = _FT("ucomiss"); +extern const fcml_cstring M_UD2 = _FT("ud2"); +extern const fcml_cstring M_UNPCKHPD = _FT("unpckhpd"); +extern const fcml_cstring M_UNPCKHPS = _FT("unpckhps"); +extern const fcml_cstring M_UNPCKLPD = _FT("unpcklpd"); +extern const fcml_cstring M_UNPCKLPS = _FT("unpcklps"); +extern const fcml_cstring M_V4FMADDPS = _FT("v4fmaddps"); +extern const fcml_cstring M_V4FMADDSS = _FT("v4fmaddss"); +extern const fcml_cstring M_V4FNMADDPS = _FT("v4fnmaddps"); +extern const fcml_cstring M_V4FNMADDSS = _FT("v4fnmaddss"); +extern const fcml_cstring M_VADDPD = _FT("vaddpd"); +extern const fcml_cstring M_VADDPS = _FT("vaddps"); +extern const fcml_cstring M_VADDSD = _FT("vaddsd"); +extern const fcml_cstring M_VADDSS = _FT("vaddss"); +extern const fcml_cstring M_VADDSUBPD = _FT("vaddsubpd"); +extern const fcml_cstring M_VADDSUBPS = _FT("vaddsubps"); +extern const fcml_cstring M_VAESDEC = _FT("vaesdec"); +extern const fcml_cstring M_VAESDECLAST = _FT("vaesdeclast"); +extern const fcml_cstring M_VAESENC = _FT("vaesenc"); +extern const fcml_cstring M_VAESENCLAST = _FT("vaesenclast"); +extern const fcml_cstring M_VAESIMC = _FT("vaesimc"); +extern const fcml_cstring M_VAESKEYGENASSIST = _FT("vaeskeygenassist"); +extern const fcml_cstring M_VALIGND = _FT("valignd"); +extern const fcml_cstring M_VALIGNQ = _FT("valignq"); +extern const fcml_cstring M_VANDNPD = _FT("vandnpd"); +extern const fcml_cstring M_VANDNPS = _FT("vandnps"); +extern const fcml_cstring M_VANDPD = _FT("vandpd"); +extern const fcml_cstring M_VANDPS = _FT("vandps"); +extern const fcml_cstring M_VBLENDMPD = _FT("vblendmpd"); +extern const fcml_cstring M_VBLENDMPS = _FT("vblendmps"); +extern const fcml_cstring M_VBLENDPD = _FT("vblendpd"); +extern const fcml_cstring M_VBLENDPS = _FT("vblendps"); +extern const fcml_cstring M_VBLENDVPD = _FT("vblendvpd"); +extern const fcml_cstring M_VBLENDVPS = _FT("vblendvps"); +extern const fcml_cstring M_VBROADCASTF128 = _FT("vbroadcastf128"); +extern const fcml_cstring M_VBROADCASTF32X2 = _FT("vbroadcastf32x2"); +extern const fcml_cstring M_VBROADCASTF32X4 = _FT("vbroadcastf32x4"); +extern const fcml_cstring M_VBROADCASTF32X8 = _FT("vbroadcastf32x8"); +extern const fcml_cstring M_VBROADCASTF64X2 = _FT("vbroadcastf64x2"); +extern const fcml_cstring M_VBROADCASTF64X4 = _FT("vbroadcastf64x4"); +extern const fcml_cstring M_VBROADCASTI128 = _FT("vbroadcasti128"); +extern const fcml_cstring M_VBROADCASTI32X2 = _FT("vbroadcasti32x2"); +extern const fcml_cstring M_VBROADCASTI32X4 = _FT("vbroadcasti32x4"); +extern const fcml_cstring M_VBROADCASTI32X8 = _FT("vbroadcasti32x8"); +extern const fcml_cstring M_VBROADCASTI64X2 = _FT("vbroadcasti64x2"); +extern const fcml_cstring M_VBROADCASTI64X4 = _FT("vbroadcasti64x4"); +extern const fcml_cstring M_VBROADCASTSD = _FT("vbroadcastsd"); +extern const fcml_cstring M_VBROADCASTSS = _FT("vbroadcastss"); +extern const fcml_cstring M_VCMPEQ_OSPD = _FT("vcmpeq_ospd"); +extern const fcml_cstring M_VCMPEQ_OSPS = _FT("vcmpeq_osps"); +extern const fcml_cstring M_VCMPEQ_OSSD = _FT("vcmpeq_ossd"); +extern const fcml_cstring M_VCMPEQ_OSSS = _FT("vcmpeq_osss"); +extern const fcml_cstring M_VCMPEQ_UQPD = _FT("vcmpeq_uqpd"); +extern const fcml_cstring M_VCMPEQ_UQPS = _FT("vcmpeq_uqps"); +extern const fcml_cstring M_VCMPEQ_UQSD = _FT("vcmpeq_uqsd"); +extern const fcml_cstring M_VCMPEQ_UQSS = _FT("vcmpeq_uqss"); +extern const fcml_cstring M_VCMPEQ_USPD = _FT("vcmpeq_uspd"); +extern const fcml_cstring M_VCMPEQ_USPS = _FT("vcmpeq_usps"); +extern const fcml_cstring M_VCMPEQ_USSD = _FT("vcmpeq_ussd"); +extern const fcml_cstring M_VCMPEQ_USSS = _FT("vcmpeq_usss"); +extern const fcml_cstring M_VCMPEQPD = _FT("vcmpeqpd"); +extern const fcml_cstring M_VCMPEQPS = _FT("vcmpeqps"); +extern const fcml_cstring M_VCMPEQSD = _FT("vcmpeqsd"); +extern const fcml_cstring M_VCMPEQSS = _FT("vcmpeqss"); +extern const fcml_cstring M_VCMPFALSE_OSPD = _FT("vcmpfalse_ospd"); +extern const fcml_cstring M_VCMPFALSE_OSPS = _FT("vcmpfalse_osps"); +extern const fcml_cstring M_VCMPFALSE_OSSD = _FT("vcmpfalse_ossd"); +extern const fcml_cstring M_VCMPFALSE_OSSS = _FT("vcmpfalse_osss"); +extern const fcml_cstring M_VCMPFALSEPD = _FT("vcmpfalsepd"); +extern const fcml_cstring M_VCMPFALSEPS = _FT("vcmpfalseps"); +extern const fcml_cstring M_VCMPFALSESD = _FT("vcmpfalsesd"); +extern const fcml_cstring M_VCMPFALSESS = _FT("vcmpfalsess"); +extern const fcml_cstring M_VCMPGE_OQPD = _FT("vcmpge_oqpd"); +extern const fcml_cstring M_VCMPGE_OQPS = _FT("vcmpge_oqps"); +extern const fcml_cstring M_VCMPGE_OQSD = _FT("vcmpge_oqsd"); +extern const fcml_cstring M_VCMPGE_OQSS = _FT("vcmpge_oqss"); +extern const fcml_cstring M_VCMPGEPD = _FT("vcmpgepd"); +extern const fcml_cstring M_VCMPGEPS = _FT("vcmpgeps"); +extern const fcml_cstring M_VCMPGESD = _FT("vcmpgesd"); +extern const fcml_cstring M_VCMPGESS = _FT("vcmpgess"); +extern const fcml_cstring M_VCMPGT_OQPD = _FT("vcmpgt_oqpd"); +extern const fcml_cstring M_VCMPGT_OQPS = _FT("vcmpgt_oqps"); +extern const fcml_cstring M_VCMPGT_OQSD = _FT("vcmpgt_oqsd"); +extern const fcml_cstring M_VCMPGT_OQSS = _FT("vcmpgt_oqss"); +extern const fcml_cstring M_VCMPGTPD = _FT("vcmpgtpd"); +extern const fcml_cstring M_VCMPGTPS = _FT("vcmpgtps"); +extern const fcml_cstring M_VCMPGTSD = _FT("vcmpgtsd"); +extern const fcml_cstring M_VCMPGTSS = _FT("vcmpgtss"); +extern const fcml_cstring M_VCMPLE_OQPD = _FT("vcmple_oqpd"); +extern const fcml_cstring M_VCMPLE_OQPS = _FT("vcmple_oqps"); +extern const fcml_cstring M_VCMPLE_OQSD = _FT("vcmple_oqsd"); +extern const fcml_cstring M_VCMPLE_OQSS = _FT("vcmple_oqss"); +extern const fcml_cstring M_VCMPLEPD = _FT("vcmplepd"); +extern const fcml_cstring M_VCMPLEPS = _FT("vcmpleps"); +extern const fcml_cstring M_VCMPLESD = _FT("vcmplesd"); +extern const fcml_cstring M_VCMPLESS = _FT("vcmpless"); +extern const fcml_cstring M_VCMPLT_OQPD = _FT("vcmplt_oqpd"); +extern const fcml_cstring M_VCMPLT_OQPS = _FT("vcmplt_oqps"); +extern const fcml_cstring M_VCMPLT_OQSD = _FT("vcmplt_oqsd"); +extern const fcml_cstring M_VCMPLT_OQSS = _FT("vcmplt_oqss"); +extern const fcml_cstring M_VCMPLTPD = _FT("vcmpltpd"); +extern const fcml_cstring M_VCMPLTPS = _FT("vcmpltps"); +extern const fcml_cstring M_VCMPLTSD = _FT("vcmpltsd"); +extern const fcml_cstring M_VCMPLTSS = _FT("vcmpltss"); +extern const fcml_cstring M_VCMPNEQ_OQPD = _FT("vcmpneq_oqpd"); +extern const fcml_cstring M_VCMPNEQ_OQPS = _FT("vcmpneq_oqps"); +extern const fcml_cstring M_VCMPNEQ_OQSD = _FT("vcmpneq_oqsd"); +extern const fcml_cstring M_VCMPNEQ_OQSS = _FT("vcmpneq_oqss"); +extern const fcml_cstring M_VCMPNEQ_OSPD = _FT("vcmpneq_ospd"); +extern const fcml_cstring M_VCMPNEQ_OSPS = _FT("vcmpneq_osps"); +extern const fcml_cstring M_VCMPNEQ_OSSD = _FT("vcmpneq_ossd"); +extern const fcml_cstring M_VCMPNEQ_OSSS = _FT("vcmpneq_osss"); +extern const fcml_cstring M_VCMPNEQ_USPD = _FT("vcmpneq_uspd"); +extern const fcml_cstring M_VCMPNEQ_USPS = _FT("vcmpneq_usps"); +extern const fcml_cstring M_VCMPNEQ_USSD = _FT("vcmpneq_ussd"); +extern const fcml_cstring M_VCMPNEQ_USSS = _FT("vcmpneq_usss"); +extern const fcml_cstring M_VCMPNEQPD = _FT("vcmpneqpd"); +extern const fcml_cstring M_VCMPNEQPS = _FT("vcmpneqps"); +extern const fcml_cstring M_VCMPNEQSD = _FT("vcmpneqsd"); +extern const fcml_cstring M_VCMPNEQSS = _FT("vcmpneqss"); +extern const fcml_cstring M_VCMPNGE_UQPD = _FT("vcmpnge_uqpd"); +extern const fcml_cstring M_VCMPNGE_UQPS = _FT("vcmpnge_uqps"); +extern const fcml_cstring M_VCMPNGE_UQSD = _FT("vcmpnge_uqsd"); +extern const fcml_cstring M_VCMPNGE_UQSS = _FT("vcmpnge_uqss"); +extern const fcml_cstring M_VCMPNGEPD = _FT("vcmpngepd"); +extern const fcml_cstring M_VCMPNGEPS = _FT("vcmpngeps"); +extern const fcml_cstring M_VCMPNGESD = _FT("vcmpngesd"); +extern const fcml_cstring M_VCMPNGESS = _FT("vcmpngess"); +extern const fcml_cstring M_VCMPNGT_UQPD = _FT("vcmpngt_uqpd"); +extern const fcml_cstring M_VCMPNGT_UQPS = _FT("vcmpngt_uqps"); +extern const fcml_cstring M_VCMPNGT_UQSD = _FT("vcmpngt_uqsd"); +extern const fcml_cstring M_VCMPNGT_UQSS = _FT("vcmpngt_uqss"); +extern const fcml_cstring M_VCMPNGTPD = _FT("vcmpngtpd"); +extern const fcml_cstring M_VCMPNGTPS = _FT("vcmpngtps"); +extern const fcml_cstring M_VCMPNGTSD = _FT("vcmpngtsd"); +extern const fcml_cstring M_VCMPNGTSS = _FT("vcmpngtss"); +extern const fcml_cstring M_VCMPNLE_UQPD = _FT("vcmpnle_uqpd"); +extern const fcml_cstring M_VCMPNLE_UQPS = _FT("vcmpnle_uqps"); +extern const fcml_cstring M_VCMPNLE_UQSD = _FT("vcmpnle_uqsd"); +extern const fcml_cstring M_VCMPNLE_UQSS = _FT("vcmpnle_uqss"); +extern const fcml_cstring M_VCMPNLEPD = _FT("vcmpnlepd"); +extern const fcml_cstring M_VCMPNLEPS = _FT("vcmpnleps"); +extern const fcml_cstring M_VCMPNLESD = _FT("vcmpnlesd"); +extern const fcml_cstring M_VCMPNLESS = _FT("vcmpnless"); +extern const fcml_cstring M_VCMPNLT_UQPD = _FT("vcmpnlt_uqpd"); +extern const fcml_cstring M_VCMPNLT_UQPS = _FT("vcmpnlt_uqps"); +extern const fcml_cstring M_VCMPNLT_UQSD = _FT("vcmpnlt_uqsd"); +extern const fcml_cstring M_VCMPNLT_UQSS = _FT("vcmpnlt_uqss"); +extern const fcml_cstring M_VCMPNLTPD = _FT("vcmpnltpd"); +extern const fcml_cstring M_VCMPNLTPS = _FT("vcmpnltps"); +extern const fcml_cstring M_VCMPNLTSD = _FT("vcmpnltsd"); +extern const fcml_cstring M_VCMPNLTSS = _FT("vcmpnltss"); +extern const fcml_cstring M_VCMPORD_SPD = _FT("vcmpord_spd"); +extern const fcml_cstring M_VCMPORD_SPS = _FT("vcmpord_sps"); +extern const fcml_cstring M_VCMPORD_SSD = _FT("vcmpord_ssd"); +extern const fcml_cstring M_VCMPORD_SSS = _FT("vcmpord_sss"); +extern const fcml_cstring M_VCMPORDPD = _FT("vcmpordpd"); +extern const fcml_cstring M_VCMPORDPS = _FT("vcmpordps"); +extern const fcml_cstring M_VCMPORDSD = _FT("vcmpordsd"); +extern const fcml_cstring M_VCMPORDSS = _FT("vcmpordss"); +extern const fcml_cstring M_VCMPPD = _FT("vcmppd"); +extern const fcml_cstring M_VCMPPS = _FT("vcmpps"); +extern const fcml_cstring M_VCMPSD = _FT("vcmpsd"); +extern const fcml_cstring M_VCMPSS = _FT("vcmpss"); +extern const fcml_cstring M_VCMPTRUE_USPD = _FT("vcmptrue_uspd"); +extern const fcml_cstring M_VCMPTRUE_USPS = _FT("vcmptrue_usps"); +extern const fcml_cstring M_VCMPTRUE_USSD = _FT("vcmptrue_ussd"); +extern const fcml_cstring M_VCMPTRUE_USSS = _FT("vcmptrue_usss"); +extern const fcml_cstring M_VCMPTRUEPD = _FT("vcmptruepd"); +extern const fcml_cstring M_VCMPTRUEPS = _FT("vcmptrueps"); +extern const fcml_cstring M_VCMPTRUESD = _FT("vcmptruesd"); +extern const fcml_cstring M_VCMPTRUESS = _FT("vcmptruess"); +extern const fcml_cstring M_VCMPUNORD_SPD = _FT("vcmpunord_spd"); +extern const fcml_cstring M_VCMPUNORD_SPS = _FT("vcmpunord_sps"); +extern const fcml_cstring M_VCMPUNORD_SSD = _FT("vcmpunord_ssd"); +extern const fcml_cstring M_VCMPUNORD_SSS = _FT("vcmpunord_sss"); +extern const fcml_cstring M_VCMPUNORDPD = _FT("vcmpunordpd"); +extern const fcml_cstring M_VCMPUNORDPS = _FT("vcmpunordps"); +extern const fcml_cstring M_VCMPUNORDSD = _FT("vcmpunordsd"); +extern const fcml_cstring M_VCMPUNORDSS = _FT("vcmpunordss"); +extern const fcml_cstring M_VCOMISD = _FT("vcomisd"); +extern const fcml_cstring M_VCOMISS = _FT("vcomiss"); +extern const fcml_cstring M_VCOMPRESSPD = _FT("vcompresspd"); +extern const fcml_cstring M_VCOMPRESSPS = _FT("vcompressps"); +extern const fcml_cstring M_VCVTDQ2PD = _FT("vcvtdq2pd"); +extern const fcml_cstring M_VCVTDQ2PS = _FT("vcvtdq2ps"); +extern const fcml_cstring M_VCVTPD2DQ = _FT("vcvtpd2dq"); +extern const fcml_cstring M_VCVTPD2DQX = _FT("vcvtpd2dqx"); +extern const fcml_cstring M_VCVTPD2DQY = _FT("vcvtpd2dqy"); +extern const fcml_cstring M_VCVTPD2PS = _FT("vcvtpd2ps"); +extern const fcml_cstring M_VCVTPD2PSX = _FT("vcvtpd2psx"); +extern const fcml_cstring M_VCVTPD2PSY = _FT("vcvtpd2psy"); +extern const fcml_cstring M_VCVTPD2QQ = _FT("vcvtpd2qq"); +extern const fcml_cstring M_VCVTPD2UDQ = _FT("vcvtpd2udq"); +extern const fcml_cstring M_VCVTPD2UDQX = _FT("vcvtpd2udqx"); +extern const fcml_cstring M_VCVTPD2UDQY = _FT("vcvtpd2udqy"); +extern const fcml_cstring M_VCVTPD2UQQ = _FT("vcvtpd2uqq"); +extern const fcml_cstring M_VCVTPH2PS = _FT("vcvtph2ps"); +extern const fcml_cstring M_VCVTPS2DQ = _FT("vcvtps2dq"); +extern const fcml_cstring M_VCVTPS2PD = _FT("vcvtps2pd"); +extern const fcml_cstring M_VCVTPS2PH = _FT("vcvtps2ph"); +extern const fcml_cstring M_VCVTPS2QQ = _FT("vcvtps2qq"); +extern const fcml_cstring M_VCVTPS2UDQ = _FT("vcvtps2udq"); +extern const fcml_cstring M_VCVTPS2UQQ = _FT("vcvtps2uqq"); +extern const fcml_cstring M_VCVTQQ2PD = _FT("vcvtqq2pd"); +extern const fcml_cstring M_VCVTQQ2PS = _FT("vcvtqq2ps"); +extern const fcml_cstring M_VCVTQQ2PSX = _FT("vcvtqq2psx"); +extern const fcml_cstring M_VCVTQQ2PSY = _FT("vcvtqq2psy"); +extern const fcml_cstring M_VCVTSD2SI = _FT("vcvtsd2si"); +extern const fcml_cstring M_VCVTSD2SS = _FT("vcvtsd2ss"); +extern const fcml_cstring M_VCVTSD2USI = _FT("vcvtsd2usi"); +extern const fcml_cstring M_VCVTSI2SDL = _FT("vcvtsi2sdl"); +extern const fcml_cstring M_VCVTSI2SDQ = _FT("vcvtsi2sdq"); +extern const fcml_cstring M_VCVTSI2SSL = _FT("vcvtsi2ssl"); +extern const fcml_cstring M_VCVTSI2SSQ = _FT("vcvtsi2ssq"); +extern const fcml_cstring M_VCVTSS2SD = _FT("vcvtss2sd"); +extern const fcml_cstring M_VCVTSS2SI = _FT("vcvtss2si"); +extern const fcml_cstring M_VCVTSS2USI = _FT("vcvtss2usi"); +extern const fcml_cstring M_VCVTTPD2DQ = _FT("vcvttpd2dq"); +extern const fcml_cstring M_VCVTTPD2DQX = _FT("vcvttpd2dqx"); +extern const fcml_cstring M_VCVTTPD2DQY = _FT("vcvttpd2dqy"); +extern const fcml_cstring M_VCVTTPD2QQ = _FT("vcvttpd2qq"); +extern const fcml_cstring M_VCVTTPD2UDQ = _FT("vcvttpd2udq"); +extern const fcml_cstring M_VCVTTPD2UDQX = _FT("vcvttpd2udqx"); +extern const fcml_cstring M_VCVTTPD2UDQY = _FT("vcvttpd2udqy"); +extern const fcml_cstring M_VCVTTPD2UQQ = _FT("vcvttpd2uqq"); +extern const fcml_cstring M_VCVTTPS2DQ = _FT("vcvttps2dq"); +extern const fcml_cstring M_VCVTTPS2QQ = _FT("vcvttps2qq"); +extern const fcml_cstring M_VCVTTPS2UDQ = _FT("vcvttps2udq"); +extern const fcml_cstring M_VCVTTPS2UQQ = _FT("vcvttps2uqq"); +extern const fcml_cstring M_VCVTTSD2SI = _FT("vcvttsd2si"); +extern const fcml_cstring M_VCVTTSD2USI = _FT("vcvttsd2usi"); +extern const fcml_cstring M_VCVTTSS2SI = _FT("vcvttss2si"); +extern const fcml_cstring M_VCVTTSS2USI = _FT("vcvttss2usi"); +extern const fcml_cstring M_VCVTUDQ2PD = _FT("vcvtudq2pd"); +extern const fcml_cstring M_VCVTUDQ2PS = _FT("vcvtudq2ps"); +extern const fcml_cstring M_VCVTUQQ2PD = _FT("vcvtuqq2pd"); +extern const fcml_cstring M_VCVTUQQ2PS = _FT("vcvtuqq2ps"); +extern const fcml_cstring M_VCVTUQQ2PSX = _FT("vcvtuqq2psx"); +extern const fcml_cstring M_VCVTUQQ2PSY = _FT("vcvtuqq2psy"); +extern const fcml_cstring M_VCVTUSI2SD = _FT("vcvtusi2sd"); +extern const fcml_cstring M_VCVTUSI2SS = _FT("vcvtusi2ss"); +extern const fcml_cstring M_VDBPSADBW = _FT("vdbpsadbw"); +extern const fcml_cstring M_VDIVPD = _FT("vdivpd"); +extern const fcml_cstring M_VDIVPS = _FT("vdivps"); +extern const fcml_cstring M_VDIVSD = _FT("vdivsd"); +extern const fcml_cstring M_VDIVSS = _FT("vdivss"); +extern const fcml_cstring M_VDPPD = _FT("vdppd"); +extern const fcml_cstring M_VDPPS = _FT("vdpps"); +extern const fcml_cstring M_VERR = _FT("verr"); +extern const fcml_cstring M_VERW = _FT("verw"); +extern const fcml_cstring M_VEXP2PD = _FT("vexp2pd"); +extern const fcml_cstring M_VEXP2PS = _FT("vexp2ps"); +extern const fcml_cstring M_VEXPANDPD = _FT("vexpandpd"); +extern const fcml_cstring M_VEXPANDPS = _FT("vexpandps"); +extern const fcml_cstring M_VEXTRACTF128 = _FT("vextractf128"); +extern const fcml_cstring M_VEXTRACTF32X4 = _FT("vextractf32x4"); +extern const fcml_cstring M_VEXTRACTF32X8 = _FT("vextractf32x8"); +extern const fcml_cstring M_VEXTRACTF64X2 = _FT("vextractf64x2"); +extern const fcml_cstring M_VEXTRACTF64X4 = _FT("vextractf64x4"); +extern const fcml_cstring M_VEXTRACTI128 = _FT("vextracti128"); +extern const fcml_cstring M_VEXTRACTI32X4 = _FT("vextracti32x4"); +extern const fcml_cstring M_VEXTRACTI32X8 = _FT("vextracti32x8"); +extern const fcml_cstring M_VEXTRACTI64X2 = _FT("vextracti64x2"); +extern const fcml_cstring M_VEXTRACTI64X4 = _FT("vextracti64x4"); +extern const fcml_cstring M_VEXTRACTPS = _FT("vextractps"); +extern const fcml_cstring M_VFIXUPIMMPD = _FT("vfixupimmpd"); +extern const fcml_cstring M_VFIXUPIMMPS = _FT("vfixupimmps"); +extern const fcml_cstring M_VFIXUPIMMSD = _FT("vfixupimmsd"); +extern const fcml_cstring M_VFIXUPIMMSS = _FT("vfixupimmss"); +extern const fcml_cstring M_VFMADD132PD = _FT("vfmadd132pd"); +extern const fcml_cstring M_VFMADD132PS = _FT("vfmadd132ps"); +extern const fcml_cstring M_VFMADD132SD = _FT("vfmadd132sd"); +extern const fcml_cstring M_VFMADD132SS = _FT("vfmadd132ss"); +extern const fcml_cstring M_VFMADD213PD = _FT("vfmadd213pd"); +extern const fcml_cstring M_VFMADD213PS = _FT("vfmadd213ps"); +extern const fcml_cstring M_VFMADD213SD = _FT("vfmadd213sd"); +extern const fcml_cstring M_VFMADD213SS = _FT("vfmadd213ss"); +extern const fcml_cstring M_VFMADD231PD = _FT("vfmadd231pd"); +extern const fcml_cstring M_VFMADD231PS = _FT("vfmadd231ps"); +extern const fcml_cstring M_VFMADD231SD = _FT("vfmadd231sd"); +extern const fcml_cstring M_VFMADD231SS = _FT("vfmadd231ss"); +extern const fcml_cstring M_VFMADDPD = _FT("vfmaddpd"); +extern const fcml_cstring M_VFMADDPS = _FT("vfmaddps"); +extern const fcml_cstring M_VFMADDSD = _FT("vfmaddsd"); +extern const fcml_cstring M_VFMADDSS = _FT("vfmaddss"); +extern const fcml_cstring M_VFMADDSUB132PD = _FT("vfmaddsub132pd"); +extern const fcml_cstring M_VFMADDSUB132PS = _FT("vfmaddsub132ps"); +extern const fcml_cstring M_VFMADDSUB213PD = _FT("vfmaddsub213pd"); +extern const fcml_cstring M_VFMADDSUB213PS = _FT("vfmaddsub213ps"); +extern const fcml_cstring M_VFMADDSUB231PD = _FT("vfmaddsub231pd"); +extern const fcml_cstring M_VFMADDSUB231PS = _FT("vfmaddsub231ps"); +extern const fcml_cstring M_VFMADDSUBPD = _FT("vfmaddsubpd"); +extern const fcml_cstring M_VFMADDSUBPS = _FT("vfmaddsubps"); +extern const fcml_cstring M_VFMSUB132PD = _FT("vfmsub132pd"); +extern const fcml_cstring M_VFMSUB132PS = _FT("vfmsub132ps"); +extern const fcml_cstring M_VFMSUB132SD = _FT("vfmsub132sd"); +extern const fcml_cstring M_VFMSUB132SS = _FT("vfmsub132ss"); +extern const fcml_cstring M_VFMSUB213PD = _FT("vfmsub213pd"); +extern const fcml_cstring M_VFMSUB213PS = _FT("vfmsub213ps"); +extern const fcml_cstring M_VFMSUB213SD = _FT("vfmsub213sd"); +extern const fcml_cstring M_VFMSUB213SS = _FT("vfmsub213ss"); +extern const fcml_cstring M_VFMSUB231PD = _FT("vfmsub231pd"); +extern const fcml_cstring M_VFMSUB231PS = _FT("vfmsub231ps"); +extern const fcml_cstring M_VFMSUB231SD = _FT("vfmsub231sd"); +extern const fcml_cstring M_VFMSUB231SS = _FT("vfmsub231ss"); +extern const fcml_cstring M_VFMSUBADD132PD = _FT("vfmsubadd132pd"); +extern const fcml_cstring M_VFMSUBADD132PS = _FT("vfmsubadd132ps"); +extern const fcml_cstring M_VFMSUBADD213PD = _FT("vfmsubadd213pd"); +extern const fcml_cstring M_VFMSUBADD213PS = _FT("vfmsubadd213ps"); +extern const fcml_cstring M_VFMSUBADD231PD = _FT("vfmsubadd231pd"); +extern const fcml_cstring M_VFMSUBADD231PS = _FT("vfmsubadd231ps"); +extern const fcml_cstring M_VFMSUBADDPD = _FT("vfmsubaddpd"); +extern const fcml_cstring M_VFMSUBADDPS = _FT("vfmsubaddps"); +extern const fcml_cstring M_VFMSUBPD = _FT("vfmsubpd"); +extern const fcml_cstring M_VFMSUBPS = _FT("vfmsubps"); +extern const fcml_cstring M_VFMSUBSD = _FT("vfmsubsd"); +extern const fcml_cstring M_VFMSUBSS = _FT("vfmsubss"); +extern const fcml_cstring M_VFNMADD132PD = _FT("vfnmadd132pd"); +extern const fcml_cstring M_VFNMADD132PS = _FT("vfnmadd132ps"); +extern const fcml_cstring M_VFNMADD132SD = _FT("vfnmadd132sd"); +extern const fcml_cstring M_VFNMADD132SS = _FT("vfnmadd132ss"); +extern const fcml_cstring M_VFNMADD213PD = _FT("vfnmadd213pd"); +extern const fcml_cstring M_VFNMADD213PS = _FT("vfnmadd213ps"); +extern const fcml_cstring M_VFNMADD213SD = _FT("vfnmadd213sd"); +extern const fcml_cstring M_VFNMADD213SS = _FT("vfnmadd213ss"); +extern const fcml_cstring M_VFNMADD231PD = _FT("vfnmadd231pd"); +extern const fcml_cstring M_VFNMADD231PS = _FT("vfnmadd231ps"); +extern const fcml_cstring M_VFNMADD231SD = _FT("vfnmadd231sd"); +extern const fcml_cstring M_VFNMADD231SS = _FT("vfnmadd231ss"); +extern const fcml_cstring M_VFNMADDPD = _FT("vfnmaddpd"); +extern const fcml_cstring M_VFNMADDPS = _FT("vfnmaddps"); +extern const fcml_cstring M_VFNMADDSD = _FT("vfnmaddsd"); +extern const fcml_cstring M_VFNMADDSS = _FT("vfnmaddss"); +extern const fcml_cstring M_VFNMSUB132PD = _FT("vfnmsub132pd"); +extern const fcml_cstring M_VFNMSUB132PS = _FT("vfnmsub132ps"); +extern const fcml_cstring M_VFNMSUB132SD = _FT("vfnmsub132sd"); +extern const fcml_cstring M_VFNMSUB132SS = _FT("vfnmsub132ss"); +extern const fcml_cstring M_VFNMSUB213PD = _FT("vfnmsub213pd"); +extern const fcml_cstring M_VFNMSUB213PS = _FT("vfnmsub213ps"); +extern const fcml_cstring M_VFNMSUB213SD = _FT("vfnmsub213sd"); +extern const fcml_cstring M_VFNMSUB213SS = _FT("vfnmsub213ss"); +extern const fcml_cstring M_VFNMSUB231PD = _FT("vfnmsub231pd"); +extern const fcml_cstring M_VFNMSUB231PS = _FT("vfnmsub231ps"); +extern const fcml_cstring M_VFNMSUB231SD = _FT("vfnmsub231sd"); +extern const fcml_cstring M_VFNMSUB231SS = _FT("vfnmsub231ss"); +extern const fcml_cstring M_VFNMSUBPD = _FT("vfnmsubpd"); +extern const fcml_cstring M_VFNMSUBPS = _FT("vfnmsubps"); +extern const fcml_cstring M_VFNMSUBSD = _FT("vfnmsubsd"); +extern const fcml_cstring M_VFNMSUBSS = _FT("vfnmsubss"); +extern const fcml_cstring M_VFPCLASSPD = _FT("vfpclasspd"); +extern const fcml_cstring M_VFPCLASSPS = _FT("vfpclassps"); +extern const fcml_cstring M_VFPCLASSSD = _FT("vfpclasssd"); +extern const fcml_cstring M_VFPCLASSSS = _FT("vfpclassss"); +extern const fcml_cstring M_VFRCZPD = _FT("vfrczpd"); +extern const fcml_cstring M_VFRCZPS = _FT("vfrczps"); +extern const fcml_cstring M_VFRCZSD = _FT("vfrczsd"); +extern const fcml_cstring M_VFRCZSS = _FT("vfrczss"); +extern const fcml_cstring M_VGATHERDPD = _FT("vgatherdpd"); +extern const fcml_cstring M_VGATHERDPS = _FT("vgatherdps"); +extern const fcml_cstring M_VGATHERPF0DPD = _FT("vgatherpf0dpd"); +extern const fcml_cstring M_VGATHERPF0DPS = _FT("vgatherpf0dps"); +extern const fcml_cstring M_VGATHERPF0QPD = _FT("vgatherpf0qpd"); +extern const fcml_cstring M_VGATHERPF0QPS = _FT("vgatherpf0qps"); +extern const fcml_cstring M_VGATHERPF1DPD = _FT("vgatherpf1dpd"); +extern const fcml_cstring M_VGATHERPF1DPS = _FT("vgatherpf1dps"); +extern const fcml_cstring M_VGATHERPF1QPD = _FT("vgatherpf1qpd"); +extern const fcml_cstring M_VGATHERPF1QPS = _FT("vgatherpf1qps"); +extern const fcml_cstring M_VGATHERQPD = _FT("vgatherqpd"); +extern const fcml_cstring M_VGATHERQPS = _FT("vgatherqps"); +extern const fcml_cstring M_VGETEXPPD = _FT("vgetexppd"); +extern const fcml_cstring M_VGETEXPPS = _FT("vgetexpps"); +extern const fcml_cstring M_VGETEXPSD = _FT("vgetexpsd"); +extern const fcml_cstring M_VGETEXPSS = _FT("vgetexpss"); +extern const fcml_cstring M_VGETMANTPD = _FT("vgetmantpd"); +extern const fcml_cstring M_VGETMANTPS = _FT("vgetmantps"); +extern const fcml_cstring M_VGETMANTSD = _FT("vgetmantsd"); +extern const fcml_cstring M_VGETMANTSS = _FT("vgetmantss"); +extern const fcml_cstring M_VHADDPD = _FT("vhaddpd"); +extern const fcml_cstring M_VHADDPS = _FT("vhaddps"); +extern const fcml_cstring M_VHSUBPD = _FT("vhsubpd"); +extern const fcml_cstring M_VHSUBPS = _FT("vhsubps"); +extern const fcml_cstring M_VINSERTF128 = _FT("vinsertf128"); +extern const fcml_cstring M_VINSERTF32X4 = _FT("vinsertf32x4"); +extern const fcml_cstring M_VINSERTF32X8 = _FT("vinsertf32x8"); +extern const fcml_cstring M_VINSERTF64X2 = _FT("vinsertf64x2"); +extern const fcml_cstring M_VINSERTF64X4 = _FT("vinsertf64x4"); +extern const fcml_cstring M_VINSERTI128 = _FT("vinserti128"); +extern const fcml_cstring M_VINSERTI32X4 = _FT("vinserti32x4"); +extern const fcml_cstring M_VINSERTI32X8 = _FT("vinserti32x8"); +extern const fcml_cstring M_VINSERTI64X2 = _FT("vinserti64x2"); +extern const fcml_cstring M_VINSERTI64X4 = _FT("vinserti64x4"); +extern const fcml_cstring M_VINSERTPS = _FT("vinsertps"); +extern const fcml_cstring M_VLDDQU = _FT("vlddqu"); +extern const fcml_cstring M_VLDMXCSR = _FT("vldmxcsr"); +extern const fcml_cstring M_VMASKMOVDQU = _FT("vmaskmovdqu"); +extern const fcml_cstring M_VMASKMOVPD = _FT("vmaskmovpd"); +extern const fcml_cstring M_VMASKMOVPS = _FT("vmaskmovps"); +extern const fcml_cstring M_VMAXPD = _FT("vmaxpd"); +extern const fcml_cstring M_VMAXPS = _FT("vmaxps"); +extern const fcml_cstring M_VMAXSD = _FT("vmaxsd"); +extern const fcml_cstring M_VMAXSS = _FT("vmaxss"); +extern const fcml_cstring M_VMCALL = _FT("vmcall"); +extern const fcml_cstring M_VMCLEAR = _FT("vmclear"); +extern const fcml_cstring M_VMFUNC = _FT("vmfunc"); +extern const fcml_cstring M_VMINPD = _FT("vminpd"); +extern const fcml_cstring M_VMINPS = _FT("vminps"); +extern const fcml_cstring M_VMINSD = _FT("vminsd"); +extern const fcml_cstring M_VMINSS = _FT("vminss"); +extern const fcml_cstring M_VMLAUNCH = _FT("vmlaunch"); +extern const fcml_cstring M_VMLOAD = _FT("vmload"); +extern const fcml_cstring M_VMMCALL = _FT("vmmcall"); +extern const fcml_cstring M_VMOVAPD = _FT("vmovapd"); +extern const fcml_cstring M_VMOVAPS = _FT("vmovaps"); +extern const fcml_cstring M_VMOVD = _FT("vmovd"); +extern const fcml_cstring M_VMOVDDUP = _FT("vmovddup"); +extern const fcml_cstring M_VMOVDQA = _FT("vmovdqa"); +extern const fcml_cstring M_VMOVDQA32 = _FT("vmovdqa32"); +extern const fcml_cstring M_VMOVDQA64 = _FT("vmovdqa64"); +extern const fcml_cstring M_VMOVDQU = _FT("vmovdqu"); +extern const fcml_cstring M_VMOVDQU16 = _FT("vmovdqu16"); +extern const fcml_cstring M_VMOVDQU32 = _FT("vmovdqu32"); +extern const fcml_cstring M_VMOVDQU64 = _FT("vmovdqu64"); +extern const fcml_cstring M_VMOVDQU8 = _FT("vmovdqu8"); +extern const fcml_cstring M_VMOVHLPS = _FT("vmovhlps"); +extern const fcml_cstring M_VMOVHPD = _FT("vmovhpd"); +extern const fcml_cstring M_VMOVHPS = _FT("vmovhps"); +extern const fcml_cstring M_VMOVLHPS = _FT("vmovlhps"); +extern const fcml_cstring M_VMOVLPD = _FT("vmovlpd"); +extern const fcml_cstring M_VMOVLPS = _FT("vmovlps"); +extern const fcml_cstring M_VMOVMSKPD = _FT("vmovmskpd"); +extern const fcml_cstring M_VMOVMSKPS = _FT("vmovmskps"); +extern const fcml_cstring M_VMOVNTDQ = _FT("vmovntdq"); +extern const fcml_cstring M_VMOVNTDQA = _FT("vmovntdqa"); +extern const fcml_cstring M_VMOVNTPD = _FT("vmovntpd"); +extern const fcml_cstring M_VMOVNTPS = _FT("vmovntps"); +extern const fcml_cstring M_VMOVQ = _FT("vmovq"); +extern const fcml_cstring M_VMOVSD = _FT("vmovsd"); +extern const fcml_cstring M_VMOVSHDUP = _FT("vmovshdup"); +extern const fcml_cstring M_VMOVSLDUP = _FT("vmovsldup"); +extern const fcml_cstring M_VMOVSS = _FT("vmovss"); +extern const fcml_cstring M_VMOVUPD = _FT("vmovupd"); +extern const fcml_cstring M_VMOVUPS = _FT("vmovups"); +extern const fcml_cstring M_VMPSADBW = _FT("vmpsadbw"); +extern const fcml_cstring M_VMPTRLD = _FT("vmptrld"); +extern const fcml_cstring M_VMPTRST = _FT("vmptrst"); +extern const fcml_cstring M_VMREAD = _FT("vmread"); +extern const fcml_cstring M_VMRESUME = _FT("vmresume"); +extern const fcml_cstring M_VMRUN = _FT("vmrun"); +extern const fcml_cstring M_VMSAVE = _FT("vmsave"); +extern const fcml_cstring M_VMULPD = _FT("vmulpd"); +extern const fcml_cstring M_VMULPS = _FT("vmulps"); +extern const fcml_cstring M_VMULSD = _FT("vmulsd"); +extern const fcml_cstring M_VMULSS = _FT("vmulss"); +extern const fcml_cstring M_VMWRITE = _FT("vmwrite"); +extern const fcml_cstring M_VMXOFF = _FT("vmxoff"); +extern const fcml_cstring M_VMXON = _FT("vmxon"); +extern const fcml_cstring M_VORPD = _FT("vorpd"); +extern const fcml_cstring M_VORPS = _FT("vorps"); +extern const fcml_cstring M_VP4DPWSSD = _FT("vp4dpwssd"); +extern const fcml_cstring M_VP4DPWSSDS = _FT("vp4dpwssds"); +extern const fcml_cstring M_VPABSB = _FT("vpabsb"); +extern const fcml_cstring M_VPABSD = _FT("vpabsd"); +extern const fcml_cstring M_VPABSQ = _FT("vpabsq"); +extern const fcml_cstring M_VPABSW = _FT("vpabsw"); +extern const fcml_cstring M_VPACKSSDW = _FT("vpackssdw"); +extern const fcml_cstring M_VPACKSSWB = _FT("vpacksswb"); +extern const fcml_cstring M_VPACKUSDW = _FT("vpackusdw"); +extern const fcml_cstring M_VPACKUSWB = _FT("vpackuswb"); +extern const fcml_cstring M_VPADDB = _FT("vpaddb"); +extern const fcml_cstring M_VPADDD = _FT("vpaddd"); +extern const fcml_cstring M_VPADDQ = _FT("vpaddq"); +extern const fcml_cstring M_VPADDSB = _FT("vpaddsb"); +extern const fcml_cstring M_VPADDSW = _FT("vpaddsw"); +extern const fcml_cstring M_VPADDUSB = _FT("vpaddusb"); +extern const fcml_cstring M_VPADDUSW = _FT("vpaddusw"); +extern const fcml_cstring M_VPADDW = _FT("vpaddw"); +extern const fcml_cstring M_VPALIGNR = _FT("vpalignr"); +extern const fcml_cstring M_VPAND = _FT("vpand"); +extern const fcml_cstring M_VPANDD = _FT("vpandd"); +extern const fcml_cstring M_VPANDN = _FT("vpandn"); +extern const fcml_cstring M_VPANDND = _FT("vpandnd"); +extern const fcml_cstring M_VPANDNQ = _FT("vpandnq"); +extern const fcml_cstring M_VPANDQ = _FT("vpandq"); +extern const fcml_cstring M_VPAVGB = _FT("vpavgb"); +extern const fcml_cstring M_VPAVGW = _FT("vpavgw"); +extern const fcml_cstring M_VPBLENDD = _FT("vpblendd"); +extern const fcml_cstring M_VPBLENDMB = _FT("vpblendmb"); +extern const fcml_cstring M_VPBLENDMD = _FT("vpblendmd"); +extern const fcml_cstring M_VPBLENDMQ = _FT("vpblendmq"); +extern const fcml_cstring M_VPBLENDMW = _FT("vpblendmw"); +extern const fcml_cstring M_VPBLENDVB = _FT("vpblendvb"); +extern const fcml_cstring M_VPBLENDW = _FT("vpblendw"); +extern const fcml_cstring M_VPBROADCASTB = _FT("vpbroadcastb"); +extern const fcml_cstring M_VPBROADCASTD = _FT("vpbroadcastd"); +extern const fcml_cstring M_VPBROADCASTMB2Q = _FT("vpbroadcastmb2q"); +extern const fcml_cstring M_VPBROADCASTMW2D = _FT("vpbroadcastmw2d"); +extern const fcml_cstring M_VPBROADCASTQ = _FT("vpbroadcastq"); +extern const fcml_cstring M_VPBROADCASTW = _FT("vpbroadcastw"); +extern const fcml_cstring M_VPCLMULQDQ = _FT("vpclmulqdq"); +extern const fcml_cstring M_VPCMOV = _FT("vpcmov"); +extern const fcml_cstring M_VPCMPB = _FT("vpcmpb"); +extern const fcml_cstring M_VPCMPD = _FT("vpcmpd"); +extern const fcml_cstring M_VPCMPEQB = _FT("vpcmpeqb"); +extern const fcml_cstring M_VPCMPEQD = _FT("vpcmpeqd"); +extern const fcml_cstring M_VPCMPEQQ = _FT("vpcmpeqq"); +extern const fcml_cstring M_VPCMPEQW = _FT("vpcmpeqw"); +extern const fcml_cstring M_VPCMPESTRI = _FT("vpcmpestri"); +extern const fcml_cstring M_VPCMPESTRM = _FT("vpcmpestrm"); +extern const fcml_cstring M_VPCMPGTB = _FT("vpcmpgtb"); +extern const fcml_cstring M_VPCMPGTD = _FT("vpcmpgtd"); +extern const fcml_cstring M_VPCMPGTQ = _FT("vpcmpgtq"); +extern const fcml_cstring M_VPCMPGTW = _FT("vpcmpgtw"); +extern const fcml_cstring M_VPCMPISTRI = _FT("vpcmpistri"); +extern const fcml_cstring M_VPCMPISTRM = _FT("vpcmpistrm"); +extern const fcml_cstring M_VPCMPQ = _FT("vpcmpq"); +extern const fcml_cstring M_VPCMPUB = _FT("vpcmpub"); +extern const fcml_cstring M_VPCMPUD = _FT("vpcmpud"); +extern const fcml_cstring M_VPCMPUQ = _FT("vpcmpuq"); +extern const fcml_cstring M_VPCMPUW = _FT("vpcmpuw"); +extern const fcml_cstring M_VPCMPW = _FT("vpcmpw"); +extern const fcml_cstring M_VPCOMB = _FT("vpcomb"); +extern const fcml_cstring M_VPCOMD = _FT("vpcomd"); +extern const fcml_cstring M_VPCOMEQB = _FT("vpcomeqb"); +extern const fcml_cstring M_VPCOMEQD = _FT("vpcomeqd"); +extern const fcml_cstring M_VPCOMEQQ = _FT("vpcomeqq"); +extern const fcml_cstring M_VPCOMEQUB = _FT("vpcomequb"); +extern const fcml_cstring M_VPCOMEQUD = _FT("vpcomequd"); +extern const fcml_cstring M_VPCOMEQUQ = _FT("vpcomequq"); +extern const fcml_cstring M_VPCOMEQUW = _FT("vpcomequw"); +extern const fcml_cstring M_VPCOMEQW = _FT("vpcomeqw"); +extern const fcml_cstring M_VPCOMFALSEB = _FT("vpcomfalseb"); +extern const fcml_cstring M_VPCOMFALSED = _FT("vpcomfalsed"); +extern const fcml_cstring M_VPCOMFALSEQ = _FT("vpcomfalseq"); +extern const fcml_cstring M_VPCOMFALSEUB = _FT("vpcomfalseub"); +extern const fcml_cstring M_VPCOMFALSEUD = _FT("vpcomfalseud"); +extern const fcml_cstring M_VPCOMFALSEUQ = _FT("vpcomfalseuq"); +extern const fcml_cstring M_VPCOMFALSEUW = _FT("vpcomfalseuw"); +extern const fcml_cstring M_VPCOMFALSEW = _FT("vpcomfalsew"); +extern const fcml_cstring M_VPCOMGEB = _FT("vpcomgeb"); +extern const fcml_cstring M_VPCOMGED = _FT("vpcomged"); +extern const fcml_cstring M_VPCOMGEQ = _FT("vpcomgeq"); +extern const fcml_cstring M_VPCOMGEUB = _FT("vpcomgeub"); +extern const fcml_cstring M_VPCOMGEUD = _FT("vpcomgeud"); +extern const fcml_cstring M_VPCOMGEUQ = _FT("vpcomgeuq"); +extern const fcml_cstring M_VPCOMGEUW = _FT("vpcomgeuw"); +extern const fcml_cstring M_VPCOMGEW = _FT("vpcomgew"); +extern const fcml_cstring M_VPCOMGTB = _FT("vpcomgtb"); +extern const fcml_cstring M_VPCOMGTD = _FT("vpcomgtd"); +extern const fcml_cstring M_VPCOMGTQ = _FT("vpcomgtq"); +extern const fcml_cstring M_VPCOMGTUB = _FT("vpcomgtub"); +extern const fcml_cstring M_VPCOMGTUD = _FT("vpcomgtud"); +extern const fcml_cstring M_VPCOMGTUQ = _FT("vpcomgtuq"); +extern const fcml_cstring M_VPCOMGTUW = _FT("vpcomgtuw"); +extern const fcml_cstring M_VPCOMGTW = _FT("vpcomgtw"); +extern const fcml_cstring M_VPCOMLEB = _FT("vpcomleb"); +extern const fcml_cstring M_VPCOMLED = _FT("vpcomled"); +extern const fcml_cstring M_VPCOMLEQ = _FT("vpcomleq"); +extern const fcml_cstring M_VPCOMLEUB = _FT("vpcomleub"); +extern const fcml_cstring M_VPCOMLEUD = _FT("vpcomleud"); +extern const fcml_cstring M_VPCOMLEUQ = _FT("vpcomleuq"); +extern const fcml_cstring M_VPCOMLEUW = _FT("vpcomleuw"); +extern const fcml_cstring M_VPCOMLEW = _FT("vpcomlew"); +extern const fcml_cstring M_VPCOMLTB = _FT("vpcomltb"); +extern const fcml_cstring M_VPCOMLTD = _FT("vpcomltd"); +extern const fcml_cstring M_VPCOMLTQ = _FT("vpcomltq"); +extern const fcml_cstring M_VPCOMLTUB = _FT("vpcomltub"); +extern const fcml_cstring M_VPCOMLTUD = _FT("vpcomltud"); +extern const fcml_cstring M_VPCOMLTUQ = _FT("vpcomltuq"); +extern const fcml_cstring M_VPCOMLTUW = _FT("vpcomltuw"); +extern const fcml_cstring M_VPCOMLTW = _FT("vpcomltw"); +extern const fcml_cstring M_VPCOMNEQB = _FT("vpcomneqb"); +extern const fcml_cstring M_VPCOMNEQD = _FT("vpcomneqd"); +extern const fcml_cstring M_VPCOMNEQQ = _FT("vpcomneqq"); +extern const fcml_cstring M_VPCOMNEQUB = _FT("vpcomnequb"); +extern const fcml_cstring M_VPCOMNEQUD = _FT("vpcomnequd"); +extern const fcml_cstring M_VPCOMNEQUQ = _FT("vpcomnequq"); +extern const fcml_cstring M_VPCOMNEQUW = _FT("vpcomnequw"); +extern const fcml_cstring M_VPCOMNEQW = _FT("vpcomneqw"); +extern const fcml_cstring M_VPCOMPRESSD = _FT("vpcompressd"); +extern const fcml_cstring M_VPCOMPRESSQ = _FT("vpcompressq"); +extern const fcml_cstring M_VPCOMQ = _FT("vpcomq"); +extern const fcml_cstring M_VPCOMTRUEB = _FT("vpcomtrueb"); +extern const fcml_cstring M_VPCOMTRUED = _FT("vpcomtrued"); +extern const fcml_cstring M_VPCOMTRUEQ = _FT("vpcomtrueq"); +extern const fcml_cstring M_VPCOMTRUEUB = _FT("vpcomtrueub"); +extern const fcml_cstring M_VPCOMTRUEUD = _FT("vpcomtrueud"); +extern const fcml_cstring M_VPCOMTRUEUQ = _FT("vpcomtrueuq"); +extern const fcml_cstring M_VPCOMTRUEUW = _FT("vpcomtrueuw"); +extern const fcml_cstring M_VPCOMTRUEW = _FT("vpcomtruew"); +extern const fcml_cstring M_VPCOMUB = _FT("vpcomub"); +extern const fcml_cstring M_VPCOMUD = _FT("vpcomud"); +extern const fcml_cstring M_VPCOMUQ = _FT("vpcomuq"); +extern const fcml_cstring M_VPCOMUW = _FT("vpcomuw"); +extern const fcml_cstring M_VPCOMW = _FT("vpcomw"); +extern const fcml_cstring M_VPERM2F128 = _FT("vperm2f128"); +extern const fcml_cstring M_VPERM2I128 = _FT("vperm2i128"); +extern const fcml_cstring M_VPERMB = _FT("vpermb"); +extern const fcml_cstring M_VPERMD = _FT("vpermd"); +extern const fcml_cstring M_VPERMI2B = _FT("vpermi2b"); +extern const fcml_cstring M_VPERMI2D = _FT("vpermi2d"); +extern const fcml_cstring M_VPERMI2PD = _FT("vpermi2pd"); +extern const fcml_cstring M_VPERMI2PS = _FT("vpermi2ps"); +extern const fcml_cstring M_VPERMI2Q = _FT("vpermi2q"); +extern const fcml_cstring M_VPERMI2W = _FT("vpermi2w"); +extern const fcml_cstring M_VPERMIL2PD = _FT("vpermil2pd"); +extern const fcml_cstring M_VPERMIL2PS = _FT("vpermil2ps"); +extern const fcml_cstring M_VPERMILPD = _FT("vpermilpd"); +extern const fcml_cstring M_VPERMILPS = _FT("vpermilps"); +extern const fcml_cstring M_VPERMPD = _FT("vpermpd"); +extern const fcml_cstring M_VPERMPS = _FT("vpermps"); +extern const fcml_cstring M_VPERMQ = _FT("vpermq"); +extern const fcml_cstring M_VPERMT2B = _FT("vpermt2b"); +extern const fcml_cstring M_VPERMT2D = _FT("vpermt2d"); +extern const fcml_cstring M_VPERMT2PD = _FT("vpermt2pd"); +extern const fcml_cstring M_VPERMT2PS = _FT("vpermt2ps"); +extern const fcml_cstring M_VPERMT2Q = _FT("vpermt2q"); +extern const fcml_cstring M_VPERMT2W = _FT("vpermt2w"); +extern const fcml_cstring M_VPERMW = _FT("vpermw"); +extern const fcml_cstring M_VPEXPANDD = _FT("vpexpandd"); +extern const fcml_cstring M_VPEXPANDQ = _FT("vpexpandq"); +extern const fcml_cstring M_VPEXTRB = _FT("vpextrb"); +extern const fcml_cstring M_VPEXTRD = _FT("vpextrd"); +extern const fcml_cstring M_VPEXTRQ = _FT("vpextrq"); +extern const fcml_cstring M_VPEXTRW = _FT("vpextrw"); +extern const fcml_cstring M_VPGATHERDD = _FT("vpgatherdd"); +extern const fcml_cstring M_VPGATHERDQ = _FT("vpgatherdq"); +extern const fcml_cstring M_VPGATHERQD = _FT("vpgatherqd"); +extern const fcml_cstring M_VPGATHERQQ = _FT("vpgatherqq"); +extern const fcml_cstring M_VPHADDBD = _FT("vphaddbd"); +extern const fcml_cstring M_VPHADDBQ = _FT("vphaddbq"); +extern const fcml_cstring M_VPHADDBW = _FT("vphaddbw"); +extern const fcml_cstring M_VPHADDD = _FT("vphaddd"); +extern const fcml_cstring M_VPHADDDQ = _FT("vphadddq"); +extern const fcml_cstring M_VPHADDSW = _FT("vphaddsw"); +extern const fcml_cstring M_VPHADDUBD = _FT("vphaddubd"); +extern const fcml_cstring M_VPHADDUBQ = _FT("vphaddubq"); +extern const fcml_cstring M_VPHADDUBW = _FT("vphaddubw"); +extern const fcml_cstring M_VPHADDUDQ = _FT("vphaddudq"); +extern const fcml_cstring M_VPHADDUWD = _FT("vphadduwd"); +extern const fcml_cstring M_VPHADDUWQ = _FT("vphadduwq"); +extern const fcml_cstring M_VPHADDW = _FT("vphaddw"); +extern const fcml_cstring M_VPHADDWD = _FT("vphaddwd"); +extern const fcml_cstring M_VPHADDWQ = _FT("vphaddwq"); +extern const fcml_cstring M_VPHMINPOSUW = _FT("vphminposuw"); +extern const fcml_cstring M_VPHSUBBW = _FT("vphsubbw"); +extern const fcml_cstring M_VPHSUBD = _FT("vphsubd"); +extern const fcml_cstring M_VPHSUBDQ = _FT("vphsubdq"); +extern const fcml_cstring M_VPHSUBSW = _FT("vphsubsw"); +extern const fcml_cstring M_VPHSUBW = _FT("vphsubw"); +extern const fcml_cstring M_VPHSUBWD = _FT("vphsubwd"); +extern const fcml_cstring M_VPINSRB = _FT("vpinsrb"); +extern const fcml_cstring M_VPINSRD = _FT("vpinsrd"); +extern const fcml_cstring M_VPINSRQ = _FT("vpinsrq"); +extern const fcml_cstring M_VPINSRW = _FT("vpinsrw"); +extern const fcml_cstring M_VPLZCNTD = _FT("vplzcntd"); +extern const fcml_cstring M_VPLZCNTQ = _FT("vplzcntq"); +extern const fcml_cstring M_VPMACSDD = _FT("vpmacsdd"); +extern const fcml_cstring M_VPMACSDQH = _FT("vpmacsdqh"); +extern const fcml_cstring M_VPMACSDQL = _FT("vpmacsdql"); +extern const fcml_cstring M_VPMACSSDD = _FT("vpmacssdd"); +extern const fcml_cstring M_VPMACSSDQH = _FT("vpmacssdqh"); +extern const fcml_cstring M_VPMACSSDQL = _FT("vpmacssdql"); +extern const fcml_cstring M_VPMACSSWD = _FT("vpmacsswd"); +extern const fcml_cstring M_VPMACSSWW = _FT("vpmacssww"); +extern const fcml_cstring M_VPMACSWD = _FT("vpmacswd"); +extern const fcml_cstring M_VPMACSWW = _FT("vpmacsww"); +extern const fcml_cstring M_VPMADCSSWD = _FT("vpmadcsswd"); +extern const fcml_cstring M_VPMADCSWD = _FT("vpmadcswd"); +extern const fcml_cstring M_VPMADD52HUQ = _FT("vpmadd52huq"); +extern const fcml_cstring M_VPMADD52LUQ = _FT("vpmadd52luq"); +extern const fcml_cstring M_VPMADDUBSW = _FT("vpmaddubsw"); +extern const fcml_cstring M_VPMADDWD = _FT("vpmaddwd"); +extern const fcml_cstring M_VPMASKMOV = _FT("vpmaskmov"); +extern const fcml_cstring M_VPMASKMOVD = _FT("vpmaskmovd"); +extern const fcml_cstring M_VPMASKMOVQ = _FT("vpmaskmovq"); +extern const fcml_cstring M_VPMAXSB = _FT("vpmaxsb"); +extern const fcml_cstring M_VPMAXSD = _FT("vpmaxsd"); +extern const fcml_cstring M_VPMAXSQ = _FT("vpmaxsq"); +extern const fcml_cstring M_VPMAXSW = _FT("vpmaxsw"); +extern const fcml_cstring M_VPMAXUB = _FT("vpmaxub"); +extern const fcml_cstring M_VPMAXUD = _FT("vpmaxud"); +extern const fcml_cstring M_VPMAXUQ = _FT("vpmaxuq"); +extern const fcml_cstring M_VPMAXUW = _FT("vpmaxuw"); +extern const fcml_cstring M_VPMINSB = _FT("vpminsb"); +extern const fcml_cstring M_VPMINSD = _FT("vpminsd"); +extern const fcml_cstring M_VPMINSQ = _FT("vpminsq"); +extern const fcml_cstring M_VPMINSW = _FT("vpminsw"); +extern const fcml_cstring M_VPMINUB = _FT("vpminub"); +extern const fcml_cstring M_VPMINUD = _FT("vpminud"); +extern const fcml_cstring M_VPMINUQ = _FT("vpminuq"); +extern const fcml_cstring M_VPMINUW = _FT("vpminuw"); +extern const fcml_cstring M_VPMOVB2M = _FT("vpmovb2m"); +extern const fcml_cstring M_VPMOVD2M = _FT("vpmovd2m"); +extern const fcml_cstring M_VPMOVDB = _FT("vpmovdb"); +extern const fcml_cstring M_VPMOVDW = _FT("vpmovdw"); +extern const fcml_cstring M_VPMOVM2B = _FT("vpmovm2b"); +extern const fcml_cstring M_VPMOVM2D = _FT("vpmovm2d"); +extern const fcml_cstring M_VPMOVM2Q = _FT("vpmovm2q"); +extern const fcml_cstring M_VPMOVM2W = _FT("vpmovm2w"); +extern const fcml_cstring M_VPMOVMSKB = _FT("vpmovmskb"); +extern const fcml_cstring M_VPMOVQ2M = _FT("vpmovq2m"); +extern const fcml_cstring M_VPMOVQB = _FT("vpmovqb"); +extern const fcml_cstring M_VPMOVQD = _FT("vpmovqd"); +extern const fcml_cstring M_VPMOVQW = _FT("vpmovqw"); +extern const fcml_cstring M_VPMOVSDB = _FT("vpmovsdb"); +extern const fcml_cstring M_VPMOVSDW = _FT("vpmovsdw"); +extern const fcml_cstring M_VPMOVSQB = _FT("vpmovsqb"); +extern const fcml_cstring M_VPMOVSQD = _FT("vpmovsqd"); +extern const fcml_cstring M_VPMOVSQW = _FT("vpmovsqw"); +extern const fcml_cstring M_VPMOVSWB = _FT("vpmovswb"); +extern const fcml_cstring M_VPMOVSXBD = _FT("vpmovsxbd"); +extern const fcml_cstring M_VPMOVSXBQ = _FT("vpmovsxbq"); +extern const fcml_cstring M_VPMOVSXBW = _FT("vpmovsxbw"); +extern const fcml_cstring M_VPMOVSXDQ = _FT("vpmovsxdq"); +extern const fcml_cstring M_VPMOVSXWD = _FT("vpmovsxwd"); +extern const fcml_cstring M_VPMOVSXWQ = _FT("vpmovsxwq"); +extern const fcml_cstring M_VPMOVUSDB = _FT("vpmovusdb"); +extern const fcml_cstring M_VPMOVUSDW = _FT("vpmovusdw"); +extern const fcml_cstring M_VPMOVUSQB = _FT("vpmovusqb"); +extern const fcml_cstring M_VPMOVUSQD = _FT("vpmovusqd"); +extern const fcml_cstring M_VPMOVUSQW = _FT("vpmovusqw"); +extern const fcml_cstring M_VPMOVUSWB = _FT("vpmovuswb"); +extern const fcml_cstring M_VPMOVW2M = _FT("vpmovw2m"); +extern const fcml_cstring M_VPMOVWB = _FT("vpmovwb"); +extern const fcml_cstring M_VPMOVZXBD = _FT("vpmovzxbd"); +extern const fcml_cstring M_VPMOVZXBQ = _FT("vpmovzxbq"); +extern const fcml_cstring M_VPMOVZXBW = _FT("vpmovzxbw"); +extern const fcml_cstring M_VPMOVZXDQ = _FT("vpmovzxdq"); +extern const fcml_cstring M_VPMOVZXWD = _FT("vpmovzxwd"); +extern const fcml_cstring M_VPMOVZXWQ = _FT("vpmovzxwq"); +extern const fcml_cstring M_VPMULDQ = _FT("vpmuldq"); +extern const fcml_cstring M_VPMULHRSW = _FT("vpmulhrsw"); +extern const fcml_cstring M_VPMULHUW = _FT("vpmulhuw"); +extern const fcml_cstring M_VPMULHW = _FT("vpmulhw"); +extern const fcml_cstring M_VPMULLD = _FT("vpmulld"); +extern const fcml_cstring M_VPMULLQ = _FT("vpmullq"); +extern const fcml_cstring M_VPMULLW = _FT("vpmullw"); +extern const fcml_cstring M_VPMULTISHIFTQB = _FT("vpmultishiftqb"); +extern const fcml_cstring M_VPMULUDQ = _FT("vpmuludq"); +extern const fcml_cstring M_VPOR = _FT("vpor"); +extern const fcml_cstring M_VPORD = _FT("vpord"); +extern const fcml_cstring M_VPORQ = _FT("vporq"); +extern const fcml_cstring M_VPPERM = _FT("vpperm"); +extern const fcml_cstring M_VPROLD = _FT("vprold"); +extern const fcml_cstring M_VPROLQ = _FT("vprolq"); +extern const fcml_cstring M_VPROLVD = _FT("vprolvd"); +extern const fcml_cstring M_VPROLVQ = _FT("vprolvq"); +extern const fcml_cstring M_VPRORD = _FT("vprord"); +extern const fcml_cstring M_VPRORQ = _FT("vprorq"); +extern const fcml_cstring M_VPRORVD = _FT("vprorvd"); +extern const fcml_cstring M_VPRORVQ = _FT("vprorvq"); +extern const fcml_cstring M_VPROTB = _FT("vprotb"); +extern const fcml_cstring M_VPROTD = _FT("vprotd"); +extern const fcml_cstring M_VPROTQ = _FT("vprotq"); +extern const fcml_cstring M_VPROTW = _FT("vprotw"); +extern const fcml_cstring M_VPSADBW = _FT("vpsadbw"); +extern const fcml_cstring M_VPSCATTERDD = _FT("vpscatterdd"); +extern const fcml_cstring M_VPSCATTERDQ = _FT("vpscatterdq"); +extern const fcml_cstring M_VPSCATTERQD = _FT("vpscatterqd"); +extern const fcml_cstring M_VPSCATTERQQ = _FT("vpscatterqq"); +extern const fcml_cstring M_VPSHAB = _FT("vpshab"); +extern const fcml_cstring M_VPSHAD = _FT("vpshad"); +extern const fcml_cstring M_VPSHAQ = _FT("vpshaq"); +extern const fcml_cstring M_VPSHAW = _FT("vpshaw"); +extern const fcml_cstring M_VPSHLB = _FT("vpshlb"); +extern const fcml_cstring M_VPSHLD = _FT("vpshld"); +extern const fcml_cstring M_VPSHLQ = _FT("vpshlq"); +extern const fcml_cstring M_VPSHLW = _FT("vpshlw"); +extern const fcml_cstring M_VPSHUFB = _FT("vpshufb"); +extern const fcml_cstring M_VPSHUFD = _FT("vpshufd"); +extern const fcml_cstring M_VPSHUFHW = _FT("vpshufhw"); +extern const fcml_cstring M_VPSHUFLW = _FT("vpshuflw"); +extern const fcml_cstring M_VPSIGNB = _FT("vpsignb"); +extern const fcml_cstring M_VPSIGND = _FT("vpsignd"); +extern const fcml_cstring M_VPSIGNW = _FT("vpsignw"); +extern const fcml_cstring M_VPSLLD = _FT("vpslld"); +extern const fcml_cstring M_VPSLLDQ = _FT("vpslldq"); +extern const fcml_cstring M_VPSLLQ = _FT("vpsllq"); +extern const fcml_cstring M_VPSLLVD = _FT("vpsllvd"); +extern const fcml_cstring M_VPSLLVQ = _FT("vpsllvq"); +extern const fcml_cstring M_VPSLLVW = _FT("vpsllvw"); +extern const fcml_cstring M_VPSLLW = _FT("vpsllw"); +extern const fcml_cstring M_VPSRAD = _FT("vpsrad"); +extern const fcml_cstring M_VPSRAQ = _FT("vpsraq"); +extern const fcml_cstring M_VPSRAVD = _FT("vpsravd"); +extern const fcml_cstring M_VPSRAVQ = _FT("vpsravq"); +extern const fcml_cstring M_VPSRAVW = _FT("vpsravw"); +extern const fcml_cstring M_VPSRAW = _FT("vpsraw"); +extern const fcml_cstring M_VPSRLD = _FT("vpsrld"); +extern const fcml_cstring M_VPSRLDQ = _FT("vpsrldq"); +extern const fcml_cstring M_VPSRLQ = _FT("vpsrlq"); +extern const fcml_cstring M_VPSRLVD = _FT("vpsrlvd"); +extern const fcml_cstring M_VPSRLVQ = _FT("vpsrlvq"); +extern const fcml_cstring M_VPSRLVW = _FT("vpsrlvw"); +extern const fcml_cstring M_VPSRLW = _FT("vpsrlw"); +extern const fcml_cstring M_VPSUBB = _FT("vpsubb"); +extern const fcml_cstring M_VPSUBD = _FT("vpsubd"); +extern const fcml_cstring M_VPSUBQ = _FT("vpsubq"); +extern const fcml_cstring M_VPSUBSB = _FT("vpsubsb"); +extern const fcml_cstring M_VPSUBSW = _FT("vpsubsw"); +extern const fcml_cstring M_VPSUBUSB = _FT("vpsubusb"); +extern const fcml_cstring M_VPSUBUSW = _FT("vpsubusw"); +extern const fcml_cstring M_VPSUBW = _FT("vpsubw"); +extern const fcml_cstring M_VPTERNLOGD = _FT("vpternlogd"); +extern const fcml_cstring M_VPTERNLOGQ = _FT("vpternlogq"); +extern const fcml_cstring M_VPTEST = _FT("vptest"); +extern const fcml_cstring M_VPTESTMB = _FT("vptestmb"); +extern const fcml_cstring M_VPTESTMD = _FT("vptestmd"); +extern const fcml_cstring M_VPTESTMQ = _FT("vptestmq"); +extern const fcml_cstring M_VPTESTMW = _FT("vptestmw"); +extern const fcml_cstring M_VPTESTNMB = _FT("vptestnmb"); +extern const fcml_cstring M_VPTESTNMD = _FT("vptestnmd"); +extern const fcml_cstring M_VPTESTNMQ = _FT("vptestnmq"); +extern const fcml_cstring M_VPTESTNMW = _FT("vptestnmw"); +extern const fcml_cstring M_VPUNPCKHBW = _FT("vpunpckhbw"); +extern const fcml_cstring M_VPUNPCKHDQ = _FT("vpunpckhdq"); +extern const fcml_cstring M_VPUNPCKHQDQ = _FT("vpunpckhqdq"); +extern const fcml_cstring M_VPUNPCKHWD = _FT("vpunpckhwd"); +extern const fcml_cstring M_VPUNPCKLBW = _FT("vpunpcklbw"); +extern const fcml_cstring M_VPUNPCKLDQ = _FT("vpunpckldq"); +extern const fcml_cstring M_VPUNPCKLQDQ = _FT("vpunpcklqdq"); +extern const fcml_cstring M_VPUNPCKLWD = _FT("vpunpcklwd"); +extern const fcml_cstring M_VPXOR = _FT("vpxor"); +extern const fcml_cstring M_VPXORD = _FT("vpxord"); +extern const fcml_cstring M_VPXORQ = _FT("vpxorq"); +extern const fcml_cstring M_VRANGEPD = _FT("vrangepd"); +extern const fcml_cstring M_VRANGEPS = _FT("vrangeps"); +extern const fcml_cstring M_VRANGESD = _FT("vrangesd"); +extern const fcml_cstring M_VRANGESS = _FT("vrangess"); +extern const fcml_cstring M_VRCP14PD = _FT("vrcp14pd"); +extern const fcml_cstring M_VRCP14PS = _FT("vrcp14ps"); +extern const fcml_cstring M_VRCP14SD = _FT("vrcp14sd"); +extern const fcml_cstring M_VRCP14SS = _FT("vrcp14ss"); +extern const fcml_cstring M_VRCP28PD = _FT("vrcp28pd"); +extern const fcml_cstring M_VRCP28PS = _FT("vrcp28ps"); +extern const fcml_cstring M_VRCP28SD = _FT("vrcp28sd"); +extern const fcml_cstring M_VRCP28SS = _FT("vrcp28ss"); +extern const fcml_cstring M_VRCPPS = _FT("vrcpps"); +extern const fcml_cstring M_VRCPSS = _FT("vrcpss"); +extern const fcml_cstring M_VREDUCEPD = _FT("vreducepd"); +extern const fcml_cstring M_VREDUCEPS = _FT("vreduceps"); +extern const fcml_cstring M_VREDUCESD = _FT("vreducesd"); +extern const fcml_cstring M_VREDUCESS = _FT("vreducess"); +extern const fcml_cstring M_VRNDSCALEPD = _FT("vrndscalepd"); +extern const fcml_cstring M_VRNDSCALEPS = _FT("vrndscaleps"); +extern const fcml_cstring M_VRNDSCALESD = _FT("vrndscalesd"); +extern const fcml_cstring M_VRNDSCALESS = _FT("vrndscaless"); +extern const fcml_cstring M_VROUNDPD = _FT("vroundpd"); +extern const fcml_cstring M_VROUNDPS = _FT("vroundps"); +extern const fcml_cstring M_VROUNDSD = _FT("vroundsd"); +extern const fcml_cstring M_VROUNDSS = _FT("vroundss"); +extern const fcml_cstring M_VRSQRT14PD = _FT("vrsqrt14pd"); +extern const fcml_cstring M_VRSQRT14PS = _FT("vrsqrt14ps"); +extern const fcml_cstring M_VRSQRT14SD = _FT("vrsqrt14sd"); +extern const fcml_cstring M_VRSQRT14SS = _FT("vrsqrt14ss"); +extern const fcml_cstring M_VRSQRT28PD = _FT("vrsqrt28pd"); +extern const fcml_cstring M_VRSQRT28PS = _FT("vrsqrt28ps"); +extern const fcml_cstring M_VRSQRT28SD = _FT("vrsqrt28sd"); +extern const fcml_cstring M_VRSQRT28SS = _FT("vrsqrt28ss"); +extern const fcml_cstring M_VRSQRTPS = _FT("vrsqrtps"); +extern const fcml_cstring M_VRSQRTSS = _FT("vrsqrtss"); +extern const fcml_cstring M_VSCALEFPD = _FT("vscalefpd"); +extern const fcml_cstring M_VSCALEFPS = _FT("vscalefps"); +extern const fcml_cstring M_VSCALEFSD = _FT("vscalefsd"); +extern const fcml_cstring M_VSCALEFSS = _FT("vscalefss"); +extern const fcml_cstring M_VSCATTERDPD = _FT("vscatterdpd"); +extern const fcml_cstring M_VSCATTERDPS = _FT("vscatterdps"); +extern const fcml_cstring M_VSCATTERPF0DPD = _FT("vscatterpf0dpd"); +extern const fcml_cstring M_VSCATTERPF0DPS = _FT("vscatterpf0dps"); +extern const fcml_cstring M_VSCATTERPF0QPD = _FT("vscatterpf0qpd"); +extern const fcml_cstring M_VSCATTERPF0QPS = _FT("vscatterpf0qps"); +extern const fcml_cstring M_VSCATTERPF1DPD = _FT("vscatterpf1dpd"); +extern const fcml_cstring M_VSCATTERPF1DPS = _FT("vscatterpf1dps"); +extern const fcml_cstring M_VSCATTERPF1QPD = _FT("vscatterpf1qpd"); +extern const fcml_cstring M_VSCATTERPF1QPS = _FT("vscatterpf1qps"); +extern const fcml_cstring M_VSCATTERQPD = _FT("vscatterqpd"); +extern const fcml_cstring M_VSCATTERQPS = _FT("vscatterqps"); +extern const fcml_cstring M_VSHUFF32X4 = _FT("vshuff32x4"); +extern const fcml_cstring M_VSHUFF64X2 = _FT("vshuff64x2"); +extern const fcml_cstring M_VSHUFI32X4 = _FT("vshufi32x4"); +extern const fcml_cstring M_VSHUFI64X2 = _FT("vshufi64x2"); +extern const fcml_cstring M_VSHUFPD = _FT("vshufpd"); +extern const fcml_cstring M_VSHUFPS = _FT("vshufps"); +extern const fcml_cstring M_VSQRTPD = _FT("vsqrtpd"); +extern const fcml_cstring M_VSQRTPS = _FT("vsqrtps"); +extern const fcml_cstring M_VSQRTSD = _FT("vsqrtsd"); +extern const fcml_cstring M_VSQRTSS = _FT("vsqrtss"); +extern const fcml_cstring M_VSTMXCSR = _FT("vstmxcsr"); +extern const fcml_cstring M_VSUBPD = _FT("vsubpd"); +extern const fcml_cstring M_VSUBPS = _FT("vsubps"); +extern const fcml_cstring M_VSUBSD = _FT("vsubsd"); +extern const fcml_cstring M_VSUBSS = _FT("vsubss"); +extern const fcml_cstring M_VTESTPD = _FT("vtestpd"); +extern const fcml_cstring M_VTESTPS = _FT("vtestps"); +extern const fcml_cstring M_VUCOMISD = _FT("vucomisd"); +extern const fcml_cstring M_VUCOMISS = _FT("vucomiss"); +extern const fcml_cstring M_VUNPCKHPD = _FT("vunpckhpd"); +extern const fcml_cstring M_VUNPCKHPS = _FT("vunpckhps"); +extern const fcml_cstring M_VUNPCKLPD = _FT("vunpcklpd"); +extern const fcml_cstring M_VUNPCKLPS = _FT("vunpcklps"); +extern const fcml_cstring M_VXORPD = _FT("vxorpd"); +extern const fcml_cstring M_VXORPS = _FT("vxorps"); +extern const fcml_cstring M_VZEROALL = _FT("vzeroall"); +extern const fcml_cstring M_VZEROUPPER = _FT("vzeroupper"); +extern const fcml_cstring M_WAIT = _FT("wait"); +extern const fcml_cstring M_WBINVD = _FT("wbinvd"); +extern const fcml_cstring M_WRFSBASE = _FT("wrfsbase"); +extern const fcml_cstring M_WRGSBASE = _FT("wrgsbase"); +extern const fcml_cstring M_WRMSR = _FT("wrmsr"); +extern const fcml_cstring M_XABORT = _FT("xabort"); +extern const fcml_cstring M_XADD = _FT("xadd"); +extern const fcml_cstring M_XBEGIN = _FT("xbegin"); +extern const fcml_cstring M_XCHG = _FT("xchg"); +extern const fcml_cstring M_XEND = _FT("xend"); +extern const fcml_cstring M_XGETBV = _FT("xgetbv"); +extern const fcml_cstring M_XLAT = _FT("xlat"); +extern const fcml_cstring M_XLATB = _FT("xlatb"); +extern const fcml_cstring M_XOR = _FT("xor"); +extern const fcml_cstring M_XORB = _FT("xorb"); +extern const fcml_cstring M_XORL = _FT("xorl"); +extern const fcml_cstring M_XORPD = _FT("xorpd"); +extern const fcml_cstring M_XORPS = _FT("xorps"); +extern const fcml_cstring M_XORQ = _FT("xorq"); +extern const fcml_cstring M_XORW = _FT("xorw"); +extern const fcml_cstring M_XRSTOR = _FT("xrstor"); +extern const fcml_cstring M_XRSTOR64 = _FT("xrstor64"); +extern const fcml_cstring M_XSAVE = _FT("xsave"); +extern const fcml_cstring M_XSAVE64 = _FT("xsave64"); +extern const fcml_cstring M_XSAVEOPT = _FT("xsaveopt"); +extern const fcml_cstring M_XSAVEOPT64 = _FT("xsaveopt64"); +extern const fcml_cstring M_XSETBV = _FT("xsetbv"); +extern const fcml_cstring M_XTEST = _FT("xtest"); + +} +} + + diff --git a/dependencies/fcml/include/fcml_gas_mnemonics.h b/dependencies/fcml/include/fcml_gas_mnemonics.h new file mode 100644 index 0000000..f12e38e --- /dev/null +++ b/dependencies/fcml/include/fcml_gas_mnemonics.h @@ -0,0 +1,1931 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_gas_mnemonics.h + * Declarations of AT&T mnemonics for C. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_GAS_MNEMONICS_H_ +#define FCML_GAS_MNEMONICS_H_ + +#include "fcml_types.h" + +#define M_AAA FCML_TEXT("aaa") +#define M_AAD FCML_TEXT("aad") +#define M_AAM FCML_TEXT("aam") +#define M_AAS FCML_TEXT("aas") +#define M_ADC FCML_TEXT("adc") +#define M_ADCB FCML_TEXT("adcb") +#define M_ADCL FCML_TEXT("adcl") +#define M_ADCQ FCML_TEXT("adcq") +#define M_ADCW FCML_TEXT("adcw") +#define M_ADCX FCML_TEXT("adcx") +#define M_ADD FCML_TEXT("add") +#define M_ADDB FCML_TEXT("addb") +#define M_ADDL FCML_TEXT("addl") +#define M_ADDPD FCML_TEXT("addpd") +#define M_ADDPS FCML_TEXT("addps") +#define M_ADDQ FCML_TEXT("addq") +#define M_ADDSD FCML_TEXT("addsd") +#define M_ADDSS FCML_TEXT("addss") +#define M_ADDSUBPD FCML_TEXT("addsubpd") +#define M_ADDSUBPS FCML_TEXT("addsubps") +#define M_ADDW FCML_TEXT("addw") +#define M_ADOX FCML_TEXT("adox") +#define M_AESDEC FCML_TEXT("aesdec") +#define M_AESDECLAST FCML_TEXT("aesdeclast") +#define M_AESENC FCML_TEXT("aesenc") +#define M_AESENCLAST FCML_TEXT("aesenclast") +#define M_AESIMC FCML_TEXT("aesimc") +#define M_AESKEYGENASSIST FCML_TEXT("aeskeygenassist") +#define M_AND FCML_TEXT("and") +#define M_ANDB FCML_TEXT("andb") +#define M_ANDL FCML_TEXT("andl") +#define M_ANDN FCML_TEXT("andn") +#define M_ANDNPD FCML_TEXT("andnpd") +#define M_ANDNPS FCML_TEXT("andnps") +#define M_ANDPD FCML_TEXT("andpd") +#define M_ANDPS FCML_TEXT("andps") +#define M_ANDQ FCML_TEXT("andq") +#define M_ANDW FCML_TEXT("andw") +#define M_ARPL FCML_TEXT("arpl") +#define M_BEXR FCML_TEXT("bexr") +#define M_BEXTR FCML_TEXT("bextr") +#define M_BLCFILL FCML_TEXT("blcfill") +#define M_BLCI FCML_TEXT("blci") +#define M_BLCIC FCML_TEXT("blcic") +#define M_BLCMSK FCML_TEXT("blcmsk") +#define M_BLCS FCML_TEXT("blcs") +#define M_BLENDPD FCML_TEXT("blendpd") +#define M_BLENDPS FCML_TEXT("blendps") +#define M_BLENDVPD FCML_TEXT("blendvpd") +#define M_BLENDVPS FCML_TEXT("blendvps") +#define M_BLSFILL FCML_TEXT("blsfill") +#define M_BLSI FCML_TEXT("blsi") +#define M_BLSIC FCML_TEXT("blsic") +#define M_BLSMSK FCML_TEXT("blsmsk") +#define M_BLSR FCML_TEXT("blsr") +#define M_BOUND FCML_TEXT("bound") +#define M_BSF FCML_TEXT("bsf") +#define M_BSR FCML_TEXT("bsr") +#define M_BSWAP FCML_TEXT("bswap") +#define M_BT FCML_TEXT("bt") +#define M_BTC FCML_TEXT("btc") +#define M_BTCL FCML_TEXT("btcl") +#define M_BTCQ FCML_TEXT("btcq") +#define M_BTCW FCML_TEXT("btcw") +#define M_BTL FCML_TEXT("btl") +#define M_BTQ FCML_TEXT("btq") +#define M_BTR FCML_TEXT("btr") +#define M_BTRL FCML_TEXT("btrl") +#define M_BTRQ FCML_TEXT("btrq") +#define M_BTRW FCML_TEXT("btrw") +#define M_BTS FCML_TEXT("bts") +#define M_BTSL FCML_TEXT("btsl") +#define M_BTSQ FCML_TEXT("btsq") +#define M_BTSW FCML_TEXT("btsw") +#define M_BTW FCML_TEXT("btw") +#define M_BZHI FCML_TEXT("bzhi") +#define M_CALL FCML_TEXT("call") +#define M_CALLQ FCML_TEXT("callq") +#define M_CALLW FCML_TEXT("callw") +#define M_CBTW FCML_TEXT("cbtw") +#define M_CLAC FCML_TEXT("clac") +#define M_CLC FCML_TEXT("clc") +#define M_CLD FCML_TEXT("cld") +#define M_CLFLUSH FCML_TEXT("clflush") +#define M_CLGI FCML_TEXT("clgi") +#define M_CLI FCML_TEXT("cli") +#define M_CLTD FCML_TEXT("cltd") +#define M_CLTQ FCML_TEXT("cltq") +#define M_CLTS FCML_TEXT("clts") +#define M_CMC FCML_TEXT("cmc") +#define M_CMOVA FCML_TEXT("cmova") +#define M_CMOVAE FCML_TEXT("cmovae") +#define M_CMOVB FCML_TEXT("cmovb") +#define M_CMOVBE FCML_TEXT("cmovbe") +#define M_CMOVC FCML_TEXT("cmovc") +#define M_CMOVENE FCML_TEXT("cmovene") +#define M_CMOVG FCML_TEXT("cmovg") +#define M_CMOVGE FCML_TEXT("cmovge") +#define M_CMOVL FCML_TEXT("cmovl") +#define M_CMOVLE FCML_TEXT("cmovle") +#define M_CMOVNA FCML_TEXT("cmovna") +#define M_CMOVNAE FCML_TEXT("cmovnae") +#define M_CMOVNB FCML_TEXT("cmovnb") +#define M_CMOVNBE FCML_TEXT("cmovnbe") +#define M_CMOVNC FCML_TEXT("cmovnc") +#define M_CMOVNG FCML_TEXT("cmovng") +#define M_CMOVNGE FCML_TEXT("cmovnge") +#define M_CMOVNL FCML_TEXT("cmovnl") +#define M_CMOVNLE FCML_TEXT("cmovnle") +#define M_CMOVNO FCML_TEXT("cmovno") +#define M_CMOVNP FCML_TEXT("cmovnp") +#define M_CMOVNS FCML_TEXT("cmovns") +#define M_CMOVNZ FCML_TEXT("cmovnz") +#define M_CMOVO FCML_TEXT("cmovo") +#define M_CMOVP FCML_TEXT("cmovp") +#define M_CMOVPE FCML_TEXT("cmovpe") +#define M_CMOVPO FCML_TEXT("cmovpo") +#define M_CMOVS FCML_TEXT("cmovs") +#define M_CMOVZ FCML_TEXT("cmovz") +#define M_CMP FCML_TEXT("cmp") +#define M_CMPB FCML_TEXT("cmpb") +#define M_CMPEQPD FCML_TEXT("cmpeqpd") +#define M_CMPEQPS FCML_TEXT("cmpeqps") +#define M_CMPEQSD FCML_TEXT("cmpeqsd") +#define M_CMPEQSS FCML_TEXT("cmpeqss") +#define M_CMPL FCML_TEXT("cmpl") +#define M_CMPLEPD FCML_TEXT("cmplepd") +#define M_CMPLEPS FCML_TEXT("cmpleps") +#define M_CMPLESD FCML_TEXT("cmplesd") +#define M_CMPLESS FCML_TEXT("cmpless") +#define M_CMPLTPD FCML_TEXT("cmpltpd") +#define M_CMPLTPS FCML_TEXT("cmpltps") +#define M_CMPLTSD FCML_TEXT("cmpltsd") +#define M_CMPLTSS FCML_TEXT("cmpltss") +#define M_CMPNEQPD FCML_TEXT("cmpneqpd") +#define M_CMPNEQPS FCML_TEXT("cmpneqps") +#define M_CMPNEQSD FCML_TEXT("cmpneqsd") +#define M_CMPNEQSS FCML_TEXT("cmpneqss") +#define M_CMPNLEPD FCML_TEXT("cmpnlepd") +#define M_CMPNLEPS FCML_TEXT("cmpnleps") +#define M_CMPNLESD FCML_TEXT("cmpnlesd") +#define M_CMPNLESS FCML_TEXT("cmpnless") +#define M_CMPNLTPD FCML_TEXT("cmpnltpd") +#define M_CMPNLTPS FCML_TEXT("cmpnltps") +#define M_CMPNLTSD FCML_TEXT("cmpnltsd") +#define M_CMPNLTSS FCML_TEXT("cmpnltss") +#define M_CMPORDPD FCML_TEXT("cmpordpd") +#define M_CMPORDPS FCML_TEXT("cmpordps") +#define M_CMPORDSD FCML_TEXT("cmpordsd") +#define M_CMPORDSS FCML_TEXT("cmpordss") +#define M_CMPPD FCML_TEXT("cmppd") +#define M_CMPPS FCML_TEXT("cmpps") +#define M_CMPQ FCML_TEXT("cmpq") +#define M_CMPSB FCML_TEXT("cmpsb") +#define M_CMPSD FCML_TEXT("cmpsd") +#define M_CMPSL FCML_TEXT("cmpsl") +#define M_CMPSQ FCML_TEXT("cmpsq") +#define M_CMPSS FCML_TEXT("cmpss") +#define M_CMPSW FCML_TEXT("cmpsw") +#define M_CMPUNORDPD FCML_TEXT("cmpunordpd") +#define M_CMPUNORDPS FCML_TEXT("cmpunordps") +#define M_CMPUNORDSD FCML_TEXT("cmpunordsd") +#define M_CMPUNORDSS FCML_TEXT("cmpunordss") +#define M_CMPW FCML_TEXT("cmpw") +#define M_CMPXCHG FCML_TEXT("cmpxchg") +#define M_CMPXCHG16B FCML_TEXT("cmpxchg16b") +#define M_CMPXCHG8B FCML_TEXT("cmpxchg8b") +#define M_COMISD FCML_TEXT("comisd") +#define M_COMISS FCML_TEXT("comiss") +#define M_CPUID FCML_TEXT("cpuid") +#define M_CQTO FCML_TEXT("cqto") +#define M_CRC32B FCML_TEXT("crc32b") +#define M_CRC32L FCML_TEXT("crc32l") +#define M_CRC32Q FCML_TEXT("crc32q") +#define M_CRC32W FCML_TEXT("crc32w") +#define M_CVTDQ2PD FCML_TEXT("cvtdq2pd") +#define M_CVTDQ2PS FCML_TEXT("cvtdq2ps") +#define M_CVTPD2DQ FCML_TEXT("cvtpd2dq") +#define M_CVTPD2PI FCML_TEXT("cvtpd2pi") +#define M_CVTPD2PS FCML_TEXT("cvtpd2ps") +#define M_CVTPI2PD FCML_TEXT("cvtpi2pd") +#define M_CVTPI2PS FCML_TEXT("cvtpi2ps") +#define M_CVTPS2DQ FCML_TEXT("cvtps2dq") +#define M_CVTPS2PD FCML_TEXT("cvtps2pd") +#define M_CVTPS2PI FCML_TEXT("cvtps2pi") +#define M_CVTSD2SI FCML_TEXT("cvtsd2si") +#define M_CVTSD2SS FCML_TEXT("cvtsd2ss") +#define M_CVTSI2SDL FCML_TEXT("cvtsi2sdl") +#define M_CVTSI2SDQ FCML_TEXT("cvtsi2sdq") +#define M_CVTSI2SSL FCML_TEXT("cvtsi2ssl") +#define M_CVTSI2SSQ FCML_TEXT("cvtsi2ssq") +#define M_CVTSS2SD FCML_TEXT("cvtss2sd") +#define M_CVTSS2SI FCML_TEXT("cvtss2si") +#define M_CVTTPD2DQ FCML_TEXT("cvttpd2dq") +#define M_CVTTPD2PI FCML_TEXT("cvttpd2pi") +#define M_CVTTPS2DQ FCML_TEXT("cvttps2dq") +#define M_CVTTPS2PI FCML_TEXT("cvttps2pi") +#define M_CVTTSD2SI FCML_TEXT("cvttsd2si") +#define M_CVTTSS2SI FCML_TEXT("cvttss2si") +#define M_CWTD FCML_TEXT("cwtd") +#define M_CWTL FCML_TEXT("cwtl") +#define M_DAA FCML_TEXT("daa") +#define M_DAS FCML_TEXT("das") +#define M_DEC FCML_TEXT("dec") +#define M_DECB FCML_TEXT("decb") +#define M_DECL FCML_TEXT("decl") +#define M_DECQ FCML_TEXT("decq") +#define M_DECW FCML_TEXT("decw") +#define M_DIV FCML_TEXT("div") +#define M_DIVB FCML_TEXT("divb") +#define M_DIVL FCML_TEXT("divl") +#define M_DIVPD FCML_TEXT("divpd") +#define M_DIVPS FCML_TEXT("divps") +#define M_DIVQ FCML_TEXT("divq") +#define M_DIVSD FCML_TEXT("divsd") +#define M_DIVSS FCML_TEXT("divss") +#define M_DIVW FCML_TEXT("divw") +#define M_DPPD FCML_TEXT("dppd") +#define M_DPPS FCML_TEXT("dpps") +#define M_EMMS FCML_TEXT("emms") +#define M_ENTER FCML_TEXT("enter") +#define M_ENTERQ FCML_TEXT("enterq") +#define M_EXTRACTPS FCML_TEXT("extractps") +#define M_EXTRQ FCML_TEXT("extrq") +#define M_F2XM1 FCML_TEXT("f2xm1") +#define M_FABS FCML_TEXT("fabs") +#define M_FADD FCML_TEXT("fadd") +#define M_FADDL FCML_TEXT("faddl") +#define M_FADDP FCML_TEXT("faddp") +#define M_FADDS FCML_TEXT("fadds") +#define M_FBLD FCML_TEXT("fbld") +#define M_FBSTP FCML_TEXT("fbstp") +#define M_FCHS FCML_TEXT("fchs") +#define M_FCLEX FCML_TEXT("fclex") +#define M_FCMOVB FCML_TEXT("fcmovb") +#define M_FCMOVBE FCML_TEXT("fcmovbe") +#define M_FCMOVE FCML_TEXT("fcmove") +#define M_FCMOVNB FCML_TEXT("fcmovnb") +#define M_FCMOVNBE FCML_TEXT("fcmovnbe") +#define M_FCMOVNE FCML_TEXT("fcmovne") +#define M_FCMOVNU FCML_TEXT("fcmovnu") +#define M_FCMOVU FCML_TEXT("fcmovu") +#define M_FCOM FCML_TEXT("fcom") +#define M_FCOMI FCML_TEXT("fcomi") +#define M_FCOMIP FCML_TEXT("fcomip") +#define M_FCOML FCML_TEXT("fcoml") +#define M_FCOMP FCML_TEXT("fcomp") +#define M_FCOMPL FCML_TEXT("fcompl") +#define M_FCOMPP FCML_TEXT("fcompp") +#define M_FCOMPS FCML_TEXT("fcomps") +#define M_FCOMS FCML_TEXT("fcoms") +#define M_FCOS FCML_TEXT("fcos") +#define M_FDECSTP FCML_TEXT("fdecstp") +#define M_FDIV FCML_TEXT("fdiv") +#define M_FDIVL FCML_TEXT("fdivl") +#define M_FDIVP FCML_TEXT("fdivp") +#define M_FDIVR FCML_TEXT("fdivr") +#define M_FDIVRL FCML_TEXT("fdivrl") +#define M_FDIVRP FCML_TEXT("fdivrp") +#define M_FDIVRS FCML_TEXT("fdivrs") +#define M_FDIVS FCML_TEXT("fdivs") +#define M_FEMMS FCML_TEXT("femms") +#define M_FFREE FCML_TEXT("ffree") +#define M_FIADD FCML_TEXT("fiadd") +#define M_FIADDL FCML_TEXT("fiaddl") +#define M_FICOM FCML_TEXT("ficom") +#define M_FICOML FCML_TEXT("ficoml") +#define M_FICOMP FCML_TEXT("ficomp") +#define M_FICOMPL FCML_TEXT("ficompl") +#define M_FIDIV FCML_TEXT("fidiv") +#define M_FIDIVL FCML_TEXT("fidivl") +#define M_FIDIVR FCML_TEXT("fidivr") +#define M_FIDIVRL FCML_TEXT("fidivrl") +#define M_FILD FCML_TEXT("fild") +#define M_FILDL FCML_TEXT("fildl") +#define M_FILDLL FCML_TEXT("fildll") +#define M_FIMUL FCML_TEXT("fimul") +#define M_FIMULL FCML_TEXT("fimull") +#define M_FINCSTP FCML_TEXT("fincstp") +#define M_FINIT FCML_TEXT("finit") +#define M_FIST FCML_TEXT("fist") +#define M_FISTL FCML_TEXT("fistl") +#define M_FISTP FCML_TEXT("fistp") +#define M_FISTPL FCML_TEXT("fistpl") +#define M_FISTPLL FCML_TEXT("fistpll") +#define M_FISTTP FCML_TEXT("fisttp") +#define M_FISTTPL FCML_TEXT("fisttpl") +#define M_FISTTPLL FCML_TEXT("fisttpll") +#define M_FISUB FCML_TEXT("fisub") +#define M_FISUBL FCML_TEXT("fisubl") +#define M_FISUBR FCML_TEXT("fisubr") +#define M_FISUBRL FCML_TEXT("fisubrl") +#define M_FLD FCML_TEXT("fld") +#define M_FLD1 FCML_TEXT("fld1") +#define M_FLDCW FCML_TEXT("fldcw") +#define M_FLDENV FCML_TEXT("fldenv") +#define M_FLDENVS FCML_TEXT("fldenvs") +#define M_FLDL FCML_TEXT("fldl") +#define M_FLDL2E FCML_TEXT("fldl2e") +#define M_FLDL2T FCML_TEXT("fldl2t") +#define M_FLDLG2 FCML_TEXT("fldlg2") +#define M_FLDLN2 FCML_TEXT("fldln2") +#define M_FLDPI FCML_TEXT("fldpi") +#define M_FLDS FCML_TEXT("flds") +#define M_FLDT FCML_TEXT("fldt") +#define M_FLDZ FCML_TEXT("fldz") +#define M_FMUL FCML_TEXT("fmul") +#define M_FMULL FCML_TEXT("fmull") +#define M_FMULP FCML_TEXT("fmulp") +#define M_FMULS FCML_TEXT("fmuls") +#define M_FNCLEX FCML_TEXT("fnclex") +#define M_FNINIT FCML_TEXT("fninit") +#define M_FNOP FCML_TEXT("fnop") +#define M_FNSAVE FCML_TEXT("fnsave") +#define M_FNSAVES FCML_TEXT("fnsaves") +#define M_FNSTCW FCML_TEXT("fnstcw") +#define M_FNSTENV FCML_TEXT("fnstenv") +#define M_FNSTENVS FCML_TEXT("fnstenvs") +#define M_FNSTSW FCML_TEXT("fnstsw") +#define M_FPATAN FCML_TEXT("fpatan") +#define M_FPREM FCML_TEXT("fprem") +#define M_FPREM1 FCML_TEXT("fprem1") +#define M_FPTAN FCML_TEXT("fptan") +#define M_FRNDINT FCML_TEXT("frndint") +#define M_FRSTOR FCML_TEXT("frstor") +#define M_FRSTORS FCML_TEXT("frstors") +#define M_FSAVE FCML_TEXT("fsave") +#define M_FSAVES FCML_TEXT("fsaves") +#define M_FSCALE FCML_TEXT("fscale") +#define M_FSIN FCML_TEXT("fsin") +#define M_FSINCOS FCML_TEXT("fsincos") +#define M_FSQRT FCML_TEXT("fsqrt") +#define M_FST FCML_TEXT("fst") +#define M_FSTCW FCML_TEXT("fstcw") +#define M_FSTENV FCML_TEXT("fstenv") +#define M_FSTENVS FCML_TEXT("fstenvs") +#define M_FSTL FCML_TEXT("fstl") +#define M_FSTP FCML_TEXT("fstp") +#define M_FSTPL FCML_TEXT("fstpl") +#define M_FSTPS FCML_TEXT("fstps") +#define M_FSTPT FCML_TEXT("fstpt") +#define M_FSTS FCML_TEXT("fsts") +#define M_FSTSW FCML_TEXT("fstsw") +#define M_FSUB FCML_TEXT("fsub") +#define M_FSUBL FCML_TEXT("fsubl") +#define M_FSUBP FCML_TEXT("fsubp") +#define M_FSUBR FCML_TEXT("fsubr") +#define M_FSUBRL FCML_TEXT("fsubrl") +#define M_FSUBRP FCML_TEXT("fsubrp") +#define M_FSUBRS FCML_TEXT("fsubrs") +#define M_FSUBS FCML_TEXT("fsubs") +#define M_FTST FCML_TEXT("ftst") +#define M_FUCOM FCML_TEXT("fucom") +#define M_FUCOMI FCML_TEXT("fucomi") +#define M_FUCOMIP FCML_TEXT("fucomip") +#define M_FUCOMP FCML_TEXT("fucomp") +#define M_FUCOMPP FCML_TEXT("fucompp") +#define M_FWAIT FCML_TEXT("fwait") +#define M_FXAM FCML_TEXT("fxam") +#define M_FXCH FCML_TEXT("fxch") +#define M_FXRSTOR FCML_TEXT("fxrstor") +#define M_FXRSTOR64 FCML_TEXT("fxrstor64") +#define M_FXSAVE FCML_TEXT("fxsave") +#define M_FXSAVE64 FCML_TEXT("fxsave64") +#define M_FXTRACT FCML_TEXT("fxtract") +#define M_FYL2X FCML_TEXT("fyl2x") +#define M_FYL2XP1 FCML_TEXT("fyl2xp1") +#define M_GETSEC FCML_TEXT("getsec") +#define M_HADDPD FCML_TEXT("haddpd") +#define M_HADDPS FCML_TEXT("haddps") +#define M_HLT FCML_TEXT("hlt") +#define M_HSUBPD FCML_TEXT("hsubpd") +#define M_HSUBPS FCML_TEXT("hsubps") +#define M_IDIV FCML_TEXT("idiv") +#define M_IDIVB FCML_TEXT("idivb") +#define M_IDIVL FCML_TEXT("idivl") +#define M_IDIVQ FCML_TEXT("idivq") +#define M_IDIVW FCML_TEXT("idivw") +#define M_IMUL FCML_TEXT("imul") +#define M_IMULB FCML_TEXT("imulb") +#define M_IMULL FCML_TEXT("imull") +#define M_IMULQ FCML_TEXT("imulq") +#define M_IMULW FCML_TEXT("imulw") +#define M_IN FCML_TEXT("in") +#define M_INC FCML_TEXT("inc") +#define M_INCB FCML_TEXT("incb") +#define M_INCL FCML_TEXT("incl") +#define M_INCQ FCML_TEXT("incq") +#define M_INCW FCML_TEXT("incw") +#define M_INSB FCML_TEXT("insb") +#define M_INSERTPS FCML_TEXT("insertps") +#define M_INSERTQ FCML_TEXT("insertq") +#define M_INSL FCML_TEXT("insl") +#define M_INSW FCML_TEXT("insw") +#define M_INT FCML_TEXT("int") +#define M_INT3 FCML_TEXT("int3") +#define M_INTO FCML_TEXT("into") +#define M_INVD FCML_TEXT("invd") +#define M_INVEPT FCML_TEXT("invept") +#define M_INVLPG FCML_TEXT("invlpg") +#define M_INVLPGA FCML_TEXT("invlpga") +#define M_INVPCID FCML_TEXT("invpcid") +#define M_INVVPID FCML_TEXT("invvpid") +#define M_IRET FCML_TEXT("iret") +#define M_IRETQ FCML_TEXT("iretq") +#define M_IRETW FCML_TEXT("iretw") +#define M_JA FCML_TEXT("ja") +#define M_JAE FCML_TEXT("jae") +#define M_JB FCML_TEXT("jb") +#define M_JBE FCML_TEXT("jbe") +#define M_JC FCML_TEXT("jc") +#define M_JCXZ FCML_TEXT("jcxz") +#define M_JECXZ FCML_TEXT("jecxz") +#define M_JENE FCML_TEXT("jene") +#define M_JG FCML_TEXT("jg") +#define M_JGE FCML_TEXT("jge") +#define M_JL FCML_TEXT("jl") +#define M_JLE FCML_TEXT("jle") +#define M_JMP FCML_TEXT("jmp") +#define M_JMPQ FCML_TEXT("jmpq") +#define M_JMPW FCML_TEXT("jmpw") +#define M_JNA FCML_TEXT("jna") +#define M_JNAE FCML_TEXT("jnae") +#define M_JNB FCML_TEXT("jnb") +#define M_JNBE FCML_TEXT("jnbe") +#define M_JNC FCML_TEXT("jnc") +#define M_JNG FCML_TEXT("jng") +#define M_JNGE FCML_TEXT("jnge") +#define M_JNL FCML_TEXT("jnl") +#define M_JNLE FCML_TEXT("jnle") +#define M_JNO FCML_TEXT("jno") +#define M_JNP FCML_TEXT("jnp") +#define M_JNS FCML_TEXT("jns") +#define M_JNZ FCML_TEXT("jnz") +#define M_JO FCML_TEXT("jo") +#define M_JP FCML_TEXT("jp") +#define M_JPE FCML_TEXT("jpe") +#define M_JPO FCML_TEXT("jpo") +#define M_JRCXZ FCML_TEXT("jrcxz") +#define M_JS FCML_TEXT("js") +#define M_JZ FCML_TEXT("jz") +#define M_KADDB FCML_TEXT("kaddb") +#define M_KADDD FCML_TEXT("kaddd") +#define M_KADDQ FCML_TEXT("kaddq") +#define M_KADDW FCML_TEXT("kaddw") +#define M_KANDB FCML_TEXT("kandb") +#define M_KANDD FCML_TEXT("kandd") +#define M_KANDNB FCML_TEXT("kandnb") +#define M_KANDND FCML_TEXT("kandnd") +#define M_KANDNQ FCML_TEXT("kandnq") +#define M_KANDNW FCML_TEXT("kandnw") +#define M_KANDQ FCML_TEXT("kandq") +#define M_KANDW FCML_TEXT("kandw") +#define M_KMOVB FCML_TEXT("kmovb") +#define M_KMOVD FCML_TEXT("kmovd") +#define M_KMOVQ FCML_TEXT("kmovq") +#define M_KMOVW FCML_TEXT("kmovw") +#define M_KNOTB FCML_TEXT("knotb") +#define M_KNOTD FCML_TEXT("knotd") +#define M_KNOTQ FCML_TEXT("knotq") +#define M_KNOTW FCML_TEXT("knotw") +#define M_KORB FCML_TEXT("korb") +#define M_KORD FCML_TEXT("kord") +#define M_KORQ FCML_TEXT("korq") +#define M_KORTESTB FCML_TEXT("kortestb") +#define M_KORTESTD FCML_TEXT("kortestd") +#define M_KORTESTQ FCML_TEXT("kortestq") +#define M_KORTESTW FCML_TEXT("kortestw") +#define M_KORW FCML_TEXT("korw") +#define M_KSHIFTLB FCML_TEXT("kshiftlb") +#define M_KSHIFTLD FCML_TEXT("kshiftld") +#define M_KSHIFTLQ FCML_TEXT("kshiftlq") +#define M_KSHIFTLW FCML_TEXT("kshiftlw") +#define M_KSHIFTRB FCML_TEXT("kshiftrb") +#define M_KSHIFTRD FCML_TEXT("kshiftrd") +#define M_KSHIFTRQ FCML_TEXT("kshiftrq") +#define M_KSHIFTRW FCML_TEXT("kshiftrw") +#define M_KTESTB FCML_TEXT("ktestb") +#define M_KTESTD FCML_TEXT("ktestd") +#define M_KTESTQ FCML_TEXT("ktestq") +#define M_KTESTW FCML_TEXT("ktestw") +#define M_KXNORB FCML_TEXT("kxnorb") +#define M_KXNORD FCML_TEXT("kxnord") +#define M_KXNORQ FCML_TEXT("kxnorq") +#define M_KXNORW FCML_TEXT("kxnorw") +#define M_KXORB FCML_TEXT("kxorb") +#define M_KXORD FCML_TEXT("kxord") +#define M_KXORQ FCML_TEXT("kxorq") +#define M_KXORW FCML_TEXT("kxorw") +#define M_LAHF FCML_TEXT("lahf") +#define M_LAR FCML_TEXT("lar") +#define M_LCALL FCML_TEXT("lcall") +#define M_LCALLQ FCML_TEXT("lcallq") +#define M_LCALLW FCML_TEXT("lcallw") +#define M_LDDQU FCML_TEXT("lddqu") +#define M_LDMXCSR FCML_TEXT("ldmxcsr") +#define M_LDS FCML_TEXT("lds") +#define M_LEA FCML_TEXT("lea") +#define M_LEAVE FCML_TEXT("leave") +#define M_LES FCML_TEXT("les") +#define M_LFENCE FCML_TEXT("lfence") +#define M_LFS FCML_TEXT("lfs") +#define M_LGDT FCML_TEXT("lgdt") +#define M_LGS FCML_TEXT("lgs") +#define M_LIDT FCML_TEXT("lidt") +#define M_LJMP FCML_TEXT("ljmp") +#define M_LJMPL FCML_TEXT("ljmpl") +#define M_LJMPQ FCML_TEXT("ljmpq") +#define M_LJMPW FCML_TEXT("ljmpw") +#define M_LLDT FCML_TEXT("lldt") +#define M_LLWPCB FCML_TEXT("llwpcb") +#define M_LMSW FCML_TEXT("lmsw") +#define M_LODS FCML_TEXT("lods") +#define M_LODSB FCML_TEXT("lodsb") +#define M_LODSL FCML_TEXT("lodsl") +#define M_LODSQ FCML_TEXT("lodsq") +#define M_LODSW FCML_TEXT("lodsw") +#define M_LOOP FCML_TEXT("loop") +#define M_LOOPE FCML_TEXT("loope") +#define M_LOOPNE FCML_TEXT("loopne") +#define M_LOOPNZ FCML_TEXT("loopnz") +#define M_LOOPZ FCML_TEXT("loopz") +#define M_LRET FCML_TEXT("lret") +#define M_LRETQ FCML_TEXT("lretq") +#define M_LRETW FCML_TEXT("lretw") +#define M_LSL FCML_TEXT("lsl") +#define M_LSS FCML_TEXT("lss") +#define M_LTR FCML_TEXT("ltr") +#define M_LWPINS FCML_TEXT("lwpins") +#define M_LWPVAL FCML_TEXT("lwpval") +#define M_LZCNT FCML_TEXT("lzcnt") +#define M_MASKMOVDQU FCML_TEXT("maskmovdqu") +#define M_MASKMOVQ FCML_TEXT("maskmovq") +#define M_MAXPD FCML_TEXT("maxpd") +#define M_MAXPS FCML_TEXT("maxps") +#define M_MAXSD FCML_TEXT("maxsd") +#define M_MAXSS FCML_TEXT("maxss") +#define M_MFENCE FCML_TEXT("mfence") +#define M_MINPD FCML_TEXT("minpd") +#define M_MINPS FCML_TEXT("minps") +#define M_MINSD FCML_TEXT("minsd") +#define M_MINSS FCML_TEXT("minss") +#define M_MONITOR FCML_TEXT("monitor") +#define M_MOV FCML_TEXT("mov") +#define M_MOVABS FCML_TEXT("movabs") +#define M_MOVAPD FCML_TEXT("movapd") +#define M_MOVAPS FCML_TEXT("movaps") +#define M_MOVB FCML_TEXT("movb") +#define M_MOVBE FCML_TEXT("movbe") +#define M_MOVD FCML_TEXT("movd") +#define M_MOVDDUP FCML_TEXT("movddup") +#define M_MOVDQ2Q FCML_TEXT("movdq2q") +#define M_MOVDQA FCML_TEXT("movdqa") +#define M_MOVDQU FCML_TEXT("movdqu") +#define M_MOVHLPS FCML_TEXT("movhlps") +#define M_MOVHPD FCML_TEXT("movhpd") +#define M_MOVHPS FCML_TEXT("movhps") +#define M_MOVL FCML_TEXT("movl") +#define M_MOVLHPS FCML_TEXT("movlhps") +#define M_MOVLPD FCML_TEXT("movlpd") +#define M_MOVLPS FCML_TEXT("movlps") +#define M_MOVMSKPD FCML_TEXT("movmskpd") +#define M_MOVMSKPS FCML_TEXT("movmskps") +#define M_MOVNTDQ FCML_TEXT("movntdq") +#define M_MOVNTDQA FCML_TEXT("movntdqa") +#define M_MOVNTI FCML_TEXT("movnti") +#define M_MOVNTPD FCML_TEXT("movntpd") +#define M_MOVNTPS FCML_TEXT("movntps") +#define M_MOVNTQ FCML_TEXT("movntq") +#define M_MOVNTSD FCML_TEXT("movntsd") +#define M_MOVNTSS FCML_TEXT("movntss") +#define M_MOVQ FCML_TEXT("movq") +#define M_MOVQ2DQ FCML_TEXT("movq2dq") +#define M_MOVS FCML_TEXT("movs") +#define M_MOVSB FCML_TEXT("movsb") +#define M_MOVSBL FCML_TEXT("movsbl") +#define M_MOVSBQ FCML_TEXT("movsbq") +#define M_MOVSBW FCML_TEXT("movsbw") +#define M_MOVSD FCML_TEXT("movsd") +#define M_MOVSHDUP FCML_TEXT("movshdup") +#define M_MOVSL FCML_TEXT("movsl") +#define M_MOVSLDUP FCML_TEXT("movsldup") +#define M_MOVSQ FCML_TEXT("movsq") +#define M_MOVSS FCML_TEXT("movss") +#define M_MOVSW FCML_TEXT("movsw") +#define M_MOVSWL FCML_TEXT("movswl") +#define M_MOVSWQ FCML_TEXT("movswq") +#define M_MOVSWW FCML_TEXT("movsww") +#define M_MOVSXD FCML_TEXT("movsxd") +#define M_MOVUPD FCML_TEXT("movupd") +#define M_MOVUPS FCML_TEXT("movups") +#define M_MOVW FCML_TEXT("movw") +#define M_MOVZBL FCML_TEXT("movzbl") +#define M_MOVZBQ FCML_TEXT("movzbq") +#define M_MOVZBW FCML_TEXT("movzbw") +#define M_MOVZWL FCML_TEXT("movzwl") +#define M_MOVZWQ FCML_TEXT("movzwq") +#define M_MOVZWW FCML_TEXT("movzww") +#define M_MPSADBW FCML_TEXT("mpsadbw") +#define M_MUL FCML_TEXT("mul") +#define M_MULB FCML_TEXT("mulb") +#define M_MULL FCML_TEXT("mull") +#define M_MULPD FCML_TEXT("mulpd") +#define M_MULPS FCML_TEXT("mulps") +#define M_MULQ FCML_TEXT("mulq") +#define M_MULSD FCML_TEXT("mulsd") +#define M_MULSS FCML_TEXT("mulss") +#define M_MULW FCML_TEXT("mulw") +#define M_MULX FCML_TEXT("mulx") +#define M_MWAIT FCML_TEXT("mwait") +#define M_NEG FCML_TEXT("neg") +#define M_NEGB FCML_TEXT("negb") +#define M_NEGL FCML_TEXT("negl") +#define M_NEGQ FCML_TEXT("negq") +#define M_NEGW FCML_TEXT("negw") +#define M_NOP FCML_TEXT("nop") +#define M_NOPL FCML_TEXT("nopl") +#define M_NOPQ FCML_TEXT("nopq") +#define M_NOPW FCML_TEXT("nopw") +#define M_NOT FCML_TEXT("not") +#define M_NOTB FCML_TEXT("notb") +#define M_NOTL FCML_TEXT("notl") +#define M_NOTQ FCML_TEXT("notq") +#define M_NOTW FCML_TEXT("notw") +#define M_OR FCML_TEXT("or") +#define M_ORB FCML_TEXT("orb") +#define M_ORL FCML_TEXT("orl") +#define M_ORPD FCML_TEXT("orpd") +#define M_ORPS FCML_TEXT("orps") +#define M_ORQ FCML_TEXT("orq") +#define M_ORW FCML_TEXT("orw") +#define M_OUT FCML_TEXT("out") +#define M_OUTSB FCML_TEXT("outsb") +#define M_OUTSL FCML_TEXT("outsl") +#define M_OUTSW FCML_TEXT("outsw") +#define M_PABSB FCML_TEXT("pabsb") +#define M_PABSD FCML_TEXT("pabsd") +#define M_PABSW FCML_TEXT("pabsw") +#define M_PACKSSDW FCML_TEXT("packssdw") +#define M_PACKSSWB FCML_TEXT("packsswb") +#define M_PACKUSDW FCML_TEXT("packusdw") +#define M_PACKUSWB FCML_TEXT("packuswb") +#define M_PADDB FCML_TEXT("paddb") +#define M_PADDD FCML_TEXT("paddd") +#define M_PADDQ FCML_TEXT("paddq") +#define M_PADDSB FCML_TEXT("paddsb") +#define M_PADDSW FCML_TEXT("paddsw") +#define M_PADDUSB FCML_TEXT("paddusb") +#define M_PADDUSW FCML_TEXT("paddusw") +#define M_PADDW FCML_TEXT("paddw") +#define M_PALIGNR FCML_TEXT("palignr") +#define M_PAND FCML_TEXT("pand") +#define M_PANDN FCML_TEXT("pandn") +#define M_PAUSE FCML_TEXT("pause") +#define M_PAVGB FCML_TEXT("pavgb") +#define M_PAVGUSB FCML_TEXT("pavgusb") +#define M_PAVGW FCML_TEXT("pavgw") +#define M_PBLENDVB FCML_TEXT("pblendvb") +#define M_PBLENDW FCML_TEXT("pblendw") +#define M_PCLMULQDQ FCML_TEXT("pclmulqdq") +#define M_PCMPEQB FCML_TEXT("pcmpeqb") +#define M_PCMPEQD FCML_TEXT("pcmpeqd") +#define M_PCMPEQQ FCML_TEXT("pcmpeqq") +#define M_PCMPEQW FCML_TEXT("pcmpeqw") +#define M_PCMPESTRI FCML_TEXT("pcmpestri") +#define M_PCMPESTRM FCML_TEXT("pcmpestrm") +#define M_PCMPGTB FCML_TEXT("pcmpgtb") +#define M_PCMPGTD FCML_TEXT("pcmpgtd") +#define M_PCMPGTQ FCML_TEXT("pcmpgtq") +#define M_PCMPGTW FCML_TEXT("pcmpgtw") +#define M_PCMPISTRI FCML_TEXT("pcmpistri") +#define M_PCMPISTRM FCML_TEXT("pcmpistrm") +#define M_PDEP FCML_TEXT("pdep") +#define M_PEXT FCML_TEXT("pext") +#define M_PEXTRB FCML_TEXT("pextrb") +#define M_PEXTRD FCML_TEXT("pextrd") +#define M_PEXTRQ FCML_TEXT("pextrq") +#define M_PEXTRW FCML_TEXT("pextrw") +#define M_PF2ID FCML_TEXT("pf2id") +#define M_PF2IW FCML_TEXT("pf2iw") +#define M_PFACC FCML_TEXT("pfacc") +#define M_PFADD FCML_TEXT("pfadd") +#define M_PFCMPEQ FCML_TEXT("pfcmpeq") +#define M_PFCMPGE FCML_TEXT("pfcmpge") +#define M_PFCMPGT FCML_TEXT("pfcmpgt") +#define M_PFMAX FCML_TEXT("pfmax") +#define M_PFMIN FCML_TEXT("pfmin") +#define M_PFMUL FCML_TEXT("pfmul") +#define M_PFNACC FCML_TEXT("pfnacc") +#define M_PFPNACC FCML_TEXT("pfpnacc") +#define M_PFRCP FCML_TEXT("pfrcp") +#define M_PFRCPIT1 FCML_TEXT("pfrcpit1") +#define M_PFRCPIT2 FCML_TEXT("pfrcpit2") +#define M_PFRSQIT1 FCML_TEXT("pfrsqit1") +#define M_PFRSQRT FCML_TEXT("pfrsqrt") +#define M_PFSUB FCML_TEXT("pfsub") +#define M_PFSUBR FCML_TEXT("pfsubr") +#define M_PHADDD FCML_TEXT("phaddd") +#define M_PHADDSW FCML_TEXT("phaddsw") +#define M_PHADDW FCML_TEXT("phaddw") +#define M_PHMINPOSUW FCML_TEXT("phminposuw") +#define M_PHSUBD FCML_TEXT("phsubd") +#define M_PHSUBSW FCML_TEXT("phsubsw") +#define M_PHSUBW FCML_TEXT("phsubw") +#define M_PI2FD FCML_TEXT("pi2fd") +#define M_PI2FW FCML_TEXT("pi2fw") +#define M_PINSRB FCML_TEXT("pinsrb") +#define M_PINSRD FCML_TEXT("pinsrd") +#define M_PINSRQ FCML_TEXT("pinsrq") +#define M_PINSRW FCML_TEXT("pinsrw") +#define M_PMADDUBSW FCML_TEXT("pmaddubsw") +#define M_PMADDWD FCML_TEXT("pmaddwd") +#define M_PMAXSB FCML_TEXT("pmaxsb") +#define M_PMAXSD FCML_TEXT("pmaxsd") +#define M_PMAXSW FCML_TEXT("pmaxsw") +#define M_PMAXUB FCML_TEXT("pmaxub") +#define M_PMAXUD FCML_TEXT("pmaxud") +#define M_PMAXUW FCML_TEXT("pmaxuw") +#define M_PMINSB FCML_TEXT("pminsb") +#define M_PMINSD FCML_TEXT("pminsd") +#define M_PMINSW FCML_TEXT("pminsw") +#define M_PMINUB FCML_TEXT("pminub") +#define M_PMINUD FCML_TEXT("pminud") +#define M_PMINUW FCML_TEXT("pminuw") +#define M_PMOVMSKB FCML_TEXT("pmovmskb") +#define M_PMOVSXBD FCML_TEXT("pmovsxbd") +#define M_PMOVSXBQ FCML_TEXT("pmovsxbq") +#define M_PMOVSXBW FCML_TEXT("pmovsxbw") +#define M_PMOVSXDQ FCML_TEXT("pmovsxdq") +#define M_PMOVSXWD FCML_TEXT("pmovsxwd") +#define M_PMOVSXWQ FCML_TEXT("pmovsxwq") +#define M_PMOVZXBD FCML_TEXT("pmovzxbd") +#define M_PMOVZXBQ FCML_TEXT("pmovzxbq") +#define M_PMOVZXBW FCML_TEXT("pmovzxbw") +#define M_PMOVZXDQ FCML_TEXT("pmovzxdq") +#define M_PMOVZXWD FCML_TEXT("pmovzxwd") +#define M_PMOVZXWQ FCML_TEXT("pmovzxwq") +#define M_PMULDQ FCML_TEXT("pmuldq") +#define M_PMULHRSW FCML_TEXT("pmulhrsw") +#define M_PMULHRW FCML_TEXT("pmulhrw") +#define M_PMULHUW FCML_TEXT("pmulhuw") +#define M_PMULHW FCML_TEXT("pmulhw") +#define M_PMULLD FCML_TEXT("pmulld") +#define M_PMULLW FCML_TEXT("pmullw") +#define M_PMULUDQ FCML_TEXT("pmuludq") +#define M_POP FCML_TEXT("pop") +#define M_POPA FCML_TEXT("popa") +#define M_POPAW FCML_TEXT("popaw") +#define M_POPCNT FCML_TEXT("popcnt") +#define M_POPF FCML_TEXT("popf") +#define M_POPFQ FCML_TEXT("popfq") +#define M_POPFW FCML_TEXT("popfw") +#define M_POPL FCML_TEXT("popl") +#define M_POPQ FCML_TEXT("popq") +#define M_POPW FCML_TEXT("popw") +#define M_POR FCML_TEXT("por") +#define M_PREFETCH FCML_TEXT("prefetch") +#define M_PREFETCHNTA FCML_TEXT("prefetchnta") +#define M_PREFETCHT0 FCML_TEXT("prefetcht0") +#define M_PREFETCHT1 FCML_TEXT("prefetcht1") +#define M_PREFETCHT2 FCML_TEXT("prefetcht2") +#define M_PREFETCHW FCML_TEXT("prefetchw") +#define M_PREFETCHWT1 FCML_TEXT("prefetchwt1") +#define M_PSADBW FCML_TEXT("psadbw") +#define M_PSHUFB FCML_TEXT("pshufb") +#define M_PSHUFD FCML_TEXT("pshufd") +#define M_PSHUFHW FCML_TEXT("pshufhw") +#define M_PSHUFLW FCML_TEXT("pshuflw") +#define M_PSHUFW FCML_TEXT("pshufw") +#define M_PSIGNB FCML_TEXT("psignb") +#define M_PSIGND FCML_TEXT("psignd") +#define M_PSIGNW FCML_TEXT("psignw") +#define M_PSLLD FCML_TEXT("pslld") +#define M_PSLLDQ FCML_TEXT("pslldq") +#define M_PSLLQ FCML_TEXT("psllq") +#define M_PSLLW FCML_TEXT("psllw") +#define M_PSRAD FCML_TEXT("psrad") +#define M_PSRAW FCML_TEXT("psraw") +#define M_PSRLD FCML_TEXT("psrld") +#define M_PSRLDQ FCML_TEXT("psrldq") +#define M_PSRLQ FCML_TEXT("psrlq") +#define M_PSRLW FCML_TEXT("psrlw") +#define M_PSUBB FCML_TEXT("psubb") +#define M_PSUBD FCML_TEXT("psubd") +#define M_PSUBQ FCML_TEXT("psubq") +#define M_PSUBSB FCML_TEXT("psubsb") +#define M_PSUBSW FCML_TEXT("psubsw") +#define M_PSUBUSB FCML_TEXT("psubusb") +#define M_PSUBUSW FCML_TEXT("psubusw") +#define M_PSUBW FCML_TEXT("psubw") +#define M_PSWAPD FCML_TEXT("pswapd") +#define M_PTEST FCML_TEXT("ptest") +#define M_PUNPCKHBW FCML_TEXT("punpckhbw") +#define M_PUNPCKHDQ FCML_TEXT("punpckhdq") +#define M_PUNPCKHQDQ FCML_TEXT("punpckhqdq") +#define M_PUNPCKHWD FCML_TEXT("punpckhwd") +#define M_PUNPCKLBW FCML_TEXT("punpcklbw") +#define M_PUNPCKLDQ FCML_TEXT("punpckldq") +#define M_PUNPCKLQDQ FCML_TEXT("punpcklqdq") +#define M_PUNPCKLWD FCML_TEXT("punpcklwd") +#define M_PUSH FCML_TEXT("push") +#define M_PUSHA FCML_TEXT("pusha") +#define M_PUSHAW FCML_TEXT("pushaw") +#define M_PUSHB FCML_TEXT("pushb") +#define M_PUSHF FCML_TEXT("pushf") +#define M_PUSHFQ FCML_TEXT("pushfq") +#define M_PUSHFW FCML_TEXT("pushfw") +#define M_PUSHL FCML_TEXT("pushl") +#define M_PUSHQ FCML_TEXT("pushq") +#define M_PUSHW FCML_TEXT("pushw") +#define M_PXOR FCML_TEXT("pxor") +#define M_RCL FCML_TEXT("rcl") +#define M_RCLB FCML_TEXT("rclb") +#define M_RCLL FCML_TEXT("rcll") +#define M_RCLQ FCML_TEXT("rclq") +#define M_RCLW FCML_TEXT("rclw") +#define M_RCPPS FCML_TEXT("rcpps") +#define M_RCPSS FCML_TEXT("rcpss") +#define M_RCR FCML_TEXT("rcr") +#define M_RCRB FCML_TEXT("rcrb") +#define M_RCRL FCML_TEXT("rcrl") +#define M_RCRQ FCML_TEXT("rcrq") +#define M_RCRW FCML_TEXT("rcrw") +#define M_RDFSBASE FCML_TEXT("rdfsbase") +#define M_RDGSBASE FCML_TEXT("rdgsbase") +#define M_RDMSR FCML_TEXT("rdmsr") +#define M_RDPMC FCML_TEXT("rdpmc") +#define M_RDRAND FCML_TEXT("rdrand") +#define M_RDSEED FCML_TEXT("rdseed") +#define M_RDTSC FCML_TEXT("rdtsc") +#define M_RDTSCP FCML_TEXT("rdtscp") +#define M_RET FCML_TEXT("ret") +#define M_RETQ FCML_TEXT("retq") +#define M_RETW FCML_TEXT("retw") +#define M_ROL FCML_TEXT("rol") +#define M_ROLB FCML_TEXT("rolb") +#define M_ROLL FCML_TEXT("roll") +#define M_ROLQ FCML_TEXT("rolq") +#define M_ROLW FCML_TEXT("rolw") +#define M_ROR FCML_TEXT("ror") +#define M_RORB FCML_TEXT("rorb") +#define M_RORL FCML_TEXT("rorl") +#define M_RORQ FCML_TEXT("rorq") +#define M_RORW FCML_TEXT("rorw") +#define M_RORX FCML_TEXT("rorx") +#define M_ROUNDPD FCML_TEXT("roundpd") +#define M_ROUNDPS FCML_TEXT("roundps") +#define M_ROUNDSD FCML_TEXT("roundsd") +#define M_ROUNDSS FCML_TEXT("roundss") +#define M_RSM FCML_TEXT("rsm") +#define M_RSQRTPS FCML_TEXT("rsqrtps") +#define M_RSQRTSS FCML_TEXT("rsqrtss") +#define M_SAHF FCML_TEXT("sahf") +#define M_SAL FCML_TEXT("sal") +#define M_SALB FCML_TEXT("salb") +#define M_SALL FCML_TEXT("sall") +#define M_SALQ FCML_TEXT("salq") +#define M_SALW FCML_TEXT("salw") +#define M_SAR FCML_TEXT("sar") +#define M_SARB FCML_TEXT("sarb") +#define M_SARL FCML_TEXT("sarl") +#define M_SARQ FCML_TEXT("sarq") +#define M_SARW FCML_TEXT("sarw") +#define M_SARX FCML_TEXT("sarx") +#define M_SBB FCML_TEXT("sbb") +#define M_SBBB FCML_TEXT("sbbb") +#define M_SBBL FCML_TEXT("sbbl") +#define M_SBBQ FCML_TEXT("sbbq") +#define M_SBBW FCML_TEXT("sbbw") +#define M_SCAS FCML_TEXT("scas") +#define M_SCASB FCML_TEXT("scasb") +#define M_SCASL FCML_TEXT("scasl") +#define M_SCASQ FCML_TEXT("scasq") +#define M_SCASW FCML_TEXT("scasw") +#define M_SETA FCML_TEXT("seta") +#define M_SETAE FCML_TEXT("setae") +#define M_SETB FCML_TEXT("setb") +#define M_SETBE FCML_TEXT("setbe") +#define M_SETC FCML_TEXT("setc") +#define M_SETENE FCML_TEXT("setene") +#define M_SETG FCML_TEXT("setg") +#define M_SETGE FCML_TEXT("setge") +#define M_SETL FCML_TEXT("setl") +#define M_SETLE FCML_TEXT("setle") +#define M_SETNA FCML_TEXT("setna") +#define M_SETNAE FCML_TEXT("setnae") +#define M_SETNB FCML_TEXT("setnb") +#define M_SETNBE FCML_TEXT("setnbe") +#define M_SETNC FCML_TEXT("setnc") +#define M_SETNG FCML_TEXT("setng") +#define M_SETNGE FCML_TEXT("setnge") +#define M_SETNL FCML_TEXT("setnl") +#define M_SETNLE FCML_TEXT("setnle") +#define M_SETNO FCML_TEXT("setno") +#define M_SETNP FCML_TEXT("setnp") +#define M_SETNS FCML_TEXT("setns") +#define M_SETNZ FCML_TEXT("setnz") +#define M_SETO FCML_TEXT("seto") +#define M_SETP FCML_TEXT("setp") +#define M_SETPE FCML_TEXT("setpe") +#define M_SETPO FCML_TEXT("setpo") +#define M_SETS FCML_TEXT("sets") +#define M_SETZ FCML_TEXT("setz") +#define M_SFENCE FCML_TEXT("sfence") +#define M_SGDT FCML_TEXT("sgdt") +#define M_SHL FCML_TEXT("shl") +#define M_SHLB FCML_TEXT("shlb") +#define M_SHLD FCML_TEXT("shld") +#define M_SHLL FCML_TEXT("shll") +#define M_SHLQ FCML_TEXT("shlq") +#define M_SHLW FCML_TEXT("shlw") +#define M_SHLX FCML_TEXT("shlx") +#define M_SHR FCML_TEXT("shr") +#define M_SHRB FCML_TEXT("shrb") +#define M_SHRD FCML_TEXT("shrd") +#define M_SHRL FCML_TEXT("shrl") +#define M_SHRQ FCML_TEXT("shrq") +#define M_SHRW FCML_TEXT("shrw") +#define M_SHRX FCML_TEXT("shrx") +#define M_SHUFPD FCML_TEXT("shufpd") +#define M_SHUFPS FCML_TEXT("shufps") +#define M_SIDT FCML_TEXT("sidt") +#define M_SKINIT FCML_TEXT("skinit") +#define M_SLDT FCML_TEXT("sldt") +#define M_SLWPCB FCML_TEXT("slwpcb") +#define M_SMSW FCML_TEXT("smsw") +#define M_SQRTPD FCML_TEXT("sqrtpd") +#define M_SQRTPS FCML_TEXT("sqrtps") +#define M_SQRTSD FCML_TEXT("sqrtsd") +#define M_SQRTSS FCML_TEXT("sqrtss") +#define M_STAC FCML_TEXT("stac") +#define M_STC FCML_TEXT("stc") +#define M_STD FCML_TEXT("std") +#define M_STGI FCML_TEXT("stgi") +#define M_STI FCML_TEXT("sti") +#define M_STMXCSR FCML_TEXT("stmxcsr") +#define M_STOS FCML_TEXT("stos") +#define M_STOSB FCML_TEXT("stosb") +#define M_STOSL FCML_TEXT("stosl") +#define M_STOSQ FCML_TEXT("stosq") +#define M_STOSW FCML_TEXT("stosw") +#define M_STR FCML_TEXT("str") +#define M_SUB FCML_TEXT("sub") +#define M_SUBB FCML_TEXT("subb") +#define M_SUBL FCML_TEXT("subl") +#define M_SUBPD FCML_TEXT("subpd") +#define M_SUBPS FCML_TEXT("subps") +#define M_SUBQ FCML_TEXT("subq") +#define M_SUBSD FCML_TEXT("subsd") +#define M_SUBSS FCML_TEXT("subss") +#define M_SUBW FCML_TEXT("subw") +#define M_SWAPGS FCML_TEXT("swapgs") +#define M_SYSCALL FCML_TEXT("syscall") +#define M_SYSENTER FCML_TEXT("sysenter") +#define M_SYSEXIT FCML_TEXT("sysexit") +#define M_SYSRET FCML_TEXT("sysret") +#define M_T1MSKC FCML_TEXT("t1mskc") +#define M_TEST FCML_TEXT("test") +#define M_TESTB FCML_TEXT("testb") +#define M_TESTL FCML_TEXT("testl") +#define M_TESTQ FCML_TEXT("testq") +#define M_TESTW FCML_TEXT("testw") +#define M_TZCNT FCML_TEXT("tzcnt") +#define M_TZMSK FCML_TEXT("tzmsk") +#define M_UCOMISD FCML_TEXT("ucomisd") +#define M_UCOMISS FCML_TEXT("ucomiss") +#define M_UD2 FCML_TEXT("ud2") +#define M_UNPCKHPD FCML_TEXT("unpckhpd") +#define M_UNPCKHPS FCML_TEXT("unpckhps") +#define M_UNPCKLPD FCML_TEXT("unpcklpd") +#define M_UNPCKLPS FCML_TEXT("unpcklps") +#define M_V4FMADDPS FCML_TEXT("v4fmaddps") +#define M_V4FMADDSS FCML_TEXT("v4fmaddss") +#define M_V4FNMADDPS FCML_TEXT("v4fnmaddps") +#define M_V4FNMADDSS FCML_TEXT("v4fnmaddss") +#define M_VADDPD FCML_TEXT("vaddpd") +#define M_VADDPS FCML_TEXT("vaddps") +#define M_VADDSD FCML_TEXT("vaddsd") +#define M_VADDSS FCML_TEXT("vaddss") +#define M_VADDSUBPD FCML_TEXT("vaddsubpd") +#define M_VADDSUBPS FCML_TEXT("vaddsubps") +#define M_VAESDEC FCML_TEXT("vaesdec") +#define M_VAESDECLAST FCML_TEXT("vaesdeclast") +#define M_VAESENC FCML_TEXT("vaesenc") +#define M_VAESENCLAST FCML_TEXT("vaesenclast") +#define M_VAESIMC FCML_TEXT("vaesimc") +#define M_VAESKEYGENASSIST FCML_TEXT("vaeskeygenassist") +#define M_VALIGND FCML_TEXT("valignd") +#define M_VALIGNQ FCML_TEXT("valignq") +#define M_VANDNPD FCML_TEXT("vandnpd") +#define M_VANDNPS FCML_TEXT("vandnps") +#define M_VANDPD FCML_TEXT("vandpd") +#define M_VANDPS FCML_TEXT("vandps") +#define M_VBLENDMPD FCML_TEXT("vblendmpd") +#define M_VBLENDMPS FCML_TEXT("vblendmps") +#define M_VBLENDPD FCML_TEXT("vblendpd") +#define M_VBLENDPS FCML_TEXT("vblendps") +#define M_VBLENDVPD FCML_TEXT("vblendvpd") +#define M_VBLENDVPS FCML_TEXT("vblendvps") +#define M_VBROADCASTF128 FCML_TEXT("vbroadcastf128") +#define M_VBROADCASTF32X2 FCML_TEXT("vbroadcastf32x2") +#define M_VBROADCASTF32X4 FCML_TEXT("vbroadcastf32x4") +#define M_VBROADCASTF32X8 FCML_TEXT("vbroadcastf32x8") +#define M_VBROADCASTF64X2 FCML_TEXT("vbroadcastf64x2") +#define M_VBROADCASTF64X4 FCML_TEXT("vbroadcastf64x4") +#define M_VBROADCASTI128 FCML_TEXT("vbroadcasti128") +#define M_VBROADCASTI32X2 FCML_TEXT("vbroadcasti32x2") +#define M_VBROADCASTI32X4 FCML_TEXT("vbroadcasti32x4") +#define M_VBROADCASTI32X8 FCML_TEXT("vbroadcasti32x8") +#define M_VBROADCASTI64X2 FCML_TEXT("vbroadcasti64x2") +#define M_VBROADCASTI64X4 FCML_TEXT("vbroadcasti64x4") +#define M_VBROADCASTSD FCML_TEXT("vbroadcastsd") +#define M_VBROADCASTSS FCML_TEXT("vbroadcastss") +#define M_VCMPEQ_OSPD FCML_TEXT("vcmpeq_ospd") +#define M_VCMPEQ_OSPS FCML_TEXT("vcmpeq_osps") +#define M_VCMPEQ_OSSD FCML_TEXT("vcmpeq_ossd") +#define M_VCMPEQ_OSSS FCML_TEXT("vcmpeq_osss") +#define M_VCMPEQ_UQPD FCML_TEXT("vcmpeq_uqpd") +#define M_VCMPEQ_UQPS FCML_TEXT("vcmpeq_uqps") +#define M_VCMPEQ_UQSD FCML_TEXT("vcmpeq_uqsd") +#define M_VCMPEQ_UQSS FCML_TEXT("vcmpeq_uqss") +#define M_VCMPEQ_USPD FCML_TEXT("vcmpeq_uspd") +#define M_VCMPEQ_USPS FCML_TEXT("vcmpeq_usps") +#define M_VCMPEQ_USSD FCML_TEXT("vcmpeq_ussd") +#define M_VCMPEQ_USSS FCML_TEXT("vcmpeq_usss") +#define M_VCMPEQPD FCML_TEXT("vcmpeqpd") +#define M_VCMPEQPS FCML_TEXT("vcmpeqps") +#define M_VCMPEQSD FCML_TEXT("vcmpeqsd") +#define M_VCMPEQSS FCML_TEXT("vcmpeqss") +#define M_VCMPFALSE_OSPD FCML_TEXT("vcmpfalse_ospd") +#define M_VCMPFALSE_OSPS FCML_TEXT("vcmpfalse_osps") +#define M_VCMPFALSE_OSSD FCML_TEXT("vcmpfalse_ossd") +#define M_VCMPFALSE_OSSS FCML_TEXT("vcmpfalse_osss") +#define M_VCMPFALSEPD FCML_TEXT("vcmpfalsepd") +#define M_VCMPFALSEPS FCML_TEXT("vcmpfalseps") +#define M_VCMPFALSESD FCML_TEXT("vcmpfalsesd") +#define M_VCMPFALSESS FCML_TEXT("vcmpfalsess") +#define M_VCMPGE_OQPD FCML_TEXT("vcmpge_oqpd") +#define M_VCMPGE_OQPS FCML_TEXT("vcmpge_oqps") +#define M_VCMPGE_OQSD FCML_TEXT("vcmpge_oqsd") +#define M_VCMPGE_OQSS FCML_TEXT("vcmpge_oqss") +#define M_VCMPGEPD FCML_TEXT("vcmpgepd") +#define M_VCMPGEPS FCML_TEXT("vcmpgeps") +#define M_VCMPGESD FCML_TEXT("vcmpgesd") +#define M_VCMPGESS FCML_TEXT("vcmpgess") +#define M_VCMPGT_OQPD FCML_TEXT("vcmpgt_oqpd") +#define M_VCMPGT_OQPS FCML_TEXT("vcmpgt_oqps") +#define M_VCMPGT_OQSD FCML_TEXT("vcmpgt_oqsd") +#define M_VCMPGT_OQSS FCML_TEXT("vcmpgt_oqss") +#define M_VCMPGTPD FCML_TEXT("vcmpgtpd") +#define M_VCMPGTPS FCML_TEXT("vcmpgtps") +#define M_VCMPGTSD FCML_TEXT("vcmpgtsd") +#define M_VCMPGTSS FCML_TEXT("vcmpgtss") +#define M_VCMPLE_OQPD FCML_TEXT("vcmple_oqpd") +#define M_VCMPLE_OQPS FCML_TEXT("vcmple_oqps") +#define M_VCMPLE_OQSD FCML_TEXT("vcmple_oqsd") +#define M_VCMPLE_OQSS FCML_TEXT("vcmple_oqss") +#define M_VCMPLEPD FCML_TEXT("vcmplepd") +#define M_VCMPLEPS FCML_TEXT("vcmpleps") +#define M_VCMPLESD FCML_TEXT("vcmplesd") +#define M_VCMPLESS FCML_TEXT("vcmpless") +#define M_VCMPLT_OQPD FCML_TEXT("vcmplt_oqpd") +#define M_VCMPLT_OQPS FCML_TEXT("vcmplt_oqps") +#define M_VCMPLT_OQSD FCML_TEXT("vcmplt_oqsd") +#define M_VCMPLT_OQSS FCML_TEXT("vcmplt_oqss") +#define M_VCMPLTPD FCML_TEXT("vcmpltpd") +#define M_VCMPLTPS FCML_TEXT("vcmpltps") +#define M_VCMPLTSD FCML_TEXT("vcmpltsd") +#define M_VCMPLTSS FCML_TEXT("vcmpltss") +#define M_VCMPNEQ_OQPD FCML_TEXT("vcmpneq_oqpd") +#define M_VCMPNEQ_OQPS FCML_TEXT("vcmpneq_oqps") +#define M_VCMPNEQ_OQSD FCML_TEXT("vcmpneq_oqsd") +#define M_VCMPNEQ_OQSS FCML_TEXT("vcmpneq_oqss") +#define M_VCMPNEQ_OSPD FCML_TEXT("vcmpneq_ospd") +#define M_VCMPNEQ_OSPS FCML_TEXT("vcmpneq_osps") +#define M_VCMPNEQ_OSSD FCML_TEXT("vcmpneq_ossd") +#define M_VCMPNEQ_OSSS FCML_TEXT("vcmpneq_osss") +#define M_VCMPNEQ_USPD FCML_TEXT("vcmpneq_uspd") +#define M_VCMPNEQ_USPS FCML_TEXT("vcmpneq_usps") +#define M_VCMPNEQ_USSD FCML_TEXT("vcmpneq_ussd") +#define M_VCMPNEQ_USSS FCML_TEXT("vcmpneq_usss") +#define M_VCMPNEQPD FCML_TEXT("vcmpneqpd") +#define M_VCMPNEQPS FCML_TEXT("vcmpneqps") +#define M_VCMPNEQSD FCML_TEXT("vcmpneqsd") +#define M_VCMPNEQSS FCML_TEXT("vcmpneqss") +#define M_VCMPNGE_UQPD FCML_TEXT("vcmpnge_uqpd") +#define M_VCMPNGE_UQPS FCML_TEXT("vcmpnge_uqps") +#define M_VCMPNGE_UQSD FCML_TEXT("vcmpnge_uqsd") +#define M_VCMPNGE_UQSS FCML_TEXT("vcmpnge_uqss") +#define M_VCMPNGEPD FCML_TEXT("vcmpngepd") +#define M_VCMPNGEPS FCML_TEXT("vcmpngeps") +#define M_VCMPNGESD FCML_TEXT("vcmpngesd") +#define M_VCMPNGESS FCML_TEXT("vcmpngess") +#define M_VCMPNGT_UQPD FCML_TEXT("vcmpngt_uqpd") +#define M_VCMPNGT_UQPS FCML_TEXT("vcmpngt_uqps") +#define M_VCMPNGT_UQSD FCML_TEXT("vcmpngt_uqsd") +#define M_VCMPNGT_UQSS FCML_TEXT("vcmpngt_uqss") +#define M_VCMPNGTPD FCML_TEXT("vcmpngtpd") +#define M_VCMPNGTPS FCML_TEXT("vcmpngtps") +#define M_VCMPNGTSD FCML_TEXT("vcmpngtsd") +#define M_VCMPNGTSS FCML_TEXT("vcmpngtss") +#define M_VCMPNLE_UQPD FCML_TEXT("vcmpnle_uqpd") +#define M_VCMPNLE_UQPS FCML_TEXT("vcmpnle_uqps") +#define M_VCMPNLE_UQSD FCML_TEXT("vcmpnle_uqsd") +#define M_VCMPNLE_UQSS FCML_TEXT("vcmpnle_uqss") +#define M_VCMPNLEPD FCML_TEXT("vcmpnlepd") +#define M_VCMPNLEPS FCML_TEXT("vcmpnleps") +#define M_VCMPNLESD FCML_TEXT("vcmpnlesd") +#define M_VCMPNLESS FCML_TEXT("vcmpnless") +#define M_VCMPNLT_UQPD FCML_TEXT("vcmpnlt_uqpd") +#define M_VCMPNLT_UQPS FCML_TEXT("vcmpnlt_uqps") +#define M_VCMPNLT_UQSD FCML_TEXT("vcmpnlt_uqsd") +#define M_VCMPNLT_UQSS FCML_TEXT("vcmpnlt_uqss") +#define M_VCMPNLTPD FCML_TEXT("vcmpnltpd") +#define M_VCMPNLTPS FCML_TEXT("vcmpnltps") +#define M_VCMPNLTSD FCML_TEXT("vcmpnltsd") +#define M_VCMPNLTSS FCML_TEXT("vcmpnltss") +#define M_VCMPORD_SPD FCML_TEXT("vcmpord_spd") +#define M_VCMPORD_SPS FCML_TEXT("vcmpord_sps") +#define M_VCMPORD_SSD FCML_TEXT("vcmpord_ssd") +#define M_VCMPORD_SSS FCML_TEXT("vcmpord_sss") +#define M_VCMPORDPD FCML_TEXT("vcmpordpd") +#define M_VCMPORDPS FCML_TEXT("vcmpordps") +#define M_VCMPORDSD FCML_TEXT("vcmpordsd") +#define M_VCMPORDSS FCML_TEXT("vcmpordss") +#define M_VCMPPD FCML_TEXT("vcmppd") +#define M_VCMPPS FCML_TEXT("vcmpps") +#define M_VCMPSD FCML_TEXT("vcmpsd") +#define M_VCMPSS FCML_TEXT("vcmpss") +#define M_VCMPTRUE_USPD FCML_TEXT("vcmptrue_uspd") +#define M_VCMPTRUE_USPS FCML_TEXT("vcmptrue_usps") +#define M_VCMPTRUE_USSD FCML_TEXT("vcmptrue_ussd") +#define M_VCMPTRUE_USSS FCML_TEXT("vcmptrue_usss") +#define M_VCMPTRUEPD FCML_TEXT("vcmptruepd") +#define M_VCMPTRUEPS FCML_TEXT("vcmptrueps") +#define M_VCMPTRUESD FCML_TEXT("vcmptruesd") +#define M_VCMPTRUESS FCML_TEXT("vcmptruess") +#define M_VCMPUNORD_SPD FCML_TEXT("vcmpunord_spd") +#define M_VCMPUNORD_SPS FCML_TEXT("vcmpunord_sps") +#define M_VCMPUNORD_SSD FCML_TEXT("vcmpunord_ssd") +#define M_VCMPUNORD_SSS FCML_TEXT("vcmpunord_sss") +#define M_VCMPUNORDPD FCML_TEXT("vcmpunordpd") +#define M_VCMPUNORDPS FCML_TEXT("vcmpunordps") +#define M_VCMPUNORDSD FCML_TEXT("vcmpunordsd") +#define M_VCMPUNORDSS FCML_TEXT("vcmpunordss") +#define M_VCOMISD FCML_TEXT("vcomisd") +#define M_VCOMISS FCML_TEXT("vcomiss") +#define M_VCOMPRESSPD FCML_TEXT("vcompresspd") +#define M_VCOMPRESSPS FCML_TEXT("vcompressps") +#define M_VCVTDQ2PD FCML_TEXT("vcvtdq2pd") +#define M_VCVTDQ2PS FCML_TEXT("vcvtdq2ps") +#define M_VCVTPD2DQ FCML_TEXT("vcvtpd2dq") +#define M_VCVTPD2DQX FCML_TEXT("vcvtpd2dqx") +#define M_VCVTPD2DQY FCML_TEXT("vcvtpd2dqy") +#define M_VCVTPD2PS FCML_TEXT("vcvtpd2ps") +#define M_VCVTPD2PSX FCML_TEXT("vcvtpd2psx") +#define M_VCVTPD2PSY FCML_TEXT("vcvtpd2psy") +#define M_VCVTPD2QQ FCML_TEXT("vcvtpd2qq") +#define M_VCVTPD2UDQ FCML_TEXT("vcvtpd2udq") +#define M_VCVTPD2UDQX FCML_TEXT("vcvtpd2udqx") +#define M_VCVTPD2UDQY FCML_TEXT("vcvtpd2udqy") +#define M_VCVTPD2UQQ FCML_TEXT("vcvtpd2uqq") +#define M_VCVTPH2PS FCML_TEXT("vcvtph2ps") +#define M_VCVTPS2DQ FCML_TEXT("vcvtps2dq") +#define M_VCVTPS2PD FCML_TEXT("vcvtps2pd") +#define M_VCVTPS2PH FCML_TEXT("vcvtps2ph") +#define M_VCVTPS2QQ FCML_TEXT("vcvtps2qq") +#define M_VCVTPS2UDQ FCML_TEXT("vcvtps2udq") +#define M_VCVTPS2UQQ FCML_TEXT("vcvtps2uqq") +#define M_VCVTQQ2PD FCML_TEXT("vcvtqq2pd") +#define M_VCVTQQ2PS FCML_TEXT("vcvtqq2ps") +#define M_VCVTQQ2PSX FCML_TEXT("vcvtqq2psx") +#define M_VCVTQQ2PSY FCML_TEXT("vcvtqq2psy") +#define M_VCVTSD2SI FCML_TEXT("vcvtsd2si") +#define M_VCVTSD2SS FCML_TEXT("vcvtsd2ss") +#define M_VCVTSD2USI FCML_TEXT("vcvtsd2usi") +#define M_VCVTSI2SDL FCML_TEXT("vcvtsi2sdl") +#define M_VCVTSI2SDQ FCML_TEXT("vcvtsi2sdq") +#define M_VCVTSI2SSL FCML_TEXT("vcvtsi2ssl") +#define M_VCVTSI2SSQ FCML_TEXT("vcvtsi2ssq") +#define M_VCVTSS2SD FCML_TEXT("vcvtss2sd") +#define M_VCVTSS2SI FCML_TEXT("vcvtss2si") +#define M_VCVTSS2USI FCML_TEXT("vcvtss2usi") +#define M_VCVTTPD2DQ FCML_TEXT("vcvttpd2dq") +#define M_VCVTTPD2DQX FCML_TEXT("vcvttpd2dqx") +#define M_VCVTTPD2DQY FCML_TEXT("vcvttpd2dqy") +#define M_VCVTTPD2QQ FCML_TEXT("vcvttpd2qq") +#define M_VCVTTPD2UDQ FCML_TEXT("vcvttpd2udq") +#define M_VCVTTPD2UDQX FCML_TEXT("vcvttpd2udqx") +#define M_VCVTTPD2UDQY FCML_TEXT("vcvttpd2udqy") +#define M_VCVTTPD2UQQ FCML_TEXT("vcvttpd2uqq") +#define M_VCVTTPS2DQ FCML_TEXT("vcvttps2dq") +#define M_VCVTTPS2QQ FCML_TEXT("vcvttps2qq") +#define M_VCVTTPS2UDQ FCML_TEXT("vcvttps2udq") +#define M_VCVTTPS2UQQ FCML_TEXT("vcvttps2uqq") +#define M_VCVTTSD2SI FCML_TEXT("vcvttsd2si") +#define M_VCVTTSD2USI FCML_TEXT("vcvttsd2usi") +#define M_VCVTTSS2SI FCML_TEXT("vcvttss2si") +#define M_VCVTTSS2USI FCML_TEXT("vcvttss2usi") +#define M_VCVTUDQ2PD FCML_TEXT("vcvtudq2pd") +#define M_VCVTUDQ2PS FCML_TEXT("vcvtudq2ps") +#define M_VCVTUQQ2PD FCML_TEXT("vcvtuqq2pd") +#define M_VCVTUQQ2PS FCML_TEXT("vcvtuqq2ps") +#define M_VCVTUQQ2PSX FCML_TEXT("vcvtuqq2psx") +#define M_VCVTUQQ2PSY FCML_TEXT("vcvtuqq2psy") +#define M_VCVTUSI2SD FCML_TEXT("vcvtusi2sd") +#define M_VCVTUSI2SS FCML_TEXT("vcvtusi2ss") +#define M_VDBPSADBW FCML_TEXT("vdbpsadbw") +#define M_VDIVPD FCML_TEXT("vdivpd") +#define M_VDIVPS FCML_TEXT("vdivps") +#define M_VDIVSD FCML_TEXT("vdivsd") +#define M_VDIVSS FCML_TEXT("vdivss") +#define M_VDPPD FCML_TEXT("vdppd") +#define M_VDPPS FCML_TEXT("vdpps") +#define M_VERR FCML_TEXT("verr") +#define M_VERW FCML_TEXT("verw") +#define M_VEXP2PD FCML_TEXT("vexp2pd") +#define M_VEXP2PS FCML_TEXT("vexp2ps") +#define M_VEXPANDPD FCML_TEXT("vexpandpd") +#define M_VEXPANDPS FCML_TEXT("vexpandps") +#define M_VEXTRACTF128 FCML_TEXT("vextractf128") +#define M_VEXTRACTF32X4 FCML_TEXT("vextractf32x4") +#define M_VEXTRACTF32X8 FCML_TEXT("vextractf32x8") +#define M_VEXTRACTF64X2 FCML_TEXT("vextractf64x2") +#define M_VEXTRACTF64X4 FCML_TEXT("vextractf64x4") +#define M_VEXTRACTI128 FCML_TEXT("vextracti128") +#define M_VEXTRACTI32X4 FCML_TEXT("vextracti32x4") +#define M_VEXTRACTI32X8 FCML_TEXT("vextracti32x8") +#define M_VEXTRACTI64X2 FCML_TEXT("vextracti64x2") +#define M_VEXTRACTI64X4 FCML_TEXT("vextracti64x4") +#define M_VEXTRACTPS FCML_TEXT("vextractps") +#define M_VFIXUPIMMPD FCML_TEXT("vfixupimmpd") +#define M_VFIXUPIMMPS FCML_TEXT("vfixupimmps") +#define M_VFIXUPIMMSD FCML_TEXT("vfixupimmsd") +#define M_VFIXUPIMMSS FCML_TEXT("vfixupimmss") +#define M_VFMADD132PD FCML_TEXT("vfmadd132pd") +#define M_VFMADD132PS FCML_TEXT("vfmadd132ps") +#define M_VFMADD132SD FCML_TEXT("vfmadd132sd") +#define M_VFMADD132SS FCML_TEXT("vfmadd132ss") +#define M_VFMADD213PD FCML_TEXT("vfmadd213pd") +#define M_VFMADD213PS FCML_TEXT("vfmadd213ps") +#define M_VFMADD213SD FCML_TEXT("vfmadd213sd") +#define M_VFMADD213SS FCML_TEXT("vfmadd213ss") +#define M_VFMADD231PD FCML_TEXT("vfmadd231pd") +#define M_VFMADD231PS FCML_TEXT("vfmadd231ps") +#define M_VFMADD231SD FCML_TEXT("vfmadd231sd") +#define M_VFMADD231SS FCML_TEXT("vfmadd231ss") +#define M_VFMADDPD FCML_TEXT("vfmaddpd") +#define M_VFMADDPS FCML_TEXT("vfmaddps") +#define M_VFMADDSD FCML_TEXT("vfmaddsd") +#define M_VFMADDSS FCML_TEXT("vfmaddss") +#define M_VFMADDSUB132PD FCML_TEXT("vfmaddsub132pd") +#define M_VFMADDSUB132PS FCML_TEXT("vfmaddsub132ps") +#define M_VFMADDSUB213PD FCML_TEXT("vfmaddsub213pd") +#define M_VFMADDSUB213PS FCML_TEXT("vfmaddsub213ps") +#define M_VFMADDSUB231PD FCML_TEXT("vfmaddsub231pd") +#define M_VFMADDSUB231PS FCML_TEXT("vfmaddsub231ps") +#define M_VFMADDSUBPD FCML_TEXT("vfmaddsubpd") +#define M_VFMADDSUBPS FCML_TEXT("vfmaddsubps") +#define M_VFMSUB132PD FCML_TEXT("vfmsub132pd") +#define M_VFMSUB132PS FCML_TEXT("vfmsub132ps") +#define M_VFMSUB132SD FCML_TEXT("vfmsub132sd") +#define M_VFMSUB132SS FCML_TEXT("vfmsub132ss") +#define M_VFMSUB213PD FCML_TEXT("vfmsub213pd") +#define M_VFMSUB213PS FCML_TEXT("vfmsub213ps") +#define M_VFMSUB213SD FCML_TEXT("vfmsub213sd") +#define M_VFMSUB213SS FCML_TEXT("vfmsub213ss") +#define M_VFMSUB231PD FCML_TEXT("vfmsub231pd") +#define M_VFMSUB231PS FCML_TEXT("vfmsub231ps") +#define M_VFMSUB231SD FCML_TEXT("vfmsub231sd") +#define M_VFMSUB231SS FCML_TEXT("vfmsub231ss") +#define M_VFMSUBADD132PD FCML_TEXT("vfmsubadd132pd") +#define M_VFMSUBADD132PS FCML_TEXT("vfmsubadd132ps") +#define M_VFMSUBADD213PD FCML_TEXT("vfmsubadd213pd") +#define M_VFMSUBADD213PS FCML_TEXT("vfmsubadd213ps") +#define M_VFMSUBADD231PD FCML_TEXT("vfmsubadd231pd") +#define M_VFMSUBADD231PS FCML_TEXT("vfmsubadd231ps") +#define M_VFMSUBADDPD FCML_TEXT("vfmsubaddpd") +#define M_VFMSUBADDPS FCML_TEXT("vfmsubaddps") +#define M_VFMSUBPD FCML_TEXT("vfmsubpd") +#define M_VFMSUBPS FCML_TEXT("vfmsubps") +#define M_VFMSUBSD FCML_TEXT("vfmsubsd") +#define M_VFMSUBSS FCML_TEXT("vfmsubss") +#define M_VFNMADD132PD FCML_TEXT("vfnmadd132pd") +#define M_VFNMADD132PS FCML_TEXT("vfnmadd132ps") +#define M_VFNMADD132SD FCML_TEXT("vfnmadd132sd") +#define M_VFNMADD132SS FCML_TEXT("vfnmadd132ss") +#define M_VFNMADD213PD FCML_TEXT("vfnmadd213pd") +#define M_VFNMADD213PS FCML_TEXT("vfnmadd213ps") +#define M_VFNMADD213SD FCML_TEXT("vfnmadd213sd") +#define M_VFNMADD213SS FCML_TEXT("vfnmadd213ss") +#define M_VFNMADD231PD FCML_TEXT("vfnmadd231pd") +#define M_VFNMADD231PS FCML_TEXT("vfnmadd231ps") +#define M_VFNMADD231SD FCML_TEXT("vfnmadd231sd") +#define M_VFNMADD231SS FCML_TEXT("vfnmadd231ss") +#define M_VFNMADDPD FCML_TEXT("vfnmaddpd") +#define M_VFNMADDPS FCML_TEXT("vfnmaddps") +#define M_VFNMADDSD FCML_TEXT("vfnmaddsd") +#define M_VFNMADDSS FCML_TEXT("vfnmaddss") +#define M_VFNMSUB132PD FCML_TEXT("vfnmsub132pd") +#define M_VFNMSUB132PS FCML_TEXT("vfnmsub132ps") +#define M_VFNMSUB132SD FCML_TEXT("vfnmsub132sd") +#define M_VFNMSUB132SS FCML_TEXT("vfnmsub132ss") +#define M_VFNMSUB213PD FCML_TEXT("vfnmsub213pd") +#define M_VFNMSUB213PS FCML_TEXT("vfnmsub213ps") +#define M_VFNMSUB213SD FCML_TEXT("vfnmsub213sd") +#define M_VFNMSUB213SS FCML_TEXT("vfnmsub213ss") +#define M_VFNMSUB231PD FCML_TEXT("vfnmsub231pd") +#define M_VFNMSUB231PS FCML_TEXT("vfnmsub231ps") +#define M_VFNMSUB231SD FCML_TEXT("vfnmsub231sd") +#define M_VFNMSUB231SS FCML_TEXT("vfnmsub231ss") +#define M_VFNMSUBPD FCML_TEXT("vfnmsubpd") +#define M_VFNMSUBPS FCML_TEXT("vfnmsubps") +#define M_VFNMSUBSD FCML_TEXT("vfnmsubsd") +#define M_VFNMSUBSS FCML_TEXT("vfnmsubss") +#define M_VFPCLASSPD FCML_TEXT("vfpclasspd") +#define M_VFPCLASSPS FCML_TEXT("vfpclassps") +#define M_VFPCLASSSD FCML_TEXT("vfpclasssd") +#define M_VFPCLASSSS FCML_TEXT("vfpclassss") +#define M_VFRCZPD FCML_TEXT("vfrczpd") +#define M_VFRCZPS FCML_TEXT("vfrczps") +#define M_VFRCZSD FCML_TEXT("vfrczsd") +#define M_VFRCZSS FCML_TEXT("vfrczss") +#define M_VGATHERDPD FCML_TEXT("vgatherdpd") +#define M_VGATHERDPS FCML_TEXT("vgatherdps") +#define M_VGATHERPF0DPD FCML_TEXT("vgatherpf0dpd") +#define M_VGATHERPF0DPS FCML_TEXT("vgatherpf0dps") +#define M_VGATHERPF0QPD FCML_TEXT("vgatherpf0qpd") +#define M_VGATHERPF0QPS FCML_TEXT("vgatherpf0qps") +#define M_VGATHERPF1DPD FCML_TEXT("vgatherpf1dpd") +#define M_VGATHERPF1DPS FCML_TEXT("vgatherpf1dps") +#define M_VGATHERPF1QPD FCML_TEXT("vgatherpf1qpd") +#define M_VGATHERPF1QPS FCML_TEXT("vgatherpf1qps") +#define M_VGATHERQPD FCML_TEXT("vgatherqpd") +#define M_VGATHERQPS FCML_TEXT("vgatherqps") +#define M_VGETEXPPD FCML_TEXT("vgetexppd") +#define M_VGETEXPPS FCML_TEXT("vgetexpps") +#define M_VGETEXPSD FCML_TEXT("vgetexpsd") +#define M_VGETEXPSS FCML_TEXT("vgetexpss") +#define M_VGETMANTPD FCML_TEXT("vgetmantpd") +#define M_VGETMANTPS FCML_TEXT("vgetmantps") +#define M_VGETMANTSD FCML_TEXT("vgetmantsd") +#define M_VGETMANTSS FCML_TEXT("vgetmantss") +#define M_VHADDPD FCML_TEXT("vhaddpd") +#define M_VHADDPS FCML_TEXT("vhaddps") +#define M_VHSUBPD FCML_TEXT("vhsubpd") +#define M_VHSUBPS FCML_TEXT("vhsubps") +#define M_VINSERTF128 FCML_TEXT("vinsertf128") +#define M_VINSERTF32X4 FCML_TEXT("vinsertf32x4") +#define M_VINSERTF32X8 FCML_TEXT("vinsertf32x8") +#define M_VINSERTF64X2 FCML_TEXT("vinsertf64x2") +#define M_VINSERTF64X4 FCML_TEXT("vinsertf64x4") +#define M_VINSERTI128 FCML_TEXT("vinserti128") +#define M_VINSERTI32X4 FCML_TEXT("vinserti32x4") +#define M_VINSERTI32X8 FCML_TEXT("vinserti32x8") +#define M_VINSERTI64X2 FCML_TEXT("vinserti64x2") +#define M_VINSERTI64X4 FCML_TEXT("vinserti64x4") +#define M_VINSERTPS FCML_TEXT("vinsertps") +#define M_VLDDQU FCML_TEXT("vlddqu") +#define M_VLDMXCSR FCML_TEXT("vldmxcsr") +#define M_VMASKMOVDQU FCML_TEXT("vmaskmovdqu") +#define M_VMASKMOVPD FCML_TEXT("vmaskmovpd") +#define M_VMASKMOVPS FCML_TEXT("vmaskmovps") +#define M_VMAXPD FCML_TEXT("vmaxpd") +#define M_VMAXPS FCML_TEXT("vmaxps") +#define M_VMAXSD FCML_TEXT("vmaxsd") +#define M_VMAXSS FCML_TEXT("vmaxss") +#define M_VMCALL FCML_TEXT("vmcall") +#define M_VMCLEAR FCML_TEXT("vmclear") +#define M_VMFUNC FCML_TEXT("vmfunc") +#define M_VMINPD FCML_TEXT("vminpd") +#define M_VMINPS FCML_TEXT("vminps") +#define M_VMINSD FCML_TEXT("vminsd") +#define M_VMINSS FCML_TEXT("vminss") +#define M_VMLAUNCH FCML_TEXT("vmlaunch") +#define M_VMLOAD FCML_TEXT("vmload") +#define M_VMMCALL FCML_TEXT("vmmcall") +#define M_VMOVAPD FCML_TEXT("vmovapd") +#define M_VMOVAPS FCML_TEXT("vmovaps") +#define M_VMOVD FCML_TEXT("vmovd") +#define M_VMOVDDUP FCML_TEXT("vmovddup") +#define M_VMOVDQA FCML_TEXT("vmovdqa") +#define M_VMOVDQA32 FCML_TEXT("vmovdqa32") +#define M_VMOVDQA64 FCML_TEXT("vmovdqa64") +#define M_VMOVDQU FCML_TEXT("vmovdqu") +#define M_VMOVDQU16 FCML_TEXT("vmovdqu16") +#define M_VMOVDQU32 FCML_TEXT("vmovdqu32") +#define M_VMOVDQU64 FCML_TEXT("vmovdqu64") +#define M_VMOVDQU8 FCML_TEXT("vmovdqu8") +#define M_VMOVHLPS FCML_TEXT("vmovhlps") +#define M_VMOVHPD FCML_TEXT("vmovhpd") +#define M_VMOVHPS FCML_TEXT("vmovhps") +#define M_VMOVLHPS FCML_TEXT("vmovlhps") +#define M_VMOVLPD FCML_TEXT("vmovlpd") +#define M_VMOVLPS FCML_TEXT("vmovlps") +#define M_VMOVMSKPD FCML_TEXT("vmovmskpd") +#define M_VMOVMSKPS FCML_TEXT("vmovmskps") +#define M_VMOVNTDQ FCML_TEXT("vmovntdq") +#define M_VMOVNTDQA FCML_TEXT("vmovntdqa") +#define M_VMOVNTPD FCML_TEXT("vmovntpd") +#define M_VMOVNTPS FCML_TEXT("vmovntps") +#define M_VMOVQ FCML_TEXT("vmovq") +#define M_VMOVSD FCML_TEXT("vmovsd") +#define M_VMOVSHDUP FCML_TEXT("vmovshdup") +#define M_VMOVSLDUP FCML_TEXT("vmovsldup") +#define M_VMOVSS FCML_TEXT("vmovss") +#define M_VMOVUPD FCML_TEXT("vmovupd") +#define M_VMOVUPS FCML_TEXT("vmovups") +#define M_VMPSADBW FCML_TEXT("vmpsadbw") +#define M_VMPTRLD FCML_TEXT("vmptrld") +#define M_VMPTRST FCML_TEXT("vmptrst") +#define M_VMREAD FCML_TEXT("vmread") +#define M_VMRESUME FCML_TEXT("vmresume") +#define M_VMRUN FCML_TEXT("vmrun") +#define M_VMSAVE FCML_TEXT("vmsave") +#define M_VMULPD FCML_TEXT("vmulpd") +#define M_VMULPS FCML_TEXT("vmulps") +#define M_VMULSD FCML_TEXT("vmulsd") +#define M_VMULSS FCML_TEXT("vmulss") +#define M_VMWRITE FCML_TEXT("vmwrite") +#define M_VMXOFF FCML_TEXT("vmxoff") +#define M_VMXON FCML_TEXT("vmxon") +#define M_VORPD FCML_TEXT("vorpd") +#define M_VORPS FCML_TEXT("vorps") +#define M_VP4DPWSSD FCML_TEXT("vp4dpwssd") +#define M_VP4DPWSSDS FCML_TEXT("vp4dpwssds") +#define M_VPABSB FCML_TEXT("vpabsb") +#define M_VPABSD FCML_TEXT("vpabsd") +#define M_VPABSQ FCML_TEXT("vpabsq") +#define M_VPABSW FCML_TEXT("vpabsw") +#define M_VPACKSSDW FCML_TEXT("vpackssdw") +#define M_VPACKSSWB FCML_TEXT("vpacksswb") +#define M_VPACKUSDW FCML_TEXT("vpackusdw") +#define M_VPACKUSWB FCML_TEXT("vpackuswb") +#define M_VPADDB FCML_TEXT("vpaddb") +#define M_VPADDD FCML_TEXT("vpaddd") +#define M_VPADDQ FCML_TEXT("vpaddq") +#define M_VPADDSB FCML_TEXT("vpaddsb") +#define M_VPADDSW FCML_TEXT("vpaddsw") +#define M_VPADDUSB FCML_TEXT("vpaddusb") +#define M_VPADDUSW FCML_TEXT("vpaddusw") +#define M_VPADDW FCML_TEXT("vpaddw") +#define M_VPALIGNR FCML_TEXT("vpalignr") +#define M_VPAND FCML_TEXT("vpand") +#define M_VPANDD FCML_TEXT("vpandd") +#define M_VPANDN FCML_TEXT("vpandn") +#define M_VPANDND FCML_TEXT("vpandnd") +#define M_VPANDNQ FCML_TEXT("vpandnq") +#define M_VPANDQ FCML_TEXT("vpandq") +#define M_VPAVGB FCML_TEXT("vpavgb") +#define M_VPAVGW FCML_TEXT("vpavgw") +#define M_VPBLENDD FCML_TEXT("vpblendd") +#define M_VPBLENDMB FCML_TEXT("vpblendmb") +#define M_VPBLENDMD FCML_TEXT("vpblendmd") +#define M_VPBLENDMQ FCML_TEXT("vpblendmq") +#define M_VPBLENDMW FCML_TEXT("vpblendmw") +#define M_VPBLENDVB FCML_TEXT("vpblendvb") +#define M_VPBLENDW FCML_TEXT("vpblendw") +#define M_VPBROADCASTB FCML_TEXT("vpbroadcastb") +#define M_VPBROADCASTD FCML_TEXT("vpbroadcastd") +#define M_VPBROADCASTMB2Q FCML_TEXT("vpbroadcastmb2q") +#define M_VPBROADCASTMW2D FCML_TEXT("vpbroadcastmw2d") +#define M_VPBROADCASTQ FCML_TEXT("vpbroadcastq") +#define M_VPBROADCASTW FCML_TEXT("vpbroadcastw") +#define M_VPCLMULQDQ FCML_TEXT("vpclmulqdq") +#define M_VPCMOV FCML_TEXT("vpcmov") +#define M_VPCMPB FCML_TEXT("vpcmpb") +#define M_VPCMPD FCML_TEXT("vpcmpd") +#define M_VPCMPEQB FCML_TEXT("vpcmpeqb") +#define M_VPCMPEQD FCML_TEXT("vpcmpeqd") +#define M_VPCMPEQQ FCML_TEXT("vpcmpeqq") +#define M_VPCMPEQW FCML_TEXT("vpcmpeqw") +#define M_VPCMPESTRI FCML_TEXT("vpcmpestri") +#define M_VPCMPESTRM FCML_TEXT("vpcmpestrm") +#define M_VPCMPGTB FCML_TEXT("vpcmpgtb") +#define M_VPCMPGTD FCML_TEXT("vpcmpgtd") +#define M_VPCMPGTQ FCML_TEXT("vpcmpgtq") +#define M_VPCMPGTW FCML_TEXT("vpcmpgtw") +#define M_VPCMPISTRI FCML_TEXT("vpcmpistri") +#define M_VPCMPISTRM FCML_TEXT("vpcmpistrm") +#define M_VPCMPQ FCML_TEXT("vpcmpq") +#define M_VPCMPUB FCML_TEXT("vpcmpub") +#define M_VPCMPUD FCML_TEXT("vpcmpud") +#define M_VPCMPUQ FCML_TEXT("vpcmpuq") +#define M_VPCMPUW FCML_TEXT("vpcmpuw") +#define M_VPCMPW FCML_TEXT("vpcmpw") +#define M_VPCOMB FCML_TEXT("vpcomb") +#define M_VPCOMD FCML_TEXT("vpcomd") +#define M_VPCOMEQB FCML_TEXT("vpcomeqb") +#define M_VPCOMEQD FCML_TEXT("vpcomeqd") +#define M_VPCOMEQQ FCML_TEXT("vpcomeqq") +#define M_VPCOMEQUB FCML_TEXT("vpcomequb") +#define M_VPCOMEQUD FCML_TEXT("vpcomequd") +#define M_VPCOMEQUQ FCML_TEXT("vpcomequq") +#define M_VPCOMEQUW FCML_TEXT("vpcomequw") +#define M_VPCOMEQW FCML_TEXT("vpcomeqw") +#define M_VPCOMFALSEB FCML_TEXT("vpcomfalseb") +#define M_VPCOMFALSED FCML_TEXT("vpcomfalsed") +#define M_VPCOMFALSEQ FCML_TEXT("vpcomfalseq") +#define M_VPCOMFALSEUB FCML_TEXT("vpcomfalseub") +#define M_VPCOMFALSEUD FCML_TEXT("vpcomfalseud") +#define M_VPCOMFALSEUQ FCML_TEXT("vpcomfalseuq") +#define M_VPCOMFALSEUW FCML_TEXT("vpcomfalseuw") +#define M_VPCOMFALSEW FCML_TEXT("vpcomfalsew") +#define M_VPCOMGEB FCML_TEXT("vpcomgeb") +#define M_VPCOMGED FCML_TEXT("vpcomged") +#define M_VPCOMGEQ FCML_TEXT("vpcomgeq") +#define M_VPCOMGEUB FCML_TEXT("vpcomgeub") +#define M_VPCOMGEUD FCML_TEXT("vpcomgeud") +#define M_VPCOMGEUQ FCML_TEXT("vpcomgeuq") +#define M_VPCOMGEUW FCML_TEXT("vpcomgeuw") +#define M_VPCOMGEW FCML_TEXT("vpcomgew") +#define M_VPCOMGTB FCML_TEXT("vpcomgtb") +#define M_VPCOMGTD FCML_TEXT("vpcomgtd") +#define M_VPCOMGTQ FCML_TEXT("vpcomgtq") +#define M_VPCOMGTUB FCML_TEXT("vpcomgtub") +#define M_VPCOMGTUD FCML_TEXT("vpcomgtud") +#define M_VPCOMGTUQ FCML_TEXT("vpcomgtuq") +#define M_VPCOMGTUW FCML_TEXT("vpcomgtuw") +#define M_VPCOMGTW FCML_TEXT("vpcomgtw") +#define M_VPCOMLEB FCML_TEXT("vpcomleb") +#define M_VPCOMLED FCML_TEXT("vpcomled") +#define M_VPCOMLEQ FCML_TEXT("vpcomleq") +#define M_VPCOMLEUB FCML_TEXT("vpcomleub") +#define M_VPCOMLEUD FCML_TEXT("vpcomleud") +#define M_VPCOMLEUQ FCML_TEXT("vpcomleuq") +#define M_VPCOMLEUW FCML_TEXT("vpcomleuw") +#define M_VPCOMLEW FCML_TEXT("vpcomlew") +#define M_VPCOMLTB FCML_TEXT("vpcomltb") +#define M_VPCOMLTD FCML_TEXT("vpcomltd") +#define M_VPCOMLTQ FCML_TEXT("vpcomltq") +#define M_VPCOMLTUB FCML_TEXT("vpcomltub") +#define M_VPCOMLTUD FCML_TEXT("vpcomltud") +#define M_VPCOMLTUQ FCML_TEXT("vpcomltuq") +#define M_VPCOMLTUW FCML_TEXT("vpcomltuw") +#define M_VPCOMLTW FCML_TEXT("vpcomltw") +#define M_VPCOMNEQB FCML_TEXT("vpcomneqb") +#define M_VPCOMNEQD FCML_TEXT("vpcomneqd") +#define M_VPCOMNEQQ FCML_TEXT("vpcomneqq") +#define M_VPCOMNEQUB FCML_TEXT("vpcomnequb") +#define M_VPCOMNEQUD FCML_TEXT("vpcomnequd") +#define M_VPCOMNEQUQ FCML_TEXT("vpcomnequq") +#define M_VPCOMNEQUW FCML_TEXT("vpcomnequw") +#define M_VPCOMNEQW FCML_TEXT("vpcomneqw") +#define M_VPCOMPRESSD FCML_TEXT("vpcompressd") +#define M_VPCOMPRESSQ FCML_TEXT("vpcompressq") +#define M_VPCOMQ FCML_TEXT("vpcomq") +#define M_VPCOMTRUEB FCML_TEXT("vpcomtrueb") +#define M_VPCOMTRUED FCML_TEXT("vpcomtrued") +#define M_VPCOMTRUEQ FCML_TEXT("vpcomtrueq") +#define M_VPCOMTRUEUB FCML_TEXT("vpcomtrueub") +#define M_VPCOMTRUEUD FCML_TEXT("vpcomtrueud") +#define M_VPCOMTRUEUQ FCML_TEXT("vpcomtrueuq") +#define M_VPCOMTRUEUW FCML_TEXT("vpcomtrueuw") +#define M_VPCOMTRUEW FCML_TEXT("vpcomtruew") +#define M_VPCOMUB FCML_TEXT("vpcomub") +#define M_VPCOMUD FCML_TEXT("vpcomud") +#define M_VPCOMUQ FCML_TEXT("vpcomuq") +#define M_VPCOMUW FCML_TEXT("vpcomuw") +#define M_VPCOMW FCML_TEXT("vpcomw") +#define M_VPERM2F128 FCML_TEXT("vperm2f128") +#define M_VPERM2I128 FCML_TEXT("vperm2i128") +#define M_VPERMB FCML_TEXT("vpermb") +#define M_VPERMD FCML_TEXT("vpermd") +#define M_VPERMI2B FCML_TEXT("vpermi2b") +#define M_VPERMI2D FCML_TEXT("vpermi2d") +#define M_VPERMI2PD FCML_TEXT("vpermi2pd") +#define M_VPERMI2PS FCML_TEXT("vpermi2ps") +#define M_VPERMI2Q FCML_TEXT("vpermi2q") +#define M_VPERMI2W FCML_TEXT("vpermi2w") +#define M_VPERMIL2PD FCML_TEXT("vpermil2pd") +#define M_VPERMIL2PS FCML_TEXT("vpermil2ps") +#define M_VPERMILPD FCML_TEXT("vpermilpd") +#define M_VPERMILPS FCML_TEXT("vpermilps") +#define M_VPERMPD FCML_TEXT("vpermpd") +#define M_VPERMPS FCML_TEXT("vpermps") +#define M_VPERMQ FCML_TEXT("vpermq") +#define M_VPERMT2B FCML_TEXT("vpermt2b") +#define M_VPERMT2D FCML_TEXT("vpermt2d") +#define M_VPERMT2PD FCML_TEXT("vpermt2pd") +#define M_VPERMT2PS FCML_TEXT("vpermt2ps") +#define M_VPERMT2Q FCML_TEXT("vpermt2q") +#define M_VPERMT2W FCML_TEXT("vpermt2w") +#define M_VPERMW FCML_TEXT("vpermw") +#define M_VPEXPANDD FCML_TEXT("vpexpandd") +#define M_VPEXPANDQ FCML_TEXT("vpexpandq") +#define M_VPEXTRB FCML_TEXT("vpextrb") +#define M_VPEXTRD FCML_TEXT("vpextrd") +#define M_VPEXTRQ FCML_TEXT("vpextrq") +#define M_VPEXTRW FCML_TEXT("vpextrw") +#define M_VPGATHERDD FCML_TEXT("vpgatherdd") +#define M_VPGATHERDQ FCML_TEXT("vpgatherdq") +#define M_VPGATHERQD FCML_TEXT("vpgatherqd") +#define M_VPGATHERQQ FCML_TEXT("vpgatherqq") +#define M_VPHADDBD FCML_TEXT("vphaddbd") +#define M_VPHADDBQ FCML_TEXT("vphaddbq") +#define M_VPHADDBW FCML_TEXT("vphaddbw") +#define M_VPHADDD FCML_TEXT("vphaddd") +#define M_VPHADDDQ FCML_TEXT("vphadddq") +#define M_VPHADDSW FCML_TEXT("vphaddsw") +#define M_VPHADDUBD FCML_TEXT("vphaddubd") +#define M_VPHADDUBQ FCML_TEXT("vphaddubq") +#define M_VPHADDUBW FCML_TEXT("vphaddubw") +#define M_VPHADDUDQ FCML_TEXT("vphaddudq") +#define M_VPHADDUWD FCML_TEXT("vphadduwd") +#define M_VPHADDUWQ FCML_TEXT("vphadduwq") +#define M_VPHADDW FCML_TEXT("vphaddw") +#define M_VPHADDWD FCML_TEXT("vphaddwd") +#define M_VPHADDWQ FCML_TEXT("vphaddwq") +#define M_VPHMINPOSUW FCML_TEXT("vphminposuw") +#define M_VPHSUBBW FCML_TEXT("vphsubbw") +#define M_VPHSUBD FCML_TEXT("vphsubd") +#define M_VPHSUBDQ FCML_TEXT("vphsubdq") +#define M_VPHSUBSW FCML_TEXT("vphsubsw") +#define M_VPHSUBW FCML_TEXT("vphsubw") +#define M_VPHSUBWD FCML_TEXT("vphsubwd") +#define M_VPINSRB FCML_TEXT("vpinsrb") +#define M_VPINSRD FCML_TEXT("vpinsrd") +#define M_VPINSRQ FCML_TEXT("vpinsrq") +#define M_VPINSRW FCML_TEXT("vpinsrw") +#define M_VPLZCNTD FCML_TEXT("vplzcntd") +#define M_VPLZCNTQ FCML_TEXT("vplzcntq") +#define M_VPMACSDD FCML_TEXT("vpmacsdd") +#define M_VPMACSDQH FCML_TEXT("vpmacsdqh") +#define M_VPMACSDQL FCML_TEXT("vpmacsdql") +#define M_VPMACSSDD FCML_TEXT("vpmacssdd") +#define M_VPMACSSDQH FCML_TEXT("vpmacssdqh") +#define M_VPMACSSDQL FCML_TEXT("vpmacssdql") +#define M_VPMACSSWD FCML_TEXT("vpmacsswd") +#define M_VPMACSSWW FCML_TEXT("vpmacssww") +#define M_VPMACSWD FCML_TEXT("vpmacswd") +#define M_VPMACSWW FCML_TEXT("vpmacsww") +#define M_VPMADCSSWD FCML_TEXT("vpmadcsswd") +#define M_VPMADCSWD FCML_TEXT("vpmadcswd") +#define M_VPMADD52HUQ FCML_TEXT("vpmadd52huq") +#define M_VPMADD52LUQ FCML_TEXT("vpmadd52luq") +#define M_VPMADDUBSW FCML_TEXT("vpmaddubsw") +#define M_VPMADDWD FCML_TEXT("vpmaddwd") +#define M_VPMASKMOV FCML_TEXT("vpmaskmov") +#define M_VPMASKMOVD FCML_TEXT("vpmaskmovd") +#define M_VPMASKMOVQ FCML_TEXT("vpmaskmovq") +#define M_VPMAXSB FCML_TEXT("vpmaxsb") +#define M_VPMAXSD FCML_TEXT("vpmaxsd") +#define M_VPMAXSQ FCML_TEXT("vpmaxsq") +#define M_VPMAXSW FCML_TEXT("vpmaxsw") +#define M_VPMAXUB FCML_TEXT("vpmaxub") +#define M_VPMAXUD FCML_TEXT("vpmaxud") +#define M_VPMAXUQ FCML_TEXT("vpmaxuq") +#define M_VPMAXUW FCML_TEXT("vpmaxuw") +#define M_VPMINSB FCML_TEXT("vpminsb") +#define M_VPMINSD FCML_TEXT("vpminsd") +#define M_VPMINSQ FCML_TEXT("vpminsq") +#define M_VPMINSW FCML_TEXT("vpminsw") +#define M_VPMINUB FCML_TEXT("vpminub") +#define M_VPMINUD FCML_TEXT("vpminud") +#define M_VPMINUQ FCML_TEXT("vpminuq") +#define M_VPMINUW FCML_TEXT("vpminuw") +#define M_VPMOVB2M FCML_TEXT("vpmovb2m") +#define M_VPMOVD2M FCML_TEXT("vpmovd2m") +#define M_VPMOVDB FCML_TEXT("vpmovdb") +#define M_VPMOVDW FCML_TEXT("vpmovdw") +#define M_VPMOVM2B FCML_TEXT("vpmovm2b") +#define M_VPMOVM2D FCML_TEXT("vpmovm2d") +#define M_VPMOVM2Q FCML_TEXT("vpmovm2q") +#define M_VPMOVM2W FCML_TEXT("vpmovm2w") +#define M_VPMOVMSKB FCML_TEXT("vpmovmskb") +#define M_VPMOVQ2M FCML_TEXT("vpmovq2m") +#define M_VPMOVQB FCML_TEXT("vpmovqb") +#define M_VPMOVQD FCML_TEXT("vpmovqd") +#define M_VPMOVQW FCML_TEXT("vpmovqw") +#define M_VPMOVSDB FCML_TEXT("vpmovsdb") +#define M_VPMOVSDW FCML_TEXT("vpmovsdw") +#define M_VPMOVSQB FCML_TEXT("vpmovsqb") +#define M_VPMOVSQD FCML_TEXT("vpmovsqd") +#define M_VPMOVSQW FCML_TEXT("vpmovsqw") +#define M_VPMOVSWB FCML_TEXT("vpmovswb") +#define M_VPMOVSXBD FCML_TEXT("vpmovsxbd") +#define M_VPMOVSXBQ FCML_TEXT("vpmovsxbq") +#define M_VPMOVSXBW FCML_TEXT("vpmovsxbw") +#define M_VPMOVSXDQ FCML_TEXT("vpmovsxdq") +#define M_VPMOVSXWD FCML_TEXT("vpmovsxwd") +#define M_VPMOVSXWQ FCML_TEXT("vpmovsxwq") +#define M_VPMOVUSDB FCML_TEXT("vpmovusdb") +#define M_VPMOVUSDW FCML_TEXT("vpmovusdw") +#define M_VPMOVUSQB FCML_TEXT("vpmovusqb") +#define M_VPMOVUSQD FCML_TEXT("vpmovusqd") +#define M_VPMOVUSQW FCML_TEXT("vpmovusqw") +#define M_VPMOVUSWB FCML_TEXT("vpmovuswb") +#define M_VPMOVW2M FCML_TEXT("vpmovw2m") +#define M_VPMOVWB FCML_TEXT("vpmovwb") +#define M_VPMOVZXBD FCML_TEXT("vpmovzxbd") +#define M_VPMOVZXBQ FCML_TEXT("vpmovzxbq") +#define M_VPMOVZXBW FCML_TEXT("vpmovzxbw") +#define M_VPMOVZXDQ FCML_TEXT("vpmovzxdq") +#define M_VPMOVZXWD FCML_TEXT("vpmovzxwd") +#define M_VPMOVZXWQ FCML_TEXT("vpmovzxwq") +#define M_VPMULDQ FCML_TEXT("vpmuldq") +#define M_VPMULHRSW FCML_TEXT("vpmulhrsw") +#define M_VPMULHUW FCML_TEXT("vpmulhuw") +#define M_VPMULHW FCML_TEXT("vpmulhw") +#define M_VPMULLD FCML_TEXT("vpmulld") +#define M_VPMULLQ FCML_TEXT("vpmullq") +#define M_VPMULLW FCML_TEXT("vpmullw") +#define M_VPMULTISHIFTQB FCML_TEXT("vpmultishiftqb") +#define M_VPMULUDQ FCML_TEXT("vpmuludq") +#define M_VPOR FCML_TEXT("vpor") +#define M_VPORD FCML_TEXT("vpord") +#define M_VPORQ FCML_TEXT("vporq") +#define M_VPPERM FCML_TEXT("vpperm") +#define M_VPROLD FCML_TEXT("vprold") +#define M_VPROLQ FCML_TEXT("vprolq") +#define M_VPROLVD FCML_TEXT("vprolvd") +#define M_VPROLVQ FCML_TEXT("vprolvq") +#define M_VPRORD FCML_TEXT("vprord") +#define M_VPRORQ FCML_TEXT("vprorq") +#define M_VPRORVD FCML_TEXT("vprorvd") +#define M_VPRORVQ FCML_TEXT("vprorvq") +#define M_VPROTB FCML_TEXT("vprotb") +#define M_VPROTD FCML_TEXT("vprotd") +#define M_VPROTQ FCML_TEXT("vprotq") +#define M_VPROTW FCML_TEXT("vprotw") +#define M_VPSADBW FCML_TEXT("vpsadbw") +#define M_VPSCATTERDD FCML_TEXT("vpscatterdd") +#define M_VPSCATTERDQ FCML_TEXT("vpscatterdq") +#define M_VPSCATTERQD FCML_TEXT("vpscatterqd") +#define M_VPSCATTERQQ FCML_TEXT("vpscatterqq") +#define M_VPSHAB FCML_TEXT("vpshab") +#define M_VPSHAD FCML_TEXT("vpshad") +#define M_VPSHAQ FCML_TEXT("vpshaq") +#define M_VPSHAW FCML_TEXT("vpshaw") +#define M_VPSHLB FCML_TEXT("vpshlb") +#define M_VPSHLD FCML_TEXT("vpshld") +#define M_VPSHLQ FCML_TEXT("vpshlq") +#define M_VPSHLW FCML_TEXT("vpshlw") +#define M_VPSHUFB FCML_TEXT("vpshufb") +#define M_VPSHUFD FCML_TEXT("vpshufd") +#define M_VPSHUFHW FCML_TEXT("vpshufhw") +#define M_VPSHUFLW FCML_TEXT("vpshuflw") +#define M_VPSIGNB FCML_TEXT("vpsignb") +#define M_VPSIGND FCML_TEXT("vpsignd") +#define M_VPSIGNW FCML_TEXT("vpsignw") +#define M_VPSLLD FCML_TEXT("vpslld") +#define M_VPSLLDQ FCML_TEXT("vpslldq") +#define M_VPSLLQ FCML_TEXT("vpsllq") +#define M_VPSLLVD FCML_TEXT("vpsllvd") +#define M_VPSLLVQ FCML_TEXT("vpsllvq") +#define M_VPSLLVW FCML_TEXT("vpsllvw") +#define M_VPSLLW FCML_TEXT("vpsllw") +#define M_VPSRAD FCML_TEXT("vpsrad") +#define M_VPSRAQ FCML_TEXT("vpsraq") +#define M_VPSRAVD FCML_TEXT("vpsravd") +#define M_VPSRAVQ FCML_TEXT("vpsravq") +#define M_VPSRAVW FCML_TEXT("vpsravw") +#define M_VPSRAW FCML_TEXT("vpsraw") +#define M_VPSRLD FCML_TEXT("vpsrld") +#define M_VPSRLDQ FCML_TEXT("vpsrldq") +#define M_VPSRLQ FCML_TEXT("vpsrlq") +#define M_VPSRLVD FCML_TEXT("vpsrlvd") +#define M_VPSRLVQ FCML_TEXT("vpsrlvq") +#define M_VPSRLVW FCML_TEXT("vpsrlvw") +#define M_VPSRLW FCML_TEXT("vpsrlw") +#define M_VPSUBB FCML_TEXT("vpsubb") +#define M_VPSUBD FCML_TEXT("vpsubd") +#define M_VPSUBQ FCML_TEXT("vpsubq") +#define M_VPSUBSB FCML_TEXT("vpsubsb") +#define M_VPSUBSW FCML_TEXT("vpsubsw") +#define M_VPSUBUSB FCML_TEXT("vpsubusb") +#define M_VPSUBUSW FCML_TEXT("vpsubusw") +#define M_VPSUBW FCML_TEXT("vpsubw") +#define M_VPTERNLOGD FCML_TEXT("vpternlogd") +#define M_VPTERNLOGQ FCML_TEXT("vpternlogq") +#define M_VPTEST FCML_TEXT("vptest") +#define M_VPTESTMB FCML_TEXT("vptestmb") +#define M_VPTESTMD FCML_TEXT("vptestmd") +#define M_VPTESTMQ FCML_TEXT("vptestmq") +#define M_VPTESTMW FCML_TEXT("vptestmw") +#define M_VPTESTNMB FCML_TEXT("vptestnmb") +#define M_VPTESTNMD FCML_TEXT("vptestnmd") +#define M_VPTESTNMQ FCML_TEXT("vptestnmq") +#define M_VPTESTNMW FCML_TEXT("vptestnmw") +#define M_VPUNPCKHBW FCML_TEXT("vpunpckhbw") +#define M_VPUNPCKHDQ FCML_TEXT("vpunpckhdq") +#define M_VPUNPCKHQDQ FCML_TEXT("vpunpckhqdq") +#define M_VPUNPCKHWD FCML_TEXT("vpunpckhwd") +#define M_VPUNPCKLBW FCML_TEXT("vpunpcklbw") +#define M_VPUNPCKLDQ FCML_TEXT("vpunpckldq") +#define M_VPUNPCKLQDQ FCML_TEXT("vpunpcklqdq") +#define M_VPUNPCKLWD FCML_TEXT("vpunpcklwd") +#define M_VPXOR FCML_TEXT("vpxor") +#define M_VPXORD FCML_TEXT("vpxord") +#define M_VPXORQ FCML_TEXT("vpxorq") +#define M_VRANGEPD FCML_TEXT("vrangepd") +#define M_VRANGEPS FCML_TEXT("vrangeps") +#define M_VRANGESD FCML_TEXT("vrangesd") +#define M_VRANGESS FCML_TEXT("vrangess") +#define M_VRCP14PD FCML_TEXT("vrcp14pd") +#define M_VRCP14PS FCML_TEXT("vrcp14ps") +#define M_VRCP14SD FCML_TEXT("vrcp14sd") +#define M_VRCP14SS FCML_TEXT("vrcp14ss") +#define M_VRCP28PD FCML_TEXT("vrcp28pd") +#define M_VRCP28PS FCML_TEXT("vrcp28ps") +#define M_VRCP28SD FCML_TEXT("vrcp28sd") +#define M_VRCP28SS FCML_TEXT("vrcp28ss") +#define M_VRCPPS FCML_TEXT("vrcpps") +#define M_VRCPSS FCML_TEXT("vrcpss") +#define M_VREDUCEPD FCML_TEXT("vreducepd") +#define M_VREDUCEPS FCML_TEXT("vreduceps") +#define M_VREDUCESD FCML_TEXT("vreducesd") +#define M_VREDUCESS FCML_TEXT("vreducess") +#define M_VRNDSCALEPD FCML_TEXT("vrndscalepd") +#define M_VRNDSCALEPS FCML_TEXT("vrndscaleps") +#define M_VRNDSCALESD FCML_TEXT("vrndscalesd") +#define M_VRNDSCALESS FCML_TEXT("vrndscaless") +#define M_VROUNDPD FCML_TEXT("vroundpd") +#define M_VROUNDPS FCML_TEXT("vroundps") +#define M_VROUNDSD FCML_TEXT("vroundsd") +#define M_VROUNDSS FCML_TEXT("vroundss") +#define M_VRSQRT14PD FCML_TEXT("vrsqrt14pd") +#define M_VRSQRT14PS FCML_TEXT("vrsqrt14ps") +#define M_VRSQRT14SD FCML_TEXT("vrsqrt14sd") +#define M_VRSQRT14SS FCML_TEXT("vrsqrt14ss") +#define M_VRSQRT28PD FCML_TEXT("vrsqrt28pd") +#define M_VRSQRT28PS FCML_TEXT("vrsqrt28ps") +#define M_VRSQRT28SD FCML_TEXT("vrsqrt28sd") +#define M_VRSQRT28SS FCML_TEXT("vrsqrt28ss") +#define M_VRSQRTPS FCML_TEXT("vrsqrtps") +#define M_VRSQRTSS FCML_TEXT("vrsqrtss") +#define M_VSCALEFPD FCML_TEXT("vscalefpd") +#define M_VSCALEFPS FCML_TEXT("vscalefps") +#define M_VSCALEFSD FCML_TEXT("vscalefsd") +#define M_VSCALEFSS FCML_TEXT("vscalefss") +#define M_VSCATTERDPD FCML_TEXT("vscatterdpd") +#define M_VSCATTERDPS FCML_TEXT("vscatterdps") +#define M_VSCATTERPF0DPD FCML_TEXT("vscatterpf0dpd") +#define M_VSCATTERPF0DPS FCML_TEXT("vscatterpf0dps") +#define M_VSCATTERPF0QPD FCML_TEXT("vscatterpf0qpd") +#define M_VSCATTERPF0QPS FCML_TEXT("vscatterpf0qps") +#define M_VSCATTERPF1DPD FCML_TEXT("vscatterpf1dpd") +#define M_VSCATTERPF1DPS FCML_TEXT("vscatterpf1dps") +#define M_VSCATTERPF1QPD FCML_TEXT("vscatterpf1qpd") +#define M_VSCATTERPF1QPS FCML_TEXT("vscatterpf1qps") +#define M_VSCATTERQPD FCML_TEXT("vscatterqpd") +#define M_VSCATTERQPS FCML_TEXT("vscatterqps") +#define M_VSHUFF32X4 FCML_TEXT("vshuff32x4") +#define M_VSHUFF64X2 FCML_TEXT("vshuff64x2") +#define M_VSHUFI32X4 FCML_TEXT("vshufi32x4") +#define M_VSHUFI64X2 FCML_TEXT("vshufi64x2") +#define M_VSHUFPD FCML_TEXT("vshufpd") +#define M_VSHUFPS FCML_TEXT("vshufps") +#define M_VSQRTPD FCML_TEXT("vsqrtpd") +#define M_VSQRTPS FCML_TEXT("vsqrtps") +#define M_VSQRTSD FCML_TEXT("vsqrtsd") +#define M_VSQRTSS FCML_TEXT("vsqrtss") +#define M_VSTMXCSR FCML_TEXT("vstmxcsr") +#define M_VSUBPD FCML_TEXT("vsubpd") +#define M_VSUBPS FCML_TEXT("vsubps") +#define M_VSUBSD FCML_TEXT("vsubsd") +#define M_VSUBSS FCML_TEXT("vsubss") +#define M_VTESTPD FCML_TEXT("vtestpd") +#define M_VTESTPS FCML_TEXT("vtestps") +#define M_VUCOMISD FCML_TEXT("vucomisd") +#define M_VUCOMISS FCML_TEXT("vucomiss") +#define M_VUNPCKHPD FCML_TEXT("vunpckhpd") +#define M_VUNPCKHPS FCML_TEXT("vunpckhps") +#define M_VUNPCKLPD FCML_TEXT("vunpcklpd") +#define M_VUNPCKLPS FCML_TEXT("vunpcklps") +#define M_VXORPD FCML_TEXT("vxorpd") +#define M_VXORPS FCML_TEXT("vxorps") +#define M_VZEROALL FCML_TEXT("vzeroall") +#define M_VZEROUPPER FCML_TEXT("vzeroupper") +#define M_WAIT FCML_TEXT("wait") +#define M_WBINVD FCML_TEXT("wbinvd") +#define M_WRFSBASE FCML_TEXT("wrfsbase") +#define M_WRGSBASE FCML_TEXT("wrgsbase") +#define M_WRMSR FCML_TEXT("wrmsr") +#define M_XABORT FCML_TEXT("xabort") +#define M_XADD FCML_TEXT("xadd") +#define M_XBEGIN FCML_TEXT("xbegin") +#define M_XCHG FCML_TEXT("xchg") +#define M_XEND FCML_TEXT("xend") +#define M_XGETBV FCML_TEXT("xgetbv") +#define M_XLAT FCML_TEXT("xlat") +#define M_XLATB FCML_TEXT("xlatb") +#define M_XOR FCML_TEXT("xor") +#define M_XORB FCML_TEXT("xorb") +#define M_XORL FCML_TEXT("xorl") +#define M_XORPD FCML_TEXT("xorpd") +#define M_XORPS FCML_TEXT("xorps") +#define M_XORQ FCML_TEXT("xorq") +#define M_XORW FCML_TEXT("xorw") +#define M_XRSTOR FCML_TEXT("xrstor") +#define M_XRSTOR64 FCML_TEXT("xrstor64") +#define M_XSAVE FCML_TEXT("xsave") +#define M_XSAVE64 FCML_TEXT("xsave64") +#define M_XSAVEOPT FCML_TEXT("xsaveopt") +#define M_XSAVEOPT64 FCML_TEXT("xsaveopt64") +#define M_XSETBV FCML_TEXT("xsetbv") +#define M_XTEST FCML_TEXT("xtest") + +#endif /* FCML_GAS_MNEMONICS_H_ */ diff --git a/dependencies/fcml/include/fcml_gas_mnemonics.hpp b/dependencies/fcml/include/fcml_gas_mnemonics.hpp new file mode 100644 index 0000000..4c11198 --- /dev/null +++ b/dependencies/fcml/include/fcml_gas_mnemonics.hpp @@ -0,0 +1,1938 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_gas_mnemonics.hpp + * Declarations of AT&T mnemonics for C++. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_GAS_MNEMONICS_HPP_ +#define FCML_GAS_MNEMONICS_HPP_ + +#include "fcml_types.h" +#include + +namespace fcml { +namespace gas { + +extern const fcml_cstring M_AAA; +extern const fcml_cstring M_AAD; +extern const fcml_cstring M_AAM; +extern const fcml_cstring M_AAS; +extern const fcml_cstring M_ADC; +extern const fcml_cstring M_ADCB; +extern const fcml_cstring M_ADCL; +extern const fcml_cstring M_ADCQ; +extern const fcml_cstring M_ADCW; +extern const fcml_cstring M_ADCX; +extern const fcml_cstring M_ADD; +extern const fcml_cstring M_ADDB; +extern const fcml_cstring M_ADDL; +extern const fcml_cstring M_ADDPD; +extern const fcml_cstring M_ADDPS; +extern const fcml_cstring M_ADDQ; +extern const fcml_cstring M_ADDSD; +extern const fcml_cstring M_ADDSS; +extern const fcml_cstring M_ADDSUBPD; +extern const fcml_cstring M_ADDSUBPS; +extern const fcml_cstring M_ADDW; +extern const fcml_cstring M_ADOX; +extern const fcml_cstring M_AESDEC; +extern const fcml_cstring M_AESDECLAST; +extern const fcml_cstring M_AESENC; +extern const fcml_cstring M_AESENCLAST; +extern const fcml_cstring M_AESIMC; +extern const fcml_cstring M_AESKEYGENASSIST; +extern const fcml_cstring M_AND; +extern const fcml_cstring M_ANDB; +extern const fcml_cstring M_ANDL; +extern const fcml_cstring M_ANDN; +extern const fcml_cstring M_ANDNPD; +extern const fcml_cstring M_ANDNPS; +extern const fcml_cstring M_ANDPD; +extern const fcml_cstring M_ANDPS; +extern const fcml_cstring M_ANDQ; +extern const fcml_cstring M_ANDW; +extern const fcml_cstring M_ARPL; +extern const fcml_cstring M_BEXR; +extern const fcml_cstring M_BEXTR; +extern const fcml_cstring M_BLCFILL; +extern const fcml_cstring M_BLCI; +extern const fcml_cstring M_BLCIC; +extern const fcml_cstring M_BLCMSK; +extern const fcml_cstring M_BLCS; +extern const fcml_cstring M_BLENDPD; +extern const fcml_cstring M_BLENDPS; +extern const fcml_cstring M_BLENDVPD; +extern const fcml_cstring M_BLENDVPS; +extern const fcml_cstring M_BLSFILL; +extern const fcml_cstring M_BLSI; +extern const fcml_cstring M_BLSIC; +extern const fcml_cstring M_BLSMSK; +extern const fcml_cstring M_BLSR; +extern const fcml_cstring M_BOUND; +extern const fcml_cstring M_BSF; +extern const fcml_cstring M_BSR; +extern const fcml_cstring M_BSWAP; +extern const fcml_cstring M_BT; +extern const fcml_cstring M_BTC; +extern const fcml_cstring M_BTCL; +extern const fcml_cstring M_BTCQ; +extern const fcml_cstring M_BTCW; +extern const fcml_cstring M_BTL; +extern const fcml_cstring M_BTQ; +extern const fcml_cstring M_BTR; +extern const fcml_cstring M_BTRL; +extern const fcml_cstring M_BTRQ; +extern const fcml_cstring M_BTRW; +extern const fcml_cstring M_BTS; +extern const fcml_cstring M_BTSL; +extern const fcml_cstring M_BTSQ; +extern const fcml_cstring M_BTSW; +extern const fcml_cstring M_BTW; +extern const fcml_cstring M_BZHI; +extern const fcml_cstring M_CALL; +extern const fcml_cstring M_CALLQ; +extern const fcml_cstring M_CALLW; +extern const fcml_cstring M_CBTW; +extern const fcml_cstring M_CLAC; +extern const fcml_cstring M_CLC; +extern const fcml_cstring M_CLD; +extern const fcml_cstring M_CLFLUSH; +extern const fcml_cstring M_CLGI; +extern const fcml_cstring M_CLI; +extern const fcml_cstring M_CLTD; +extern const fcml_cstring M_CLTQ; +extern const fcml_cstring M_CLTS; +extern const fcml_cstring M_CMC; +extern const fcml_cstring M_CMOVA; +extern const fcml_cstring M_CMOVAE; +extern const fcml_cstring M_CMOVB; +extern const fcml_cstring M_CMOVBE; +extern const fcml_cstring M_CMOVC; +extern const fcml_cstring M_CMOVENE; +extern const fcml_cstring M_CMOVG; +extern const fcml_cstring M_CMOVGE; +extern const fcml_cstring M_CMOVL; +extern const fcml_cstring M_CMOVLE; +extern const fcml_cstring M_CMOVNA; +extern const fcml_cstring M_CMOVNAE; +extern const fcml_cstring M_CMOVNB; +extern const fcml_cstring M_CMOVNBE; +extern const fcml_cstring M_CMOVNC; +extern const fcml_cstring M_CMOVNG; +extern const fcml_cstring M_CMOVNGE; +extern const fcml_cstring M_CMOVNL; +extern const fcml_cstring M_CMOVNLE; +extern const fcml_cstring M_CMOVNO; +extern const fcml_cstring M_CMOVNP; +extern const fcml_cstring M_CMOVNS; +extern const fcml_cstring M_CMOVNZ; +extern const fcml_cstring M_CMOVO; +extern const fcml_cstring M_CMOVP; +extern const fcml_cstring M_CMOVPE; +extern const fcml_cstring M_CMOVPO; +extern const fcml_cstring M_CMOVS; +extern const fcml_cstring M_CMOVZ; +extern const fcml_cstring M_CMP; +extern const fcml_cstring M_CMPB; +extern const fcml_cstring M_CMPEQPD; +extern const fcml_cstring M_CMPEQPS; +extern const fcml_cstring M_CMPEQSD; +extern const fcml_cstring M_CMPEQSS; +extern const fcml_cstring M_CMPL; +extern const fcml_cstring M_CMPLEPD; +extern const fcml_cstring M_CMPLEPS; +extern const fcml_cstring M_CMPLESD; +extern const fcml_cstring M_CMPLESS; +extern const fcml_cstring M_CMPLTPD; +extern const fcml_cstring M_CMPLTPS; +extern const fcml_cstring M_CMPLTSD; +extern const fcml_cstring M_CMPLTSS; +extern const fcml_cstring M_CMPNEQPD; +extern const fcml_cstring M_CMPNEQPS; +extern const fcml_cstring M_CMPNEQSD; +extern const fcml_cstring M_CMPNEQSS; +extern const fcml_cstring M_CMPNLEPD; +extern const fcml_cstring M_CMPNLEPS; +extern const fcml_cstring M_CMPNLESD; +extern const fcml_cstring M_CMPNLESS; +extern const fcml_cstring M_CMPNLTPD; +extern const fcml_cstring M_CMPNLTPS; +extern const fcml_cstring M_CMPNLTSD; +extern const fcml_cstring M_CMPNLTSS; +extern const fcml_cstring M_CMPORDPD; +extern const fcml_cstring M_CMPORDPS; +extern const fcml_cstring M_CMPORDSD; +extern const fcml_cstring M_CMPORDSS; +extern const fcml_cstring M_CMPPD; +extern const fcml_cstring M_CMPPS; +extern const fcml_cstring M_CMPQ; +extern const fcml_cstring M_CMPSB; +extern const fcml_cstring M_CMPSD; +extern const fcml_cstring M_CMPSL; +extern const fcml_cstring M_CMPSQ; +extern const fcml_cstring M_CMPSS; +extern const fcml_cstring M_CMPSW; +extern const fcml_cstring M_CMPUNORDPD; +extern const fcml_cstring M_CMPUNORDPS; +extern const fcml_cstring M_CMPUNORDSD; +extern const fcml_cstring M_CMPUNORDSS; +extern const fcml_cstring M_CMPW; +extern const fcml_cstring M_CMPXCHG; +extern const fcml_cstring M_CMPXCHG16B; +extern const fcml_cstring M_CMPXCHG8B; +extern const fcml_cstring M_COMISD; +extern const fcml_cstring M_COMISS; +extern const fcml_cstring M_CPUID; +extern const fcml_cstring M_CQTO; +extern const fcml_cstring M_CRC32B; +extern const fcml_cstring M_CRC32L; +extern const fcml_cstring M_CRC32Q; +extern const fcml_cstring M_CRC32W; +extern const fcml_cstring M_CVTDQ2PD; +extern const fcml_cstring M_CVTDQ2PS; +extern const fcml_cstring M_CVTPD2DQ; +extern const fcml_cstring M_CVTPD2PI; +extern const fcml_cstring M_CVTPD2PS; +extern const fcml_cstring M_CVTPI2PD; +extern const fcml_cstring M_CVTPI2PS; +extern const fcml_cstring M_CVTPS2DQ; +extern const fcml_cstring M_CVTPS2PD; +extern const fcml_cstring M_CVTPS2PI; +extern const fcml_cstring M_CVTSD2SI; +extern const fcml_cstring M_CVTSD2SS; +extern const fcml_cstring M_CVTSI2SDL; +extern const fcml_cstring M_CVTSI2SDQ; +extern const fcml_cstring M_CVTSI2SSL; +extern const fcml_cstring M_CVTSI2SSQ; +extern const fcml_cstring M_CVTSS2SD; +extern const fcml_cstring M_CVTSS2SI; +extern const fcml_cstring M_CVTTPD2DQ; +extern const fcml_cstring M_CVTTPD2PI; +extern const fcml_cstring M_CVTTPS2DQ; +extern const fcml_cstring M_CVTTPS2PI; +extern const fcml_cstring M_CVTTSD2SI; +extern const fcml_cstring M_CVTTSS2SI; +extern const fcml_cstring M_CWTD; +extern const fcml_cstring M_CWTL; +extern const fcml_cstring M_DAA; +extern const fcml_cstring M_DAS; +extern const fcml_cstring M_DEC; +extern const fcml_cstring M_DECB; +extern const fcml_cstring M_DECL; +extern const fcml_cstring M_DECQ; +extern const fcml_cstring M_DECW; +extern const fcml_cstring M_DIV; +extern const fcml_cstring M_DIVB; +extern const fcml_cstring M_DIVL; +extern const fcml_cstring M_DIVPD; +extern const fcml_cstring M_DIVPS; +extern const fcml_cstring M_DIVQ; +extern const fcml_cstring M_DIVSD; +extern const fcml_cstring M_DIVSS; +extern const fcml_cstring M_DIVW; +extern const fcml_cstring M_DPPD; +extern const fcml_cstring M_DPPS; +extern const fcml_cstring M_EMMS; +extern const fcml_cstring M_ENTER; +extern const fcml_cstring M_ENTERQ; +extern const fcml_cstring M_EXTRACTPS; +extern const fcml_cstring M_EXTRQ; +extern const fcml_cstring M_F2XM1; +extern const fcml_cstring M_FABS; +extern const fcml_cstring M_FADD; +extern const fcml_cstring M_FADDL; +extern const fcml_cstring M_FADDP; +extern const fcml_cstring M_FADDS; +extern const fcml_cstring M_FBLD; +extern const fcml_cstring M_FBSTP; +extern const fcml_cstring M_FCHS; +extern const fcml_cstring M_FCLEX; +extern const fcml_cstring M_FCMOVB; +extern const fcml_cstring M_FCMOVBE; +extern const fcml_cstring M_FCMOVE; +extern const fcml_cstring M_FCMOVNB; +extern const fcml_cstring M_FCMOVNBE; +extern const fcml_cstring M_FCMOVNE; +extern const fcml_cstring M_FCMOVNU; +extern const fcml_cstring M_FCMOVU; +extern const fcml_cstring M_FCOM; +extern const fcml_cstring M_FCOMI; +extern const fcml_cstring M_FCOMIP; +extern const fcml_cstring M_FCOML; +extern const fcml_cstring M_FCOMP; +extern const fcml_cstring M_FCOMPL; +extern const fcml_cstring M_FCOMPP; +extern const fcml_cstring M_FCOMPS; +extern const fcml_cstring M_FCOMS; +extern const fcml_cstring M_FCOS; +extern const fcml_cstring M_FDECSTP; +extern const fcml_cstring M_FDIV; +extern const fcml_cstring M_FDIVL; +extern const fcml_cstring M_FDIVP; +extern const fcml_cstring M_FDIVR; +extern const fcml_cstring M_FDIVRL; +extern const fcml_cstring M_FDIVRP; +extern const fcml_cstring M_FDIVRS; +extern const fcml_cstring M_FDIVS; +extern const fcml_cstring M_FEMMS; +extern const fcml_cstring M_FFREE; +extern const fcml_cstring M_FIADD; +extern const fcml_cstring M_FIADDL; +extern const fcml_cstring M_FICOM; +extern const fcml_cstring M_FICOML; +extern const fcml_cstring M_FICOMP; +extern const fcml_cstring M_FICOMPL; +extern const fcml_cstring M_FIDIV; +extern const fcml_cstring M_FIDIVL; +extern const fcml_cstring M_FIDIVR; +extern const fcml_cstring M_FIDIVRL; +extern const fcml_cstring M_FILD; +extern const fcml_cstring M_FILDL; +extern const fcml_cstring M_FILDLL; +extern const fcml_cstring M_FIMUL; +extern const fcml_cstring M_FIMULL; +extern const fcml_cstring M_FINCSTP; +extern const fcml_cstring M_FINIT; +extern const fcml_cstring M_FIST; +extern const fcml_cstring M_FISTL; +extern const fcml_cstring M_FISTP; +extern const fcml_cstring M_FISTPL; +extern const fcml_cstring M_FISTPLL; +extern const fcml_cstring M_FISTTP; +extern const fcml_cstring M_FISTTPL; +extern const fcml_cstring M_FISTTPLL; +extern const fcml_cstring M_FISUB; +extern const fcml_cstring M_FISUBL; +extern const fcml_cstring M_FISUBR; +extern const fcml_cstring M_FISUBRL; +extern const fcml_cstring M_FLD; +extern const fcml_cstring M_FLD1; +extern const fcml_cstring M_FLDCW; +extern const fcml_cstring M_FLDENV; +extern const fcml_cstring M_FLDENVS; +extern const fcml_cstring M_FLDL; +extern const fcml_cstring M_FLDL2E; +extern const fcml_cstring M_FLDL2T; +extern const fcml_cstring M_FLDLG2; +extern const fcml_cstring M_FLDLN2; +extern const fcml_cstring M_FLDPI; +extern const fcml_cstring M_FLDS; +extern const fcml_cstring M_FLDT; +extern const fcml_cstring M_FLDZ; +extern const fcml_cstring M_FMUL; +extern const fcml_cstring M_FMULL; +extern const fcml_cstring M_FMULP; +extern const fcml_cstring M_FMULS; +extern const fcml_cstring M_FNCLEX; +extern const fcml_cstring M_FNINIT; +extern const fcml_cstring M_FNOP; +extern const fcml_cstring M_FNSAVE; +extern const fcml_cstring M_FNSAVES; +extern const fcml_cstring M_FNSTCW; +extern const fcml_cstring M_FNSTENV; +extern const fcml_cstring M_FNSTENVS; +extern const fcml_cstring M_FNSTSW; +extern const fcml_cstring M_FPATAN; +extern const fcml_cstring M_FPREM; +extern const fcml_cstring M_FPREM1; +extern const fcml_cstring M_FPTAN; +extern const fcml_cstring M_FRNDINT; +extern const fcml_cstring M_FRSTOR; +extern const fcml_cstring M_FRSTORS; +extern const fcml_cstring M_FSAVE; +extern const fcml_cstring M_FSAVES; +extern const fcml_cstring M_FSCALE; +extern const fcml_cstring M_FSIN; +extern const fcml_cstring M_FSINCOS; +extern const fcml_cstring M_FSQRT; +extern const fcml_cstring M_FST; +extern const fcml_cstring M_FSTCW; +extern const fcml_cstring M_FSTENV; +extern const fcml_cstring M_FSTENVS; +extern const fcml_cstring M_FSTL; +extern const fcml_cstring M_FSTP; +extern const fcml_cstring M_FSTPL; +extern const fcml_cstring M_FSTPS; +extern const fcml_cstring M_FSTPT; +extern const fcml_cstring M_FSTS; +extern const fcml_cstring M_FSTSW; +extern const fcml_cstring M_FSUB; +extern const fcml_cstring M_FSUBL; +extern const fcml_cstring M_FSUBP; +extern const fcml_cstring M_FSUBR; +extern const fcml_cstring M_FSUBRL; +extern const fcml_cstring M_FSUBRP; +extern const fcml_cstring M_FSUBRS; +extern const fcml_cstring M_FSUBS; +extern const fcml_cstring M_FTST; +extern const fcml_cstring M_FUCOM; +extern const fcml_cstring M_FUCOMI; +extern const fcml_cstring M_FUCOMIP; +extern const fcml_cstring M_FUCOMP; +extern const fcml_cstring M_FUCOMPP; +extern const fcml_cstring M_FWAIT; +extern const fcml_cstring M_FXAM; +extern const fcml_cstring M_FXCH; +extern const fcml_cstring M_FXRSTOR; +extern const fcml_cstring M_FXRSTOR64; +extern const fcml_cstring M_FXSAVE; +extern const fcml_cstring M_FXSAVE64; +extern const fcml_cstring M_FXTRACT; +extern const fcml_cstring M_FYL2X; +extern const fcml_cstring M_FYL2XP1; +extern const fcml_cstring M_GETSEC; +extern const fcml_cstring M_HADDPD; +extern const fcml_cstring M_HADDPS; +extern const fcml_cstring M_HLT; +extern const fcml_cstring M_HSUBPD; +extern const fcml_cstring M_HSUBPS; +extern const fcml_cstring M_IDIV; +extern const fcml_cstring M_IDIVB; +extern const fcml_cstring M_IDIVL; +extern const fcml_cstring M_IDIVQ; +extern const fcml_cstring M_IDIVW; +extern const fcml_cstring M_IMUL; +extern const fcml_cstring M_IMULB; +extern const fcml_cstring M_IMULL; +extern const fcml_cstring M_IMULQ; +extern const fcml_cstring M_IMULW; +extern const fcml_cstring M_IN; +extern const fcml_cstring M_INC; +extern const fcml_cstring M_INCB; +extern const fcml_cstring M_INCL; +extern const fcml_cstring M_INCQ; +extern const fcml_cstring M_INCW; +extern const fcml_cstring M_INSB; +extern const fcml_cstring M_INSERTPS; +extern const fcml_cstring M_INSERTQ; +extern const fcml_cstring M_INSL; +extern const fcml_cstring M_INSW; +extern const fcml_cstring M_INT; +extern const fcml_cstring M_INT3; +extern const fcml_cstring M_INTO; +extern const fcml_cstring M_INVD; +extern const fcml_cstring M_INVEPT; +extern const fcml_cstring M_INVLPG; +extern const fcml_cstring M_INVLPGA; +extern const fcml_cstring M_INVPCID; +extern const fcml_cstring M_INVVPID; +extern const fcml_cstring M_IRET; +extern const fcml_cstring M_IRETQ; +extern const fcml_cstring M_IRETW; +extern const fcml_cstring M_JA; +extern const fcml_cstring M_JAE; +extern const fcml_cstring M_JB; +extern const fcml_cstring M_JBE; +extern const fcml_cstring M_JC; +extern const fcml_cstring M_JCXZ; +extern const fcml_cstring M_JECXZ; +extern const fcml_cstring M_JENE; +extern const fcml_cstring M_JG; +extern const fcml_cstring M_JGE; +extern const fcml_cstring M_JL; +extern const fcml_cstring M_JLE; +extern const fcml_cstring M_JMP; +extern const fcml_cstring M_JMPQ; +extern const fcml_cstring M_JMPW; +extern const fcml_cstring M_JNA; +extern const fcml_cstring M_JNAE; +extern const fcml_cstring M_JNB; +extern const fcml_cstring M_JNBE; +extern const fcml_cstring M_JNC; +extern const fcml_cstring M_JNG; +extern const fcml_cstring M_JNGE; +extern const fcml_cstring M_JNL; +extern const fcml_cstring M_JNLE; +extern const fcml_cstring M_JNO; +extern const fcml_cstring M_JNP; +extern const fcml_cstring M_JNS; +extern const fcml_cstring M_JNZ; +extern const fcml_cstring M_JO; +extern const fcml_cstring M_JP; +extern const fcml_cstring M_JPE; +extern const fcml_cstring M_JPO; +extern const fcml_cstring M_JRCXZ; +extern const fcml_cstring M_JS; +extern const fcml_cstring M_JZ; +extern const fcml_cstring M_KADDB; +extern const fcml_cstring M_KADDD; +extern const fcml_cstring M_KADDQ; +extern const fcml_cstring M_KADDW; +extern const fcml_cstring M_KANDB; +extern const fcml_cstring M_KANDD; +extern const fcml_cstring M_KANDNB; +extern const fcml_cstring M_KANDND; +extern const fcml_cstring M_KANDNQ; +extern const fcml_cstring M_KANDNW; +extern const fcml_cstring M_KANDQ; +extern const fcml_cstring M_KANDW; +extern const fcml_cstring M_KMOVB; +extern const fcml_cstring M_KMOVD; +extern const fcml_cstring M_KMOVQ; +extern const fcml_cstring M_KMOVW; +extern const fcml_cstring M_KNOTB; +extern const fcml_cstring M_KNOTD; +extern const fcml_cstring M_KNOTQ; +extern const fcml_cstring M_KNOTW; +extern const fcml_cstring M_KORB; +extern const fcml_cstring M_KORD; +extern const fcml_cstring M_KORQ; +extern const fcml_cstring M_KORTESTB; +extern const fcml_cstring M_KORTESTD; +extern const fcml_cstring M_KORTESTQ; +extern const fcml_cstring M_KORTESTW; +extern const fcml_cstring M_KORW; +extern const fcml_cstring M_KSHIFTLB; +extern const fcml_cstring M_KSHIFTLD; +extern const fcml_cstring M_KSHIFTLQ; +extern const fcml_cstring M_KSHIFTLW; +extern const fcml_cstring M_KSHIFTRB; +extern const fcml_cstring M_KSHIFTRD; +extern const fcml_cstring M_KSHIFTRQ; +extern const fcml_cstring M_KSHIFTRW; +extern const fcml_cstring M_KTESTB; +extern const fcml_cstring M_KTESTD; +extern const fcml_cstring M_KTESTQ; +extern const fcml_cstring M_KTESTW; +extern const fcml_cstring M_KXNORB; +extern const fcml_cstring M_KXNORD; +extern const fcml_cstring M_KXNORQ; +extern const fcml_cstring M_KXNORW; +extern const fcml_cstring M_KXORB; +extern const fcml_cstring M_KXORD; +extern const fcml_cstring M_KXORQ; +extern const fcml_cstring M_KXORW; +extern const fcml_cstring M_LAHF; +extern const fcml_cstring M_LAR; +extern const fcml_cstring M_LCALL; +extern const fcml_cstring M_LCALLQ; +extern const fcml_cstring M_LCALLW; +extern const fcml_cstring M_LDDQU; +extern const fcml_cstring M_LDMXCSR; +extern const fcml_cstring M_LDS; +extern const fcml_cstring M_LEA; +extern const fcml_cstring M_LEAVE; +extern const fcml_cstring M_LES; +extern const fcml_cstring M_LFENCE; +extern const fcml_cstring M_LFS; +extern const fcml_cstring M_LGDT; +extern const fcml_cstring M_LGS; +extern const fcml_cstring M_LIDT; +extern const fcml_cstring M_LJMP; +extern const fcml_cstring M_LJMPL; +extern const fcml_cstring M_LJMPQ; +extern const fcml_cstring M_LJMPW; +extern const fcml_cstring M_LLDT; +extern const fcml_cstring M_LLWPCB; +extern const fcml_cstring M_LMSW; +extern const fcml_cstring M_LODS; +extern const fcml_cstring M_LODSB; +extern const fcml_cstring M_LODSL; +extern const fcml_cstring M_LODSQ; +extern const fcml_cstring M_LODSW; +extern const fcml_cstring M_LOOP; +extern const fcml_cstring M_LOOPE; +extern const fcml_cstring M_LOOPNE; +extern const fcml_cstring M_LOOPNZ; +extern const fcml_cstring M_LOOPZ; +extern const fcml_cstring M_LRET; +extern const fcml_cstring M_LRETQ; +extern const fcml_cstring M_LRETW; +extern const fcml_cstring M_LSL; +extern const fcml_cstring M_LSS; +extern const fcml_cstring M_LTR; +extern const fcml_cstring M_LWPINS; +extern const fcml_cstring M_LWPVAL; +extern const fcml_cstring M_LZCNT; +extern const fcml_cstring M_MASKMOVDQU; +extern const fcml_cstring M_MASKMOVQ; +extern const fcml_cstring M_MAXPD; +extern const fcml_cstring M_MAXPS; +extern const fcml_cstring M_MAXSD; +extern const fcml_cstring M_MAXSS; +extern const fcml_cstring M_MFENCE; +extern const fcml_cstring M_MINPD; +extern const fcml_cstring M_MINPS; +extern const fcml_cstring M_MINSD; +extern const fcml_cstring M_MINSS; +extern const fcml_cstring M_MONITOR; +extern const fcml_cstring M_MOV; +extern const fcml_cstring M_MOVABS; +extern const fcml_cstring M_MOVAPD; +extern const fcml_cstring M_MOVAPS; +extern const fcml_cstring M_MOVB; +extern const fcml_cstring M_MOVBE; +extern const fcml_cstring M_MOVD; +extern const fcml_cstring M_MOVDDUP; +extern const fcml_cstring M_MOVDQ2Q; +extern const fcml_cstring M_MOVDQA; +extern const fcml_cstring M_MOVDQU; +extern const fcml_cstring M_MOVHLPS; +extern const fcml_cstring M_MOVHPD; +extern const fcml_cstring M_MOVHPS; +extern const fcml_cstring M_MOVL; +extern const fcml_cstring M_MOVLHPS; +extern const fcml_cstring M_MOVLPD; +extern const fcml_cstring M_MOVLPS; +extern const fcml_cstring M_MOVMSKPD; +extern const fcml_cstring M_MOVMSKPS; +extern const fcml_cstring M_MOVNTDQ; +extern const fcml_cstring M_MOVNTDQA; +extern const fcml_cstring M_MOVNTI; +extern const fcml_cstring M_MOVNTPD; +extern const fcml_cstring M_MOVNTPS; +extern const fcml_cstring M_MOVNTQ; +extern const fcml_cstring M_MOVNTSD; +extern const fcml_cstring M_MOVNTSS; +extern const fcml_cstring M_MOVQ; +extern const fcml_cstring M_MOVQ2DQ; +extern const fcml_cstring M_MOVS; +extern const fcml_cstring M_MOVSB; +extern const fcml_cstring M_MOVSBL; +extern const fcml_cstring M_MOVSBQ; +extern const fcml_cstring M_MOVSBW; +extern const fcml_cstring M_MOVSD; +extern const fcml_cstring M_MOVSHDUP; +extern const fcml_cstring M_MOVSL; +extern const fcml_cstring M_MOVSLDUP; +extern const fcml_cstring M_MOVSQ; +extern const fcml_cstring M_MOVSS; +extern const fcml_cstring M_MOVSW; +extern const fcml_cstring M_MOVSWL; +extern const fcml_cstring M_MOVSWQ; +extern const fcml_cstring M_MOVSWW; +extern const fcml_cstring M_MOVSXD; +extern const fcml_cstring M_MOVUPD; +extern const fcml_cstring M_MOVUPS; +extern const fcml_cstring M_MOVW; +extern const fcml_cstring M_MOVZBL; +extern const fcml_cstring M_MOVZBQ; +extern const fcml_cstring M_MOVZBW; +extern const fcml_cstring M_MOVZWL; +extern const fcml_cstring M_MOVZWQ; +extern const fcml_cstring M_MOVZWW; +extern const fcml_cstring M_MPSADBW; +extern const fcml_cstring M_MUL; +extern const fcml_cstring M_MULB; +extern const fcml_cstring M_MULL; +extern const fcml_cstring M_MULPD; +extern const fcml_cstring M_MULPS; +extern const fcml_cstring M_MULQ; +extern const fcml_cstring M_MULSD; +extern const fcml_cstring M_MULSS; +extern const fcml_cstring M_MULW; +extern const fcml_cstring M_MULX; +extern const fcml_cstring M_MWAIT; +extern const fcml_cstring M_NEG; +extern const fcml_cstring M_NEGB; +extern const fcml_cstring M_NEGL; +extern const fcml_cstring M_NEGQ; +extern const fcml_cstring M_NEGW; +extern const fcml_cstring M_NOP; +extern const fcml_cstring M_NOPL; +extern const fcml_cstring M_NOPQ; +extern const fcml_cstring M_NOPW; +extern const fcml_cstring M_NOT; +extern const fcml_cstring M_NOTB; +extern const fcml_cstring M_NOTL; +extern const fcml_cstring M_NOTQ; +extern const fcml_cstring M_NOTW; +extern const fcml_cstring M_OR; +extern const fcml_cstring M_ORB; +extern const fcml_cstring M_ORL; +extern const fcml_cstring M_ORPD; +extern const fcml_cstring M_ORPS; +extern const fcml_cstring M_ORQ; +extern const fcml_cstring M_ORW; +extern const fcml_cstring M_OUT; +extern const fcml_cstring M_OUTSB; +extern const fcml_cstring M_OUTSL; +extern const fcml_cstring M_OUTSW; +extern const fcml_cstring M_PABSB; +extern const fcml_cstring M_PABSD; +extern const fcml_cstring M_PABSW; +extern const fcml_cstring M_PACKSSDW; +extern const fcml_cstring M_PACKSSWB; +extern const fcml_cstring M_PACKUSDW; +extern const fcml_cstring M_PACKUSWB; +extern const fcml_cstring M_PADDB; +extern const fcml_cstring M_PADDD; +extern const fcml_cstring M_PADDQ; +extern const fcml_cstring M_PADDSB; +extern const fcml_cstring M_PADDSW; +extern const fcml_cstring M_PADDUSB; +extern const fcml_cstring M_PADDUSW; +extern const fcml_cstring M_PADDW; +extern const fcml_cstring M_PALIGNR; +extern const fcml_cstring M_PAND; +extern const fcml_cstring M_PANDN; +extern const fcml_cstring M_PAUSE; +extern const fcml_cstring M_PAVGB; +extern const fcml_cstring M_PAVGUSB; +extern const fcml_cstring M_PAVGW; +extern const fcml_cstring M_PBLENDVB; +extern const fcml_cstring M_PBLENDW; +extern const fcml_cstring M_PCLMULQDQ; +extern const fcml_cstring M_PCMPEQB; +extern const fcml_cstring M_PCMPEQD; +extern const fcml_cstring M_PCMPEQQ; +extern const fcml_cstring M_PCMPEQW; +extern const fcml_cstring M_PCMPESTRI; +extern const fcml_cstring M_PCMPESTRM; +extern const fcml_cstring M_PCMPGTB; +extern const fcml_cstring M_PCMPGTD; +extern const fcml_cstring M_PCMPGTQ; +extern const fcml_cstring M_PCMPGTW; +extern const fcml_cstring M_PCMPISTRI; +extern const fcml_cstring M_PCMPISTRM; +extern const fcml_cstring M_PDEP; +extern const fcml_cstring M_PEXT; +extern const fcml_cstring M_PEXTRB; +extern const fcml_cstring M_PEXTRD; +extern const fcml_cstring M_PEXTRQ; +extern const fcml_cstring M_PEXTRW; +extern const fcml_cstring M_PF2ID; +extern const fcml_cstring M_PF2IW; +extern const fcml_cstring M_PFACC; +extern const fcml_cstring M_PFADD; +extern const fcml_cstring M_PFCMPEQ; +extern const fcml_cstring M_PFCMPGE; +extern const fcml_cstring M_PFCMPGT; +extern const fcml_cstring M_PFMAX; +extern const fcml_cstring M_PFMIN; +extern const fcml_cstring M_PFMUL; +extern const fcml_cstring M_PFNACC; +extern const fcml_cstring M_PFPNACC; +extern const fcml_cstring M_PFRCP; +extern const fcml_cstring M_PFRCPIT1; +extern const fcml_cstring M_PFRCPIT2; +extern const fcml_cstring M_PFRSQIT1; +extern const fcml_cstring M_PFRSQRT; +extern const fcml_cstring M_PFSUB; +extern const fcml_cstring M_PFSUBR; +extern const fcml_cstring M_PHADDD; +extern const fcml_cstring M_PHADDSW; +extern const fcml_cstring M_PHADDW; +extern const fcml_cstring M_PHMINPOSUW; +extern const fcml_cstring M_PHSUBD; +extern const fcml_cstring M_PHSUBSW; +extern const fcml_cstring M_PHSUBW; +extern const fcml_cstring M_PI2FD; +extern const fcml_cstring M_PI2FW; +extern const fcml_cstring M_PINSRB; +extern const fcml_cstring M_PINSRD; +extern const fcml_cstring M_PINSRQ; +extern const fcml_cstring M_PINSRW; +extern const fcml_cstring M_PMADDUBSW; +extern const fcml_cstring M_PMADDWD; +extern const fcml_cstring M_PMAXSB; +extern const fcml_cstring M_PMAXSD; +extern const fcml_cstring M_PMAXSW; +extern const fcml_cstring M_PMAXUB; +extern const fcml_cstring M_PMAXUD; +extern const fcml_cstring M_PMAXUW; +extern const fcml_cstring M_PMINSB; +extern const fcml_cstring M_PMINSD; +extern const fcml_cstring M_PMINSW; +extern const fcml_cstring M_PMINUB; +extern const fcml_cstring M_PMINUD; +extern const fcml_cstring M_PMINUW; +extern const fcml_cstring M_PMOVMSKB; +extern const fcml_cstring M_PMOVSXBD; +extern const fcml_cstring M_PMOVSXBQ; +extern const fcml_cstring M_PMOVSXBW; +extern const fcml_cstring M_PMOVSXDQ; +extern const fcml_cstring M_PMOVSXWD; +extern const fcml_cstring M_PMOVSXWQ; +extern const fcml_cstring M_PMOVZXBD; +extern const fcml_cstring M_PMOVZXBQ; +extern const fcml_cstring M_PMOVZXBW; +extern const fcml_cstring M_PMOVZXDQ; +extern const fcml_cstring M_PMOVZXWD; +extern const fcml_cstring M_PMOVZXWQ; +extern const fcml_cstring M_PMULDQ; +extern const fcml_cstring M_PMULHRSW; +extern const fcml_cstring M_PMULHRW; +extern const fcml_cstring M_PMULHUW; +extern const fcml_cstring M_PMULHW; +extern const fcml_cstring M_PMULLD; +extern const fcml_cstring M_PMULLW; +extern const fcml_cstring M_PMULUDQ; +extern const fcml_cstring M_POP; +extern const fcml_cstring M_POPA; +extern const fcml_cstring M_POPAW; +extern const fcml_cstring M_POPCNT; +extern const fcml_cstring M_POPF; +extern const fcml_cstring M_POPFQ; +extern const fcml_cstring M_POPFW; +extern const fcml_cstring M_POPL; +extern const fcml_cstring M_POPQ; +extern const fcml_cstring M_POPW; +extern const fcml_cstring M_POR; +extern const fcml_cstring M_PREFETCH; +extern const fcml_cstring M_PREFETCHNTA; +extern const fcml_cstring M_PREFETCHT0; +extern const fcml_cstring M_PREFETCHT1; +extern const fcml_cstring M_PREFETCHT2; +extern const fcml_cstring M_PREFETCHW; +extern const fcml_cstring M_PREFETCHWT1; +extern const fcml_cstring M_PSADBW; +extern const fcml_cstring M_PSHUFB; +extern const fcml_cstring M_PSHUFD; +extern const fcml_cstring M_PSHUFHW; +extern const fcml_cstring M_PSHUFLW; +extern const fcml_cstring M_PSHUFW; +extern const fcml_cstring M_PSIGNB; +extern const fcml_cstring M_PSIGND; +extern const fcml_cstring M_PSIGNW; +extern const fcml_cstring M_PSLLD; +extern const fcml_cstring M_PSLLDQ; +extern const fcml_cstring M_PSLLQ; +extern const fcml_cstring M_PSLLW; +extern const fcml_cstring M_PSRAD; +extern const fcml_cstring M_PSRAW; +extern const fcml_cstring M_PSRLD; +extern const fcml_cstring M_PSRLDQ; +extern const fcml_cstring M_PSRLQ; +extern const fcml_cstring M_PSRLW; +extern const fcml_cstring M_PSUBB; +extern const fcml_cstring M_PSUBD; +extern const fcml_cstring M_PSUBQ; +extern const fcml_cstring M_PSUBSB; +extern const fcml_cstring M_PSUBSW; +extern const fcml_cstring M_PSUBUSB; +extern const fcml_cstring M_PSUBUSW; +extern const fcml_cstring M_PSUBW; +extern const fcml_cstring M_PSWAPD; +extern const fcml_cstring M_PTEST; +extern const fcml_cstring M_PUNPCKHBW; +extern const fcml_cstring M_PUNPCKHDQ; +extern const fcml_cstring M_PUNPCKHQDQ; +extern const fcml_cstring M_PUNPCKHWD; +extern const fcml_cstring M_PUNPCKLBW; +extern const fcml_cstring M_PUNPCKLDQ; +extern const fcml_cstring M_PUNPCKLQDQ; +extern const fcml_cstring M_PUNPCKLWD; +extern const fcml_cstring M_PUSH; +extern const fcml_cstring M_PUSHA; +extern const fcml_cstring M_PUSHAW; +extern const fcml_cstring M_PUSHB; +extern const fcml_cstring M_PUSHF; +extern const fcml_cstring M_PUSHFQ; +extern const fcml_cstring M_PUSHFW; +extern const fcml_cstring M_PUSHL; +extern const fcml_cstring M_PUSHQ; +extern const fcml_cstring M_PUSHW; +extern const fcml_cstring M_PXOR; +extern const fcml_cstring M_RCL; +extern const fcml_cstring M_RCLB; +extern const fcml_cstring M_RCLL; +extern const fcml_cstring M_RCLQ; +extern const fcml_cstring M_RCLW; +extern const fcml_cstring M_RCPPS; +extern const fcml_cstring M_RCPSS; +extern const fcml_cstring M_RCR; +extern const fcml_cstring M_RCRB; +extern const fcml_cstring M_RCRL; +extern const fcml_cstring M_RCRQ; +extern const fcml_cstring M_RCRW; +extern const fcml_cstring M_RDFSBASE; +extern const fcml_cstring M_RDGSBASE; +extern const fcml_cstring M_RDMSR; +extern const fcml_cstring M_RDPMC; +extern const fcml_cstring M_RDRAND; +extern const fcml_cstring M_RDSEED; +extern const fcml_cstring M_RDTSC; +extern const fcml_cstring M_RDTSCP; +extern const fcml_cstring M_RET; +extern const fcml_cstring M_RETQ; +extern const fcml_cstring M_RETW; +extern const fcml_cstring M_ROL; +extern const fcml_cstring M_ROLB; +extern const fcml_cstring M_ROLL; +extern const fcml_cstring M_ROLQ; +extern const fcml_cstring M_ROLW; +extern const fcml_cstring M_ROR; +extern const fcml_cstring M_RORB; +extern const fcml_cstring M_RORL; +extern const fcml_cstring M_RORQ; +extern const fcml_cstring M_RORW; +extern const fcml_cstring M_RORX; +extern const fcml_cstring M_ROUNDPD; +extern const fcml_cstring M_ROUNDPS; +extern const fcml_cstring M_ROUNDSD; +extern const fcml_cstring M_ROUNDSS; +extern const fcml_cstring M_RSM; +extern const fcml_cstring M_RSQRTPS; +extern const fcml_cstring M_RSQRTSS; +extern const fcml_cstring M_SAHF; +extern const fcml_cstring M_SAL; +extern const fcml_cstring M_SALB; +extern const fcml_cstring M_SALL; +extern const fcml_cstring M_SALQ; +extern const fcml_cstring M_SALW; +extern const fcml_cstring M_SAR; +extern const fcml_cstring M_SARB; +extern const fcml_cstring M_SARL; +extern const fcml_cstring M_SARQ; +extern const fcml_cstring M_SARW; +extern const fcml_cstring M_SARX; +extern const fcml_cstring M_SBB; +extern const fcml_cstring M_SBBB; +extern const fcml_cstring M_SBBL; +extern const fcml_cstring M_SBBQ; +extern const fcml_cstring M_SBBW; +extern const fcml_cstring M_SCAS; +extern const fcml_cstring M_SCASB; +extern const fcml_cstring M_SCASL; +extern const fcml_cstring M_SCASQ; +extern const fcml_cstring M_SCASW; +extern const fcml_cstring M_SETA; +extern const fcml_cstring M_SETAE; +extern const fcml_cstring M_SETB; +extern const fcml_cstring M_SETBE; +extern const fcml_cstring M_SETC; +extern const fcml_cstring M_SETENE; +extern const fcml_cstring M_SETG; +extern const fcml_cstring M_SETGE; +extern const fcml_cstring M_SETL; +extern const fcml_cstring M_SETLE; +extern const fcml_cstring M_SETNA; +extern const fcml_cstring M_SETNAE; +extern const fcml_cstring M_SETNB; +extern const fcml_cstring M_SETNBE; +extern const fcml_cstring M_SETNC; +extern const fcml_cstring M_SETNG; +extern const fcml_cstring M_SETNGE; +extern const fcml_cstring M_SETNL; +extern const fcml_cstring M_SETNLE; +extern const fcml_cstring M_SETNO; +extern const fcml_cstring M_SETNP; +extern const fcml_cstring M_SETNS; +extern const fcml_cstring M_SETNZ; +extern const fcml_cstring M_SETO; +extern const fcml_cstring M_SETP; +extern const fcml_cstring M_SETPE; +extern const fcml_cstring M_SETPO; +extern const fcml_cstring M_SETS; +extern const fcml_cstring M_SETZ; +extern const fcml_cstring M_SFENCE; +extern const fcml_cstring M_SGDT; +extern const fcml_cstring M_SHL; +extern const fcml_cstring M_SHLB; +extern const fcml_cstring M_SHLD; +extern const fcml_cstring M_SHLL; +extern const fcml_cstring M_SHLQ; +extern const fcml_cstring M_SHLW; +extern const fcml_cstring M_SHLX; +extern const fcml_cstring M_SHR; +extern const fcml_cstring M_SHRB; +extern const fcml_cstring M_SHRD; +extern const fcml_cstring M_SHRL; +extern const fcml_cstring M_SHRQ; +extern const fcml_cstring M_SHRW; +extern const fcml_cstring M_SHRX; +extern const fcml_cstring M_SHUFPD; +extern const fcml_cstring M_SHUFPS; +extern const fcml_cstring M_SIDT; +extern const fcml_cstring M_SKINIT; +extern const fcml_cstring M_SLDT; +extern const fcml_cstring M_SLWPCB; +extern const fcml_cstring M_SMSW; +extern const fcml_cstring M_SQRTPD; +extern const fcml_cstring M_SQRTPS; +extern const fcml_cstring M_SQRTSD; +extern const fcml_cstring M_SQRTSS; +extern const fcml_cstring M_STAC; +extern const fcml_cstring M_STC; +extern const fcml_cstring M_STD; +extern const fcml_cstring M_STGI; +extern const fcml_cstring M_STI; +extern const fcml_cstring M_STMXCSR; +extern const fcml_cstring M_STOS; +extern const fcml_cstring M_STOSB; +extern const fcml_cstring M_STOSL; +extern const fcml_cstring M_STOSQ; +extern const fcml_cstring M_STOSW; +extern const fcml_cstring M_STR; +extern const fcml_cstring M_SUB; +extern const fcml_cstring M_SUBB; +extern const fcml_cstring M_SUBL; +extern const fcml_cstring M_SUBPD; +extern const fcml_cstring M_SUBPS; +extern const fcml_cstring M_SUBQ; +extern const fcml_cstring M_SUBSD; +extern const fcml_cstring M_SUBSS; +extern const fcml_cstring M_SUBW; +extern const fcml_cstring M_SWAPGS; +extern const fcml_cstring M_SYSCALL; +extern const fcml_cstring M_SYSENTER; +extern const fcml_cstring M_SYSEXIT; +extern const fcml_cstring M_SYSRET; +extern const fcml_cstring M_T1MSKC; +extern const fcml_cstring M_TEST; +extern const fcml_cstring M_TESTB; +extern const fcml_cstring M_TESTL; +extern const fcml_cstring M_TESTQ; +extern const fcml_cstring M_TESTW; +extern const fcml_cstring M_TZCNT; +extern const fcml_cstring M_TZMSK; +extern const fcml_cstring M_UCOMISD; +extern const fcml_cstring M_UCOMISS; +extern const fcml_cstring M_UD2; +extern const fcml_cstring M_UNPCKHPD; +extern const fcml_cstring M_UNPCKHPS; +extern const fcml_cstring M_UNPCKLPD; +extern const fcml_cstring M_UNPCKLPS; +extern const fcml_cstring M_V4FMADDPS; +extern const fcml_cstring M_V4FMADDSS; +extern const fcml_cstring M_V4FNMADDPS; +extern const fcml_cstring M_V4FNMADDSS; +extern const fcml_cstring M_VADDPD; +extern const fcml_cstring M_VADDPS; +extern const fcml_cstring M_VADDSD; +extern const fcml_cstring M_VADDSS; +extern const fcml_cstring M_VADDSUBPD; +extern const fcml_cstring M_VADDSUBPS; +extern const fcml_cstring M_VAESDEC; +extern const fcml_cstring M_VAESDECLAST; +extern const fcml_cstring M_VAESENC; +extern const fcml_cstring M_VAESENCLAST; +extern const fcml_cstring M_VAESIMC; +extern const fcml_cstring M_VAESKEYGENASSIST; +extern const fcml_cstring M_VALIGND; +extern const fcml_cstring M_VALIGNQ; +extern const fcml_cstring M_VANDNPD; +extern const fcml_cstring M_VANDNPS; +extern const fcml_cstring M_VANDPD; +extern const fcml_cstring M_VANDPS; +extern const fcml_cstring M_VBLENDMPD; +extern const fcml_cstring M_VBLENDMPS; +extern const fcml_cstring M_VBLENDPD; +extern const fcml_cstring M_VBLENDPS; +extern const fcml_cstring M_VBLENDVPD; +extern const fcml_cstring M_VBLENDVPS; +extern const fcml_cstring M_VBROADCASTF128; +extern const fcml_cstring M_VBROADCASTF32X2; +extern const fcml_cstring M_VBROADCASTF32X4; +extern const fcml_cstring M_VBROADCASTF32X8; +extern const fcml_cstring M_VBROADCASTF64X2; +extern const fcml_cstring M_VBROADCASTF64X4; +extern const fcml_cstring M_VBROADCASTI128; +extern const fcml_cstring M_VBROADCASTI32X2; +extern const fcml_cstring M_VBROADCASTI32X4; +extern const fcml_cstring M_VBROADCASTI32X8; +extern const fcml_cstring M_VBROADCASTI64X2; +extern const fcml_cstring M_VBROADCASTI64X4; +extern const fcml_cstring M_VBROADCASTSD; +extern const fcml_cstring M_VBROADCASTSS; +extern const fcml_cstring M_VCMPEQ_OSPD; +extern const fcml_cstring M_VCMPEQ_OSPS; +extern const fcml_cstring M_VCMPEQ_OSSD; +extern const fcml_cstring M_VCMPEQ_OSSS; +extern const fcml_cstring M_VCMPEQ_UQPD; +extern const fcml_cstring M_VCMPEQ_UQPS; +extern const fcml_cstring M_VCMPEQ_UQSD; +extern const fcml_cstring M_VCMPEQ_UQSS; +extern const fcml_cstring M_VCMPEQ_USPD; +extern const fcml_cstring M_VCMPEQ_USPS; +extern const fcml_cstring M_VCMPEQ_USSD; +extern const fcml_cstring M_VCMPEQ_USSS; +extern const fcml_cstring M_VCMPEQPD; +extern const fcml_cstring M_VCMPEQPS; +extern const fcml_cstring M_VCMPEQSD; +extern const fcml_cstring M_VCMPEQSS; +extern const fcml_cstring M_VCMPFALSE_OSPD; +extern const fcml_cstring M_VCMPFALSE_OSPS; +extern const fcml_cstring M_VCMPFALSE_OSSD; +extern const fcml_cstring M_VCMPFALSE_OSSS; +extern const fcml_cstring M_VCMPFALSEPD; +extern const fcml_cstring M_VCMPFALSEPS; +extern const fcml_cstring M_VCMPFALSESD; +extern const fcml_cstring M_VCMPFALSESS; +extern const fcml_cstring M_VCMPGE_OQPD; +extern const fcml_cstring M_VCMPGE_OQPS; +extern const fcml_cstring M_VCMPGE_OQSD; +extern const fcml_cstring M_VCMPGE_OQSS; +extern const fcml_cstring M_VCMPGEPD; +extern const fcml_cstring M_VCMPGEPS; +extern const fcml_cstring M_VCMPGESD; +extern const fcml_cstring M_VCMPGESS; +extern const fcml_cstring M_VCMPGT_OQPD; +extern const fcml_cstring M_VCMPGT_OQPS; +extern const fcml_cstring M_VCMPGT_OQSD; +extern const fcml_cstring M_VCMPGT_OQSS; +extern const fcml_cstring M_VCMPGTPD; +extern const fcml_cstring M_VCMPGTPS; +extern const fcml_cstring M_VCMPGTSD; +extern const fcml_cstring M_VCMPGTSS; +extern const fcml_cstring M_VCMPLE_OQPD; +extern const fcml_cstring M_VCMPLE_OQPS; +extern const fcml_cstring M_VCMPLE_OQSD; +extern const fcml_cstring M_VCMPLE_OQSS; +extern const fcml_cstring M_VCMPLEPD; +extern const fcml_cstring M_VCMPLEPS; +extern const fcml_cstring M_VCMPLESD; +extern const fcml_cstring M_VCMPLESS; +extern const fcml_cstring M_VCMPLT_OQPD; +extern const fcml_cstring M_VCMPLT_OQPS; +extern const fcml_cstring M_VCMPLT_OQSD; +extern const fcml_cstring M_VCMPLT_OQSS; +extern const fcml_cstring M_VCMPLTPD; +extern const fcml_cstring M_VCMPLTPS; +extern const fcml_cstring M_VCMPLTSD; +extern const fcml_cstring M_VCMPLTSS; +extern const fcml_cstring M_VCMPNEQ_OQPD; +extern const fcml_cstring M_VCMPNEQ_OQPS; +extern const fcml_cstring M_VCMPNEQ_OQSD; +extern const fcml_cstring M_VCMPNEQ_OQSS; +extern const fcml_cstring M_VCMPNEQ_OSPD; +extern const fcml_cstring M_VCMPNEQ_OSPS; +extern const fcml_cstring M_VCMPNEQ_OSSD; +extern const fcml_cstring M_VCMPNEQ_OSSS; +extern const fcml_cstring M_VCMPNEQ_USPD; +extern const fcml_cstring M_VCMPNEQ_USPS; +extern const fcml_cstring M_VCMPNEQ_USSD; +extern const fcml_cstring M_VCMPNEQ_USSS; +extern const fcml_cstring M_VCMPNEQPD; +extern const fcml_cstring M_VCMPNEQPS; +extern const fcml_cstring M_VCMPNEQSD; +extern const fcml_cstring M_VCMPNEQSS; +extern const fcml_cstring M_VCMPNGE_UQPD; +extern const fcml_cstring M_VCMPNGE_UQPS; +extern const fcml_cstring M_VCMPNGE_UQSD; +extern const fcml_cstring M_VCMPNGE_UQSS; +extern const fcml_cstring M_VCMPNGEPD; +extern const fcml_cstring M_VCMPNGEPS; +extern const fcml_cstring M_VCMPNGESD; +extern const fcml_cstring M_VCMPNGESS; +extern const fcml_cstring M_VCMPNGT_UQPD; +extern const fcml_cstring M_VCMPNGT_UQPS; +extern const fcml_cstring M_VCMPNGT_UQSD; +extern const fcml_cstring M_VCMPNGT_UQSS; +extern const fcml_cstring M_VCMPNGTPD; +extern const fcml_cstring M_VCMPNGTPS; +extern const fcml_cstring M_VCMPNGTSD; +extern const fcml_cstring M_VCMPNGTSS; +extern const fcml_cstring M_VCMPNLE_UQPD; +extern const fcml_cstring M_VCMPNLE_UQPS; +extern const fcml_cstring M_VCMPNLE_UQSD; +extern const fcml_cstring M_VCMPNLE_UQSS; +extern const fcml_cstring M_VCMPNLEPD; +extern const fcml_cstring M_VCMPNLEPS; +extern const fcml_cstring M_VCMPNLESD; +extern const fcml_cstring M_VCMPNLESS; +extern const fcml_cstring M_VCMPNLT_UQPD; +extern const fcml_cstring M_VCMPNLT_UQPS; +extern const fcml_cstring M_VCMPNLT_UQSD; +extern const fcml_cstring M_VCMPNLT_UQSS; +extern const fcml_cstring M_VCMPNLTPD; +extern const fcml_cstring M_VCMPNLTPS; +extern const fcml_cstring M_VCMPNLTSD; +extern const fcml_cstring M_VCMPNLTSS; +extern const fcml_cstring M_VCMPORD_SPD; +extern const fcml_cstring M_VCMPORD_SPS; +extern const fcml_cstring M_VCMPORD_SSD; +extern const fcml_cstring M_VCMPORD_SSS; +extern const fcml_cstring M_VCMPORDPD; +extern const fcml_cstring M_VCMPORDPS; +extern const fcml_cstring M_VCMPORDSD; +extern const fcml_cstring M_VCMPORDSS; +extern const fcml_cstring M_VCMPPD; +extern const fcml_cstring M_VCMPPS; +extern const fcml_cstring M_VCMPSD; +extern const fcml_cstring M_VCMPSS; +extern const fcml_cstring M_VCMPTRUE_USPD; +extern const fcml_cstring M_VCMPTRUE_USPS; +extern const fcml_cstring M_VCMPTRUE_USSD; +extern const fcml_cstring M_VCMPTRUE_USSS; +extern const fcml_cstring M_VCMPTRUEPD; +extern const fcml_cstring M_VCMPTRUEPS; +extern const fcml_cstring M_VCMPTRUESD; +extern const fcml_cstring M_VCMPTRUESS; +extern const fcml_cstring M_VCMPUNORD_SPD; +extern const fcml_cstring M_VCMPUNORD_SPS; +extern const fcml_cstring M_VCMPUNORD_SSD; +extern const fcml_cstring M_VCMPUNORD_SSS; +extern const fcml_cstring M_VCMPUNORDPD; +extern const fcml_cstring M_VCMPUNORDPS; +extern const fcml_cstring M_VCMPUNORDSD; +extern const fcml_cstring M_VCMPUNORDSS; +extern const fcml_cstring M_VCOMISD; +extern const fcml_cstring M_VCOMISS; +extern const fcml_cstring M_VCOMPRESSPD; +extern const fcml_cstring M_VCOMPRESSPS; +extern const fcml_cstring M_VCVTDQ2PD; +extern const fcml_cstring M_VCVTDQ2PS; +extern const fcml_cstring M_VCVTPD2DQ; +extern const fcml_cstring M_VCVTPD2DQX; +extern const fcml_cstring M_VCVTPD2DQY; +extern const fcml_cstring M_VCVTPD2PS; +extern const fcml_cstring M_VCVTPD2PSX; +extern const fcml_cstring M_VCVTPD2PSY; +extern const fcml_cstring M_VCVTPD2QQ; +extern const fcml_cstring M_VCVTPD2UDQ; +extern const fcml_cstring M_VCVTPD2UDQX; +extern const fcml_cstring M_VCVTPD2UDQY; +extern const fcml_cstring M_VCVTPD2UQQ; +extern const fcml_cstring M_VCVTPH2PS; +extern const fcml_cstring M_VCVTPS2DQ; +extern const fcml_cstring M_VCVTPS2PD; +extern const fcml_cstring M_VCVTPS2PH; +extern const fcml_cstring M_VCVTPS2QQ; +extern const fcml_cstring M_VCVTPS2UDQ; +extern const fcml_cstring M_VCVTPS2UQQ; +extern const fcml_cstring M_VCVTQQ2PD; +extern const fcml_cstring M_VCVTQQ2PS; +extern const fcml_cstring M_VCVTQQ2PSX; +extern const fcml_cstring M_VCVTQQ2PSY; +extern const fcml_cstring M_VCVTSD2SI; +extern const fcml_cstring M_VCVTSD2SS; +extern const fcml_cstring M_VCVTSD2USI; +extern const fcml_cstring M_VCVTSI2SDL; +extern const fcml_cstring M_VCVTSI2SDQ; +extern const fcml_cstring M_VCVTSI2SSL; +extern const fcml_cstring M_VCVTSI2SSQ; +extern const fcml_cstring M_VCVTSS2SD; +extern const fcml_cstring M_VCVTSS2SI; +extern const fcml_cstring M_VCVTSS2USI; +extern const fcml_cstring M_VCVTTPD2DQ; +extern const fcml_cstring M_VCVTTPD2DQX; +extern const fcml_cstring M_VCVTTPD2DQY; +extern const fcml_cstring M_VCVTTPD2QQ; +extern const fcml_cstring M_VCVTTPD2UDQ; +extern const fcml_cstring M_VCVTTPD2UDQX; +extern const fcml_cstring M_VCVTTPD2UDQY; +extern const fcml_cstring M_VCVTTPD2UQQ; +extern const fcml_cstring M_VCVTTPS2DQ; +extern const fcml_cstring M_VCVTTPS2QQ; +extern const fcml_cstring M_VCVTTPS2UDQ; +extern const fcml_cstring M_VCVTTPS2UQQ; +extern const fcml_cstring M_VCVTTSD2SI; +extern const fcml_cstring M_VCVTTSD2USI; +extern const fcml_cstring M_VCVTTSS2SI; +extern const fcml_cstring M_VCVTTSS2USI; +extern const fcml_cstring M_VCVTUDQ2PD; +extern const fcml_cstring M_VCVTUDQ2PS; +extern const fcml_cstring M_VCVTUQQ2PD; +extern const fcml_cstring M_VCVTUQQ2PS; +extern const fcml_cstring M_VCVTUQQ2PSX; +extern const fcml_cstring M_VCVTUQQ2PSY; +extern const fcml_cstring M_VCVTUSI2SD; +extern const fcml_cstring M_VCVTUSI2SS; +extern const fcml_cstring M_VDBPSADBW; +extern const fcml_cstring M_VDIVPD; +extern const fcml_cstring M_VDIVPS; +extern const fcml_cstring M_VDIVSD; +extern const fcml_cstring M_VDIVSS; +extern const fcml_cstring M_VDPPD; +extern const fcml_cstring M_VDPPS; +extern const fcml_cstring M_VERR; +extern const fcml_cstring M_VERW; +extern const fcml_cstring M_VEXP2PD; +extern const fcml_cstring M_VEXP2PS; +extern const fcml_cstring M_VEXPANDPD; +extern const fcml_cstring M_VEXPANDPS; +extern const fcml_cstring M_VEXTRACTF128; +extern const fcml_cstring M_VEXTRACTF32X4; +extern const fcml_cstring M_VEXTRACTF32X8; +extern const fcml_cstring M_VEXTRACTF64X2; +extern const fcml_cstring M_VEXTRACTF64X4; +extern const fcml_cstring M_VEXTRACTI128; +extern const fcml_cstring M_VEXTRACTI32X4; +extern const fcml_cstring M_VEXTRACTI32X8; +extern const fcml_cstring M_VEXTRACTI64X2; +extern const fcml_cstring M_VEXTRACTI64X4; +extern const fcml_cstring M_VEXTRACTPS; +extern const fcml_cstring M_VFIXUPIMMPD; +extern const fcml_cstring M_VFIXUPIMMPS; +extern const fcml_cstring M_VFIXUPIMMSD; +extern const fcml_cstring M_VFIXUPIMMSS; +extern const fcml_cstring M_VFMADD132PD; +extern const fcml_cstring M_VFMADD132PS; +extern const fcml_cstring M_VFMADD132SD; +extern const fcml_cstring M_VFMADD132SS; +extern const fcml_cstring M_VFMADD213PD; +extern const fcml_cstring M_VFMADD213PS; +extern const fcml_cstring M_VFMADD213SD; +extern const fcml_cstring M_VFMADD213SS; +extern const fcml_cstring M_VFMADD231PD; +extern const fcml_cstring M_VFMADD231PS; +extern const fcml_cstring M_VFMADD231SD; +extern const fcml_cstring M_VFMADD231SS; +extern const fcml_cstring M_VFMADDPD; +extern const fcml_cstring M_VFMADDPS; +extern const fcml_cstring M_VFMADDSD; +extern const fcml_cstring M_VFMADDSS; +extern const fcml_cstring M_VFMADDSUB132PD; +extern const fcml_cstring M_VFMADDSUB132PS; +extern const fcml_cstring M_VFMADDSUB213PD; +extern const fcml_cstring M_VFMADDSUB213PS; +extern const fcml_cstring M_VFMADDSUB231PD; +extern const fcml_cstring M_VFMADDSUB231PS; +extern const fcml_cstring M_VFMADDSUBPD; +extern const fcml_cstring M_VFMADDSUBPS; +extern const fcml_cstring M_VFMSUB132PD; +extern const fcml_cstring M_VFMSUB132PS; +extern const fcml_cstring M_VFMSUB132SD; +extern const fcml_cstring M_VFMSUB132SS; +extern const fcml_cstring M_VFMSUB213PD; +extern const fcml_cstring M_VFMSUB213PS; +extern const fcml_cstring M_VFMSUB213SD; +extern const fcml_cstring M_VFMSUB213SS; +extern const fcml_cstring M_VFMSUB231PD; +extern const fcml_cstring M_VFMSUB231PS; +extern const fcml_cstring M_VFMSUB231SD; +extern const fcml_cstring M_VFMSUB231SS; +extern const fcml_cstring M_VFMSUBADD132PD; +extern const fcml_cstring M_VFMSUBADD132PS; +extern const fcml_cstring M_VFMSUBADD213PD; +extern const fcml_cstring M_VFMSUBADD213PS; +extern const fcml_cstring M_VFMSUBADD231PD; +extern const fcml_cstring M_VFMSUBADD231PS; +extern const fcml_cstring M_VFMSUBADDPD; +extern const fcml_cstring M_VFMSUBADDPS; +extern const fcml_cstring M_VFMSUBPD; +extern const fcml_cstring M_VFMSUBPS; +extern const fcml_cstring M_VFMSUBSD; +extern const fcml_cstring M_VFMSUBSS; +extern const fcml_cstring M_VFNMADD132PD; +extern const fcml_cstring M_VFNMADD132PS; +extern const fcml_cstring M_VFNMADD132SD; +extern const fcml_cstring M_VFNMADD132SS; +extern const fcml_cstring M_VFNMADD213PD; +extern const fcml_cstring M_VFNMADD213PS; +extern const fcml_cstring M_VFNMADD213SD; +extern const fcml_cstring M_VFNMADD213SS; +extern const fcml_cstring M_VFNMADD231PD; +extern const fcml_cstring M_VFNMADD231PS; +extern const fcml_cstring M_VFNMADD231SD; +extern const fcml_cstring M_VFNMADD231SS; +extern const fcml_cstring M_VFNMADDPD; +extern const fcml_cstring M_VFNMADDPS; +extern const fcml_cstring M_VFNMADDSD; +extern const fcml_cstring M_VFNMADDSS; +extern const fcml_cstring M_VFNMSUB132PD; +extern const fcml_cstring M_VFNMSUB132PS; +extern const fcml_cstring M_VFNMSUB132SD; +extern const fcml_cstring M_VFNMSUB132SS; +extern const fcml_cstring M_VFNMSUB213PD; +extern const fcml_cstring M_VFNMSUB213PS; +extern const fcml_cstring M_VFNMSUB213SD; +extern const fcml_cstring M_VFNMSUB213SS; +extern const fcml_cstring M_VFNMSUB231PD; +extern const fcml_cstring M_VFNMSUB231PS; +extern const fcml_cstring M_VFNMSUB231SD; +extern const fcml_cstring M_VFNMSUB231SS; +extern const fcml_cstring M_VFNMSUBPD; +extern const fcml_cstring M_VFNMSUBPS; +extern const fcml_cstring M_VFNMSUBSD; +extern const fcml_cstring M_VFNMSUBSS; +extern const fcml_cstring M_VFPCLASSPD; +extern const fcml_cstring M_VFPCLASSPS; +extern const fcml_cstring M_VFPCLASSSD; +extern const fcml_cstring M_VFPCLASSSS; +extern const fcml_cstring M_VFRCZPD; +extern const fcml_cstring M_VFRCZPS; +extern const fcml_cstring M_VFRCZSD; +extern const fcml_cstring M_VFRCZSS; +extern const fcml_cstring M_VGATHERDPD; +extern const fcml_cstring M_VGATHERDPS; +extern const fcml_cstring M_VGATHERPF0DPD; +extern const fcml_cstring M_VGATHERPF0DPS; +extern const fcml_cstring M_VGATHERPF0QPD; +extern const fcml_cstring M_VGATHERPF0QPS; +extern const fcml_cstring M_VGATHERPF1DPD; +extern const fcml_cstring M_VGATHERPF1DPS; +extern const fcml_cstring M_VGATHERPF1QPD; +extern const fcml_cstring M_VGATHERPF1QPS; +extern const fcml_cstring M_VGATHERQPD; +extern const fcml_cstring M_VGATHERQPS; +extern const fcml_cstring M_VGETEXPPD; +extern const fcml_cstring M_VGETEXPPS; +extern const fcml_cstring M_VGETEXPSD; +extern const fcml_cstring M_VGETEXPSS; +extern const fcml_cstring M_VGETMANTPD; +extern const fcml_cstring M_VGETMANTPS; +extern const fcml_cstring M_VGETMANTSD; +extern const fcml_cstring M_VGETMANTSS; +extern const fcml_cstring M_VHADDPD; +extern const fcml_cstring M_VHADDPS; +extern const fcml_cstring M_VHSUBPD; +extern const fcml_cstring M_VHSUBPS; +extern const fcml_cstring M_VINSERTF128; +extern const fcml_cstring M_VINSERTF32X4; +extern const fcml_cstring M_VINSERTF32X8; +extern const fcml_cstring M_VINSERTF64X2; +extern const fcml_cstring M_VINSERTF64X4; +extern const fcml_cstring M_VINSERTI128; +extern const fcml_cstring M_VINSERTI32X4; +extern const fcml_cstring M_VINSERTI32X8; +extern const fcml_cstring M_VINSERTI64X2; +extern const fcml_cstring M_VINSERTI64X4; +extern const fcml_cstring M_VINSERTPS; +extern const fcml_cstring M_VLDDQU; +extern const fcml_cstring M_VLDMXCSR; +extern const fcml_cstring M_VMASKMOVDQU; +extern const fcml_cstring M_VMASKMOVPD; +extern const fcml_cstring M_VMASKMOVPS; +extern const fcml_cstring M_VMAXPD; +extern const fcml_cstring M_VMAXPS; +extern const fcml_cstring M_VMAXSD; +extern const fcml_cstring M_VMAXSS; +extern const fcml_cstring M_VMCALL; +extern const fcml_cstring M_VMCLEAR; +extern const fcml_cstring M_VMFUNC; +extern const fcml_cstring M_VMINPD; +extern const fcml_cstring M_VMINPS; +extern const fcml_cstring M_VMINSD; +extern const fcml_cstring M_VMINSS; +extern const fcml_cstring M_VMLAUNCH; +extern const fcml_cstring M_VMLOAD; +extern const fcml_cstring M_VMMCALL; +extern const fcml_cstring M_VMOVAPD; +extern const fcml_cstring M_VMOVAPS; +extern const fcml_cstring M_VMOVD; +extern const fcml_cstring M_VMOVDDUP; +extern const fcml_cstring M_VMOVDQA; +extern const fcml_cstring M_VMOVDQA32; +extern const fcml_cstring M_VMOVDQA64; +extern const fcml_cstring M_VMOVDQU; +extern const fcml_cstring M_VMOVDQU16; +extern const fcml_cstring M_VMOVDQU32; +extern const fcml_cstring M_VMOVDQU64; +extern const fcml_cstring M_VMOVDQU8; +extern const fcml_cstring M_VMOVHLPS; +extern const fcml_cstring M_VMOVHPD; +extern const fcml_cstring M_VMOVHPS; +extern const fcml_cstring M_VMOVLHPS; +extern const fcml_cstring M_VMOVLPD; +extern const fcml_cstring M_VMOVLPS; +extern const fcml_cstring M_VMOVMSKPD; +extern const fcml_cstring M_VMOVMSKPS; +extern const fcml_cstring M_VMOVNTDQ; +extern const fcml_cstring M_VMOVNTDQA; +extern const fcml_cstring M_VMOVNTPD; +extern const fcml_cstring M_VMOVNTPS; +extern const fcml_cstring M_VMOVQ; +extern const fcml_cstring M_VMOVSD; +extern const fcml_cstring M_VMOVSHDUP; +extern const fcml_cstring M_VMOVSLDUP; +extern const fcml_cstring M_VMOVSS; +extern const fcml_cstring M_VMOVUPD; +extern const fcml_cstring M_VMOVUPS; +extern const fcml_cstring M_VMPSADBW; +extern const fcml_cstring M_VMPTRLD; +extern const fcml_cstring M_VMPTRST; +extern const fcml_cstring M_VMREAD; +extern const fcml_cstring M_VMRESUME; +extern const fcml_cstring M_VMRUN; +extern const fcml_cstring M_VMSAVE; +extern const fcml_cstring M_VMULPD; +extern const fcml_cstring M_VMULPS; +extern const fcml_cstring M_VMULSD; +extern const fcml_cstring M_VMULSS; +extern const fcml_cstring M_VMWRITE; +extern const fcml_cstring M_VMXOFF; +extern const fcml_cstring M_VMXON; +extern const fcml_cstring M_VORPD; +extern const fcml_cstring M_VORPS; +extern const fcml_cstring M_VP4DPWSSD; +extern const fcml_cstring M_VP4DPWSSDS; +extern const fcml_cstring M_VPABSB; +extern const fcml_cstring M_VPABSD; +extern const fcml_cstring M_VPABSQ; +extern const fcml_cstring M_VPABSW; +extern const fcml_cstring M_VPACKSSDW; +extern const fcml_cstring M_VPACKSSWB; +extern const fcml_cstring M_VPACKUSDW; +extern const fcml_cstring M_VPACKUSWB; +extern const fcml_cstring M_VPADDB; +extern const fcml_cstring M_VPADDD; +extern const fcml_cstring M_VPADDQ; +extern const fcml_cstring M_VPADDSB; +extern const fcml_cstring M_VPADDSW; +extern const fcml_cstring M_VPADDUSB; +extern const fcml_cstring M_VPADDUSW; +extern const fcml_cstring M_VPADDW; +extern const fcml_cstring M_VPALIGNR; +extern const fcml_cstring M_VPAND; +extern const fcml_cstring M_VPANDD; +extern const fcml_cstring M_VPANDN; +extern const fcml_cstring M_VPANDND; +extern const fcml_cstring M_VPANDNQ; +extern const fcml_cstring M_VPANDQ; +extern const fcml_cstring M_VPAVGB; +extern const fcml_cstring M_VPAVGW; +extern const fcml_cstring M_VPBLENDD; +extern const fcml_cstring M_VPBLENDMB; +extern const fcml_cstring M_VPBLENDMD; +extern const fcml_cstring M_VPBLENDMQ; +extern const fcml_cstring M_VPBLENDMW; +extern const fcml_cstring M_VPBLENDVB; +extern const fcml_cstring M_VPBLENDW; +extern const fcml_cstring M_VPBROADCASTB; +extern const fcml_cstring M_VPBROADCASTD; +extern const fcml_cstring M_VPBROADCASTMB2Q; +extern const fcml_cstring M_VPBROADCASTMW2D; +extern const fcml_cstring M_VPBROADCASTQ; +extern const fcml_cstring M_VPBROADCASTW; +extern const fcml_cstring M_VPCLMULQDQ; +extern const fcml_cstring M_VPCMOV; +extern const fcml_cstring M_VPCMPB; +extern const fcml_cstring M_VPCMPD; +extern const fcml_cstring M_VPCMPEQB; +extern const fcml_cstring M_VPCMPEQD; +extern const fcml_cstring M_VPCMPEQQ; +extern const fcml_cstring M_VPCMPEQW; +extern const fcml_cstring M_VPCMPESTRI; +extern const fcml_cstring M_VPCMPESTRM; +extern const fcml_cstring M_VPCMPGTB; +extern const fcml_cstring M_VPCMPGTD; +extern const fcml_cstring M_VPCMPGTQ; +extern const fcml_cstring M_VPCMPGTW; +extern const fcml_cstring M_VPCMPISTRI; +extern const fcml_cstring M_VPCMPISTRM; +extern const fcml_cstring M_VPCMPQ; +extern const fcml_cstring M_VPCMPUB; +extern const fcml_cstring M_VPCMPUD; +extern const fcml_cstring M_VPCMPUQ; +extern const fcml_cstring M_VPCMPUW; +extern const fcml_cstring M_VPCMPW; +extern const fcml_cstring M_VPCOMB; +extern const fcml_cstring M_VPCOMD; +extern const fcml_cstring M_VPCOMEQB; +extern const fcml_cstring M_VPCOMEQD; +extern const fcml_cstring M_VPCOMEQQ; +extern const fcml_cstring M_VPCOMEQUB; +extern const fcml_cstring M_VPCOMEQUD; +extern const fcml_cstring M_VPCOMEQUQ; +extern const fcml_cstring M_VPCOMEQUW; +extern const fcml_cstring M_VPCOMEQW; +extern const fcml_cstring M_VPCOMFALSEB; +extern const fcml_cstring M_VPCOMFALSED; +extern const fcml_cstring M_VPCOMFALSEQ; +extern const fcml_cstring M_VPCOMFALSEUB; +extern const fcml_cstring M_VPCOMFALSEUD; +extern const fcml_cstring M_VPCOMFALSEUQ; +extern const fcml_cstring M_VPCOMFALSEUW; +extern const fcml_cstring M_VPCOMFALSEW; +extern const fcml_cstring M_VPCOMGEB; +extern const fcml_cstring M_VPCOMGED; +extern const fcml_cstring M_VPCOMGEQ; +extern const fcml_cstring M_VPCOMGEUB; +extern const fcml_cstring M_VPCOMGEUD; +extern const fcml_cstring M_VPCOMGEUQ; +extern const fcml_cstring M_VPCOMGEUW; +extern const fcml_cstring M_VPCOMGEW; +extern const fcml_cstring M_VPCOMGTB; +extern const fcml_cstring M_VPCOMGTD; +extern const fcml_cstring M_VPCOMGTQ; +extern const fcml_cstring M_VPCOMGTUB; +extern const fcml_cstring M_VPCOMGTUD; +extern const fcml_cstring M_VPCOMGTUQ; +extern const fcml_cstring M_VPCOMGTUW; +extern const fcml_cstring M_VPCOMGTW; +extern const fcml_cstring M_VPCOMLEB; +extern const fcml_cstring M_VPCOMLED; +extern const fcml_cstring M_VPCOMLEQ; +extern const fcml_cstring M_VPCOMLEUB; +extern const fcml_cstring M_VPCOMLEUD; +extern const fcml_cstring M_VPCOMLEUQ; +extern const fcml_cstring M_VPCOMLEUW; +extern const fcml_cstring M_VPCOMLEW; +extern const fcml_cstring M_VPCOMLTB; +extern const fcml_cstring M_VPCOMLTD; +extern const fcml_cstring M_VPCOMLTQ; +extern const fcml_cstring M_VPCOMLTUB; +extern const fcml_cstring M_VPCOMLTUD; +extern const fcml_cstring M_VPCOMLTUQ; +extern const fcml_cstring M_VPCOMLTUW; +extern const fcml_cstring M_VPCOMLTW; +extern const fcml_cstring M_VPCOMNEQB; +extern const fcml_cstring M_VPCOMNEQD; +extern const fcml_cstring M_VPCOMNEQQ; +extern const fcml_cstring M_VPCOMNEQUB; +extern const fcml_cstring M_VPCOMNEQUD; +extern const fcml_cstring M_VPCOMNEQUQ; +extern const fcml_cstring M_VPCOMNEQUW; +extern const fcml_cstring M_VPCOMNEQW; +extern const fcml_cstring M_VPCOMPRESSD; +extern const fcml_cstring M_VPCOMPRESSQ; +extern const fcml_cstring M_VPCOMQ; +extern const fcml_cstring M_VPCOMTRUEB; +extern const fcml_cstring M_VPCOMTRUED; +extern const fcml_cstring M_VPCOMTRUEQ; +extern const fcml_cstring M_VPCOMTRUEUB; +extern const fcml_cstring M_VPCOMTRUEUD; +extern const fcml_cstring M_VPCOMTRUEUQ; +extern const fcml_cstring M_VPCOMTRUEUW; +extern const fcml_cstring M_VPCOMTRUEW; +extern const fcml_cstring M_VPCOMUB; +extern const fcml_cstring M_VPCOMUD; +extern const fcml_cstring M_VPCOMUQ; +extern const fcml_cstring M_VPCOMUW; +extern const fcml_cstring M_VPCOMW; +extern const fcml_cstring M_VPERM2F128; +extern const fcml_cstring M_VPERM2I128; +extern const fcml_cstring M_VPERMB; +extern const fcml_cstring M_VPERMD; +extern const fcml_cstring M_VPERMI2B; +extern const fcml_cstring M_VPERMI2D; +extern const fcml_cstring M_VPERMI2PD; +extern const fcml_cstring M_VPERMI2PS; +extern const fcml_cstring M_VPERMI2Q; +extern const fcml_cstring M_VPERMI2W; +extern const fcml_cstring M_VPERMIL2PD; +extern const fcml_cstring M_VPERMIL2PS; +extern const fcml_cstring M_VPERMILPD; +extern const fcml_cstring M_VPERMILPS; +extern const fcml_cstring M_VPERMPD; +extern const fcml_cstring M_VPERMPS; +extern const fcml_cstring M_VPERMQ; +extern const fcml_cstring M_VPERMT2B; +extern const fcml_cstring M_VPERMT2D; +extern const fcml_cstring M_VPERMT2PD; +extern const fcml_cstring M_VPERMT2PS; +extern const fcml_cstring M_VPERMT2Q; +extern const fcml_cstring M_VPERMT2W; +extern const fcml_cstring M_VPERMW; +extern const fcml_cstring M_VPEXPANDD; +extern const fcml_cstring M_VPEXPANDQ; +extern const fcml_cstring M_VPEXTRB; +extern const fcml_cstring M_VPEXTRD; +extern const fcml_cstring M_VPEXTRQ; +extern const fcml_cstring M_VPEXTRW; +extern const fcml_cstring M_VPGATHERDD; +extern const fcml_cstring M_VPGATHERDQ; +extern const fcml_cstring M_VPGATHERQD; +extern const fcml_cstring M_VPGATHERQQ; +extern const fcml_cstring M_VPHADDBD; +extern const fcml_cstring M_VPHADDBQ; +extern const fcml_cstring M_VPHADDBW; +extern const fcml_cstring M_VPHADDD; +extern const fcml_cstring M_VPHADDDQ; +extern const fcml_cstring M_VPHADDSW; +extern const fcml_cstring M_VPHADDUBD; +extern const fcml_cstring M_VPHADDUBQ; +extern const fcml_cstring M_VPHADDUBW; +extern const fcml_cstring M_VPHADDUDQ; +extern const fcml_cstring M_VPHADDUWD; +extern const fcml_cstring M_VPHADDUWQ; +extern const fcml_cstring M_VPHADDW; +extern const fcml_cstring M_VPHADDWD; +extern const fcml_cstring M_VPHADDWQ; +extern const fcml_cstring M_VPHMINPOSUW; +extern const fcml_cstring M_VPHSUBBW; +extern const fcml_cstring M_VPHSUBD; +extern const fcml_cstring M_VPHSUBDQ; +extern const fcml_cstring M_VPHSUBSW; +extern const fcml_cstring M_VPHSUBW; +extern const fcml_cstring M_VPHSUBWD; +extern const fcml_cstring M_VPINSRB; +extern const fcml_cstring M_VPINSRD; +extern const fcml_cstring M_VPINSRQ; +extern const fcml_cstring M_VPINSRW; +extern const fcml_cstring M_VPLZCNTD; +extern const fcml_cstring M_VPLZCNTQ; +extern const fcml_cstring M_VPMACSDD; +extern const fcml_cstring M_VPMACSDQH; +extern const fcml_cstring M_VPMACSDQL; +extern const fcml_cstring M_VPMACSSDD; +extern const fcml_cstring M_VPMACSSDQH; +extern const fcml_cstring M_VPMACSSDQL; +extern const fcml_cstring M_VPMACSSWD; +extern const fcml_cstring M_VPMACSSWW; +extern const fcml_cstring M_VPMACSWD; +extern const fcml_cstring M_VPMACSWW; +extern const fcml_cstring M_VPMADCSSWD; +extern const fcml_cstring M_VPMADCSWD; +extern const fcml_cstring M_VPMADD52HUQ; +extern const fcml_cstring M_VPMADD52LUQ; +extern const fcml_cstring M_VPMADDUBSW; +extern const fcml_cstring M_VPMADDWD; +extern const fcml_cstring M_VPMASKMOV; +extern const fcml_cstring M_VPMASKMOVD; +extern const fcml_cstring M_VPMASKMOVQ; +extern const fcml_cstring M_VPMAXSB; +extern const fcml_cstring M_VPMAXSD; +extern const fcml_cstring M_VPMAXSQ; +extern const fcml_cstring M_VPMAXSW; +extern const fcml_cstring M_VPMAXUB; +extern const fcml_cstring M_VPMAXUD; +extern const fcml_cstring M_VPMAXUQ; +extern const fcml_cstring M_VPMAXUW; +extern const fcml_cstring M_VPMINSB; +extern const fcml_cstring M_VPMINSD; +extern const fcml_cstring M_VPMINSQ; +extern const fcml_cstring M_VPMINSW; +extern const fcml_cstring M_VPMINUB; +extern const fcml_cstring M_VPMINUD; +extern const fcml_cstring M_VPMINUQ; +extern const fcml_cstring M_VPMINUW; +extern const fcml_cstring M_VPMOVB2M; +extern const fcml_cstring M_VPMOVD2M; +extern const fcml_cstring M_VPMOVDB; +extern const fcml_cstring M_VPMOVDW; +extern const fcml_cstring M_VPMOVM2B; +extern const fcml_cstring M_VPMOVM2D; +extern const fcml_cstring M_VPMOVM2Q; +extern const fcml_cstring M_VPMOVM2W; +extern const fcml_cstring M_VPMOVMSKB; +extern const fcml_cstring M_VPMOVQ2M; +extern const fcml_cstring M_VPMOVQB; +extern const fcml_cstring M_VPMOVQD; +extern const fcml_cstring M_VPMOVQW; +extern const fcml_cstring M_VPMOVSDB; +extern const fcml_cstring M_VPMOVSDW; +extern const fcml_cstring M_VPMOVSQB; +extern const fcml_cstring M_VPMOVSQD; +extern const fcml_cstring M_VPMOVSQW; +extern const fcml_cstring M_VPMOVSWB; +extern const fcml_cstring M_VPMOVSXBD; +extern const fcml_cstring M_VPMOVSXBQ; +extern const fcml_cstring M_VPMOVSXBW; +extern const fcml_cstring M_VPMOVSXDQ; +extern const fcml_cstring M_VPMOVSXWD; +extern const fcml_cstring M_VPMOVSXWQ; +extern const fcml_cstring M_VPMOVUSDB; +extern const fcml_cstring M_VPMOVUSDW; +extern const fcml_cstring M_VPMOVUSQB; +extern const fcml_cstring M_VPMOVUSQD; +extern const fcml_cstring M_VPMOVUSQW; +extern const fcml_cstring M_VPMOVUSWB; +extern const fcml_cstring M_VPMOVW2M; +extern const fcml_cstring M_VPMOVWB; +extern const fcml_cstring M_VPMOVZXBD; +extern const fcml_cstring M_VPMOVZXBQ; +extern const fcml_cstring M_VPMOVZXBW; +extern const fcml_cstring M_VPMOVZXDQ; +extern const fcml_cstring M_VPMOVZXWD; +extern const fcml_cstring M_VPMOVZXWQ; +extern const fcml_cstring M_VPMULDQ; +extern const fcml_cstring M_VPMULHRSW; +extern const fcml_cstring M_VPMULHUW; +extern const fcml_cstring M_VPMULHW; +extern const fcml_cstring M_VPMULLD; +extern const fcml_cstring M_VPMULLQ; +extern const fcml_cstring M_VPMULLW; +extern const fcml_cstring M_VPMULTISHIFTQB; +extern const fcml_cstring M_VPMULUDQ; +extern const fcml_cstring M_VPOR; +extern const fcml_cstring M_VPORD; +extern const fcml_cstring M_VPORQ; +extern const fcml_cstring M_VPPERM; +extern const fcml_cstring M_VPROLD; +extern const fcml_cstring M_VPROLQ; +extern const fcml_cstring M_VPROLVD; +extern const fcml_cstring M_VPROLVQ; +extern const fcml_cstring M_VPRORD; +extern const fcml_cstring M_VPRORQ; +extern const fcml_cstring M_VPRORVD; +extern const fcml_cstring M_VPRORVQ; +extern const fcml_cstring M_VPROTB; +extern const fcml_cstring M_VPROTD; +extern const fcml_cstring M_VPROTQ; +extern const fcml_cstring M_VPROTW; +extern const fcml_cstring M_VPSADBW; +extern const fcml_cstring M_VPSCATTERDD; +extern const fcml_cstring M_VPSCATTERDQ; +extern const fcml_cstring M_VPSCATTERQD; +extern const fcml_cstring M_VPSCATTERQQ; +extern const fcml_cstring M_VPSHAB; +extern const fcml_cstring M_VPSHAD; +extern const fcml_cstring M_VPSHAQ; +extern const fcml_cstring M_VPSHAW; +extern const fcml_cstring M_VPSHLB; +extern const fcml_cstring M_VPSHLD; +extern const fcml_cstring M_VPSHLQ; +extern const fcml_cstring M_VPSHLW; +extern const fcml_cstring M_VPSHUFB; +extern const fcml_cstring M_VPSHUFD; +extern const fcml_cstring M_VPSHUFHW; +extern const fcml_cstring M_VPSHUFLW; +extern const fcml_cstring M_VPSIGNB; +extern const fcml_cstring M_VPSIGND; +extern const fcml_cstring M_VPSIGNW; +extern const fcml_cstring M_VPSLLD; +extern const fcml_cstring M_VPSLLDQ; +extern const fcml_cstring M_VPSLLQ; +extern const fcml_cstring M_VPSLLVD; +extern const fcml_cstring M_VPSLLVQ; +extern const fcml_cstring M_VPSLLVW; +extern const fcml_cstring M_VPSLLW; +extern const fcml_cstring M_VPSRAD; +extern const fcml_cstring M_VPSRAQ; +extern const fcml_cstring M_VPSRAVD; +extern const fcml_cstring M_VPSRAVQ; +extern const fcml_cstring M_VPSRAVW; +extern const fcml_cstring M_VPSRAW; +extern const fcml_cstring M_VPSRLD; +extern const fcml_cstring M_VPSRLDQ; +extern const fcml_cstring M_VPSRLQ; +extern const fcml_cstring M_VPSRLVD; +extern const fcml_cstring M_VPSRLVQ; +extern const fcml_cstring M_VPSRLVW; +extern const fcml_cstring M_VPSRLW; +extern const fcml_cstring M_VPSUBB; +extern const fcml_cstring M_VPSUBD; +extern const fcml_cstring M_VPSUBQ; +extern const fcml_cstring M_VPSUBSB; +extern const fcml_cstring M_VPSUBSW; +extern const fcml_cstring M_VPSUBUSB; +extern const fcml_cstring M_VPSUBUSW; +extern const fcml_cstring M_VPSUBW; +extern const fcml_cstring M_VPTERNLOGD; +extern const fcml_cstring M_VPTERNLOGQ; +extern const fcml_cstring M_VPTEST; +extern const fcml_cstring M_VPTESTMB; +extern const fcml_cstring M_VPTESTMD; +extern const fcml_cstring M_VPTESTMQ; +extern const fcml_cstring M_VPTESTMW; +extern const fcml_cstring M_VPTESTNMB; +extern const fcml_cstring M_VPTESTNMD; +extern const fcml_cstring M_VPTESTNMQ; +extern const fcml_cstring M_VPTESTNMW; +extern const fcml_cstring M_VPUNPCKHBW; +extern const fcml_cstring M_VPUNPCKHDQ; +extern const fcml_cstring M_VPUNPCKHQDQ; +extern const fcml_cstring M_VPUNPCKHWD; +extern const fcml_cstring M_VPUNPCKLBW; +extern const fcml_cstring M_VPUNPCKLDQ; +extern const fcml_cstring M_VPUNPCKLQDQ; +extern const fcml_cstring M_VPUNPCKLWD; +extern const fcml_cstring M_VPXOR; +extern const fcml_cstring M_VPXORD; +extern const fcml_cstring M_VPXORQ; +extern const fcml_cstring M_VRANGEPD; +extern const fcml_cstring M_VRANGEPS; +extern const fcml_cstring M_VRANGESD; +extern const fcml_cstring M_VRANGESS; +extern const fcml_cstring M_VRCP14PD; +extern const fcml_cstring M_VRCP14PS; +extern const fcml_cstring M_VRCP14SD; +extern const fcml_cstring M_VRCP14SS; +extern const fcml_cstring M_VRCP28PD; +extern const fcml_cstring M_VRCP28PS; +extern const fcml_cstring M_VRCP28SD; +extern const fcml_cstring M_VRCP28SS; +extern const fcml_cstring M_VRCPPS; +extern const fcml_cstring M_VRCPSS; +extern const fcml_cstring M_VREDUCEPD; +extern const fcml_cstring M_VREDUCEPS; +extern const fcml_cstring M_VREDUCESD; +extern const fcml_cstring M_VREDUCESS; +extern const fcml_cstring M_VRNDSCALEPD; +extern const fcml_cstring M_VRNDSCALEPS; +extern const fcml_cstring M_VRNDSCALESD; +extern const fcml_cstring M_VRNDSCALESS; +extern const fcml_cstring M_VROUNDPD; +extern const fcml_cstring M_VROUNDPS; +extern const fcml_cstring M_VROUNDSD; +extern const fcml_cstring M_VROUNDSS; +extern const fcml_cstring M_VRSQRT14PD; +extern const fcml_cstring M_VRSQRT14PS; +extern const fcml_cstring M_VRSQRT14SD; +extern const fcml_cstring M_VRSQRT14SS; +extern const fcml_cstring M_VRSQRT28PD; +extern const fcml_cstring M_VRSQRT28PS; +extern const fcml_cstring M_VRSQRT28SD; +extern const fcml_cstring M_VRSQRT28SS; +extern const fcml_cstring M_VRSQRTPS; +extern const fcml_cstring M_VRSQRTSS; +extern const fcml_cstring M_VSCALEFPD; +extern const fcml_cstring M_VSCALEFPS; +extern const fcml_cstring M_VSCALEFSD; +extern const fcml_cstring M_VSCALEFSS; +extern const fcml_cstring M_VSCATTERDPD; +extern const fcml_cstring M_VSCATTERDPS; +extern const fcml_cstring M_VSCATTERPF0DPD; +extern const fcml_cstring M_VSCATTERPF0DPS; +extern const fcml_cstring M_VSCATTERPF0QPD; +extern const fcml_cstring M_VSCATTERPF0QPS; +extern const fcml_cstring M_VSCATTERPF1DPD; +extern const fcml_cstring M_VSCATTERPF1DPS; +extern const fcml_cstring M_VSCATTERPF1QPD; +extern const fcml_cstring M_VSCATTERPF1QPS; +extern const fcml_cstring M_VSCATTERQPD; +extern const fcml_cstring M_VSCATTERQPS; +extern const fcml_cstring M_VSHUFF32X4; +extern const fcml_cstring M_VSHUFF64X2; +extern const fcml_cstring M_VSHUFI32X4; +extern const fcml_cstring M_VSHUFI64X2; +extern const fcml_cstring M_VSHUFPD; +extern const fcml_cstring M_VSHUFPS; +extern const fcml_cstring M_VSQRTPD; +extern const fcml_cstring M_VSQRTPS; +extern const fcml_cstring M_VSQRTSD; +extern const fcml_cstring M_VSQRTSS; +extern const fcml_cstring M_VSTMXCSR; +extern const fcml_cstring M_VSUBPD; +extern const fcml_cstring M_VSUBPS; +extern const fcml_cstring M_VSUBSD; +extern const fcml_cstring M_VSUBSS; +extern const fcml_cstring M_VTESTPD; +extern const fcml_cstring M_VTESTPS; +extern const fcml_cstring M_VUCOMISD; +extern const fcml_cstring M_VUCOMISS; +extern const fcml_cstring M_VUNPCKHPD; +extern const fcml_cstring M_VUNPCKHPS; +extern const fcml_cstring M_VUNPCKLPD; +extern const fcml_cstring M_VUNPCKLPS; +extern const fcml_cstring M_VXORPD; +extern const fcml_cstring M_VXORPS; +extern const fcml_cstring M_VZEROALL; +extern const fcml_cstring M_VZEROUPPER; +extern const fcml_cstring M_WAIT; +extern const fcml_cstring M_WBINVD; +extern const fcml_cstring M_WRFSBASE; +extern const fcml_cstring M_WRGSBASE; +extern const fcml_cstring M_WRMSR; +extern const fcml_cstring M_XABORT; +extern const fcml_cstring M_XADD; +extern const fcml_cstring M_XBEGIN; +extern const fcml_cstring M_XCHG; +extern const fcml_cstring M_XEND; +extern const fcml_cstring M_XGETBV; +extern const fcml_cstring M_XLAT; +extern const fcml_cstring M_XLATB; +extern const fcml_cstring M_XOR; +extern const fcml_cstring M_XORB; +extern const fcml_cstring M_XORL; +extern const fcml_cstring M_XORPD; +extern const fcml_cstring M_XORPS; +extern const fcml_cstring M_XORQ; +extern const fcml_cstring M_XORW; +extern const fcml_cstring M_XRSTOR; +extern const fcml_cstring M_XRSTOR64; +extern const fcml_cstring M_XSAVE; +extern const fcml_cstring M_XSAVE64; +extern const fcml_cstring M_XSAVEOPT; +extern const fcml_cstring M_XSAVEOPT64; +extern const fcml_cstring M_XSETBV; +extern const fcml_cstring M_XTEST; + +} +} + +#endif /* FCML_GAS_MNEMONICS_HPP_ */ diff --git a/dependencies/fcml/include/fcml_instructions.h b/dependencies/fcml/include/fcml_instructions.h new file mode 100644 index 0000000..b919567 --- /dev/null +++ b/dependencies/fcml/include/fcml_instructions.h @@ -0,0 +1,1548 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_instructions.h + * Instruction codes and addressing modes/instruction forms. + * @copyright Copyright (C) 2010-2017 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_INSTRUCTIONS_H_ +#define FCML_INSTRUCTIONS_H_ + +/** + * @defgroup INSTRUCTION_TYPES_GROUP Instructions types. + * Instructions types. + * @{ + */ + +#define FCML_AMT_UNDEF 0x0000000000000000UL +/* Grouping. */ +#define FCML_AMT_SSEx 0x0000000000000001UL +#define FCML_AMT_VEXx 0x0000000000000002UL +#define FCML_AMT_SIMD 0x0000000000000004UL +/* CPUID. */ +#define FCML_AMT_GPI 0x0000000000000008UL +#define FCML_AMT_FPU 0x0000000000000010UL +#define FCML_AMT_MMX 0x0000000000000020UL | FCML_AMT_SSEx +#define FCML_AMT_SSE 0x0000000000000040UL | FCML_AMT_SSEx +#define FCML_AMT_SSE2 0x0000000000000080UL | FCML_AMT_SSEx +#define FCML_AMT_SSE3 0x0000000000000100UL | FCML_AMT_SSEx +#define FCML_AMT_SSSE3 0x0000000000000200UL | FCML_AMT_SSEx +#define FCML_AMT_SSE41 0x0000000000000400UL | FCML_AMT_SSEx +#define FCML_AMT_SSE42 0x0000000000000800UL | FCML_AMT_SSEx +#define FCML_AMT_SSE4A 0x0000000000001000UL | FCML_AMT_SSEx +#define FCML_AMT_AVX 0x0000000000002000UL | FCML_AMT_VEXx +#define FCML_AMT_AVX2 0x0000000000004000UL | FCML_AMT_VEXx +#define FCML_AMT_AES 0x0000000000008000UL +#define FCML_AMT_SYSTEM 0x0000000000010000UL +#define FCML_AMT_3DNOW 0x0000000000020000UL | FCML_AMT_MMX +#define FCML_AMT_TBM 0x0000000000040000UL | FCML_AMT_VEXx +#define FCML_AMT_BMI1 0x0000000000080000UL +#define FCML_AMT_BMI2 0x0000000000100000UL +#define FCML_AMT_HLE 0x0000000000200000UL +#define FCML_AMT_ADX 0x0000000000400000UL +#define FCML_AMT_CLMUL 0x0000000000800000UL +#define FCML_AMT_F16C 0x0000000001000000UL | FCML_AMT_VEXx +#define FCML_AMT_RDRAND 0x0000000002000000UL +#define FCML_AMT_RDSEED 0x0000000004000000UL +#define FCML_AMT_PRFCHW 0x0000000008000000UL +#define FCML_AMT_LWP 0x0000000010000000UL | FCML_AMT_SIMD +#define FCML_AMT_SVM 0x0000000020000000UL +#define FCML_AMT_FSGSBASE 0x0000000040000000UL +#define FCML_AMT_FMA 0x0000000080000000UL | FCML_AMT_SIMD +#define FCML_AMT_FMA4 0x0000000100000000UL | FCML_AMT_SIMD +#define FCML_AMT_XOP 0x0000000200000000UL | FCML_AMT_SIMD +#define FCML_AMT_EDX 0x0000000400000000UL +#define FCML_AMT_ABM 0x0000000800000000UL +#define FCML_AMT_VMX 0x0000001000000000UL +#define FCML_AMT_SMX 0x0000002000000000UL +#define FCML_AMT_POPCNT 0x0000004000000000UL +#define FCML_AMT_RTM 0x0000008000000000UL +/* Control transfer instructions. */ +#define FCML_AMT_CTI 0x0000010000000000UL +#define FCML_AMT_BRANCH 0x0000020000000000UL +/* End of control transfer instructions. */ +#define FCML_AMT_AVX512 0x0000040000000000UL +/* Shortcuts. */ +#define FCML_AMT_MMX_SIMD FCML_AMT_MMX | FCML_AMT_SIMD +#define FCML_AMT_SSE_SIMD FCML_AMT_SSE | FCML_AMT_SIMD +#define FCML_AMT_SSE2_SIMD FCML_AMT_SSE2 | FCML_AMT_SIMD +#define FCML_AMT_SSE3_SIMD FCML_AMT_SSE3 | FCML_AMT_SIMD +#define FCML_AMT_SSSE3_SIMD FCML_AMT_SSSE3 | FCML_AMT_SIMD +#define FCML_AMT_SSE41_SIMD FCML_AMT_SSE41 | FCML_AMT_SIMD +#define FCML_AMT_SSE42_SIMD FCML_AMT_SSE42 | FCML_AMT_SIMD +#define FCML_AMT_AVX_SIMD FCML_AMT_AVX | FCML_AMT_SIMD +#define FCML_AMT_AVX2_SIMD FCML_AMT_AVX2 | FCML_AMT_SIMD +#define FCML_AMT_3DNOW_SIMD FCML_AMT_3DNOW | FCML_AMT_SIMD +#define FCML_AMT_AVX512_SIMD FCML_AMT_AVX512 | FCML_AMT_SIMD + +/** @} */ + +/** Instruction forms. */ +enum fcml_en_instruction_addr_mode_codes { + FCML_AM_UNKNOWN, + FCML_AM_NO_OPERANS, + FCML_AM_IMM8, + FCML_AM_IMMO, + FCML_AM_ER8_IMM8, + FCML_AM_R8_IMM8, + FCML_AM_ERO_IMMO, + FCML_AM_RM8_IMM8, + FCML_AM_RMO_IMMO, + FCML_AM_R0_IMM0, + FCML_AM_RMO_IMM8, + FCML_AM_RM8_R8, + FCML_AM_R8_RM8, + FCML_AM_R8_MOFF8, + FCML_AM_MOFF8_R8, + FCML_AM_R16_RM8, + FCML_AM_RO_RM16, + FCML_AM_RMO_RO, + FCML_AM_RO_RMO, + FCML_AM_RO_MOFFO, + FCML_AM_RO_MO, + FCML_AM_MOFFO_RO, + FCML_AM_MO_RO, + FCML_AM_RO_RM8, + FCML_AM_RM_SR, + FCML_AM_SR_RM, + FCML_AM_R32_DR, + FCML_AM_R64_DR, + FCML_AM_DR_R32, + FCML_AM_DR_R64, + FCML_AM_R32_CR, + FCML_AM_R64_CR, + FCML_AM_CR_R32, + FCML_AM_CR_R64, + FCML_AM_RO_RMO_IMM8, + FCML_AM_RO_RMO_IMMO, + FCML_AM_R32A_RM32_R32B, + FCML_AM_R64A_RM64_R64B, + FCML_AM_R32_RM32, + FCML_AM_R64_RM64, + FCML_AM_R32_RM32_R32, + FCML_AM_R64_RM64_R64, + FCML_AM_REL16, + FCML_AM_PTR16_O, + FCML_AM_M16_O, + FCML_AM_M8_M8, + FCML_AM_MO_MO, + FCML_AM_M8, + FCML_AM_M16, + FCML_AM_M32, + FCML_AM_M64, + FCML_AM_M80, + FCML_AM_M128, + FCML_AM_RX_RM32, + FCML_AM_RX_RM64, + FCML_AM_RX_RX_RM32, + FCML_AM_RX_RX_RM64, + FCML_AM_R32_RXM64, + FCML_AM_R64_RXM64, + FCML_AM_RM8, + FCML_AM_RMO, + FCML_AM_RO, + FCML_AM_SRO, + FCML_AM_SR_FSGSO, + FCML_AM_ST0_ST, + FCML_AM_ST_ST0, + FCML_AM_ST, + FCML_AM_M2BYTE, + FCML_AM_AX, + FCML_AM_R64_M128, + FCML_AM_R32_M128, + FCML_AM_RX_RX_I8_I8, + FCML_AM_RX_RX, + FCML_AM_REL8, + FCML_AM_REL0 +}; + +/** + * @defgroup INSTRUCTION_GROUP Supported instructions codes. + * Set of all supported instructions. Names are based on Intel syntax. + * @{ + */ + +/** Instruction codes. */ +typedef enum fcml_en_instruction { + F_UNKNOWN, + F_AAA, + F_JCC, + F_AAD, + F_AAM, + F_AAS, + F_ADC, + F_ADD, + F_ADDPD, + F_VADDPD, + F_ADDPS, + F_VADDPS, + F_ADDSD, + F_VADDSD, + F_ADDSS, + F_VADDSS, + F_ADDSUBPD, + F_VADDSUBPD, + F_ADDSUBPS, + F_VADDSUBPS, + F_AESDEC, + F_VAESDEC, + F_AESDECLAST, + F_VAESDECLAST, + F_AESENC, + F_VAESENC, + F_AESENCLAST, + F_VAESENCLAST, + F_AESIMC, + F_VAESIMC, + F_AESKEYGENASSIST, + F_VAESKEYGENASSIST, + F_AND, + F_ANDPD, + F_VANDPD, + F_ANDPS, + F_VANDPS, + F_ANDNPD, + F_VANDNPD, + F_ANDNPS, + F_VANDNPS, + F_ARPL, + F_ANDN, + F_ADCX, + F_ADOX, + F_BLENDPD, + F_VBLENDPD, + F_BLENDPS, + F_VBLENDPS, + F_BLENDVPD, + F_VBLENDVPD, + F_BLENDVPS, + F_VBLENDVPS, + F_BOUND, + F_BSF, + F_BSR, + F_BSWAP, + F_BT, + F_BTC, + F_BTR, + F_BTS, + F_BEXR, + F_BLCFILL, + F_BLCI, + F_BLCIC, + F_BLCMSK, + F_BLCS, + F_BLSFILL, + F_BLSI, + F_BLSIC, + F_BLSMSK, + F_BLSR, + F_BZHI, + F_CALL, + F_CBW, + F_CWDE = F_CBW, + F_CDQE = F_CBW, + F_CLC, + F_CLD, + F_CLFLUSH, + F_CLI, + F_CLGI, + F_CLTS, + F_CMC, + F_CMOV, + F_CMP, + F_CMPPD, + F_VCMPPD, + F_CMPPS, + F_VCMPPS, + F_CMPS, + F_CMPSD, + F_VCMPSD, + F_CMPSS, + F_VCMPSS, + F_CMPXCHG, + F_CMPXCHGxB, + F_CPUID, + F_CRC32, + F_CVTDQ2PD, + F_VCVTDQ2PD, + F_CVTDQ2PS, + F_VCVTDQ2PS, + F_CVTPD2DQ, + F_VCVTPD2DQ, + F_CVTPD2PI, + F_CVTPD2PS, + F_VCVTPD2PS, + F_CVTPI2PD, + F_CVTPI2PS, + F_CVTPS2DQ, + F_VCVTPS2DQ, + F_CVTPS2PD, + F_VCVTPS2PD, + F_CVTPS2PI, + F_CVTSD2SI, + F_VCVTSD2SI, + F_CVTSD2SS, + F_VCVTSD2SS, + F_CVTSI2SD, + F_VCVTSI2SD, + F_CVTSI2SS, + F_VCVTSI2SS, + F_CVTSS2SD, + F_VCVTSS2SD, + F_CVTSS2SI, + F_VCVTSS2SI, + F_CVTTPD2DQ, + F_VCVTTPD2DQ, + F_CVTTPD2PI, + F_CVTTPS2DQ, + F_VCVTTPS2DQ, + F_CVTTPS2PI, + F_CVTTSD2SI, + F_VCVTTSD2SI, + F_CVTTSS2SI, + F_VCVTTSS2SI, + F_CWD, + F_CDQ = F_CWD, + F_CQO = F_CWD, + F_COMISD, + F_VCOMISD, + F_COMISS, + F_VCOMISS, + F_DAA, + F_DAS, + F_DEC, + F_DIV, + F_DIVPD, + F_VDIVPD, + F_DIVPS, + F_VDIVPS, + F_DIVSD, + F_VDIVSD, + F_DIVSS, + F_VDIVSS, + F_DPPD, + F_VDPPD, + F_DPPS, + F_VDPPS, + F_EMMS, + F_ENTER, + F_EXTRACTPS, + F_VEXTRACTPS, + F_EXTRQ, + F_F2XM1, + F_FABS, + F_FADD, + F_FIADD, + F_FADDP, + F_FBLD, + F_FBSTP, + F_FCHS, + F_FCLEX, + F_FNCLEX, + F_FCMOVB, + F_FCMOVE, + F_FCMOVBE, + F_FCMOVU, + F_FCMOVNB, + F_FCMOVNE, + F_FCMOVNBE, + F_FCMOVNU, + F_FCOS, + F_FCOM, + F_FCOMP, + F_FCOMPP, + F_FCOMI, + F_FCOMIP, + F_FUCOMI, + F_FUCOMIP, + F_FDECSTP, + F_FDIV, + F_FDIVP, + F_FIDIV, + F_FDIVR, + F_FDIVRP, + F_FIDIVR, + F_FFREE, + F_FICOM, + F_FICOMP, + F_FILD, + F_FINCSTP, + F_FINIT, + F_FNINIT, + F_FIST, + F_FISTP, + F_FLD, + F_FLD1, + F_FLDL2T, + F_FLDL2E, + F_FLDPI, + F_FLDLG2, + F_FLDLN2, + F_FLDZ, + F_FLDCW, + F_FLDENV, + F_FMUL, + F_FMULP, + F_FIMUL, + F_FNOP, + F_FPATAN, + F_FPREM, + F_FPREM1, + F_FPTAN, + F_FRNDINT, + F_FRSTOR, + F_FSAVE, + F_FNSAVE, + F_FSCALE, + F_FSIN, + F_FSINCOS, + F_FSQRT, + F_FST, + F_FSTP, + F_FSTCW, + F_FNSTCW, + F_FSTENV, + F_FNSTENV, + F_FSTSW, + F_FNSTSW, + F_FSUB, + F_FSUBP, + F_FISUB, + F_FSUBR, + F_FSUBRP, + F_FISUBR, + F_FTST, + F_FUCOM, + F_FUCOMP, + F_FUCOMPP, + F_FXAM, + F_FXCH, + F_FXRSTOR, + F_FXRSTOR64, + F_FXSAVE, + F_FXSAVE64, + F_FXTRACT, + F_FYL2X, + F_FYL2XP1, + F_FEMMS, + F_FISTTP, + F_GETSEC, + F_HADDPD, + F_VHADDPD, + F_HADDPS, + F_VHADDPS, + F_HLT, + F_HSUBPD, + F_VHSUBPD, + F_HSUBPS, + F_VHSUBPS, + F_INVEPT, + F_INVVPID, + F_IDIV, + F_IMUL, + F_IN, + F_INC, + F_INS, + F_INSERTPS, + F_VINSERTPS, + F_VEXTRACTF128, + F_VEXTRACTF32X4, + F_VEXTRACTF64X2, + F_VEXTRACTF32X8, + F_VEXTRACTF64X4, + F_VEXTRACTI32X4, + F_VEXTRACTI64X2, + F_VEXTRACTI32X8, + F_VEXTRACTI64X4, + F_VINSERTF128, + F_VFIXUPIMMPD, + F_VFIXUPIMMPS, + F_VFIXUPIMMSD, + F_VFIXUPIMMSS, + F_INSERTQ, + F_INT3, + F_INT, + F_INTO, + F_INVD, + F_INVLPG, + F_INVLPGA, + F_INVPCID, + F_IRET, + F_JCXZ, + F_JECXZ = F_JCXZ, + F_JRCXZ = F_JCXZ, + F_JMP, + F_KADDB, + F_KADDD, + F_KADDW, + F_KADDQ, + F_KANDB, + F_KANDD, + F_KANDW, + F_KANDQ, + F_KANDNB, + F_KANDND, + F_KANDNW, + F_KANDNQ, + F_KMOVB, + F_KMOVW, + F_KMOVD, + F_KMOVQ, + F_KNOTB, + F_KNOTW, + F_KNOTD, + F_KNOTQ, + F_KORB, + F_KORW, + F_KORD, + F_KORQ, + F_KORTESTB, + F_KORTESTW, + F_KORTESTD, + F_KORTESTQ, + F_KSHIFTLW, + F_KSHIFTLB, + F_KSHIFTLQ, + F_KSHIFTLD, + F_KSHIFTRW, + F_KSHIFTRB, + F_KSHIFTRQ, + F_KSHIFTRD, + F_KTESTB, + F_KTESTW, + F_KTESTD, + F_KTESTQ, + F_KXNORB, + F_KXNORD, + F_KXNORW, + F_KXNORQ, + F_KXORB, + F_KXORD, + F_KXORW, + F_KXORQ, + F_LAR, + F_LAHF, + F_LDDQU, + F_VLDDQU, + F_LDMXCSR, + F_VLDMXCSR, + F_LDS, + F_LSS, + F_LES, + F_LFS, + F_LGS, + F_LEA, + F_LEAVE, + F_LFENCE, + F_LLWPCB, + F_LGDT, + F_LIDT, + F_LLDT, + F_LMSW, + F_LODS, + F_LOOP, + F_LOOPE, + F_LOOPNE, + F_LWPINS, + F_LWPVAL, + F_LSL, + F_LTR, + F_LZCNT, + F_MASKMOVDQU, + F_VMASKMOVDQU, + F_MASKMOVQ, + F_VMASKMOVPS, + F_VMASKMOVPD, + F_VPMASKMOVD, + F_VPMASKMOV, + F_VPMASKMOVQ, + F_MAXPD, + F_VMAXPD, + F_MAXPS, + F_VMAXPS, + F_MAXSD, + F_VMAXSD, + F_MAXSS, + F_VMAXSS, + F_MFENCE, + F_MINPD, + F_VMINPD, + F_MINPS, + F_VMINPS, + F_MINSD, + F_VMINSD, + F_MINSS, + F_VMINSS, + F_MONITOR, + F_MOVAPD, + F_VMOVAPD, + F_MOVAPS, + F_VMOVAPS, + F_MOVBE, + F_MOV, + F_MOVD, + F_VMOVD, + F_MOVQ, + F_VMOVQ, + F_MOVDDUP, + F_VMOVDDUP, + F_MOVDQA, + F_VMOVDQA, + F_VMOVDQA32, + F_VMOVDQA64, + F_MOVDQU, + F_VMOVDQU, + F_VMOVDQU8, + F_VMOVDQU16, + F_VMOVDQU32, + F_VMOVDQU64, + F_MOVDQ2Q, + F_MOVHLPS, + F_VMOVHLPS, + F_MOVHPD, + F_VMOVHPD, + F_MOVHPS, + F_VMOVHPS, + F_MOVLHPS, + F_VMOVLHPS, + F_MOVLPD, + F_VMOVLPD, + F_MOVLPS, + F_VMOVLPS, + F_MOVMSKPD, + F_VMOVMSKPD, + F_MOVMSKPS, + F_VMOVMSKPS, + F_MOVNTDQA, + F_VMOVNTDQA, + F_MOVNTDQ, + F_VMOVNTDQ, + F_MOVS, + F_MOVNTI, + F_MOVNTPD, + F_VMOVNTPD, + F_MOVNTPS, + F_VMOVNTPS, + F_MOVNTSD, + F_MOVNTSS, + F_MOVNTQ, + F_MOVQ2DQ, + F_MOVSD, + F_VMOVSD, + F_MOVSHDUP, + F_VMOVSHDUP, + F_MOVSLDUP, + F_VMOVSLDUP, + F_MOVSS, + F_VMOVSS, + F_MOVSX, + F_MOVSXD, + F_MOVUPD, + F_VMOVUPD, + F_MOVUPS, + F_VMOVUPS, + F_MOVZX, + F_MPSADBW, + F_VMPSADBW, + F_MUL, + F_MULPD, + F_VMULPD, + F_MULPS, + F_VMULPS, + F_MULSD, + F_VMULSD, + F_MULSS, + F_VMULSS, + F_MWAIT, + F_NEG, + F_NOP, + F_NOT, + F_OR, + F_ORPD, + F_VORPD, + F_ORPS, + F_VORPS, + F_OUT, + F_OUTS, + F_PABSW, + F_PABSB, + F_PABSD, + F_VPABSB, + F_VPABSW, + F_VPABSD, + F_VPABSQ, + F_VPACKSSWB, + F_PACKSSWB, + F_VPACKSSDW, + F_PACKSSDW, + F_PACKUSDW, + F_VPACKUSDW, + F_PACKUSWB, + F_VPACKUSWB, + F_VPADDW, + F_PADDW, + F_VPADDB, + F_VPADDD, + F_PADDB, + F_PADDD, + F_VPADDSW, + F_PADDSB, + F_PADDSW, + F_VPADDSB, + F_PADDUSW, + F_PADDUSB, + F_VPADDUSW, + F_PADDQ, + F_VPADDUSB, + F_VPADDQ, + F_POP, + F_PUSH, + F_POPA, + F_POPAD, + F_POPF, + F_POPFQ, + F_POPFD, + F_PUSHA, + F_PUSHF, + F_PUSHAD, + F_PUSHFQ, + F_PUSHFD, + F_PAVGUSB, + F_PF2ID, + F_PFACC, + F_PFADD, + F_PFCMPEQ, + F_PFCMPGE, + F_PFCMPGT, + F_PFMAX, + F_PFMIN, + F_PFMUL, + F_PFRCP, + F_PFRCPIT1, + F_PFRCPIT2, + F_PFRSQIT1, + F_PFRSQRT, + F_PFSUB, + F_PFSUBR, + F_PI2FD, + F_PMULHRW, + F_PF2IW, + F_PFNACC, + F_PFPNACC, + F_PI2FW, + F_PSWAPD, + F_PALIGNR, + F_VPALIGNR, + F_PAND, + F_VPAND, + F_VPANDD, + F_VPANDQ, + F_PANDN, + F_VPANDN, + F_VPANDND, + F_VPANDNQ, + F_PAUSE, + F_PAVGW, + F_PAVGB, + F_VPAVGW, + F_VPAVGB, + F_PBLENDVB, + F_VPBLENDVB, + F_PBLENDW, + F_VPBLENDW, + F_VPBLENDD, + F_PCLMULQDQ, + F_VPCLMULQDQ, + F_PCMPEQW, + F_PCMPEQB, + F_PCMPEQD, + F_VPCMPEQD, + F_VPCMPEQW, + F_VPCMPEQB, + F_PCMPEQQ, + F_VPCMPEQQ, + F_PCMPESTRI, + F_VPCMPESTRI, + F_PCMPESTRM, + F_VPCMPESTRM, + F_PCMPGTW, + F_PCMPGTD, + F_PCMPGTB, + F_VPCMPGTW, + F_VPCMPGTD, + F_VPCMPGTB, + F_PCMPGTQ, + F_VPCMPGTQ, + F_PCMPISTRI, + F_VPCMPISTRI, + F_PCMPISTRM, + F_VPCMPISTRM, + F_VPEXTRB, + F_VPEXTRQ, + F_PEXTRQ, + F_PEXTRB, + F_PEXTRD, + F_VPEXTRD, + F_PEXTRW, + F_VPEXTRW, + F_VPHADDW, + F_VPHADDD, + F_PHADDD, + F_PHADDW, + F_PHADDSW, + F_VPHADDSW, + F_PHMINPOSUW, + F_VPHMINPOSUW, + F_PHSUBD, + F_PHSUBW, + F_VPHSUBD, + F_VPHSUBW, + F_PHSUBSW, + F_VPHSUBSW, + F_PINSRD, + F_VPINSRQ, + F_PINSRQ, + F_PINSRB, + F_VPINSRD, + F_VPINSRB, + F_PINSRW, + F_VPINSRW, + F_PMADDUBSW, + F_VPMADDUBSW, + F_PMADDWD, + F_VPMADDWD, + F_PMAXSB, + F_VPMAXSB, + F_PMAXSD, + F_VPMAXSD, + F_VPMAXSQ, + F_PMAXSW, + F_VPMAXSW, + F_PMAXUB, + F_VPMAXUB, + F_PMAXUD, + F_VPMAXUD, + F_VPMAXUQ, + F_PMAXUW, + F_VPMAXUW, + F_PMINSB, + F_VPMINSB, + F_PMINSD, + F_VPMINSD, + F_VPMINSQ, + F_PMINSW, + F_VPMINSW, + F_PMINUW, + F_VPMINUW, + F_PMINUB, + F_VPMINUB, + F_PMINUD, + F_VPMINUD, + F_VPMINUQ, + F_PMOVMSKB, + F_VPMOVMSKB, + F_VPMOVSXBQ, + F_PMOVSXBW, + F_PMOVSXWQ, + F_VPMOVSXWQ, + F_PMOVSXWD, + F_PMOVSXBD, + F_VPMOVSXDQ, + F_VPMOVSXWD, + F_PMOVSXBQ, + F_VPMOVSXBW, + F_PMOVSXDQ, + F_VPMOVSXBD, + F_PMOVZXWD, + F_PMOVZXDQ, + F_VPMOVZXDQ, + F_PMOVZXWQ, + F_VPMOVZXBQ, + F_PMOVZXBQ, + F_VPMOVZXWD, + F_VPMOVZXBD, + F_VPMOVZXWQ, + F_PMOVZXBD, + F_VPMOVZXBW, + F_PMOVZXBW, + F_PMULDQ, + F_PMULHRSW, + F_PMULHUW, + F_VPMULDQ, + F_VPMULHRSW, + F_VPMULHUW, + F_PMULHW, + F_VPMULHW, + F_PMULUDQ, + F_VPMULUDQ, + F_PMULLW, + F_PMULLD, + F_VPMULLD, + F_VPMULLQ, + F_VPMULLW, + F_POPCNT, + F_POR, + F_VPOR, + F_VPORD, + F_VPORQ, + F_PREFETCHT2, + F_PREFETCHW, + F_PREFETCHT1, + F_PREFETCHNTA, + F_PREFETCHT0, + F_PREFETCHWT1, + F_PSADBW, + F_VPSADBW, + F_PSHUFB, + F_PSHUFD, + F_PSHUFHW, + F_VPSHUFD, + F_VPSHUFB, + F_PSHUFLW, + F_PSHUFW, + F_VPSHUFLW, + F_VPSHUFHW, + F_VPSIGNB, + F_VPSIGND, + F_PSIGNW, + F_PSIGNB, + F_VPSIGNW, + F_PSIGND, + F_PSLLDQ, + F_VPSLLDQ, + F_PSLLQ, + F_PSLLD, + F_VPSLLW, + F_VPSLLQ, + F_PSLLW, + F_VPSLLD, + F_VPSRAW, + F_PSRAD, + F_PSRAW, + F_VPSRAD, + F_VPSRAQ, + F_PSRLDQ, + F_VPSRLDQ, + F_VPSRLQ, + F_PSRLQ, + F_PSRLD, + F_PSRLW, + F_VPSRLD, + F_VPSRLW, + F_VPSUBD, + F_PSUBD, + F_PSUBW, + F_VPSUBB, + F_VPSUBQ, + F_PSUBB, + F_VPSUBW, + F_PSUBQ, + F_PSUBSB, + F_VPSUBSW, + F_VPSUBSB, + F_PSUBSW, + F_VPSUBUSW, + F_VPSUBUSB, + F_PSUBUSB, + F_PSUBUSW, + F_VPTEST, + F_PTEST, + F_PUNPCKLBW, + F_PUNPCKLQDQ, + F_VPUNPCKLWD, + F_VPUNPCKLQDQ, + F_VPUNPCKLBW, + F_PUNPCKLWD, + F_PUNPCKLDQ, + F_VPUNPCKLDQ, + F_VPUNPCKHWD, + F_PUNPCKHDQ, + F_PUNPCKHWD, + F_PUNPCKHQDQ, + F_VPUNPCKHQDQ, + F_VPUNPCKHBW, + F_PUNPCKHBW, + F_VPUNPCKHDQ, + F_PXOR, + F_VPXOR, + F_VPXORD, + F_VPXORQ, + F_PREFETCH, + F_RCL, + F_RCR, + F_ROL, + F_ROR, + F_RET, + F_RETF, + F_RCPPS, + F_VRCPPS, + F_RCPSS, + F_VRCPSS, + F_RDFSBASE, + F_RDGSBASE, + F_RDRAND, + F_RDTSCP, + F_RDTSC, + F_RDPMC, + F_RDMSR, + F_ROUNDPD, + F_VROUNDPD, + F_ROUNDPS, + F_VROUNDPS, + F_ROUNDSD, + F_VROUNDSD, + F_ROUNDSS, + F_VROUNDSS, + F_RSM, + F_RSQRTPS, + F_VRSQRTPS, + F_RSQRTSS, + F_VRSQRTSS, + F_SAHF, + F_SAR, + F_SAL, + F_SHL = F_SAL, + F_SHR, + F_SBB, + F_SCAS, + F_SET, + F_STOS, + F_SUB, + F_SFENCE, + F_SGDT, + F_SHLD, + F_SHRD, + F_SKINIT, + F_SLWPCB, + F_SHUFPD, + F_VSHUFPD, + F_SHUFPS, + F_VSHUFPS, + F_SIDT, + F_SLDT, + F_SMSW, + F_SQRTPD, + F_VSQRTPD, + F_SQRTPS, + F_VSQRTPS, + F_SQRTSD, + F_VSQRTSD, + F_SQRTSS, + F_VSQRTSS, + F_STC, + F_STD, + F_STGI, + F_STI, + F_STMXCSR, + F_VSTMXCSR, + F_STR, + F_SUBPD, + F_VSUBPD, + F_SUBPS, + F_VSUBPS, + F_SUBSD, + F_VSUBSD, + F_SUBSS, + F_VSUBSS, + F_SWAPGS, + F_SYSCALL, + F_SYSENTER, + F_SYSEXIT, + F_SYSRET, + F_TEST, + F_T1MSKC, + F_UCOMISD, + F_VUCOMISD, + F_UCOMISS, + F_VUCOMISS, + F_UD2, + F_UNPCKHPD, + F_VUNPCKHPD, + F_UNPCKHPS, + F_VUNPCKHPS, + F_UNPCKLPD, + F_VUNPCKLPD, + F_UNPCKLPS, + F_VUNPCKLPS, + F_VMLOAD, + F_VMRUN, + F_VMSAVE, + F_VFRCZPD, + F_VFRCZPS, + F_VFRCZSD, + F_VFRCZSS, + F_VPCMOV, + F_VPERMIL2PD, + F_VPERMIL2PS, + F_VPHADDBD, + F_VPHADDBW, + F_VPHADDBQ, + F_VPHADDDQ, + F_VPHADDUBD, + F_VPHADDUBQ, + F_VPHADDUBW, + F_VPHADDUDQ, + F_VPHADDUWD, + F_VPHADDUWQ, + F_VPHADDWD, + F_VPHADDWQ, + F_VPHSUBBW, + F_VPHSUBDQ, + F_VPHSUBWD, + F_VPMACSDD, + F_VPMACSDQH, + F_VPMACSDQL, + F_VPMACSSDD, + F_VPMACSSDQH, + F_VPMACSSDQL, + F_VPMACSSWD, + F_VPMACSSWW, + F_VPMACSWD, + F_VPMACSWW, + F_VPMADCSSWD, + F_VPMADCSWD, + F_VPPERM, + F_VPROTD, + F_VPROTB, + F_VPROTQ, + F_VPROTW, + F_VPSHAB, + F_VPSHAD, + F_VPSHAQ, + F_VPSHAW, + F_VPSHLB, + F_VPSHLD, + F_VPSHLQ, + F_VPSHLW, + F_VFMADD213PD, + F_VFMADDPD, + F_VFMADD132PD, + F_VFMADD231PD, + F_VFMADDPS, + F_VFMADD231PS, + F_VFMADD132PS, + F_VFMADD213PS, + F_VFMADD132SD, + F_VFMADD213SD, + F_VFMADDSD, + F_VFMADD231SD, + F_VFMADD132SS, + F_VFMADD213SS, + F_VFMADDSS, + F_VFMADD231SS, + F_VFMADDSUB132PD, + F_VFMADDSUB213PD, + F_VFMADDSUBPD, + F_VFMADDSUB231PD, + F_VFMADDSUB231PS, + F_VFMADDSUBPS, + F_VFMADDSUB132PS, + F_VFMADDSUB213PS, + F_VFMSUBADDPD, + F_VFMSUBADD213PD, + F_VFMSUBADD132PD, + F_VFMSUBADD231PD, + F_VFMSUBADDPS, + F_VFMSUBADD213PS, + F_VFMSUBADD132PS, + F_VFMSUBADD231PS, + F_VFMSUB213PD, + F_VFMSUBPD, + F_VFMSUB132PD, + F_VFMSUB231PD, + F_VFMSUB213PS, + F_VFMSUBPS, + F_VFMSUB132PS, + F_VFMSUB231PS, + F_VFMSUBSD, + F_VFMSUB231SD, + F_VFMSUB132SD, + F_VFMSUB213SD, + F_VFMSUB231SS, + F_VFMSUB213SS, + F_VFMSUB132SS, + F_VFMSUBSS, + F_VFNMADD231PD, + F_VFNMADDPD, + F_VFNMADD132PD, + F_VFNMADD213PD, + F_VFNMADD231PS, + F_VFNMADD132PS, + F_VFNMADD213PS, + F_VFNMADDPS, + F_VFNMADD213SD, + F_VFNMADDSD, + F_VFNMADD231SD, + F_VFNMADD132SD, + F_VFNMADD213SS, + F_VFNMADDSS, + F_VFNMADD231SS, + F_VFNMADD132SS, + F_VFNMSUB132PD, + F_VFNMSUB213PD, + F_VFNMSUB231PD, + F_VFNMSUBPD, + F_VFNMSUBPS, + F_VFNMSUB213PS, + F_VFNMSUB132PS, + F_VFNMSUB231PS, + F_VFNMSUBSD, + F_VFNMSUB231SD, + F_VFNMSUB213SD, + F_VFNMSUB132SD, + F_VFNMSUBSS, + F_VFNMSUB132SS, + F_VFNMSUB213SS, + F_VFNMSUB231SS, + F_VFPCLASSPD, + F_VFPCLASSPS, + F_VFPCLASSSD, + F_VFPCLASSSS, + F_BEXTR, + F_VPBROADCASTW, + F_VPBROADCASTB, + F_VPBROADCASTD, + F_VPBROADCASTQ, + F_VBROADCASTI32X2, + F_VBROADCASTI32X4, + F_VBROADCASTI64X2, + F_VBROADCASTI32X8, + F_VBROADCASTI64X4, + F_VPBROADCASTMB2Q, + F_VPBROADCASTMW2D, + F_VPCMPB, + F_VPCMPUB, + F_VPCMPW, + F_VPCMPUW, + F_VPCMPD, + F_VPCMPUD, + F_VPCMPQ, + F_VPCMPUQ, + F_VCOMPRESSPD, + F_VCOMPRESSPS, + F_VPCOMPRESSD, + F_VPCOMPRESSQ, + F_VCVTPD2QQ, + F_VCVTTPS2UQQ, + F_VCVTTPS2QQ, + F_VCVTPD2UDQ, + F_VCVTTPD2UQQ, + F_VCVTTPS2UDQ, + F_VMPTRLD, + F_VCVTPD2UQQ, + F_VMPTRST, + F_VMCLEAR, + F_VMREAD, + F_VMWRITE, + F_VMLAUNCH, + F_VMRESUME, + F_VMXOFF, + F_VMXON, + F_VMCALL, + F_VMFUNC, + F_VALIGND, + F_VALIGNQ, + F_VBLENDMPD, + F_VBLENDMPS, + F_VBROADCASTSD, + F_VBROADCASTSS, + F_VBROADCASTI128, + F_VBROADCASTF128, + F_VBROADCASTF32X2, + F_VBROADCASTF32X4, + F_VBROADCASTF32X8, + F_VBROADCASTF64X2, + F_VBROADCASTF64X4, + F_VCVTPH2PS, + F_VCVTPS2PH, + F_VCVTPS2QQ, + F_VCVTPS2UDQ, + F_VCVTPS2UQQ, + F_VCVTQQ2PD, + F_VCVTQQ2PS, + F_VCVTSD2USI, + F_VCVTSS2USI, + F_VCVTTSD2USI, + F_VCVTTSS2USI, + F_VCVTTPD2QQ, + F_VCVTUDQ2PS, + F_VCVTUQQ2PD, + F_VCVTUSI2SD, + F_VCVTUSI2SS, + F_VCVTUQQ2PS, + F_VCVTUDQ2PD, + F_VCVTTPD2UDQ, + F_VDBPSADBW, + F_VEXPANDPD, + F_VEXPANDPS, + F_VERR, + F_VERW, + F_VMMCALL, + F_VPERMILPD, + F_VPERMILPS, + F_VPERM2F128, + F_VPERM2I128, + F_VPERMI2W, + F_VPERMI2D, + F_VPERMI2Q, + F_VPERMI2PS, + F_VPERMI2PD, + F_VPERMT2B, + F_VPERMT2W, + F_VPERMT2D, + F_VPERMT2Q, + F_VPERMT2PS, + F_VPERMT2PD, + F_VPEXPANDD, + F_VPEXPANDQ, + F_VPLZCNTD, + F_VPLZCNTQ, + F_VPMOVB2M, + F_VPMOVW2M, + F_VPMOVD2M, + F_VPMOVQ2M, + F_VPMOVM2B, + F_VPMOVM2W, + F_VPMOVM2D, + F_VPMOVM2Q, + F_VPMOVDB, + F_VPMOVSDB, + F_VPMOVUSDB, + F_VPMOVDW, + F_VPMOVSDW, + F_VPMOVUSDW, + F_VPMOVQB, + F_VPMOVSQB, + F_VPMOVUSQB, + F_VPMOVQD, + F_VPMOVSQD, + F_VPMOVUSQD, + F_VPMOVQW, + F_VPMOVSQW, + F_VPMOVUSQW, + F_VPMOVWB, + F_VPMOVSWB, + F_VPMOVUSWB, + F_VPMULTISHIFTQB, + F_VPROLVD, + F_VPROLVQ, + F_VPROLD, + F_VPROLQ, + F_VPRORVD, + F_VPRORVQ, + F_VPRORD, + F_VPRORQ, + F_VPSCATTERDD, + F_VPSCATTERDQ, + F_VPSCATTERQD, + F_VPSCATTERQQ, + F_VPSLLVW, + F_VPSLLVD, + F_VPSLLVQ, + F_VPMADD52HUQ, + F_VPMADD52LUQ, + F_VEXTRACTI128, + F_VINSERTI128, + F_VPSRAVW, + F_VPSRAVD, + F_VPSRAVQ, + F_VPERMD, + F_VPERMW, + F_VPERMI2B, + F_VPERMB, + F_VPSRLVW, + F_VPSRLVD, + F_VPSRLVQ, + F_VPTERNLOGD, + F_VPTERNLOGQ, + F_VPTESTMB, + F_VPTESTMW, + F_VPTESTMD, + F_VPTESTMQ, + F_VPTESTNMB, + F_VPTESTNMW, + F_VPTESTNMD, + F_VPTESTNMQ, + F_VRANGEPD, + F_VRANGEPS, + F_VRANGESD, + F_VRANGESS, + F_VRCP14PD, + F_VRCP14PS, + F_VRCP14SD, + F_VRCP14SS, + F_VREDUCEPD, + F_VREDUCEPS, + F_VREDUCESD, + F_VREDUCESS, + F_VRNDSCALEPD, + F_VRNDSCALEPS, + F_VRNDSCALESD, + F_VRNDSCALESS, + F_VRSQRT14PD, + F_VRSQRT14PS, + F_VRSQRT14SD, + F_VRSQRT14SS, + F_VSCALEFPD, + F_VSCALEFPS, + F_VSCALEFSD, + F_VSCALEFSS, + F_VSCATTERDPS, + F_VSCATTERDPD, + F_VSCATTERQPS, + F_VSCATTERQPD, + F_VSHUFF32X4, + F_VSHUFF64X2, + F_VSHUFI32X4, + F_VSHUFI64X2, + F_VPERMPD, + F_VPERMQ, + F_VPERMPS, + F_VTESTPS, + F_VTESTPD, + F_VGATHERDPD, + F_VGATHERQPD, + F_VGATHERDPS, + F_VGATHERQPS, + F_VPGATHERDD, + F_VPGATHERQD, + F_VPGATHERDQ, + F_VPGATHERQQ, + F_VGETEXPPD, + F_VGETEXPPS, + F_VGETEXPSD, + F_VGETEXPSS, + F_VGETMANTPD, + F_VGETMANTPS, + F_VGETMANTSD, + F_VGETMANTSS, + F_VINSERTF32X4, + F_VINSERTF64X2, + F_VINSERTF32X8, + F_VINSERTF64X4, + F_VINSERTI32X4, + F_VINSERTI64X2, + F_VINSERTI32X8, + F_VINSERTI64X4, + F_VPBLENDMB, + F_VPBLENDMW, + F_VPBLENDMD, + F_VPBLENDMQ, + F_VZEROALL, + F_VZEROUPPER, + F_VPCOMB, + F_VPCOMW, + F_VPCOMD, + F_VPCOMQ, + F_VPCOMUB, + F_VPCOMUW, + F_VPCOMUD, + F_VPCOMUQ, + F_WAIT, + F_FWAIT = F_WAIT, + F_WBINVD, + F_WRFSBASE, + F_WRGSBASE, + F_WRMSR, + F_XLAT, + F_XOR, + F_XADD, + F_XCHG, + F_XGETBV, + F_XORPD, + F_VXORPD, + F_XORPS, + F_VXORPS, + F_XRSTOR, + F_XRSTOR64, + F_XSAVE, + F_XSAVE64, + F_XSAVEOPT, + F_XSAVEOPT64, + F_XSETBV, + F_MULX, + F_PDEP, + F_PEXT, + F_RORX, + F_SHLX, + F_SHRX, + F_SARX, + F_TZCNT, + F_TZMSK, + F_XABORT, + F_XBEGIN, + F_XEND, + F_XTEST, + F_RDSEED, + F_CLAC, + F_STAC, + F_V4FMADDPS, + F_V4FNMADDPS, + F_V4FMADDSS, + F_V4FNMADDSS, + F_VEXP2PD, + F_VEXP2PS, + F_VGATHERPF0DPS, + F_VGATHERPF0QPS, + F_VGATHERPF0DPD, + F_VGATHERPF0QPD, + F_VGATHERPF1DPS, + F_VGATHERPF1QPS, + F_VGATHERPF1DPD, + F_VGATHERPF1QPD, + F_VP4DPWSSDS, + F_VP4DPWSSD, + F_VRCP28PD, + F_VRCP28SD, + F_VRCP28PS, + F_VRCP28SS, + F_VRSQRT28PD, + F_VRSQRT28SD, + F_VRSQRT28PS, + F_VRSQRT28SS, + F_VSCATTERPF0DPS, + F_VSCATTERPF0QPS, + F_VSCATTERPF0DPD, + F_VSCATTERPF0QPD, + F_VSCATTERPF1DPS, + F_VSCATTERPF1QPS, + F_VSCATTERPF1DPD, + F_VSCATTERPF1QPD +} fcml_en_instruction; + +/** @} */ + +/** + * @defgroup PSEUDO_OPERATIONS_GROUP Supported pseudo operations. + * @{ + */ + +/** Pseudo operations. */ +typedef enum fcml_en_pseudo_operations { + /** Set if there is no pseudo operation. */ + FP_NO_PSEUDO_OP, + /** db / .byte */ + FP_DB +} fcml_en_pseudo_operations; + +/** @} */ + +#endif /* FCML_INSTRUCTIONS_H_ */ diff --git a/dependencies/fcml/include/fcml_intel_dialect.h b/dependencies/fcml/include/fcml_intel_dialect.h new file mode 100644 index 0000000..f8073b7 --- /dev/null +++ b/dependencies/fcml/include/fcml_intel_dialect.h @@ -0,0 +1,58 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_intel_dialect.h + * Intel dialect implementation. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ASM_DIALECT_INTEL_H_ +#define FCML_ASM_DIALECT_INTEL_H_ + +#include "fcml_lib_export.h" + +#include "fcml_errors.h" +#include "fcml_dialect.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Default combination of the configuration flags.*/ +#define FCML_INTEL_DIALECT_CF_DEFAULT 0 + +/** + * Initializes Intel dialect. + * Prepares new instance of Intel dialect for given set of configuration flags. + * Every dialect has to be freed using fcml_fn_dialect_free() function. + * + * @param config_flags Configuration flags dedicated to the dialect. + * @param[out] dialect Prepared dialect instance. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @see fcml_fn_dialect_free + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_dialect_init_intel( + fcml_uint32_t config_flags, fcml_st_dialect **dialect); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_ASM_DIALECT_INTEL_H_ */ diff --git a/dependencies/fcml/include/fcml_intel_dialect.hpp b/dependencies/fcml/include/fcml_intel_dialect.hpp new file mode 100644 index 0000000..65693c5 --- /dev/null +++ b/dependencies/fcml/include/fcml_intel_dialect.hpp @@ -0,0 +1,66 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_intel_dialect.hpp + * C++ wrapper for the Intel dialect. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_INTEL_DIALECT_HPP_ +#define FCML_INTEL_DIALECT_HPP_ + +#include "fcml_dialect.hpp" + +#include "fcml_intel_dialect.h" + +namespace fcml { + +/** Wraps the Intel dialect. + * @since 1.1.0 + */ +class IntelDialect: public Dialect { +public: + /** + * Creates the Intel dialect. + * + * @param flags Optional flags. + * @since 1.1.0 + */ + IntelDialect(fcml_uint32_t flags = FCML_INTEL_DIALECT_CF_DEFAULT) { + fcml_st_dialect *dialect; + fcml_ceh_error error = ::fcml_fn_dialect_init_intel(flags, &dialect); + if (error) { + throw InitException( + FCML_TEXT("Can not initialize the Intel dialect."), error); + } + Dialect::setDialect(dialect); + } + /** + * Virtual destructor. + * @since 1.1.0 + */ + virtual ~IntelDialect() { + } +}; + +} + +#endif /* FCML_INTEL_DIALECT_HPP_ */ diff --git a/dependencies/fcml/include/fcml_intel_mnemonics.cpp b/dependencies/fcml/include/fcml_intel_mnemonics.cpp new file mode 100644 index 0000000..223bfe2 --- /dev/null +++ b/dependencies/fcml/include/fcml_intel_mnemonics.cpp @@ -0,0 +1,1716 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_intel_mnemonics.cpp + * Definitions of Intel mnemonics for C++. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#include "fcml_intel_mnemonics.hpp" + +namespace fcml { +namespace intel { + +extern const fcml_cstring M_AAA = _FT("aaa"); +extern const fcml_cstring M_AAD = _FT("aad"); +extern const fcml_cstring M_AAM = _FT("aam"); +extern const fcml_cstring M_AAS = _FT("aas"); +extern const fcml_cstring M_ADC = _FT("adc"); +extern const fcml_cstring M_ADCX = _FT("adcx"); +extern const fcml_cstring M_ADD = _FT("add"); +extern const fcml_cstring M_ADDPD = _FT("addpd"); +extern const fcml_cstring M_ADDPS = _FT("addps"); +extern const fcml_cstring M_ADDSD = _FT("addsd"); +extern const fcml_cstring M_ADDSS = _FT("addss"); +extern const fcml_cstring M_ADDSUBPD = _FT("addsubpd"); +extern const fcml_cstring M_ADDSUBPS = _FT("addsubps"); +extern const fcml_cstring M_ADOX = _FT("adox"); +extern const fcml_cstring M_AESDEC = _FT("aesdec"); +extern const fcml_cstring M_AESDECLAST = _FT("aesdeclast"); +extern const fcml_cstring M_AESENC = _FT("aesenc"); +extern const fcml_cstring M_AESENCLAST = _FT("aesenclast"); +extern const fcml_cstring M_AESIMC = _FT("aesimc"); +extern const fcml_cstring M_AESKEYGENASSIST = _FT("aeskeygenassist"); +extern const fcml_cstring M_AND = _FT("and"); +extern const fcml_cstring M_ANDN = _FT("andn"); +extern const fcml_cstring M_ANDNPD = _FT("andnpd"); +extern const fcml_cstring M_ANDNPS = _FT("andnps"); +extern const fcml_cstring M_ANDPD = _FT("andpd"); +extern const fcml_cstring M_ANDPS = _FT("andps"); +extern const fcml_cstring M_ARPL = _FT("arpl"); +extern const fcml_cstring M_BEXR = _FT("bexr"); +extern const fcml_cstring M_BEXTR = _FT("bextr"); +extern const fcml_cstring M_BLCFILL = _FT("blcfill"); +extern const fcml_cstring M_BLCI = _FT("blci"); +extern const fcml_cstring M_BLCIC = _FT("blcic"); +extern const fcml_cstring M_BLCMSK = _FT("blcmsk"); +extern const fcml_cstring M_BLCS = _FT("blcs"); +extern const fcml_cstring M_BLENDPD = _FT("blendpd"); +extern const fcml_cstring M_BLENDPS = _FT("blendps"); +extern const fcml_cstring M_BLENDVPD = _FT("blendvpd"); +extern const fcml_cstring M_BLENDVPS = _FT("blendvps"); +extern const fcml_cstring M_BLSFILL = _FT("blsfill"); +extern const fcml_cstring M_BLSI = _FT("blsi"); +extern const fcml_cstring M_BLSIC = _FT("blsic"); +extern const fcml_cstring M_BLSMSK = _FT("blsmsk"); +extern const fcml_cstring M_BLSR = _FT("blsr"); +extern const fcml_cstring M_BOUND = _FT("bound"); +extern const fcml_cstring M_BSF = _FT("bsf"); +extern const fcml_cstring M_BSR = _FT("bsr"); +extern const fcml_cstring M_BSWAP = _FT("bswap"); +extern const fcml_cstring M_BT = _FT("bt"); +extern const fcml_cstring M_BTC = _FT("btc"); +extern const fcml_cstring M_BTR = _FT("btr"); +extern const fcml_cstring M_BTS = _FT("bts"); +extern const fcml_cstring M_BZHI = _FT("bzhi"); +extern const fcml_cstring M_CALL = _FT("call"); +extern const fcml_cstring M_CBW = _FT("cbw"); +extern const fcml_cstring M_CDQ = _FT("cdq"); +extern const fcml_cstring M_CDQE = _FT("cdqe"); +extern const fcml_cstring M_CLAC = _FT("clac"); +extern const fcml_cstring M_CLC = _FT("clc"); +extern const fcml_cstring M_CLD = _FT("cld"); +extern const fcml_cstring M_CLFLUSH = _FT("clflush"); +extern const fcml_cstring M_CLGI = _FT("clgi"); +extern const fcml_cstring M_CLI = _FT("cli"); +extern const fcml_cstring M_CLTS = _FT("clts"); +extern const fcml_cstring M_CMC = _FT("cmc"); +extern const fcml_cstring M_CMOVA = _FT("cmova"); +extern const fcml_cstring M_CMOVAE = _FT("cmovae"); +extern const fcml_cstring M_CMOVB = _FT("cmovb"); +extern const fcml_cstring M_CMOVBE = _FT("cmovbe"); +extern const fcml_cstring M_CMOVC = _FT("cmovc"); +extern const fcml_cstring M_CMOVENE = _FT("cmovene"); +extern const fcml_cstring M_CMOVG = _FT("cmovg"); +extern const fcml_cstring M_CMOVGE = _FT("cmovge"); +extern const fcml_cstring M_CMOVL = _FT("cmovl"); +extern const fcml_cstring M_CMOVLE = _FT("cmovle"); +extern const fcml_cstring M_CMOVNA = _FT("cmovna"); +extern const fcml_cstring M_CMOVNAE = _FT("cmovnae"); +extern const fcml_cstring M_CMOVNB = _FT("cmovnb"); +extern const fcml_cstring M_CMOVNBE = _FT("cmovnbe"); +extern const fcml_cstring M_CMOVNC = _FT("cmovnc"); +extern const fcml_cstring M_CMOVNG = _FT("cmovng"); +extern const fcml_cstring M_CMOVNGE = _FT("cmovnge"); +extern const fcml_cstring M_CMOVNL = _FT("cmovnl"); +extern const fcml_cstring M_CMOVNLE = _FT("cmovnle"); +extern const fcml_cstring M_CMOVNO = _FT("cmovno"); +extern const fcml_cstring M_CMOVNP = _FT("cmovnp"); +extern const fcml_cstring M_CMOVNS = _FT("cmovns"); +extern const fcml_cstring M_CMOVNZ = _FT("cmovnz"); +extern const fcml_cstring M_CMOVO = _FT("cmovo"); +extern const fcml_cstring M_CMOVP = _FT("cmovp"); +extern const fcml_cstring M_CMOVPE = _FT("cmovpe"); +extern const fcml_cstring M_CMOVPO = _FT("cmovpo"); +extern const fcml_cstring M_CMOVS = _FT("cmovs"); +extern const fcml_cstring M_CMOVZ = _FT("cmovz"); +extern const fcml_cstring M_CMP = _FT("cmp"); +extern const fcml_cstring M_CMPEQPD = _FT("cmpeqpd"); +extern const fcml_cstring M_CMPEQPS = _FT("cmpeqps"); +extern const fcml_cstring M_CMPEQSD = _FT("cmpeqsd"); +extern const fcml_cstring M_CMPEQSS = _FT("cmpeqss"); +extern const fcml_cstring M_CMPLEPD = _FT("cmplepd"); +extern const fcml_cstring M_CMPLEPS = _FT("cmpleps"); +extern const fcml_cstring M_CMPLESD = _FT("cmplesd"); +extern const fcml_cstring M_CMPLESS = _FT("cmpless"); +extern const fcml_cstring M_CMPLTPD = _FT("cmpltpd"); +extern const fcml_cstring M_CMPLTPS = _FT("cmpltps"); +extern const fcml_cstring M_CMPLTSD = _FT("cmpltsd"); +extern const fcml_cstring M_CMPLTSS = _FT("cmpltss"); +extern const fcml_cstring M_CMPNEQPD = _FT("cmpneqpd"); +extern const fcml_cstring M_CMPNEQPS = _FT("cmpneqps"); +extern const fcml_cstring M_CMPNEQSD = _FT("cmpneqsd"); +extern const fcml_cstring M_CMPNEQSS = _FT("cmpneqss"); +extern const fcml_cstring M_CMPNLEPD = _FT("cmpnlepd"); +extern const fcml_cstring M_CMPNLEPS = _FT("cmpnleps"); +extern const fcml_cstring M_CMPNLESD = _FT("cmpnlesd"); +extern const fcml_cstring M_CMPNLESS = _FT("cmpnless"); +extern const fcml_cstring M_CMPNLTPD = _FT("cmpnltpd"); +extern const fcml_cstring M_CMPNLTPS = _FT("cmpnltps"); +extern const fcml_cstring M_CMPNLTSD = _FT("cmpnltsd"); +extern const fcml_cstring M_CMPNLTSS = _FT("cmpnltss"); +extern const fcml_cstring M_CMPORDPD = _FT("cmpordpd"); +extern const fcml_cstring M_CMPORDPS = _FT("cmpordps"); +extern const fcml_cstring M_CMPORDSD = _FT("cmpordsd"); +extern const fcml_cstring M_CMPORDSS = _FT("cmpordss"); +extern const fcml_cstring M_CMPPD = _FT("cmppd"); +extern const fcml_cstring M_CMPPS = _FT("cmpps"); +extern const fcml_cstring M_CMPS = _FT("cmps"); +extern const fcml_cstring M_CMPSB = _FT("cmpsb"); +extern const fcml_cstring M_CMPSD = _FT("cmpsd"); +extern const fcml_cstring M_CMPSQ = _FT("cmpsq"); +extern const fcml_cstring M_CMPSS = _FT("cmpss"); +extern const fcml_cstring M_CMPSW = _FT("cmpsw"); +extern const fcml_cstring M_CMPUNORDPD = _FT("cmpunordpd"); +extern const fcml_cstring M_CMPUNORDPS = _FT("cmpunordps"); +extern const fcml_cstring M_CMPUNORDSD = _FT("cmpunordsd"); +extern const fcml_cstring M_CMPUNORDSS = _FT("cmpunordss"); +extern const fcml_cstring M_CMPXCHG = _FT("cmpxchg"); +extern const fcml_cstring M_CMPXCHG16B = _FT("cmpxchg16b"); +extern const fcml_cstring M_CMPXCHG8B = _FT("cmpxchg8b"); +extern const fcml_cstring M_COMISD = _FT("comisd"); +extern const fcml_cstring M_COMISS = _FT("comiss"); +extern const fcml_cstring M_CPUID = _FT("cpuid"); +extern const fcml_cstring M_CQO = _FT("cqo"); +extern const fcml_cstring M_CRC32 = _FT("crc32"); +extern const fcml_cstring M_CVTDQ2PD = _FT("cvtdq2pd"); +extern const fcml_cstring M_CVTDQ2PS = _FT("cvtdq2ps"); +extern const fcml_cstring M_CVTPD2DQ = _FT("cvtpd2dq"); +extern const fcml_cstring M_CVTPD2PI = _FT("cvtpd2pi"); +extern const fcml_cstring M_CVTPD2PS = _FT("cvtpd2ps"); +extern const fcml_cstring M_CVTPI2PD = _FT("cvtpi2pd"); +extern const fcml_cstring M_CVTPI2PS = _FT("cvtpi2ps"); +extern const fcml_cstring M_CVTPS2DQ = _FT("cvtps2dq"); +extern const fcml_cstring M_CVTPS2PD = _FT("cvtps2pd"); +extern const fcml_cstring M_CVTPS2PI = _FT("cvtps2pi"); +extern const fcml_cstring M_CVTSD2SI = _FT("cvtsd2si"); +extern const fcml_cstring M_CVTSD2SS = _FT("cvtsd2ss"); +extern const fcml_cstring M_CVTSI2SD = _FT("cvtsi2sd"); +extern const fcml_cstring M_CVTSI2SS = _FT("cvtsi2ss"); +extern const fcml_cstring M_CVTSS2SD = _FT("cvtss2sd"); +extern const fcml_cstring M_CVTSS2SI = _FT("cvtss2si"); +extern const fcml_cstring M_CVTTPD2DQ = _FT("cvttpd2dq"); +extern const fcml_cstring M_CVTTPD2PI = _FT("cvttpd2pi"); +extern const fcml_cstring M_CVTTPS2DQ = _FT("cvttps2dq"); +extern const fcml_cstring M_CVTTPS2PI = _FT("cvttps2pi"); +extern const fcml_cstring M_CVTTSD2SI = _FT("cvttsd2si"); +extern const fcml_cstring M_CVTTSS2SI = _FT("cvttss2si"); +extern const fcml_cstring M_CWD = _FT("cwd"); +extern const fcml_cstring M_CWDE = _FT("cwde"); +extern const fcml_cstring M_DAA = _FT("daa"); +extern const fcml_cstring M_DAS = _FT("das"); +extern const fcml_cstring M_DEC = _FT("dec"); +extern const fcml_cstring M_DIV = _FT("div"); +extern const fcml_cstring M_DIVPD = _FT("divpd"); +extern const fcml_cstring M_DIVPS = _FT("divps"); +extern const fcml_cstring M_DIVSD = _FT("divsd"); +extern const fcml_cstring M_DIVSS = _FT("divss"); +extern const fcml_cstring M_DPPD = _FT("dppd"); +extern const fcml_cstring M_DPPS = _FT("dpps"); +extern const fcml_cstring M_EMMS = _FT("emms"); +extern const fcml_cstring M_ENTER = _FT("enter"); +extern const fcml_cstring M_EXTRACTPS = _FT("extractps"); +extern const fcml_cstring M_EXTRQ = _FT("extrq"); +extern const fcml_cstring M_F2XM1 = _FT("f2xm1"); +extern const fcml_cstring M_FABS = _FT("fabs"); +extern const fcml_cstring M_FADD = _FT("fadd"); +extern const fcml_cstring M_FADDP = _FT("faddp"); +extern const fcml_cstring M_FBLD = _FT("fbld"); +extern const fcml_cstring M_FBSTP = _FT("fbstp"); +extern const fcml_cstring M_FCHS = _FT("fchs"); +extern const fcml_cstring M_FCLEX = _FT("fclex"); +extern const fcml_cstring M_FCMOVB = _FT("fcmovb"); +extern const fcml_cstring M_FCMOVBE = _FT("fcmovbe"); +extern const fcml_cstring M_FCMOVE = _FT("fcmove"); +extern const fcml_cstring M_FCMOVNB = _FT("fcmovnb"); +extern const fcml_cstring M_FCMOVNBE = _FT("fcmovnbe"); +extern const fcml_cstring M_FCMOVNE = _FT("fcmovne"); +extern const fcml_cstring M_FCMOVNU = _FT("fcmovnu"); +extern const fcml_cstring M_FCMOVU = _FT("fcmovu"); +extern const fcml_cstring M_FCOM = _FT("fcom"); +extern const fcml_cstring M_FCOMI = _FT("fcomi"); +extern const fcml_cstring M_FCOMIP = _FT("fcomip"); +extern const fcml_cstring M_FCOMP = _FT("fcomp"); +extern const fcml_cstring M_FCOMPP = _FT("fcompp"); +extern const fcml_cstring M_FCOS = _FT("fcos"); +extern const fcml_cstring M_FDECSTP = _FT("fdecstp"); +extern const fcml_cstring M_FDIV = _FT("fdiv"); +extern const fcml_cstring M_FDIVP = _FT("fdivp"); +extern const fcml_cstring M_FDIVR = _FT("fdivr"); +extern const fcml_cstring M_FDIVRP = _FT("fdivrp"); +extern const fcml_cstring M_FEMMS = _FT("femms"); +extern const fcml_cstring M_FFREE = _FT("ffree"); +extern const fcml_cstring M_FIADD = _FT("fiadd"); +extern const fcml_cstring M_FICOM = _FT("ficom"); +extern const fcml_cstring M_FICOMP = _FT("ficomp"); +extern const fcml_cstring M_FIDIV = _FT("fidiv"); +extern const fcml_cstring M_FIDIVR = _FT("fidivr"); +extern const fcml_cstring M_FILD = _FT("fild"); +extern const fcml_cstring M_FIMUL = _FT("fimul"); +extern const fcml_cstring M_FINCSTP = _FT("fincstp"); +extern const fcml_cstring M_FINIT = _FT("finit"); +extern const fcml_cstring M_FIST = _FT("fist"); +extern const fcml_cstring M_FISTP = _FT("fistp"); +extern const fcml_cstring M_FISTTP = _FT("fisttp"); +extern const fcml_cstring M_FISUB = _FT("fisub"); +extern const fcml_cstring M_FISUBR = _FT("fisubr"); +extern const fcml_cstring M_FLD = _FT("fld"); +extern const fcml_cstring M_FLD1 = _FT("fld1"); +extern const fcml_cstring M_FLDCW = _FT("fldcw"); +extern const fcml_cstring M_FLDENV = _FT("fldenv"); +extern const fcml_cstring M_FLDL2E = _FT("fldl2e"); +extern const fcml_cstring M_FLDL2T = _FT("fldl2t"); +extern const fcml_cstring M_FLDLG2 = _FT("fldlg2"); +extern const fcml_cstring M_FLDLN2 = _FT("fldln2"); +extern const fcml_cstring M_FLDPI = _FT("fldpi"); +extern const fcml_cstring M_FLDZ = _FT("fldz"); +extern const fcml_cstring M_FMUL = _FT("fmul"); +extern const fcml_cstring M_FMULP = _FT("fmulp"); +extern const fcml_cstring M_FNCLEX = _FT("fnclex"); +extern const fcml_cstring M_FNINIT = _FT("fninit"); +extern const fcml_cstring M_FNOP = _FT("fnop"); +extern const fcml_cstring M_FNSAVE = _FT("fnsave"); +extern const fcml_cstring M_FNSTCW = _FT("fnstcw"); +extern const fcml_cstring M_FNSTENV = _FT("fnstenv"); +extern const fcml_cstring M_FNSTSW = _FT("fnstsw"); +extern const fcml_cstring M_FPATAN = _FT("fpatan"); +extern const fcml_cstring M_FPREM = _FT("fprem"); +extern const fcml_cstring M_FPREM1 = _FT("fprem1"); +extern const fcml_cstring M_FPTAN = _FT("fptan"); +extern const fcml_cstring M_FRNDINT = _FT("frndint"); +extern const fcml_cstring M_FRSTOR = _FT("frstor"); +extern const fcml_cstring M_FSAVE = _FT("fsave"); +extern const fcml_cstring M_FSCALE = _FT("fscale"); +extern const fcml_cstring M_FSIN = _FT("fsin"); +extern const fcml_cstring M_FSINCOS = _FT("fsincos"); +extern const fcml_cstring M_FSQRT = _FT("fsqrt"); +extern const fcml_cstring M_FST = _FT("fst"); +extern const fcml_cstring M_FSTCW = _FT("fstcw"); +extern const fcml_cstring M_FSTENV = _FT("fstenv"); +extern const fcml_cstring M_FSTP = _FT("fstp"); +extern const fcml_cstring M_FSTSW = _FT("fstsw"); +extern const fcml_cstring M_FSUB = _FT("fsub"); +extern const fcml_cstring M_FSUBP = _FT("fsubp"); +extern const fcml_cstring M_FSUBR = _FT("fsubr"); +extern const fcml_cstring M_FSUBRP = _FT("fsubrp"); +extern const fcml_cstring M_FTST = _FT("ftst"); +extern const fcml_cstring M_FUCOM = _FT("fucom"); +extern const fcml_cstring M_FUCOMI = _FT("fucomi"); +extern const fcml_cstring M_FUCOMIP = _FT("fucomip"); +extern const fcml_cstring M_FUCOMP = _FT("fucomp"); +extern const fcml_cstring M_FUCOMPP = _FT("fucompp"); +extern const fcml_cstring M_FWAIT = _FT("fwait"); +extern const fcml_cstring M_FXAM = _FT("fxam"); +extern const fcml_cstring M_FXCH = _FT("fxch"); +extern const fcml_cstring M_FXRSTOR = _FT("fxrstor"); +extern const fcml_cstring M_FXRSTOR64 = _FT("fxrstor64"); +extern const fcml_cstring M_FXSAVE = _FT("fxsave"); +extern const fcml_cstring M_FXSAVE64 = _FT("fxsave64"); +extern const fcml_cstring M_FXTRACT = _FT("fxtract"); +extern const fcml_cstring M_FYL2X = _FT("fyl2x"); +extern const fcml_cstring M_FYL2XP1 = _FT("fyl2xp1"); +extern const fcml_cstring M_GETSEC = _FT("getsec"); +extern const fcml_cstring M_HADDPD = _FT("haddpd"); +extern const fcml_cstring M_HADDPS = _FT("haddps"); +extern const fcml_cstring M_HLT = _FT("hlt"); +extern const fcml_cstring M_HSUBPD = _FT("hsubpd"); +extern const fcml_cstring M_HSUBPS = _FT("hsubps"); +extern const fcml_cstring M_IDIV = _FT("idiv"); +extern const fcml_cstring M_IMUL = _FT("imul"); +extern const fcml_cstring M_IN = _FT("in"); +extern const fcml_cstring M_INC = _FT("inc"); +extern const fcml_cstring M_INS = _FT("ins"); +extern const fcml_cstring M_INSB = _FT("insb"); +extern const fcml_cstring M_INSD = _FT("insd"); +extern const fcml_cstring M_INSERTPS = _FT("insertps"); +extern const fcml_cstring M_INSERTQ = _FT("insertq"); +extern const fcml_cstring M_INSW = _FT("insw"); +extern const fcml_cstring M_INT = _FT("int"); +extern const fcml_cstring M_INT3 = _FT("int3"); +extern const fcml_cstring M_INTO = _FT("into"); +extern const fcml_cstring M_INVD = _FT("invd"); +extern const fcml_cstring M_INVEPT = _FT("invept"); +extern const fcml_cstring M_INVLPG = _FT("invlpg"); +extern const fcml_cstring M_INVLPGA = _FT("invlpga"); +extern const fcml_cstring M_INVPCID = _FT("invpcid"); +extern const fcml_cstring M_INVVPID = _FT("invvpid"); +extern const fcml_cstring M_IRET = _FT("iret"); +extern const fcml_cstring M_IRETD = _FT("iretd"); +extern const fcml_cstring M_IRETQ = _FT("iretq"); +extern const fcml_cstring M_JA = _FT("ja"); +extern const fcml_cstring M_JAE = _FT("jae"); +extern const fcml_cstring M_JB = _FT("jb"); +extern const fcml_cstring M_JBE = _FT("jbe"); +extern const fcml_cstring M_JC = _FT("jc"); +extern const fcml_cstring M_JCXZ = _FT("jcxz"); +extern const fcml_cstring M_JECXZ = _FT("jecxz"); +extern const fcml_cstring M_JENE = _FT("jene"); +extern const fcml_cstring M_JG = _FT("jg"); +extern const fcml_cstring M_JGE = _FT("jge"); +extern const fcml_cstring M_JL = _FT("jl"); +extern const fcml_cstring M_JLE = _FT("jle"); +extern const fcml_cstring M_JMP = _FT("jmp"); +extern const fcml_cstring M_JNA = _FT("jna"); +extern const fcml_cstring M_JNAE = _FT("jnae"); +extern const fcml_cstring M_JNB = _FT("jnb"); +extern const fcml_cstring M_JNBE = _FT("jnbe"); +extern const fcml_cstring M_JNC = _FT("jnc"); +extern const fcml_cstring M_JNG = _FT("jng"); +extern const fcml_cstring M_JNGE = _FT("jnge"); +extern const fcml_cstring M_JNL = _FT("jnl"); +extern const fcml_cstring M_JNLE = _FT("jnle"); +extern const fcml_cstring M_JNO = _FT("jno"); +extern const fcml_cstring M_JNP = _FT("jnp"); +extern const fcml_cstring M_JNS = _FT("jns"); +extern const fcml_cstring M_JNZ = _FT("jnz"); +extern const fcml_cstring M_JO = _FT("jo"); +extern const fcml_cstring M_JP = _FT("jp"); +extern const fcml_cstring M_JPE = _FT("jpe"); +extern const fcml_cstring M_JPO = _FT("jpo"); +extern const fcml_cstring M_JRCXZ = _FT("jrcxz"); +extern const fcml_cstring M_JS = _FT("js"); +extern const fcml_cstring M_JZ = _FT("jz"); +extern const fcml_cstring M_KADDB = _FT("kaddb"); +extern const fcml_cstring M_KADDD = _FT("kaddd"); +extern const fcml_cstring M_KADDQ = _FT("kaddq"); +extern const fcml_cstring M_KADDW = _FT("kaddw"); +extern const fcml_cstring M_KANDB = _FT("kandb"); +extern const fcml_cstring M_KANDD = _FT("kandd"); +extern const fcml_cstring M_KANDNB = _FT("kandnb"); +extern const fcml_cstring M_KANDND = _FT("kandnd"); +extern const fcml_cstring M_KANDNQ = _FT("kandnq"); +extern const fcml_cstring M_KANDNW = _FT("kandnw"); +extern const fcml_cstring M_KANDQ = _FT("kandq"); +extern const fcml_cstring M_KANDW = _FT("kandw"); +extern const fcml_cstring M_KMOVB = _FT("kmovb"); +extern const fcml_cstring M_KMOVD = _FT("kmovd"); +extern const fcml_cstring M_KMOVQ = _FT("kmovq"); +extern const fcml_cstring M_KMOVW = _FT("kmovw"); +extern const fcml_cstring M_KNOTB = _FT("knotb"); +extern const fcml_cstring M_KNOTD = _FT("knotd"); +extern const fcml_cstring M_KNOTQ = _FT("knotq"); +extern const fcml_cstring M_KNOTW = _FT("knotw"); +extern const fcml_cstring M_KORB = _FT("korb"); +extern const fcml_cstring M_KORD = _FT("kord"); +extern const fcml_cstring M_KORQ = _FT("korq"); +extern const fcml_cstring M_KORTESTB = _FT("kortestb"); +extern const fcml_cstring M_KORTESTD = _FT("kortestd"); +extern const fcml_cstring M_KORTESTQ = _FT("kortestq"); +extern const fcml_cstring M_KORTESTW = _FT("kortestw"); +extern const fcml_cstring M_KORW = _FT("korw"); +extern const fcml_cstring M_KSHIFTLB = _FT("kshiftlb"); +extern const fcml_cstring M_KSHIFTLD = _FT("kshiftld"); +extern const fcml_cstring M_KSHIFTLQ = _FT("kshiftlq"); +extern const fcml_cstring M_KSHIFTLW = _FT("kshiftlw"); +extern const fcml_cstring M_KSHIFTRB = _FT("kshiftrb"); +extern const fcml_cstring M_KSHIFTRD = _FT("kshiftrd"); +extern const fcml_cstring M_KSHIFTRQ = _FT("kshiftrq"); +extern const fcml_cstring M_KSHIFTRW = _FT("kshiftrw"); +extern const fcml_cstring M_KTESTB = _FT("ktestb"); +extern const fcml_cstring M_KTESTD = _FT("ktestd"); +extern const fcml_cstring M_KTESTQ = _FT("ktestq"); +extern const fcml_cstring M_KTESTW = _FT("ktestw"); +extern const fcml_cstring M_KXNORB = _FT("kxnorb"); +extern const fcml_cstring M_KXNORD = _FT("kxnord"); +extern const fcml_cstring M_KXNORQ = _FT("kxnorq"); +extern const fcml_cstring M_KXNORW = _FT("kxnorw"); +extern const fcml_cstring M_KXORB = _FT("kxorb"); +extern const fcml_cstring M_KXORD = _FT("kxord"); +extern const fcml_cstring M_KXORQ = _FT("kxorq"); +extern const fcml_cstring M_KXORW = _FT("kxorw"); +extern const fcml_cstring M_LAHF = _FT("lahf"); +extern const fcml_cstring M_LAR = _FT("lar"); +extern const fcml_cstring M_LDDQU = _FT("lddqu"); +extern const fcml_cstring M_LDMXCSR = _FT("ldmxcsr"); +extern const fcml_cstring M_LDS = _FT("lds"); +extern const fcml_cstring M_LEA = _FT("lea"); +extern const fcml_cstring M_LEAVE = _FT("leave"); +extern const fcml_cstring M_LES = _FT("les"); +extern const fcml_cstring M_LFENCE = _FT("lfence"); +extern const fcml_cstring M_LFS = _FT("lfs"); +extern const fcml_cstring M_LGDT = _FT("lgdt"); +extern const fcml_cstring M_LGS = _FT("lgs"); +extern const fcml_cstring M_LIDT = _FT("lidt"); +extern const fcml_cstring M_LLDT = _FT("lldt"); +extern const fcml_cstring M_LLWPCB = _FT("llwpcb"); +extern const fcml_cstring M_LMSW = _FT("lmsw"); +extern const fcml_cstring M_LODS = _FT("lods"); +extern const fcml_cstring M_LODSB = _FT("lodsb"); +extern const fcml_cstring M_LODSD = _FT("lodsd"); +extern const fcml_cstring M_LODSQ = _FT("lodsq"); +extern const fcml_cstring M_LODSW = _FT("lodsw"); +extern const fcml_cstring M_LOOP = _FT("loop"); +extern const fcml_cstring M_LOOPE = _FT("loope"); +extern const fcml_cstring M_LOOPNE = _FT("loopne"); +extern const fcml_cstring M_LOOPNZ = _FT("loopnz"); +extern const fcml_cstring M_LOOPZ = _FT("loopz"); +extern const fcml_cstring M_LSL = _FT("lsl"); +extern const fcml_cstring M_LSS = _FT("lss"); +extern const fcml_cstring M_LTR = _FT("ltr"); +extern const fcml_cstring M_LWPINS = _FT("lwpins"); +extern const fcml_cstring M_LWPVAL = _FT("lwpval"); +extern const fcml_cstring M_LZCNT = _FT("lzcnt"); +extern const fcml_cstring M_MASKMOVDQU = _FT("maskmovdqu"); +extern const fcml_cstring M_MASKMOVQ = _FT("maskmovq"); +extern const fcml_cstring M_MAXPD = _FT("maxpd"); +extern const fcml_cstring M_MAXPS = _FT("maxps"); +extern const fcml_cstring M_MAXSD = _FT("maxsd"); +extern const fcml_cstring M_MAXSS = _FT("maxss"); +extern const fcml_cstring M_MFENCE = _FT("mfence"); +extern const fcml_cstring M_MINPD = _FT("minpd"); +extern const fcml_cstring M_MINPS = _FT("minps"); +extern const fcml_cstring M_MINSD = _FT("minsd"); +extern const fcml_cstring M_MINSS = _FT("minss"); +extern const fcml_cstring M_MONITOR = _FT("monitor"); +extern const fcml_cstring M_MOV = _FT("mov"); +extern const fcml_cstring M_MOVAPD = _FT("movapd"); +extern const fcml_cstring M_MOVAPS = _FT("movaps"); +extern const fcml_cstring M_MOVBE = _FT("movbe"); +extern const fcml_cstring M_MOVD = _FT("movd"); +extern const fcml_cstring M_MOVDDUP = _FT("movddup"); +extern const fcml_cstring M_MOVDQ2Q = _FT("movdq2q"); +extern const fcml_cstring M_MOVDQA = _FT("movdqa"); +extern const fcml_cstring M_MOVDQU = _FT("movdqu"); +extern const fcml_cstring M_MOVHLPS = _FT("movhlps"); +extern const fcml_cstring M_MOVHPD = _FT("movhpd"); +extern const fcml_cstring M_MOVHPS = _FT("movhps"); +extern const fcml_cstring M_MOVLHPS = _FT("movlhps"); +extern const fcml_cstring M_MOVLPD = _FT("movlpd"); +extern const fcml_cstring M_MOVLPS = _FT("movlps"); +extern const fcml_cstring M_MOVMSKPD = _FT("movmskpd"); +extern const fcml_cstring M_MOVMSKPS = _FT("movmskps"); +extern const fcml_cstring M_MOVNTDQ = _FT("movntdq"); +extern const fcml_cstring M_MOVNTDQA = _FT("movntdqa"); +extern const fcml_cstring M_MOVNTI = _FT("movnti"); +extern const fcml_cstring M_MOVNTPD = _FT("movntpd"); +extern const fcml_cstring M_MOVNTPS = _FT("movntps"); +extern const fcml_cstring M_MOVNTQ = _FT("movntq"); +extern const fcml_cstring M_MOVNTSD = _FT("movntsd"); +extern const fcml_cstring M_MOVNTSS = _FT("movntss"); +extern const fcml_cstring M_MOVQ = _FT("movq"); +extern const fcml_cstring M_MOVQ2DQ = _FT("movq2dq"); +extern const fcml_cstring M_MOVS = _FT("movs"); +extern const fcml_cstring M_MOVSB = _FT("movsb"); +extern const fcml_cstring M_MOVSD = _FT("movsd"); +extern const fcml_cstring M_MOVSHDUP = _FT("movshdup"); +extern const fcml_cstring M_MOVSLDUP = _FT("movsldup"); +extern const fcml_cstring M_MOVSQ = _FT("movsq"); +extern const fcml_cstring M_MOVSS = _FT("movss"); +extern const fcml_cstring M_MOVSW = _FT("movsw"); +extern const fcml_cstring M_MOVSX = _FT("movsx"); +extern const fcml_cstring M_MOVSXD = _FT("movsxd"); +extern const fcml_cstring M_MOVUPD = _FT("movupd"); +extern const fcml_cstring M_MOVUPS = _FT("movups"); +extern const fcml_cstring M_MOVZX = _FT("movzx"); +extern const fcml_cstring M_MPSADBW = _FT("mpsadbw"); +extern const fcml_cstring M_MUL = _FT("mul"); +extern const fcml_cstring M_MULPD = _FT("mulpd"); +extern const fcml_cstring M_MULPS = _FT("mulps"); +extern const fcml_cstring M_MULSD = _FT("mulsd"); +extern const fcml_cstring M_MULSS = _FT("mulss"); +extern const fcml_cstring M_MULX = _FT("mulx"); +extern const fcml_cstring M_MWAIT = _FT("mwait"); +extern const fcml_cstring M_NEG = _FT("neg"); +extern const fcml_cstring M_NOP = _FT("nop"); +extern const fcml_cstring M_NOT = _FT("not"); +extern const fcml_cstring M_OR = _FT("or"); +extern const fcml_cstring M_ORPD = _FT("orpd"); +extern const fcml_cstring M_ORPS = _FT("orps"); +extern const fcml_cstring M_OUT = _FT("out"); +extern const fcml_cstring M_OUTS = _FT("outs"); +extern const fcml_cstring M_OUTSB = _FT("outsb"); +extern const fcml_cstring M_OUTSD = _FT("outsd"); +extern const fcml_cstring M_OUTSW = _FT("outsw"); +extern const fcml_cstring M_PABSB = _FT("pabsb"); +extern const fcml_cstring M_PABSD = _FT("pabsd"); +extern const fcml_cstring M_PABSW = _FT("pabsw"); +extern const fcml_cstring M_PACKSSDW = _FT("packssdw"); +extern const fcml_cstring M_PACKSSWB = _FT("packsswb"); +extern const fcml_cstring M_PACKUSDW = _FT("packusdw"); +extern const fcml_cstring M_PACKUSWB = _FT("packuswb"); +extern const fcml_cstring M_PADDB = _FT("paddb"); +extern const fcml_cstring M_PADDD = _FT("paddd"); +extern const fcml_cstring M_PADDQ = _FT("paddq"); +extern const fcml_cstring M_PADDSB = _FT("paddsb"); +extern const fcml_cstring M_PADDSW = _FT("paddsw"); +extern const fcml_cstring M_PADDUSB = _FT("paddusb"); +extern const fcml_cstring M_PADDUSW = _FT("paddusw"); +extern const fcml_cstring M_PADDW = _FT("paddw"); +extern const fcml_cstring M_PALIGNR = _FT("palignr"); +extern const fcml_cstring M_PAND = _FT("pand"); +extern const fcml_cstring M_PANDN = _FT("pandn"); +extern const fcml_cstring M_PAUSE = _FT("pause"); +extern const fcml_cstring M_PAVGB = _FT("pavgb"); +extern const fcml_cstring M_PAVGUSB = _FT("pavgusb"); +extern const fcml_cstring M_PAVGW = _FT("pavgw"); +extern const fcml_cstring M_PBLENDVB = _FT("pblendvb"); +extern const fcml_cstring M_PBLENDW = _FT("pblendw"); +extern const fcml_cstring M_PCLMULQDQ = _FT("pclmulqdq"); +extern const fcml_cstring M_PCMPEQB = _FT("pcmpeqb"); +extern const fcml_cstring M_PCMPEQD = _FT("pcmpeqd"); +extern const fcml_cstring M_PCMPEQQ = _FT("pcmpeqq"); +extern const fcml_cstring M_PCMPEQW = _FT("pcmpeqw"); +extern const fcml_cstring M_PCMPESTRI = _FT("pcmpestri"); +extern const fcml_cstring M_PCMPESTRM = _FT("pcmpestrm"); +extern const fcml_cstring M_PCMPGTB = _FT("pcmpgtb"); +extern const fcml_cstring M_PCMPGTD = _FT("pcmpgtd"); +extern const fcml_cstring M_PCMPGTQ = _FT("pcmpgtq"); +extern const fcml_cstring M_PCMPGTW = _FT("pcmpgtw"); +extern const fcml_cstring M_PCMPISTRI = _FT("pcmpistri"); +extern const fcml_cstring M_PCMPISTRM = _FT("pcmpistrm"); +extern const fcml_cstring M_PDEP = _FT("pdep"); +extern const fcml_cstring M_PEXT = _FT("pext"); +extern const fcml_cstring M_PEXTRB = _FT("pextrb"); +extern const fcml_cstring M_PEXTRD = _FT("pextrd"); +extern const fcml_cstring M_PEXTRQ = _FT("pextrq"); +extern const fcml_cstring M_PEXTRW = _FT("pextrw"); +extern const fcml_cstring M_PF2ID = _FT("pf2id"); +extern const fcml_cstring M_PF2IW = _FT("pf2iw"); +extern const fcml_cstring M_PFACC = _FT("pfacc"); +extern const fcml_cstring M_PFADD = _FT("pfadd"); +extern const fcml_cstring M_PFCMPEQ = _FT("pfcmpeq"); +extern const fcml_cstring M_PFCMPGE = _FT("pfcmpge"); +extern const fcml_cstring M_PFCMPGT = _FT("pfcmpgt"); +extern const fcml_cstring M_PFMAX = _FT("pfmax"); +extern const fcml_cstring M_PFMIN = _FT("pfmin"); +extern const fcml_cstring M_PFMUL = _FT("pfmul"); +extern const fcml_cstring M_PFNACC = _FT("pfnacc"); +extern const fcml_cstring M_PFPNACC = _FT("pfpnacc"); +extern const fcml_cstring M_PFRCP = _FT("pfrcp"); +extern const fcml_cstring M_PFRCPIT1 = _FT("pfrcpit1"); +extern const fcml_cstring M_PFRCPIT2 = _FT("pfrcpit2"); +extern const fcml_cstring M_PFRSQIT1 = _FT("pfrsqit1"); +extern const fcml_cstring M_PFRSQRT = _FT("pfrsqrt"); +extern const fcml_cstring M_PFSUB = _FT("pfsub"); +extern const fcml_cstring M_PFSUBR = _FT("pfsubr"); +extern const fcml_cstring M_PHADDD = _FT("phaddd"); +extern const fcml_cstring M_PHADDSW = _FT("phaddsw"); +extern const fcml_cstring M_PHADDW = _FT("phaddw"); +extern const fcml_cstring M_PHMINPOSUW = _FT("phminposuw"); +extern const fcml_cstring M_PHSUBD = _FT("phsubd"); +extern const fcml_cstring M_PHSUBSW = _FT("phsubsw"); +extern const fcml_cstring M_PHSUBW = _FT("phsubw"); +extern const fcml_cstring M_PI2FD = _FT("pi2fd"); +extern const fcml_cstring M_PI2FW = _FT("pi2fw"); +extern const fcml_cstring M_PINSRB = _FT("pinsrb"); +extern const fcml_cstring M_PINSRD = _FT("pinsrd"); +extern const fcml_cstring M_PINSRQ = _FT("pinsrq"); +extern const fcml_cstring M_PINSRW = _FT("pinsrw"); +extern const fcml_cstring M_PMADDUBSW = _FT("pmaddubsw"); +extern const fcml_cstring M_PMADDWD = _FT("pmaddwd"); +extern const fcml_cstring M_PMAXSB = _FT("pmaxsb"); +extern const fcml_cstring M_PMAXSD = _FT("pmaxsd"); +extern const fcml_cstring M_PMAXSW = _FT("pmaxsw"); +extern const fcml_cstring M_PMAXUB = _FT("pmaxub"); +extern const fcml_cstring M_PMAXUD = _FT("pmaxud"); +extern const fcml_cstring M_PMAXUW = _FT("pmaxuw"); +extern const fcml_cstring M_PMINSB = _FT("pminsb"); +extern const fcml_cstring M_PMINSD = _FT("pminsd"); +extern const fcml_cstring M_PMINSW = _FT("pminsw"); +extern const fcml_cstring M_PMINUB = _FT("pminub"); +extern const fcml_cstring M_PMINUD = _FT("pminud"); +extern const fcml_cstring M_PMINUW = _FT("pminuw"); +extern const fcml_cstring M_PMOVMSKB = _FT("pmovmskb"); +extern const fcml_cstring M_PMOVSXBD = _FT("pmovsxbd"); +extern const fcml_cstring M_PMOVSXBQ = _FT("pmovsxbq"); +extern const fcml_cstring M_PMOVSXBW = _FT("pmovsxbw"); +extern const fcml_cstring M_PMOVSXDQ = _FT("pmovsxdq"); +extern const fcml_cstring M_PMOVSXWD = _FT("pmovsxwd"); +extern const fcml_cstring M_PMOVSXWQ = _FT("pmovsxwq"); +extern const fcml_cstring M_PMOVZXBD = _FT("pmovzxbd"); +extern const fcml_cstring M_PMOVZXBQ = _FT("pmovzxbq"); +extern const fcml_cstring M_PMOVZXBW = _FT("pmovzxbw"); +extern const fcml_cstring M_PMOVZXDQ = _FT("pmovzxdq"); +extern const fcml_cstring M_PMOVZXWD = _FT("pmovzxwd"); +extern const fcml_cstring M_PMOVZXWQ = _FT("pmovzxwq"); +extern const fcml_cstring M_PMULDQ = _FT("pmuldq"); +extern const fcml_cstring M_PMULHRSW = _FT("pmulhrsw"); +extern const fcml_cstring M_PMULHRW = _FT("pmulhrw"); +extern const fcml_cstring M_PMULHUW = _FT("pmulhuw"); +extern const fcml_cstring M_PMULHW = _FT("pmulhw"); +extern const fcml_cstring M_PMULLD = _FT("pmulld"); +extern const fcml_cstring M_PMULLW = _FT("pmullw"); +extern const fcml_cstring M_PMULUDQ = _FT("pmuludq"); +extern const fcml_cstring M_POP = _FT("pop"); +extern const fcml_cstring M_POPA = _FT("popa"); +extern const fcml_cstring M_POPAD = _FT("popad"); +extern const fcml_cstring M_POPCNT = _FT("popcnt"); +extern const fcml_cstring M_POPF = _FT("popf"); +extern const fcml_cstring M_POPFD = _FT("popfd"); +extern const fcml_cstring M_POPFQ = _FT("popfq"); +extern const fcml_cstring M_POR = _FT("por"); +extern const fcml_cstring M_PREFETCH = _FT("prefetch"); +extern const fcml_cstring M_PREFETCHNTA = _FT("prefetchnta"); +extern const fcml_cstring M_PREFETCHT0 = _FT("prefetcht0"); +extern const fcml_cstring M_PREFETCHT1 = _FT("prefetcht1"); +extern const fcml_cstring M_PREFETCHT2 = _FT("prefetcht2"); +extern const fcml_cstring M_PREFETCHW = _FT("prefetchw"); +extern const fcml_cstring M_PREFETCHWT1 = _FT("prefetchwt1"); +extern const fcml_cstring M_PSADBW = _FT("psadbw"); +extern const fcml_cstring M_PSHUFB = _FT("pshufb"); +extern const fcml_cstring M_PSHUFD = _FT("pshufd"); +extern const fcml_cstring M_PSHUFHW = _FT("pshufhw"); +extern const fcml_cstring M_PSHUFLW = _FT("pshuflw"); +extern const fcml_cstring M_PSHUFW = _FT("pshufw"); +extern const fcml_cstring M_PSIGNB = _FT("psignb"); +extern const fcml_cstring M_PSIGND = _FT("psignd"); +extern const fcml_cstring M_PSIGNW = _FT("psignw"); +extern const fcml_cstring M_PSLLD = _FT("pslld"); +extern const fcml_cstring M_PSLLDQ = _FT("pslldq"); +extern const fcml_cstring M_PSLLQ = _FT("psllq"); +extern const fcml_cstring M_PSLLW = _FT("psllw"); +extern const fcml_cstring M_PSRAD = _FT("psrad"); +extern const fcml_cstring M_PSRAW = _FT("psraw"); +extern const fcml_cstring M_PSRLD = _FT("psrld"); +extern const fcml_cstring M_PSRLDQ = _FT("psrldq"); +extern const fcml_cstring M_PSRLQ = _FT("psrlq"); +extern const fcml_cstring M_PSRLW = _FT("psrlw"); +extern const fcml_cstring M_PSUBB = _FT("psubb"); +extern const fcml_cstring M_PSUBD = _FT("psubd"); +extern const fcml_cstring M_PSUBQ = _FT("psubq"); +extern const fcml_cstring M_PSUBSB = _FT("psubsb"); +extern const fcml_cstring M_PSUBSW = _FT("psubsw"); +extern const fcml_cstring M_PSUBUSB = _FT("psubusb"); +extern const fcml_cstring M_PSUBUSW = _FT("psubusw"); +extern const fcml_cstring M_PSUBW = _FT("psubw"); +extern const fcml_cstring M_PSWAPD = _FT("pswapd"); +extern const fcml_cstring M_PTEST = _FT("ptest"); +extern const fcml_cstring M_PUNPCKHBW = _FT("punpckhbw"); +extern const fcml_cstring M_PUNPCKHDQ = _FT("punpckhdq"); +extern const fcml_cstring M_PUNPCKHQDQ = _FT("punpckhqdq"); +extern const fcml_cstring M_PUNPCKHWD = _FT("punpckhwd"); +extern const fcml_cstring M_PUNPCKLBW = _FT("punpcklbw"); +extern const fcml_cstring M_PUNPCKLDQ = _FT("punpckldq"); +extern const fcml_cstring M_PUNPCKLQDQ = _FT("punpcklqdq"); +extern const fcml_cstring M_PUNPCKLWD = _FT("punpcklwd"); +extern const fcml_cstring M_PUSH = _FT("push"); +extern const fcml_cstring M_PUSHA = _FT("pusha"); +extern const fcml_cstring M_PUSHAD = _FT("pushad"); +extern const fcml_cstring M_PUSHF = _FT("pushf"); +extern const fcml_cstring M_PUSHFD = _FT("pushfd"); +extern const fcml_cstring M_PUSHFQ = _FT("pushfq"); +extern const fcml_cstring M_PXOR = _FT("pxor"); +extern const fcml_cstring M_RCL = _FT("rcl"); +extern const fcml_cstring M_RCPPS = _FT("rcpps"); +extern const fcml_cstring M_RCPSS = _FT("rcpss"); +extern const fcml_cstring M_RCR = _FT("rcr"); +extern const fcml_cstring M_RDFSBASE = _FT("rdfsbase"); +extern const fcml_cstring M_RDGSBASE = _FT("rdgsbase"); +extern const fcml_cstring M_RDMSR = _FT("rdmsr"); +extern const fcml_cstring M_RDPMC = _FT("rdpmc"); +extern const fcml_cstring M_RDRAND = _FT("rdrand"); +extern const fcml_cstring M_RDSEED = _FT("rdseed"); +extern const fcml_cstring M_RDTSC = _FT("rdtsc"); +extern const fcml_cstring M_RDTSCP = _FT("rdtscp"); +extern const fcml_cstring M_RET = _FT("ret"); +extern const fcml_cstring M_RETF = _FT("retf"); +extern const fcml_cstring M_ROL = _FT("rol"); +extern const fcml_cstring M_ROR = _FT("ror"); +extern const fcml_cstring M_RORX = _FT("rorx"); +extern const fcml_cstring M_ROUNDPD = _FT("roundpd"); +extern const fcml_cstring M_ROUNDPS = _FT("roundps"); +extern const fcml_cstring M_ROUNDSD = _FT("roundsd"); +extern const fcml_cstring M_ROUNDSS = _FT("roundss"); +extern const fcml_cstring M_RSM = _FT("rsm"); +extern const fcml_cstring M_RSQRTPS = _FT("rsqrtps"); +extern const fcml_cstring M_RSQRTSS = _FT("rsqrtss"); +extern const fcml_cstring M_SAHF = _FT("sahf"); +extern const fcml_cstring M_SAL = _FT("sal"); +extern const fcml_cstring M_SAR = _FT("sar"); +extern const fcml_cstring M_SARX = _FT("sarx"); +extern const fcml_cstring M_SBB = _FT("sbb"); +extern const fcml_cstring M_SCAS = _FT("scas"); +extern const fcml_cstring M_SCASB = _FT("scasb"); +extern const fcml_cstring M_SCASD = _FT("scasd"); +extern const fcml_cstring M_SCASQ = _FT("scasq"); +extern const fcml_cstring M_SCASW = _FT("scasw"); +extern const fcml_cstring M_SETA = _FT("seta"); +extern const fcml_cstring M_SETAE = _FT("setae"); +extern const fcml_cstring M_SETB = _FT("setb"); +extern const fcml_cstring M_SETBE = _FT("setbe"); +extern const fcml_cstring M_SETC = _FT("setc"); +extern const fcml_cstring M_SETENE = _FT("setene"); +extern const fcml_cstring M_SETG = _FT("setg"); +extern const fcml_cstring M_SETGE = _FT("setge"); +extern const fcml_cstring M_SETL = _FT("setl"); +extern const fcml_cstring M_SETLE = _FT("setle"); +extern const fcml_cstring M_SETNA = _FT("setna"); +extern const fcml_cstring M_SETNAE = _FT("setnae"); +extern const fcml_cstring M_SETNB = _FT("setnb"); +extern const fcml_cstring M_SETNBE = _FT("setnbe"); +extern const fcml_cstring M_SETNC = _FT("setnc"); +extern const fcml_cstring M_SETNG = _FT("setng"); +extern const fcml_cstring M_SETNGE = _FT("setnge"); +extern const fcml_cstring M_SETNL = _FT("setnl"); +extern const fcml_cstring M_SETNLE = _FT("setnle"); +extern const fcml_cstring M_SETNO = _FT("setno"); +extern const fcml_cstring M_SETNP = _FT("setnp"); +extern const fcml_cstring M_SETNS = _FT("setns"); +extern const fcml_cstring M_SETNZ = _FT("setnz"); +extern const fcml_cstring M_SETO = _FT("seto"); +extern const fcml_cstring M_SETP = _FT("setp"); +extern const fcml_cstring M_SETPE = _FT("setpe"); +extern const fcml_cstring M_SETPO = _FT("setpo"); +extern const fcml_cstring M_SETS = _FT("sets"); +extern const fcml_cstring M_SETZ = _FT("setz"); +extern const fcml_cstring M_SFENCE = _FT("sfence"); +extern const fcml_cstring M_SGDT = _FT("sgdt"); +extern const fcml_cstring M_SHL = _FT("shl"); +extern const fcml_cstring M_SHLD = _FT("shld"); +extern const fcml_cstring M_SHLX = _FT("shlx"); +extern const fcml_cstring M_SHR = _FT("shr"); +extern const fcml_cstring M_SHRD = _FT("shrd"); +extern const fcml_cstring M_SHRX = _FT("shrx"); +extern const fcml_cstring M_SHUFPD = _FT("shufpd"); +extern const fcml_cstring M_SHUFPS = _FT("shufps"); +extern const fcml_cstring M_SIDT = _FT("sidt"); +extern const fcml_cstring M_SKINIT = _FT("skinit"); +extern const fcml_cstring M_SLDT = _FT("sldt"); +extern const fcml_cstring M_SLWPCB = _FT("slwpcb"); +extern const fcml_cstring M_SMSW = _FT("smsw"); +extern const fcml_cstring M_SQRTPD = _FT("sqrtpd"); +extern const fcml_cstring M_SQRTPS = _FT("sqrtps"); +extern const fcml_cstring M_SQRTSD = _FT("sqrtsd"); +extern const fcml_cstring M_SQRTSS = _FT("sqrtss"); +extern const fcml_cstring M_STAC = _FT("stac"); +extern const fcml_cstring M_STC = _FT("stc"); +extern const fcml_cstring M_STD = _FT("std"); +extern const fcml_cstring M_STGI = _FT("stgi"); +extern const fcml_cstring M_STI = _FT("sti"); +extern const fcml_cstring M_STMXCSR = _FT("stmxcsr"); +extern const fcml_cstring M_STOS = _FT("stos"); +extern const fcml_cstring M_STOSB = _FT("stosb"); +extern const fcml_cstring M_STOSD = _FT("stosd"); +extern const fcml_cstring M_STOSQ = _FT("stosq"); +extern const fcml_cstring M_STOSW = _FT("stosw"); +extern const fcml_cstring M_STR = _FT("str"); +extern const fcml_cstring M_SUB = _FT("sub"); +extern const fcml_cstring M_SUBPD = _FT("subpd"); +extern const fcml_cstring M_SUBPS = _FT("subps"); +extern const fcml_cstring M_SUBSD = _FT("subsd"); +extern const fcml_cstring M_SUBSS = _FT("subss"); +extern const fcml_cstring M_SWAPGS = _FT("swapgs"); +extern const fcml_cstring M_SYSCALL = _FT("syscall"); +extern const fcml_cstring M_SYSENTER = _FT("sysenter"); +extern const fcml_cstring M_SYSEXIT = _FT("sysexit"); +extern const fcml_cstring M_SYSRET = _FT("sysret"); +extern const fcml_cstring M_T1MSKC = _FT("t1mskc"); +extern const fcml_cstring M_TEST = _FT("test"); +extern const fcml_cstring M_TZCNT = _FT("tzcnt"); +extern const fcml_cstring M_TZMSK = _FT("tzmsk"); +extern const fcml_cstring M_UCOMISD = _FT("ucomisd"); +extern const fcml_cstring M_UCOMISS = _FT("ucomiss"); +extern const fcml_cstring M_UD2 = _FT("ud2"); +extern const fcml_cstring M_UNPCKHPD = _FT("unpckhpd"); +extern const fcml_cstring M_UNPCKHPS = _FT("unpckhps"); +extern const fcml_cstring M_UNPCKLPD = _FT("unpcklpd"); +extern const fcml_cstring M_UNPCKLPS = _FT("unpcklps"); +extern const fcml_cstring M_V4FMADDPS = _FT("v4fmaddps"); +extern const fcml_cstring M_V4FMADDSS = _FT("v4fmaddss"); +extern const fcml_cstring M_V4FNMADDPS = _FT("v4fnmaddps"); +extern const fcml_cstring M_V4FNMADDSS = _FT("v4fnmaddss"); +extern const fcml_cstring M_VADDPD = _FT("vaddpd"); +extern const fcml_cstring M_VADDPS = _FT("vaddps"); +extern const fcml_cstring M_VADDSD = _FT("vaddsd"); +extern const fcml_cstring M_VADDSS = _FT("vaddss"); +extern const fcml_cstring M_VADDSUBPD = _FT("vaddsubpd"); +extern const fcml_cstring M_VADDSUBPS = _FT("vaddsubps"); +extern const fcml_cstring M_VAESDEC = _FT("vaesdec"); +extern const fcml_cstring M_VAESDECLAST = _FT("vaesdeclast"); +extern const fcml_cstring M_VAESENC = _FT("vaesenc"); +extern const fcml_cstring M_VAESENCLAST = _FT("vaesenclast"); +extern const fcml_cstring M_VAESIMC = _FT("vaesimc"); +extern const fcml_cstring M_VAESKEYGENASSIST = _FT("vaeskeygenassist"); +extern const fcml_cstring M_VALIGND = _FT("valignd"); +extern const fcml_cstring M_VALIGNQ = _FT("valignq"); +extern const fcml_cstring M_VANDNPD = _FT("vandnpd"); +extern const fcml_cstring M_VANDNPS = _FT("vandnps"); +extern const fcml_cstring M_VANDPD = _FT("vandpd"); +extern const fcml_cstring M_VANDPS = _FT("vandps"); +extern const fcml_cstring M_VBLENDMPD = _FT("vblendmpd"); +extern const fcml_cstring M_VBLENDMPS = _FT("vblendmps"); +extern const fcml_cstring M_VBLENDPD = _FT("vblendpd"); +extern const fcml_cstring M_VBLENDPS = _FT("vblendps"); +extern const fcml_cstring M_VBLENDVPD = _FT("vblendvpd"); +extern const fcml_cstring M_VBLENDVPS = _FT("vblendvps"); +extern const fcml_cstring M_VBROADCASTF128 = _FT("vbroadcastf128"); +extern const fcml_cstring M_VBROADCASTF32X2 = _FT("vbroadcastf32x2"); +extern const fcml_cstring M_VBROADCASTF32X4 = _FT("vbroadcastf32x4"); +extern const fcml_cstring M_VBROADCASTF32X8 = _FT("vbroadcastf32x8"); +extern const fcml_cstring M_VBROADCASTF64X2 = _FT("vbroadcastf64x2"); +extern const fcml_cstring M_VBROADCASTF64X4 = _FT("vbroadcastf64x4"); +extern const fcml_cstring M_VBROADCASTI128 = _FT("vbroadcasti128"); +extern const fcml_cstring M_VBROADCASTI32X2 = _FT("vbroadcasti32x2"); +extern const fcml_cstring M_VBROADCASTI32X4 = _FT("vbroadcasti32x4"); +extern const fcml_cstring M_VBROADCASTI32X8 = _FT("vbroadcasti32x8"); +extern const fcml_cstring M_VBROADCASTI64X2 = _FT("vbroadcasti64x2"); +extern const fcml_cstring M_VBROADCASTI64X4 = _FT("vbroadcasti64x4"); +extern const fcml_cstring M_VBROADCASTSD = _FT("vbroadcastsd"); +extern const fcml_cstring M_VBROADCASTSS = _FT("vbroadcastss"); +extern const fcml_cstring M_VCMPEQ_OSPD = _FT("vcmpeq_ospd"); +extern const fcml_cstring M_VCMPEQ_OSPS = _FT("vcmpeq_osps"); +extern const fcml_cstring M_VCMPEQ_OSSD = _FT("vcmpeq_ossd"); +extern const fcml_cstring M_VCMPEQ_OSSS = _FT("vcmpeq_osss"); +extern const fcml_cstring M_VCMPEQ_UQPD = _FT("vcmpeq_uqpd"); +extern const fcml_cstring M_VCMPEQ_UQPS = _FT("vcmpeq_uqps"); +extern const fcml_cstring M_VCMPEQ_UQSD = _FT("vcmpeq_uqsd"); +extern const fcml_cstring M_VCMPEQ_UQSS = _FT("vcmpeq_uqss"); +extern const fcml_cstring M_VCMPEQ_USPD = _FT("vcmpeq_uspd"); +extern const fcml_cstring M_VCMPEQ_USPS = _FT("vcmpeq_usps"); +extern const fcml_cstring M_VCMPEQ_USSD = _FT("vcmpeq_ussd"); +extern const fcml_cstring M_VCMPEQ_USSS = _FT("vcmpeq_usss"); +extern const fcml_cstring M_VCMPEQPD = _FT("vcmpeqpd"); +extern const fcml_cstring M_VCMPEQPS = _FT("vcmpeqps"); +extern const fcml_cstring M_VCMPEQSD = _FT("vcmpeqsd"); +extern const fcml_cstring M_VCMPEQSS = _FT("vcmpeqss"); +extern const fcml_cstring M_VCMPFALSE_OSPD = _FT("vcmpfalse_ospd"); +extern const fcml_cstring M_VCMPFALSE_OSPS = _FT("vcmpfalse_osps"); +extern const fcml_cstring M_VCMPFALSE_OSSD = _FT("vcmpfalse_ossd"); +extern const fcml_cstring M_VCMPFALSE_OSSS = _FT("vcmpfalse_osss"); +extern const fcml_cstring M_VCMPFALSEPD = _FT("vcmpfalsepd"); +extern const fcml_cstring M_VCMPFALSEPS = _FT("vcmpfalseps"); +extern const fcml_cstring M_VCMPFALSESD = _FT("vcmpfalsesd"); +extern const fcml_cstring M_VCMPFALSESS = _FT("vcmpfalsess"); +extern const fcml_cstring M_VCMPGE_OQPD = _FT("vcmpge_oqpd"); +extern const fcml_cstring M_VCMPGE_OQPS = _FT("vcmpge_oqps"); +extern const fcml_cstring M_VCMPGE_OQSD = _FT("vcmpge_oqsd"); +extern const fcml_cstring M_VCMPGE_OQSS = _FT("vcmpge_oqss"); +extern const fcml_cstring M_VCMPGEPD = _FT("vcmpgepd"); +extern const fcml_cstring M_VCMPGEPS = _FT("vcmpgeps"); +extern const fcml_cstring M_VCMPGESD = _FT("vcmpgesd"); +extern const fcml_cstring M_VCMPGESS = _FT("vcmpgess"); +extern const fcml_cstring M_VCMPGT_OQPD = _FT("vcmpgt_oqpd"); +extern const fcml_cstring M_VCMPGT_OQPS = _FT("vcmpgt_oqps"); +extern const fcml_cstring M_VCMPGT_OQSD = _FT("vcmpgt_oqsd"); +extern const fcml_cstring M_VCMPGT_OQSS = _FT("vcmpgt_oqss"); +extern const fcml_cstring M_VCMPGTPD = _FT("vcmpgtpd"); +extern const fcml_cstring M_VCMPGTPS = _FT("vcmpgtps"); +extern const fcml_cstring M_VCMPGTSD = _FT("vcmpgtsd"); +extern const fcml_cstring M_VCMPGTSS = _FT("vcmpgtss"); +extern const fcml_cstring M_VCMPLE_OQPD = _FT("vcmple_oqpd"); +extern const fcml_cstring M_VCMPLE_OQPS = _FT("vcmple_oqps"); +extern const fcml_cstring M_VCMPLE_OQSD = _FT("vcmple_oqsd"); +extern const fcml_cstring M_VCMPLE_OQSS = _FT("vcmple_oqss"); +extern const fcml_cstring M_VCMPLEPD = _FT("vcmplepd"); +extern const fcml_cstring M_VCMPLEPS = _FT("vcmpleps"); +extern const fcml_cstring M_VCMPLESD = _FT("vcmplesd"); +extern const fcml_cstring M_VCMPLESS = _FT("vcmpless"); +extern const fcml_cstring M_VCMPLT_OQPD = _FT("vcmplt_oqpd"); +extern const fcml_cstring M_VCMPLT_OQPS = _FT("vcmplt_oqps"); +extern const fcml_cstring M_VCMPLT_OQSD = _FT("vcmplt_oqsd"); +extern const fcml_cstring M_VCMPLT_OQSS = _FT("vcmplt_oqss"); +extern const fcml_cstring M_VCMPLTPD = _FT("vcmpltpd"); +extern const fcml_cstring M_VCMPLTPS = _FT("vcmpltps"); +extern const fcml_cstring M_VCMPLTSD = _FT("vcmpltsd"); +extern const fcml_cstring M_VCMPLTSS = _FT("vcmpltss"); +extern const fcml_cstring M_VCMPNEQ_OQPD = _FT("vcmpneq_oqpd"); +extern const fcml_cstring M_VCMPNEQ_OQPS = _FT("vcmpneq_oqps"); +extern const fcml_cstring M_VCMPNEQ_OQSD = _FT("vcmpneq_oqsd"); +extern const fcml_cstring M_VCMPNEQ_OQSS = _FT("vcmpneq_oqss"); +extern const fcml_cstring M_VCMPNEQ_OSPD = _FT("vcmpneq_ospd"); +extern const fcml_cstring M_VCMPNEQ_OSPS = _FT("vcmpneq_osps"); +extern const fcml_cstring M_VCMPNEQ_OSSD = _FT("vcmpneq_ossd"); +extern const fcml_cstring M_VCMPNEQ_OSSS = _FT("vcmpneq_osss"); +extern const fcml_cstring M_VCMPNEQ_USPD = _FT("vcmpneq_uspd"); +extern const fcml_cstring M_VCMPNEQ_USPS = _FT("vcmpneq_usps"); +extern const fcml_cstring M_VCMPNEQ_USSD = _FT("vcmpneq_ussd"); +extern const fcml_cstring M_VCMPNEQ_USSS = _FT("vcmpneq_usss"); +extern const fcml_cstring M_VCMPNEQPD = _FT("vcmpneqpd"); +extern const fcml_cstring M_VCMPNEQPS = _FT("vcmpneqps"); +extern const fcml_cstring M_VCMPNEQSD = _FT("vcmpneqsd"); +extern const fcml_cstring M_VCMPNEQSS = _FT("vcmpneqss"); +extern const fcml_cstring M_VCMPNGE_UQPD = _FT("vcmpnge_uqpd"); +extern const fcml_cstring M_VCMPNGE_UQPS = _FT("vcmpnge_uqps"); +extern const fcml_cstring M_VCMPNGE_UQSD = _FT("vcmpnge_uqsd"); +extern const fcml_cstring M_VCMPNGE_UQSS = _FT("vcmpnge_uqss"); +extern const fcml_cstring M_VCMPNGEPD = _FT("vcmpngepd"); +extern const fcml_cstring M_VCMPNGEPS = _FT("vcmpngeps"); +extern const fcml_cstring M_VCMPNGESD = _FT("vcmpngesd"); +extern const fcml_cstring M_VCMPNGESS = _FT("vcmpngess"); +extern const fcml_cstring M_VCMPNGT_UQPD = _FT("vcmpngt_uqpd"); +extern const fcml_cstring M_VCMPNGT_UQPS = _FT("vcmpngt_uqps"); +extern const fcml_cstring M_VCMPNGT_UQSD = _FT("vcmpngt_uqsd"); +extern const fcml_cstring M_VCMPNGT_UQSS = _FT("vcmpngt_uqss"); +extern const fcml_cstring M_VCMPNGTPD = _FT("vcmpngtpd"); +extern const fcml_cstring M_VCMPNGTPS = _FT("vcmpngtps"); +extern const fcml_cstring M_VCMPNGTSD = _FT("vcmpngtsd"); +extern const fcml_cstring M_VCMPNGTSS = _FT("vcmpngtss"); +extern const fcml_cstring M_VCMPNLE_UQPD = _FT("vcmpnle_uqpd"); +extern const fcml_cstring M_VCMPNLE_UQPS = _FT("vcmpnle_uqps"); +extern const fcml_cstring M_VCMPNLE_UQSD = _FT("vcmpnle_uqsd"); +extern const fcml_cstring M_VCMPNLE_UQSS = _FT("vcmpnle_uqss"); +extern const fcml_cstring M_VCMPNLEPD = _FT("vcmpnlepd"); +extern const fcml_cstring M_VCMPNLEPS = _FT("vcmpnleps"); +extern const fcml_cstring M_VCMPNLESD = _FT("vcmpnlesd"); +extern const fcml_cstring M_VCMPNLESS = _FT("vcmpnless"); +extern const fcml_cstring M_VCMPNLT_UQPD = _FT("vcmpnlt_uqpd"); +extern const fcml_cstring M_VCMPNLT_UQPS = _FT("vcmpnlt_uqps"); +extern const fcml_cstring M_VCMPNLT_UQSD = _FT("vcmpnlt_uqsd"); +extern const fcml_cstring M_VCMPNLT_UQSS = _FT("vcmpnlt_uqss"); +extern const fcml_cstring M_VCMPNLTPD = _FT("vcmpnltpd"); +extern const fcml_cstring M_VCMPNLTPS = _FT("vcmpnltps"); +extern const fcml_cstring M_VCMPNLTSD = _FT("vcmpnltsd"); +extern const fcml_cstring M_VCMPNLTSS = _FT("vcmpnltss"); +extern const fcml_cstring M_VCMPORD_SPD = _FT("vcmpord_spd"); +extern const fcml_cstring M_VCMPORD_SPS = _FT("vcmpord_sps"); +extern const fcml_cstring M_VCMPORD_SSD = _FT("vcmpord_ssd"); +extern const fcml_cstring M_VCMPORD_SSS = _FT("vcmpord_sss"); +extern const fcml_cstring M_VCMPORDPD = _FT("vcmpordpd"); +extern const fcml_cstring M_VCMPORDPS = _FT("vcmpordps"); +extern const fcml_cstring M_VCMPORDSD = _FT("vcmpordsd"); +extern const fcml_cstring M_VCMPORDSS = _FT("vcmpordss"); +extern const fcml_cstring M_VCMPPD = _FT("vcmppd"); +extern const fcml_cstring M_VCMPPS = _FT("vcmpps"); +extern const fcml_cstring M_VCMPSD = _FT("vcmpsd"); +extern const fcml_cstring M_VCMPSS = _FT("vcmpss"); +extern const fcml_cstring M_VCMPTRUE_USPD = _FT("vcmptrue_uspd"); +extern const fcml_cstring M_VCMPTRUE_USPS = _FT("vcmptrue_usps"); +extern const fcml_cstring M_VCMPTRUE_USSD = _FT("vcmptrue_ussd"); +extern const fcml_cstring M_VCMPTRUE_USSS = _FT("vcmptrue_usss"); +extern const fcml_cstring M_VCMPTRUEPD = _FT("vcmptruepd"); +extern const fcml_cstring M_VCMPTRUEPS = _FT("vcmptrueps"); +extern const fcml_cstring M_VCMPTRUESD = _FT("vcmptruesd"); +extern const fcml_cstring M_VCMPTRUESS = _FT("vcmptruess"); +extern const fcml_cstring M_VCMPUNORD_SPD = _FT("vcmpunord_spd"); +extern const fcml_cstring M_VCMPUNORD_SPS = _FT("vcmpunord_sps"); +extern const fcml_cstring M_VCMPUNORD_SSD = _FT("vcmpunord_ssd"); +extern const fcml_cstring M_VCMPUNORD_SSS = _FT("vcmpunord_sss"); +extern const fcml_cstring M_VCMPUNORDPD = _FT("vcmpunordpd"); +extern const fcml_cstring M_VCMPUNORDPS = _FT("vcmpunordps"); +extern const fcml_cstring M_VCMPUNORDSD = _FT("vcmpunordsd"); +extern const fcml_cstring M_VCMPUNORDSS = _FT("vcmpunordss"); +extern const fcml_cstring M_VCOMISD = _FT("vcomisd"); +extern const fcml_cstring M_VCOMISS = _FT("vcomiss"); +extern const fcml_cstring M_VCOMPRESSPD = _FT("vcompresspd"); +extern const fcml_cstring M_VCOMPRESSPS = _FT("vcompressps"); +extern const fcml_cstring M_VCVTDQ2PD = _FT("vcvtdq2pd"); +extern const fcml_cstring M_VCVTDQ2PS = _FT("vcvtdq2ps"); +extern const fcml_cstring M_VCVTPD2DQ = _FT("vcvtpd2dq"); +extern const fcml_cstring M_VCVTPD2PS = _FT("vcvtpd2ps"); +extern const fcml_cstring M_VCVTPD2QQ = _FT("vcvtpd2qq"); +extern const fcml_cstring M_VCVTPD2UDQ = _FT("vcvtpd2udq"); +extern const fcml_cstring M_VCVTPD2UQQ = _FT("vcvtpd2uqq"); +extern const fcml_cstring M_VCVTPH2PS = _FT("vcvtph2ps"); +extern const fcml_cstring M_VCVTPS2DQ = _FT("vcvtps2dq"); +extern const fcml_cstring M_VCVTPS2PD = _FT("vcvtps2pd"); +extern const fcml_cstring M_VCVTPS2PH = _FT("vcvtps2ph"); +extern const fcml_cstring M_VCVTPS2QQ = _FT("vcvtps2qq"); +extern const fcml_cstring M_VCVTPS2UDQ = _FT("vcvtps2udq"); +extern const fcml_cstring M_VCVTPS2UQQ = _FT("vcvtps2uqq"); +extern const fcml_cstring M_VCVTQQ2PD = _FT("vcvtqq2pd"); +extern const fcml_cstring M_VCVTQQ2PS = _FT("vcvtqq2ps"); +extern const fcml_cstring M_VCVTSD2SI = _FT("vcvtsd2si"); +extern const fcml_cstring M_VCVTSD2SS = _FT("vcvtsd2ss"); +extern const fcml_cstring M_VCVTSD2USI = _FT("vcvtsd2usi"); +extern const fcml_cstring M_VCVTSI2SD = _FT("vcvtsi2sd"); +extern const fcml_cstring M_VCVTSI2SS = _FT("vcvtsi2ss"); +extern const fcml_cstring M_VCVTSS2SD = _FT("vcvtss2sd"); +extern const fcml_cstring M_VCVTSS2SI = _FT("vcvtss2si"); +extern const fcml_cstring M_VCVTSS2USI = _FT("vcvtss2usi"); +extern const fcml_cstring M_VCVTTPD2DQ = _FT("vcvttpd2dq"); +extern const fcml_cstring M_VCVTTPD2QQ = _FT("vcvttpd2qq"); +extern const fcml_cstring M_VCVTTPD2UDQ = _FT("vcvttpd2udq"); +extern const fcml_cstring M_VCVTTPD2UQQ = _FT("vcvttpd2uqq"); +extern const fcml_cstring M_VCVTTPS2DQ = _FT("vcvttps2dq"); +extern const fcml_cstring M_VCVTTPS2QQ = _FT("vcvttps2qq"); +extern const fcml_cstring M_VCVTTPS2UDQ = _FT("vcvttps2udq"); +extern const fcml_cstring M_VCVTTPS2UQQ = _FT("vcvttps2uqq"); +extern const fcml_cstring M_VCVTTSD2SI = _FT("vcvttsd2si"); +extern const fcml_cstring M_VCVTTSD2USI = _FT("vcvttsd2usi"); +extern const fcml_cstring M_VCVTTSS2SI = _FT("vcvttss2si"); +extern const fcml_cstring M_VCVTTSS2USI = _FT("vcvttss2usi"); +extern const fcml_cstring M_VCVTUDQ2PD = _FT("vcvtudq2pd"); +extern const fcml_cstring M_VCVTUDQ2PS = _FT("vcvtudq2ps"); +extern const fcml_cstring M_VCVTUQQ2PD = _FT("vcvtuqq2pd"); +extern const fcml_cstring M_VCVTUQQ2PS = _FT("vcvtuqq2ps"); +extern const fcml_cstring M_VCVTUSI2SD = _FT("vcvtusi2sd"); +extern const fcml_cstring M_VCVTUSI2SS = _FT("vcvtusi2ss"); +extern const fcml_cstring M_VDBPSADBW = _FT("vdbpsadbw"); +extern const fcml_cstring M_VDIVPD = _FT("vdivpd"); +extern const fcml_cstring M_VDIVPS = _FT("vdivps"); +extern const fcml_cstring M_VDIVSD = _FT("vdivsd"); +extern const fcml_cstring M_VDIVSS = _FT("vdivss"); +extern const fcml_cstring M_VDPPD = _FT("vdppd"); +extern const fcml_cstring M_VDPPS = _FT("vdpps"); +extern const fcml_cstring M_VERR = _FT("verr"); +extern const fcml_cstring M_VERW = _FT("verw"); +extern const fcml_cstring M_VEXP2PD = _FT("vexp2pd"); +extern const fcml_cstring M_VEXP2PS = _FT("vexp2ps"); +extern const fcml_cstring M_VEXPANDPD = _FT("vexpandpd"); +extern const fcml_cstring M_VEXPANDPS = _FT("vexpandps"); +extern const fcml_cstring M_VEXTRACTF128 = _FT("vextractf128"); +extern const fcml_cstring M_VEXTRACTF32X4 = _FT("vextractf32x4"); +extern const fcml_cstring M_VEXTRACTF32X8 = _FT("vextractf32x8"); +extern const fcml_cstring M_VEXTRACTF64X2 = _FT("vextractf64x2"); +extern const fcml_cstring M_VEXTRACTF64X4 = _FT("vextractf64x4"); +extern const fcml_cstring M_VEXTRACTI128 = _FT("vextracti128"); +extern const fcml_cstring M_VEXTRACTI32X4 = _FT("vextracti32x4"); +extern const fcml_cstring M_VEXTRACTI32X8 = _FT("vextracti32x8"); +extern const fcml_cstring M_VEXTRACTI64X2 = _FT("vextracti64x2"); +extern const fcml_cstring M_VEXTRACTI64X4 = _FT("vextracti64x4"); +extern const fcml_cstring M_VEXTRACTPS = _FT("vextractps"); +extern const fcml_cstring M_VFIXUPIMMPD = _FT("vfixupimmpd"); +extern const fcml_cstring M_VFIXUPIMMPS = _FT("vfixupimmps"); +extern const fcml_cstring M_VFIXUPIMMSD = _FT("vfixupimmsd"); +extern const fcml_cstring M_VFIXUPIMMSS = _FT("vfixupimmss"); +extern const fcml_cstring M_VFMADD132PD = _FT("vfmadd132pd"); +extern const fcml_cstring M_VFMADD132PS = _FT("vfmadd132ps"); +extern const fcml_cstring M_VFMADD132SD = _FT("vfmadd132sd"); +extern const fcml_cstring M_VFMADD132SS = _FT("vfmadd132ss"); +extern const fcml_cstring M_VFMADD213PD = _FT("vfmadd213pd"); +extern const fcml_cstring M_VFMADD213PS = _FT("vfmadd213ps"); +extern const fcml_cstring M_VFMADD213SD = _FT("vfmadd213sd"); +extern const fcml_cstring M_VFMADD213SS = _FT("vfmadd213ss"); +extern const fcml_cstring M_VFMADD231PD = _FT("vfmadd231pd"); +extern const fcml_cstring M_VFMADD231PS = _FT("vfmadd231ps"); +extern const fcml_cstring M_VFMADD231SD = _FT("vfmadd231sd"); +extern const fcml_cstring M_VFMADD231SS = _FT("vfmadd231ss"); +extern const fcml_cstring M_VFMADDPD = _FT("vfmaddpd"); +extern const fcml_cstring M_VFMADDPS = _FT("vfmaddps"); +extern const fcml_cstring M_VFMADDSD = _FT("vfmaddsd"); +extern const fcml_cstring M_VFMADDSS = _FT("vfmaddss"); +extern const fcml_cstring M_VFMADDSUB132PD = _FT("vfmaddsub132pd"); +extern const fcml_cstring M_VFMADDSUB132PS = _FT("vfmaddsub132ps"); +extern const fcml_cstring M_VFMADDSUB213PD = _FT("vfmaddsub213pd"); +extern const fcml_cstring M_VFMADDSUB213PS = _FT("vfmaddsub213ps"); +extern const fcml_cstring M_VFMADDSUB231PD = _FT("vfmaddsub231pd"); +extern const fcml_cstring M_VFMADDSUB231PS = _FT("vfmaddsub231ps"); +extern const fcml_cstring M_VFMADDSUBPD = _FT("vfmaddsubpd"); +extern const fcml_cstring M_VFMADDSUBPS = _FT("vfmaddsubps"); +extern const fcml_cstring M_VFMSUB132PD = _FT("vfmsub132pd"); +extern const fcml_cstring M_VFMSUB132PS = _FT("vfmsub132ps"); +extern const fcml_cstring M_VFMSUB132SD = _FT("vfmsub132sd"); +extern const fcml_cstring M_VFMSUB132SS = _FT("vfmsub132ss"); +extern const fcml_cstring M_VFMSUB213PD = _FT("vfmsub213pd"); +extern const fcml_cstring M_VFMSUB213PS = _FT("vfmsub213ps"); +extern const fcml_cstring M_VFMSUB213SD = _FT("vfmsub213sd"); +extern const fcml_cstring M_VFMSUB213SS = _FT("vfmsub213ss"); +extern const fcml_cstring M_VFMSUB231PD = _FT("vfmsub231pd"); +extern const fcml_cstring M_VFMSUB231PS = _FT("vfmsub231ps"); +extern const fcml_cstring M_VFMSUB231SD = _FT("vfmsub231sd"); +extern const fcml_cstring M_VFMSUB231SS = _FT("vfmsub231ss"); +extern const fcml_cstring M_VFMSUBADD132PD = _FT("vfmsubadd132pd"); +extern const fcml_cstring M_VFMSUBADD132PS = _FT("vfmsubadd132ps"); +extern const fcml_cstring M_VFMSUBADD213PD = _FT("vfmsubadd213pd"); +extern const fcml_cstring M_VFMSUBADD213PS = _FT("vfmsubadd213ps"); +extern const fcml_cstring M_VFMSUBADD231PD = _FT("vfmsubadd231pd"); +extern const fcml_cstring M_VFMSUBADD231PS = _FT("vfmsubadd231ps"); +extern const fcml_cstring M_VFMSUBADDPD = _FT("vfmsubaddpd"); +extern const fcml_cstring M_VFMSUBADDPS = _FT("vfmsubaddps"); +extern const fcml_cstring M_VFMSUBPD = _FT("vfmsubpd"); +extern const fcml_cstring M_VFMSUBPS = _FT("vfmsubps"); +extern const fcml_cstring M_VFMSUBSD = _FT("vfmsubsd"); +extern const fcml_cstring M_VFMSUBSS = _FT("vfmsubss"); +extern const fcml_cstring M_VFNMADD132PD = _FT("vfnmadd132pd"); +extern const fcml_cstring M_VFNMADD132PS = _FT("vfnmadd132ps"); +extern const fcml_cstring M_VFNMADD132SD = _FT("vfnmadd132sd"); +extern const fcml_cstring M_VFNMADD132SS = _FT("vfnmadd132ss"); +extern const fcml_cstring M_VFNMADD213PD = _FT("vfnmadd213pd"); +extern const fcml_cstring M_VFNMADD213PS = _FT("vfnmadd213ps"); +extern const fcml_cstring M_VFNMADD213SD = _FT("vfnmadd213sd"); +extern const fcml_cstring M_VFNMADD213SS = _FT("vfnmadd213ss"); +extern const fcml_cstring M_VFNMADD231PD = _FT("vfnmadd231pd"); +extern const fcml_cstring M_VFNMADD231PS = _FT("vfnmadd231ps"); +extern const fcml_cstring M_VFNMADD231SD = _FT("vfnmadd231sd"); +extern const fcml_cstring M_VFNMADD231SS = _FT("vfnmadd231ss"); +extern const fcml_cstring M_VFNMADDPD = _FT("vfnmaddpd"); +extern const fcml_cstring M_VFNMADDPS = _FT("vfnmaddps"); +extern const fcml_cstring M_VFNMADDSD = _FT("vfnmaddsd"); +extern const fcml_cstring M_VFNMADDSS = _FT("vfnmaddss"); +extern const fcml_cstring M_VFNMSUB132PD = _FT("vfnmsub132pd"); +extern const fcml_cstring M_VFNMSUB132PS = _FT("vfnmsub132ps"); +extern const fcml_cstring M_VFNMSUB132SD = _FT("vfnmsub132sd"); +extern const fcml_cstring M_VFNMSUB132SS = _FT("vfnmsub132ss"); +extern const fcml_cstring M_VFNMSUB213PD = _FT("vfnmsub213pd"); +extern const fcml_cstring M_VFNMSUB213PS = _FT("vfnmsub213ps"); +extern const fcml_cstring M_VFNMSUB213SD = _FT("vfnmsub213sd"); +extern const fcml_cstring M_VFNMSUB213SS = _FT("vfnmsub213ss"); +extern const fcml_cstring M_VFNMSUB231PD = _FT("vfnmsub231pd"); +extern const fcml_cstring M_VFNMSUB231PS = _FT("vfnmsub231ps"); +extern const fcml_cstring M_VFNMSUB231SD = _FT("vfnmsub231sd"); +extern const fcml_cstring M_VFNMSUB231SS = _FT("vfnmsub231ss"); +extern const fcml_cstring M_VFNMSUBPD = _FT("vfnmsubpd"); +extern const fcml_cstring M_VFNMSUBPS = _FT("vfnmsubps"); +extern const fcml_cstring M_VFNMSUBSD = _FT("vfnmsubsd"); +extern const fcml_cstring M_VFNMSUBSS = _FT("vfnmsubss"); +extern const fcml_cstring M_VFPCLASSPD = _FT("vfpclasspd"); +extern const fcml_cstring M_VFPCLASSPS = _FT("vfpclassps"); +extern const fcml_cstring M_VFPCLASSSD = _FT("vfpclasssd"); +extern const fcml_cstring M_VFPCLASSSS = _FT("vfpclassss"); +extern const fcml_cstring M_VFRCZPD = _FT("vfrczpd"); +extern const fcml_cstring M_VFRCZPS = _FT("vfrczps"); +extern const fcml_cstring M_VFRCZSD = _FT("vfrczsd"); +extern const fcml_cstring M_VFRCZSS = _FT("vfrczss"); +extern const fcml_cstring M_VGATHERDPD = _FT("vgatherdpd"); +extern const fcml_cstring M_VGATHERDPS = _FT("vgatherdps"); +extern const fcml_cstring M_VGATHERPF0DPD = _FT("vgatherpf0dpd"); +extern const fcml_cstring M_VGATHERPF0DPS = _FT("vgatherpf0dps"); +extern const fcml_cstring M_VGATHERPF0QPD = _FT("vgatherpf0qpd"); +extern const fcml_cstring M_VGATHERPF0QPS = _FT("vgatherpf0qps"); +extern const fcml_cstring M_VGATHERPF1DPD = _FT("vgatherpf1dpd"); +extern const fcml_cstring M_VGATHERPF1DPS = _FT("vgatherpf1dps"); +extern const fcml_cstring M_VGATHERPF1QPD = _FT("vgatherpf1qpd"); +extern const fcml_cstring M_VGATHERPF1QPS = _FT("vgatherpf1qps"); +extern const fcml_cstring M_VGATHERQPD = _FT("vgatherqpd"); +extern const fcml_cstring M_VGATHERQPS = _FT("vgatherqps"); +extern const fcml_cstring M_VGETEXPPD = _FT("vgetexppd"); +extern const fcml_cstring M_VGETEXPPS = _FT("vgetexpps"); +extern const fcml_cstring M_VGETEXPSD = _FT("vgetexpsd"); +extern const fcml_cstring M_VGETEXPSS = _FT("vgetexpss"); +extern const fcml_cstring M_VGETMANTPD = _FT("vgetmantpd"); +extern const fcml_cstring M_VGETMANTPS = _FT("vgetmantps"); +extern const fcml_cstring M_VGETMANTSD = _FT("vgetmantsd"); +extern const fcml_cstring M_VGETMANTSS = _FT("vgetmantss"); +extern const fcml_cstring M_VHADDPD = _FT("vhaddpd"); +extern const fcml_cstring M_VHADDPS = _FT("vhaddps"); +extern const fcml_cstring M_VHSUBPD = _FT("vhsubpd"); +extern const fcml_cstring M_VHSUBPS = _FT("vhsubps"); +extern const fcml_cstring M_VINSERTF128 = _FT("vinsertf128"); +extern const fcml_cstring M_VINSERTF32X4 = _FT("vinsertf32x4"); +extern const fcml_cstring M_VINSERTF32X8 = _FT("vinsertf32x8"); +extern const fcml_cstring M_VINSERTF64X2 = _FT("vinsertf64x2"); +extern const fcml_cstring M_VINSERTF64X4 = _FT("vinsertf64x4"); +extern const fcml_cstring M_VINSERTI128 = _FT("vinserti128"); +extern const fcml_cstring M_VINSERTI32X4 = _FT("vinserti32x4"); +extern const fcml_cstring M_VINSERTI32X8 = _FT("vinserti32x8"); +extern const fcml_cstring M_VINSERTI64X2 = _FT("vinserti64x2"); +extern const fcml_cstring M_VINSERTI64X4 = _FT("vinserti64x4"); +extern const fcml_cstring M_VINSERTPS = _FT("vinsertps"); +extern const fcml_cstring M_VLDDQU = _FT("vlddqu"); +extern const fcml_cstring M_VLDMXCSR = _FT("vldmxcsr"); +extern const fcml_cstring M_VMASKMOVDQU = _FT("vmaskmovdqu"); +extern const fcml_cstring M_VMASKMOVPD = _FT("vmaskmovpd"); +extern const fcml_cstring M_VMASKMOVPS = _FT("vmaskmovps"); +extern const fcml_cstring M_VMAXPD = _FT("vmaxpd"); +extern const fcml_cstring M_VMAXPS = _FT("vmaxps"); +extern const fcml_cstring M_VMAXSD = _FT("vmaxsd"); +extern const fcml_cstring M_VMAXSS = _FT("vmaxss"); +extern const fcml_cstring M_VMCALL = _FT("vmcall"); +extern const fcml_cstring M_VMCLEAR = _FT("vmclear"); +extern const fcml_cstring M_VMFUNC = _FT("vmfunc"); +extern const fcml_cstring M_VMINPD = _FT("vminpd"); +extern const fcml_cstring M_VMINPS = _FT("vminps"); +extern const fcml_cstring M_VMINSD = _FT("vminsd"); +extern const fcml_cstring M_VMINSS = _FT("vminss"); +extern const fcml_cstring M_VMLAUNCH = _FT("vmlaunch"); +extern const fcml_cstring M_VMLOAD = _FT("vmload"); +extern const fcml_cstring M_VMMCALL = _FT("vmmcall"); +extern const fcml_cstring M_VMOVAPD = _FT("vmovapd"); +extern const fcml_cstring M_VMOVAPS = _FT("vmovaps"); +extern const fcml_cstring M_VMOVD = _FT("vmovd"); +extern const fcml_cstring M_VMOVDDUP = _FT("vmovddup"); +extern const fcml_cstring M_VMOVDQA = _FT("vmovdqa"); +extern const fcml_cstring M_VMOVDQA32 = _FT("vmovdqa32"); +extern const fcml_cstring M_VMOVDQA64 = _FT("vmovdqa64"); +extern const fcml_cstring M_VMOVDQU = _FT("vmovdqu"); +extern const fcml_cstring M_VMOVDQU16 = _FT("vmovdqu16"); +extern const fcml_cstring M_VMOVDQU32 = _FT("vmovdqu32"); +extern const fcml_cstring M_VMOVDQU64 = _FT("vmovdqu64"); +extern const fcml_cstring M_VMOVDQU8 = _FT("vmovdqu8"); +extern const fcml_cstring M_VMOVHLPS = _FT("vmovhlps"); +extern const fcml_cstring M_VMOVHPD = _FT("vmovhpd"); +extern const fcml_cstring M_VMOVHPS = _FT("vmovhps"); +extern const fcml_cstring M_VMOVLHPS = _FT("vmovlhps"); +extern const fcml_cstring M_VMOVLPD = _FT("vmovlpd"); +extern const fcml_cstring M_VMOVLPS = _FT("vmovlps"); +extern const fcml_cstring M_VMOVMSKPD = _FT("vmovmskpd"); +extern const fcml_cstring M_VMOVMSKPS = _FT("vmovmskps"); +extern const fcml_cstring M_VMOVNTDQ = _FT("vmovntdq"); +extern const fcml_cstring M_VMOVNTDQA = _FT("vmovntdqa"); +extern const fcml_cstring M_VMOVNTPD = _FT("vmovntpd"); +extern const fcml_cstring M_VMOVNTPS = _FT("vmovntps"); +extern const fcml_cstring M_VMOVQ = _FT("vmovq"); +extern const fcml_cstring M_VMOVSD = _FT("vmovsd"); +extern const fcml_cstring M_VMOVSHDUP = _FT("vmovshdup"); +extern const fcml_cstring M_VMOVSLDUP = _FT("vmovsldup"); +extern const fcml_cstring M_VMOVSS = _FT("vmovss"); +extern const fcml_cstring M_VMOVUPD = _FT("vmovupd"); +extern const fcml_cstring M_VMOVUPS = _FT("vmovups"); +extern const fcml_cstring M_VMPSADBW = _FT("vmpsadbw"); +extern const fcml_cstring M_VMPTRLD = _FT("vmptrld"); +extern const fcml_cstring M_VMPTRST = _FT("vmptrst"); +extern const fcml_cstring M_VMREAD = _FT("vmread"); +extern const fcml_cstring M_VMRESUME = _FT("vmresume"); +extern const fcml_cstring M_VMRUN = _FT("vmrun"); +extern const fcml_cstring M_VMSAVE = _FT("vmsave"); +extern const fcml_cstring M_VMULPD = _FT("vmulpd"); +extern const fcml_cstring M_VMULPS = _FT("vmulps"); +extern const fcml_cstring M_VMULSD = _FT("vmulsd"); +extern const fcml_cstring M_VMULSS = _FT("vmulss"); +extern const fcml_cstring M_VMWRITE = _FT("vmwrite"); +extern const fcml_cstring M_VMXOFF = _FT("vmxoff"); +extern const fcml_cstring M_VMXON = _FT("vmxon"); +extern const fcml_cstring M_VORPD = _FT("vorpd"); +extern const fcml_cstring M_VORPS = _FT("vorps"); +extern const fcml_cstring M_VP4DPWSSD = _FT("vp4dpwssd"); +extern const fcml_cstring M_VP4DPWSSDS = _FT("vp4dpwssds"); +extern const fcml_cstring M_VPABSB = _FT("vpabsb"); +extern const fcml_cstring M_VPABSD = _FT("vpabsd"); +extern const fcml_cstring M_VPABSQ = _FT("vpabsq"); +extern const fcml_cstring M_VPABSW = _FT("vpabsw"); +extern const fcml_cstring M_VPACKSSDW = _FT("vpackssdw"); +extern const fcml_cstring M_VPACKSSWB = _FT("vpacksswb"); +extern const fcml_cstring M_VPACKUSDW = _FT("vpackusdw"); +extern const fcml_cstring M_VPACKUSWB = _FT("vpackuswb"); +extern const fcml_cstring M_VPADDB = _FT("vpaddb"); +extern const fcml_cstring M_VPADDD = _FT("vpaddd"); +extern const fcml_cstring M_VPADDQ = _FT("vpaddq"); +extern const fcml_cstring M_VPADDSB = _FT("vpaddsb"); +extern const fcml_cstring M_VPADDSW = _FT("vpaddsw"); +extern const fcml_cstring M_VPADDUSB = _FT("vpaddusb"); +extern const fcml_cstring M_VPADDUSW = _FT("vpaddusw"); +extern const fcml_cstring M_VPADDW = _FT("vpaddw"); +extern const fcml_cstring M_VPALIGNR = _FT("vpalignr"); +extern const fcml_cstring M_VPAND = _FT("vpand"); +extern const fcml_cstring M_VPANDD = _FT("vpandd"); +extern const fcml_cstring M_VPANDN = _FT("vpandn"); +extern const fcml_cstring M_VPANDND = _FT("vpandnd"); +extern const fcml_cstring M_VPANDNQ = _FT("vpandnq"); +extern const fcml_cstring M_VPANDQ = _FT("vpandq"); +extern const fcml_cstring M_VPAVGB = _FT("vpavgb"); +extern const fcml_cstring M_VPAVGW = _FT("vpavgw"); +extern const fcml_cstring M_VPBLENDD = _FT("vpblendd"); +extern const fcml_cstring M_VPBLENDMB = _FT("vpblendmb"); +extern const fcml_cstring M_VPBLENDMD = _FT("vpblendmd"); +extern const fcml_cstring M_VPBLENDMQ = _FT("vpblendmq"); +extern const fcml_cstring M_VPBLENDMW = _FT("vpblendmw"); +extern const fcml_cstring M_VPBLENDVB = _FT("vpblendvb"); +extern const fcml_cstring M_VPBLENDW = _FT("vpblendw"); +extern const fcml_cstring M_VPBROADCASTB = _FT("vpbroadcastb"); +extern const fcml_cstring M_VPBROADCASTD = _FT("vpbroadcastd"); +extern const fcml_cstring M_VPBROADCASTMB2Q = _FT("vpbroadcastmb2q"); +extern const fcml_cstring M_VPBROADCASTMW2D = _FT("vpbroadcastmw2d"); +extern const fcml_cstring M_VPBROADCASTQ = _FT("vpbroadcastq"); +extern const fcml_cstring M_VPBROADCASTW = _FT("vpbroadcastw"); +extern const fcml_cstring M_VPCLMULQDQ = _FT("vpclmulqdq"); +extern const fcml_cstring M_VPCMOV = _FT("vpcmov"); +extern const fcml_cstring M_VPCMPB = _FT("vpcmpb"); +extern const fcml_cstring M_VPCMPD = _FT("vpcmpd"); +extern const fcml_cstring M_VPCMPEQB = _FT("vpcmpeqb"); +extern const fcml_cstring M_VPCMPEQD = _FT("vpcmpeqd"); +extern const fcml_cstring M_VPCMPEQQ = _FT("vpcmpeqq"); +extern const fcml_cstring M_VPCMPEQW = _FT("vpcmpeqw"); +extern const fcml_cstring M_VPCMPESTRI = _FT("vpcmpestri"); +extern const fcml_cstring M_VPCMPESTRM = _FT("vpcmpestrm"); +extern const fcml_cstring M_VPCMPGTB = _FT("vpcmpgtb"); +extern const fcml_cstring M_VPCMPGTD = _FT("vpcmpgtd"); +extern const fcml_cstring M_VPCMPGTQ = _FT("vpcmpgtq"); +extern const fcml_cstring M_VPCMPGTW = _FT("vpcmpgtw"); +extern const fcml_cstring M_VPCMPISTRI = _FT("vpcmpistri"); +extern const fcml_cstring M_VPCMPISTRM = _FT("vpcmpistrm"); +extern const fcml_cstring M_VPCMPQ = _FT("vpcmpq"); +extern const fcml_cstring M_VPCMPUB = _FT("vpcmpub"); +extern const fcml_cstring M_VPCMPUD = _FT("vpcmpud"); +extern const fcml_cstring M_VPCMPUQ = _FT("vpcmpuq"); +extern const fcml_cstring M_VPCMPUW = _FT("vpcmpuw"); +extern const fcml_cstring M_VPCMPW = _FT("vpcmpw"); +extern const fcml_cstring M_VPCOMB = _FT("vpcomb"); +extern const fcml_cstring M_VPCOMD = _FT("vpcomd"); +extern const fcml_cstring M_VPCOMEQB = _FT("vpcomeqb"); +extern const fcml_cstring M_VPCOMEQD = _FT("vpcomeqd"); +extern const fcml_cstring M_VPCOMEQQ = _FT("vpcomeqq"); +extern const fcml_cstring M_VPCOMEQUB = _FT("vpcomequb"); +extern const fcml_cstring M_VPCOMEQUD = _FT("vpcomequd"); +extern const fcml_cstring M_VPCOMEQUQ = _FT("vpcomequq"); +extern const fcml_cstring M_VPCOMEQUW = _FT("vpcomequw"); +extern const fcml_cstring M_VPCOMEQW = _FT("vpcomeqw"); +extern const fcml_cstring M_VPCOMFALSEB = _FT("vpcomfalseb"); +extern const fcml_cstring M_VPCOMFALSED = _FT("vpcomfalsed"); +extern const fcml_cstring M_VPCOMFALSEQ = _FT("vpcomfalseq"); +extern const fcml_cstring M_VPCOMFALSEUB = _FT("vpcomfalseub"); +extern const fcml_cstring M_VPCOMFALSEUD = _FT("vpcomfalseud"); +extern const fcml_cstring M_VPCOMFALSEUQ = _FT("vpcomfalseuq"); +extern const fcml_cstring M_VPCOMFALSEUW = _FT("vpcomfalseuw"); +extern const fcml_cstring M_VPCOMFALSEW = _FT("vpcomfalsew"); +extern const fcml_cstring M_VPCOMGEB = _FT("vpcomgeb"); +extern const fcml_cstring M_VPCOMGED = _FT("vpcomged"); +extern const fcml_cstring M_VPCOMGEQ = _FT("vpcomgeq"); +extern const fcml_cstring M_VPCOMGEUB = _FT("vpcomgeub"); +extern const fcml_cstring M_VPCOMGEUD = _FT("vpcomgeud"); +extern const fcml_cstring M_VPCOMGEUQ = _FT("vpcomgeuq"); +extern const fcml_cstring M_VPCOMGEUW = _FT("vpcomgeuw"); +extern const fcml_cstring M_VPCOMGEW = _FT("vpcomgew"); +extern const fcml_cstring M_VPCOMGTB = _FT("vpcomgtb"); +extern const fcml_cstring M_VPCOMGTD = _FT("vpcomgtd"); +extern const fcml_cstring M_VPCOMGTQ = _FT("vpcomgtq"); +extern const fcml_cstring M_VPCOMGTUB = _FT("vpcomgtub"); +extern const fcml_cstring M_VPCOMGTUD = _FT("vpcomgtud"); +extern const fcml_cstring M_VPCOMGTUQ = _FT("vpcomgtuq"); +extern const fcml_cstring M_VPCOMGTUW = _FT("vpcomgtuw"); +extern const fcml_cstring M_VPCOMGTW = _FT("vpcomgtw"); +extern const fcml_cstring M_VPCOMLEB = _FT("vpcomleb"); +extern const fcml_cstring M_VPCOMLED = _FT("vpcomled"); +extern const fcml_cstring M_VPCOMLEQ = _FT("vpcomleq"); +extern const fcml_cstring M_VPCOMLEUB = _FT("vpcomleub"); +extern const fcml_cstring M_VPCOMLEUD = _FT("vpcomleud"); +extern const fcml_cstring M_VPCOMLEUQ = _FT("vpcomleuq"); +extern const fcml_cstring M_VPCOMLEUW = _FT("vpcomleuw"); +extern const fcml_cstring M_VPCOMLEW = _FT("vpcomlew"); +extern const fcml_cstring M_VPCOMLTB = _FT("vpcomltb"); +extern const fcml_cstring M_VPCOMLTD = _FT("vpcomltd"); +extern const fcml_cstring M_VPCOMLTQ = _FT("vpcomltq"); +extern const fcml_cstring M_VPCOMLTUB = _FT("vpcomltub"); +extern const fcml_cstring M_VPCOMLTUD = _FT("vpcomltud"); +extern const fcml_cstring M_VPCOMLTUQ = _FT("vpcomltuq"); +extern const fcml_cstring M_VPCOMLTUW = _FT("vpcomltuw"); +extern const fcml_cstring M_VPCOMLTW = _FT("vpcomltw"); +extern const fcml_cstring M_VPCOMNEQB = _FT("vpcomneqb"); +extern const fcml_cstring M_VPCOMNEQD = _FT("vpcomneqd"); +extern const fcml_cstring M_VPCOMNEQQ = _FT("vpcomneqq"); +extern const fcml_cstring M_VPCOMNEQUB = _FT("vpcomnequb"); +extern const fcml_cstring M_VPCOMNEQUD = _FT("vpcomnequd"); +extern const fcml_cstring M_VPCOMNEQUQ = _FT("vpcomnequq"); +extern const fcml_cstring M_VPCOMNEQUW = _FT("vpcomnequw"); +extern const fcml_cstring M_VPCOMNEQW = _FT("vpcomneqw"); +extern const fcml_cstring M_VPCOMPRESSD = _FT("vpcompressd"); +extern const fcml_cstring M_VPCOMPRESSQ = _FT("vpcompressq"); +extern const fcml_cstring M_VPCOMQ = _FT("vpcomq"); +extern const fcml_cstring M_VPCOMTRUEB = _FT("vpcomtrueb"); +extern const fcml_cstring M_VPCOMTRUED = _FT("vpcomtrued"); +extern const fcml_cstring M_VPCOMTRUEQ = _FT("vpcomtrueq"); +extern const fcml_cstring M_VPCOMTRUEUB = _FT("vpcomtrueub"); +extern const fcml_cstring M_VPCOMTRUEUD = _FT("vpcomtrueud"); +extern const fcml_cstring M_VPCOMTRUEUQ = _FT("vpcomtrueuq"); +extern const fcml_cstring M_VPCOMTRUEUW = _FT("vpcomtrueuw"); +extern const fcml_cstring M_VPCOMTRUEW = _FT("vpcomtruew"); +extern const fcml_cstring M_VPCOMUB = _FT("vpcomub"); +extern const fcml_cstring M_VPCOMUD = _FT("vpcomud"); +extern const fcml_cstring M_VPCOMUQ = _FT("vpcomuq"); +extern const fcml_cstring M_VPCOMUW = _FT("vpcomuw"); +extern const fcml_cstring M_VPCOMW = _FT("vpcomw"); +extern const fcml_cstring M_VPERM2F128 = _FT("vperm2f128"); +extern const fcml_cstring M_VPERM2I128 = _FT("vperm2i128"); +extern const fcml_cstring M_VPERMB = _FT("vpermb"); +extern const fcml_cstring M_VPERMD = _FT("vpermd"); +extern const fcml_cstring M_VPERMI2B = _FT("vpermi2b"); +extern const fcml_cstring M_VPERMI2D = _FT("vpermi2d"); +extern const fcml_cstring M_VPERMI2PD = _FT("vpermi2pd"); +extern const fcml_cstring M_VPERMI2PS = _FT("vpermi2ps"); +extern const fcml_cstring M_VPERMI2Q = _FT("vpermi2q"); +extern const fcml_cstring M_VPERMI2W = _FT("vpermi2w"); +extern const fcml_cstring M_VPERMIL2PD = _FT("vpermil2pd"); +extern const fcml_cstring M_VPERMIL2PS = _FT("vpermil2ps"); +extern const fcml_cstring M_VPERMILPD = _FT("vpermilpd"); +extern const fcml_cstring M_VPERMILPS = _FT("vpermilps"); +extern const fcml_cstring M_VPERMPD = _FT("vpermpd"); +extern const fcml_cstring M_VPERMPS = _FT("vpermps"); +extern const fcml_cstring M_VPERMQ = _FT("vpermq"); +extern const fcml_cstring M_VPERMT2B = _FT("vpermt2b"); +extern const fcml_cstring M_VPERMT2D = _FT("vpermt2d"); +extern const fcml_cstring M_VPERMT2PD = _FT("vpermt2pd"); +extern const fcml_cstring M_VPERMT2PS = _FT("vpermt2ps"); +extern const fcml_cstring M_VPERMT2Q = _FT("vpermt2q"); +extern const fcml_cstring M_VPERMT2W = _FT("vpermt2w"); +extern const fcml_cstring M_VPERMW = _FT("vpermw"); +extern const fcml_cstring M_VPEXPANDD = _FT("vpexpandd"); +extern const fcml_cstring M_VPEXPANDQ = _FT("vpexpandq"); +extern const fcml_cstring M_VPEXTRB = _FT("vpextrb"); +extern const fcml_cstring M_VPEXTRD = _FT("vpextrd"); +extern const fcml_cstring M_VPEXTRQ = _FT("vpextrq"); +extern const fcml_cstring M_VPEXTRW = _FT("vpextrw"); +extern const fcml_cstring M_VPGATHERDD = _FT("vpgatherdd"); +extern const fcml_cstring M_VPGATHERDQ = _FT("vpgatherdq"); +extern const fcml_cstring M_VPGATHERQD = _FT("vpgatherqd"); +extern const fcml_cstring M_VPGATHERQQ = _FT("vpgatherqq"); +extern const fcml_cstring M_VPHADDBD = _FT("vphaddbd"); +extern const fcml_cstring M_VPHADDBQ = _FT("vphaddbq"); +extern const fcml_cstring M_VPHADDBW = _FT("vphaddbw"); +extern const fcml_cstring M_VPHADDD = _FT("vphaddd"); +extern const fcml_cstring M_VPHADDDQ = _FT("vphadddq"); +extern const fcml_cstring M_VPHADDSW = _FT("vphaddsw"); +extern const fcml_cstring M_VPHADDUBD = _FT("vphaddubd"); +extern const fcml_cstring M_VPHADDUBQ = _FT("vphaddubq"); +extern const fcml_cstring M_VPHADDUBW = _FT("vphaddubw"); +extern const fcml_cstring M_VPHADDUDQ = _FT("vphaddudq"); +extern const fcml_cstring M_VPHADDUWD = _FT("vphadduwd"); +extern const fcml_cstring M_VPHADDUWQ = _FT("vphadduwq"); +extern const fcml_cstring M_VPHADDW = _FT("vphaddw"); +extern const fcml_cstring M_VPHADDWD = _FT("vphaddwd"); +extern const fcml_cstring M_VPHADDWQ = _FT("vphaddwq"); +extern const fcml_cstring M_VPHMINPOSUW = _FT("vphminposuw"); +extern const fcml_cstring M_VPHSUBBW = _FT("vphsubbw"); +extern const fcml_cstring M_VPHSUBD = _FT("vphsubd"); +extern const fcml_cstring M_VPHSUBDQ = _FT("vphsubdq"); +extern const fcml_cstring M_VPHSUBSW = _FT("vphsubsw"); +extern const fcml_cstring M_VPHSUBW = _FT("vphsubw"); +extern const fcml_cstring M_VPHSUBWD = _FT("vphsubwd"); +extern const fcml_cstring M_VPINSRB = _FT("vpinsrb"); +extern const fcml_cstring M_VPINSRD = _FT("vpinsrd"); +extern const fcml_cstring M_VPINSRQ = _FT("vpinsrq"); +extern const fcml_cstring M_VPINSRW = _FT("vpinsrw"); +extern const fcml_cstring M_VPLZCNTD = _FT("vplzcntd"); +extern const fcml_cstring M_VPLZCNTQ = _FT("vplzcntq"); +extern const fcml_cstring M_VPMACSDD = _FT("vpmacsdd"); +extern const fcml_cstring M_VPMACSDQH = _FT("vpmacsdqh"); +extern const fcml_cstring M_VPMACSDQL = _FT("vpmacsdql"); +extern const fcml_cstring M_VPMACSSDD = _FT("vpmacssdd"); +extern const fcml_cstring M_VPMACSSDQH = _FT("vpmacssdqh"); +extern const fcml_cstring M_VPMACSSDQL = _FT("vpmacssdql"); +extern const fcml_cstring M_VPMACSSWD = _FT("vpmacsswd"); +extern const fcml_cstring M_VPMACSSWW = _FT("vpmacssww"); +extern const fcml_cstring M_VPMACSWD = _FT("vpmacswd"); +extern const fcml_cstring M_VPMACSWW = _FT("vpmacsww"); +extern const fcml_cstring M_VPMADCSSWD = _FT("vpmadcsswd"); +extern const fcml_cstring M_VPMADCSWD = _FT("vpmadcswd"); +extern const fcml_cstring M_VPMADD52HUQ = _FT("vpmadd52huq"); +extern const fcml_cstring M_VPMADD52LUQ = _FT("vpmadd52luq"); +extern const fcml_cstring M_VPMADDUBSW = _FT("vpmaddubsw"); +extern const fcml_cstring M_VPMADDWD = _FT("vpmaddwd"); +extern const fcml_cstring M_VPMASKMOV = _FT("vpmaskmov"); +extern const fcml_cstring M_VPMASKMOVD = _FT("vpmaskmovd"); +extern const fcml_cstring M_VPMASKMOVQ = _FT("vpmaskmovq"); +extern const fcml_cstring M_VPMAXSB = _FT("vpmaxsb"); +extern const fcml_cstring M_VPMAXSD = _FT("vpmaxsd"); +extern const fcml_cstring M_VPMAXSQ = _FT("vpmaxsq"); +extern const fcml_cstring M_VPMAXSW = _FT("vpmaxsw"); +extern const fcml_cstring M_VPMAXUB = _FT("vpmaxub"); +extern const fcml_cstring M_VPMAXUD = _FT("vpmaxud"); +extern const fcml_cstring M_VPMAXUQ = _FT("vpmaxuq"); +extern const fcml_cstring M_VPMAXUW = _FT("vpmaxuw"); +extern const fcml_cstring M_VPMINSB = _FT("vpminsb"); +extern const fcml_cstring M_VPMINSD = _FT("vpminsd"); +extern const fcml_cstring M_VPMINSQ = _FT("vpminsq"); +extern const fcml_cstring M_VPMINSW = _FT("vpminsw"); +extern const fcml_cstring M_VPMINUB = _FT("vpminub"); +extern const fcml_cstring M_VPMINUD = _FT("vpminud"); +extern const fcml_cstring M_VPMINUQ = _FT("vpminuq"); +extern const fcml_cstring M_VPMINUW = _FT("vpminuw"); +extern const fcml_cstring M_VPMOVB2M = _FT("vpmovb2m"); +extern const fcml_cstring M_VPMOVD2M = _FT("vpmovd2m"); +extern const fcml_cstring M_VPMOVDB = _FT("vpmovdb"); +extern const fcml_cstring M_VPMOVDW = _FT("vpmovdw"); +extern const fcml_cstring M_VPMOVM2B = _FT("vpmovm2b"); +extern const fcml_cstring M_VPMOVM2D = _FT("vpmovm2d"); +extern const fcml_cstring M_VPMOVM2Q = _FT("vpmovm2q"); +extern const fcml_cstring M_VPMOVM2W = _FT("vpmovm2w"); +extern const fcml_cstring M_VPMOVMSKB = _FT("vpmovmskb"); +extern const fcml_cstring M_VPMOVQ2M = _FT("vpmovq2m"); +extern const fcml_cstring M_VPMOVQB = _FT("vpmovqb"); +extern const fcml_cstring M_VPMOVQD = _FT("vpmovqd"); +extern const fcml_cstring M_VPMOVQW = _FT("vpmovqw"); +extern const fcml_cstring M_VPMOVSDB = _FT("vpmovsdb"); +extern const fcml_cstring M_VPMOVSDW = _FT("vpmovsdw"); +extern const fcml_cstring M_VPMOVSQB = _FT("vpmovsqb"); +extern const fcml_cstring M_VPMOVSQD = _FT("vpmovsqd"); +extern const fcml_cstring M_VPMOVSQW = _FT("vpmovsqw"); +extern const fcml_cstring M_VPMOVSWB = _FT("vpmovswb"); +extern const fcml_cstring M_VPMOVSXBD = _FT("vpmovsxbd"); +extern const fcml_cstring M_VPMOVSXBQ = _FT("vpmovsxbq"); +extern const fcml_cstring M_VPMOVSXBW = _FT("vpmovsxbw"); +extern const fcml_cstring M_VPMOVSXDQ = _FT("vpmovsxdq"); +extern const fcml_cstring M_VPMOVSXWD = _FT("vpmovsxwd"); +extern const fcml_cstring M_VPMOVSXWQ = _FT("vpmovsxwq"); +extern const fcml_cstring M_VPMOVUSDB = _FT("vpmovusdb"); +extern const fcml_cstring M_VPMOVUSDW = _FT("vpmovusdw"); +extern const fcml_cstring M_VPMOVUSQB = _FT("vpmovusqb"); +extern const fcml_cstring M_VPMOVUSQD = _FT("vpmovusqd"); +extern const fcml_cstring M_VPMOVUSQW = _FT("vpmovusqw"); +extern const fcml_cstring M_VPMOVUSWB = _FT("vpmovuswb"); +extern const fcml_cstring M_VPMOVW2M = _FT("vpmovw2m"); +extern const fcml_cstring M_VPMOVWB = _FT("vpmovwb"); +extern const fcml_cstring M_VPMOVZXBD = _FT("vpmovzxbd"); +extern const fcml_cstring M_VPMOVZXBQ = _FT("vpmovzxbq"); +extern const fcml_cstring M_VPMOVZXBW = _FT("vpmovzxbw"); +extern const fcml_cstring M_VPMOVZXDQ = _FT("vpmovzxdq"); +extern const fcml_cstring M_VPMOVZXWD = _FT("vpmovzxwd"); +extern const fcml_cstring M_VPMOVZXWQ = _FT("vpmovzxwq"); +extern const fcml_cstring M_VPMULDQ = _FT("vpmuldq"); +extern const fcml_cstring M_VPMULHRSW = _FT("vpmulhrsw"); +extern const fcml_cstring M_VPMULHUW = _FT("vpmulhuw"); +extern const fcml_cstring M_VPMULHW = _FT("vpmulhw"); +extern const fcml_cstring M_VPMULLD = _FT("vpmulld"); +extern const fcml_cstring M_VPMULLQ = _FT("vpmullq"); +extern const fcml_cstring M_VPMULLW = _FT("vpmullw"); +extern const fcml_cstring M_VPMULTISHIFTQB = _FT("vpmultishiftqb"); +extern const fcml_cstring M_VPMULUDQ = _FT("vpmuludq"); +extern const fcml_cstring M_VPOR = _FT("vpor"); +extern const fcml_cstring M_VPORD = _FT("vpord"); +extern const fcml_cstring M_VPORQ = _FT("vporq"); +extern const fcml_cstring M_VPPERM = _FT("vpperm"); +extern const fcml_cstring M_VPROLD = _FT("vprold"); +extern const fcml_cstring M_VPROLQ = _FT("vprolq"); +extern const fcml_cstring M_VPROLVD = _FT("vprolvd"); +extern const fcml_cstring M_VPROLVQ = _FT("vprolvq"); +extern const fcml_cstring M_VPRORD = _FT("vprord"); +extern const fcml_cstring M_VPRORQ = _FT("vprorq"); +extern const fcml_cstring M_VPRORVD = _FT("vprorvd"); +extern const fcml_cstring M_VPRORVQ = _FT("vprorvq"); +extern const fcml_cstring M_VPROTB = _FT("vprotb"); +extern const fcml_cstring M_VPROTD = _FT("vprotd"); +extern const fcml_cstring M_VPROTQ = _FT("vprotq"); +extern const fcml_cstring M_VPROTW = _FT("vprotw"); +extern const fcml_cstring M_VPSADBW = _FT("vpsadbw"); +extern const fcml_cstring M_VPSCATTERDD = _FT("vpscatterdd"); +extern const fcml_cstring M_VPSCATTERDQ = _FT("vpscatterdq"); +extern const fcml_cstring M_VPSCATTERQD = _FT("vpscatterqd"); +extern const fcml_cstring M_VPSCATTERQQ = _FT("vpscatterqq"); +extern const fcml_cstring M_VPSHAB = _FT("vpshab"); +extern const fcml_cstring M_VPSHAD = _FT("vpshad"); +extern const fcml_cstring M_VPSHAQ = _FT("vpshaq"); +extern const fcml_cstring M_VPSHAW = _FT("vpshaw"); +extern const fcml_cstring M_VPSHLB = _FT("vpshlb"); +extern const fcml_cstring M_VPSHLD = _FT("vpshld"); +extern const fcml_cstring M_VPSHLQ = _FT("vpshlq"); +extern const fcml_cstring M_VPSHLW = _FT("vpshlw"); +extern const fcml_cstring M_VPSHUFB = _FT("vpshufb"); +extern const fcml_cstring M_VPSHUFD = _FT("vpshufd"); +extern const fcml_cstring M_VPSHUFHW = _FT("vpshufhw"); +extern const fcml_cstring M_VPSHUFLW = _FT("vpshuflw"); +extern const fcml_cstring M_VPSIGNB = _FT("vpsignb"); +extern const fcml_cstring M_VPSIGND = _FT("vpsignd"); +extern const fcml_cstring M_VPSIGNW = _FT("vpsignw"); +extern const fcml_cstring M_VPSLLD = _FT("vpslld"); +extern const fcml_cstring M_VPSLLDQ = _FT("vpslldq"); +extern const fcml_cstring M_VPSLLQ = _FT("vpsllq"); +extern const fcml_cstring M_VPSLLVD = _FT("vpsllvd"); +extern const fcml_cstring M_VPSLLVQ = _FT("vpsllvq"); +extern const fcml_cstring M_VPSLLVW = _FT("vpsllvw"); +extern const fcml_cstring M_VPSLLW = _FT("vpsllw"); +extern const fcml_cstring M_VPSRAD = _FT("vpsrad"); +extern const fcml_cstring M_VPSRAQ = _FT("vpsraq"); +extern const fcml_cstring M_VPSRAVD = _FT("vpsravd"); +extern const fcml_cstring M_VPSRAVQ = _FT("vpsravq"); +extern const fcml_cstring M_VPSRAVW = _FT("vpsravw"); +extern const fcml_cstring M_VPSRAW = _FT("vpsraw"); +extern const fcml_cstring M_VPSRLD = _FT("vpsrld"); +extern const fcml_cstring M_VPSRLDQ = _FT("vpsrldq"); +extern const fcml_cstring M_VPSRLQ = _FT("vpsrlq"); +extern const fcml_cstring M_VPSRLVD = _FT("vpsrlvd"); +extern const fcml_cstring M_VPSRLVQ = _FT("vpsrlvq"); +extern const fcml_cstring M_VPSRLVW = _FT("vpsrlvw"); +extern const fcml_cstring M_VPSRLW = _FT("vpsrlw"); +extern const fcml_cstring M_VPSUBB = _FT("vpsubb"); +extern const fcml_cstring M_VPSUBD = _FT("vpsubd"); +extern const fcml_cstring M_VPSUBQ = _FT("vpsubq"); +extern const fcml_cstring M_VPSUBSB = _FT("vpsubsb"); +extern const fcml_cstring M_VPSUBSW = _FT("vpsubsw"); +extern const fcml_cstring M_VPSUBUSB = _FT("vpsubusb"); +extern const fcml_cstring M_VPSUBUSW = _FT("vpsubusw"); +extern const fcml_cstring M_VPSUBW = _FT("vpsubw"); +extern const fcml_cstring M_VPTERNLOGD = _FT("vpternlogd"); +extern const fcml_cstring M_VPTERNLOGQ = _FT("vpternlogq"); +extern const fcml_cstring M_VPTEST = _FT("vptest"); +extern const fcml_cstring M_VPTESTMB = _FT("vptestmb"); +extern const fcml_cstring M_VPTESTMD = _FT("vptestmd"); +extern const fcml_cstring M_VPTESTMQ = _FT("vptestmq"); +extern const fcml_cstring M_VPTESTMW = _FT("vptestmw"); +extern const fcml_cstring M_VPTESTNMB = _FT("vptestnmb"); +extern const fcml_cstring M_VPTESTNMD = _FT("vptestnmd"); +extern const fcml_cstring M_VPTESTNMQ = _FT("vptestnmq"); +extern const fcml_cstring M_VPTESTNMW = _FT("vptestnmw"); +extern const fcml_cstring M_VPUNPCKHBW = _FT("vpunpckhbw"); +extern const fcml_cstring M_VPUNPCKHDQ = _FT("vpunpckhdq"); +extern const fcml_cstring M_VPUNPCKHQDQ = _FT("vpunpckhqdq"); +extern const fcml_cstring M_VPUNPCKHWD = _FT("vpunpckhwd"); +extern const fcml_cstring M_VPUNPCKLBW = _FT("vpunpcklbw"); +extern const fcml_cstring M_VPUNPCKLDQ = _FT("vpunpckldq"); +extern const fcml_cstring M_VPUNPCKLQDQ = _FT("vpunpcklqdq"); +extern const fcml_cstring M_VPUNPCKLWD = _FT("vpunpcklwd"); +extern const fcml_cstring M_VPXOR = _FT("vpxor"); +extern const fcml_cstring M_VPXORD = _FT("vpxord"); +extern const fcml_cstring M_VPXORQ = _FT("vpxorq"); +extern const fcml_cstring M_VRANGEPD = _FT("vrangepd"); +extern const fcml_cstring M_VRANGEPS = _FT("vrangeps"); +extern const fcml_cstring M_VRANGESD = _FT("vrangesd"); +extern const fcml_cstring M_VRANGESS = _FT("vrangess"); +extern const fcml_cstring M_VRCP14PD = _FT("vrcp14pd"); +extern const fcml_cstring M_VRCP14PS = _FT("vrcp14ps"); +extern const fcml_cstring M_VRCP14SD = _FT("vrcp14sd"); +extern const fcml_cstring M_VRCP14SS = _FT("vrcp14ss"); +extern const fcml_cstring M_VRCP28PD = _FT("vrcp28pd"); +extern const fcml_cstring M_VRCP28PS = _FT("vrcp28ps"); +extern const fcml_cstring M_VRCP28SD = _FT("vrcp28sd"); +extern const fcml_cstring M_VRCP28SS = _FT("vrcp28ss"); +extern const fcml_cstring M_VRCPPS = _FT("vrcpps"); +extern const fcml_cstring M_VRCPSS = _FT("vrcpss"); +extern const fcml_cstring M_VREDUCEPD = _FT("vreducepd"); +extern const fcml_cstring M_VREDUCEPS = _FT("vreduceps"); +extern const fcml_cstring M_VREDUCESD = _FT("vreducesd"); +extern const fcml_cstring M_VREDUCESS = _FT("vreducess"); +extern const fcml_cstring M_VRNDSCALEPD = _FT("vrndscalepd"); +extern const fcml_cstring M_VRNDSCALEPS = _FT("vrndscaleps"); +extern const fcml_cstring M_VRNDSCALESD = _FT("vrndscalesd"); +extern const fcml_cstring M_VRNDSCALESS = _FT("vrndscaless"); +extern const fcml_cstring M_VROUNDPD = _FT("vroundpd"); +extern const fcml_cstring M_VROUNDPS = _FT("vroundps"); +extern const fcml_cstring M_VROUNDSD = _FT("vroundsd"); +extern const fcml_cstring M_VROUNDSS = _FT("vroundss"); +extern const fcml_cstring M_VRSQRT14PD = _FT("vrsqrt14pd"); +extern const fcml_cstring M_VRSQRT14PS = _FT("vrsqrt14ps"); +extern const fcml_cstring M_VRSQRT14SD = _FT("vrsqrt14sd"); +extern const fcml_cstring M_VRSQRT14SS = _FT("vrsqrt14ss"); +extern const fcml_cstring M_VRSQRT28PD = _FT("vrsqrt28pd"); +extern const fcml_cstring M_VRSQRT28PS = _FT("vrsqrt28ps"); +extern const fcml_cstring M_VRSQRT28SD = _FT("vrsqrt28sd"); +extern const fcml_cstring M_VRSQRT28SS = _FT("vrsqrt28ss"); +extern const fcml_cstring M_VRSQRTPS = _FT("vrsqrtps"); +extern const fcml_cstring M_VRSQRTSS = _FT("vrsqrtss"); +extern const fcml_cstring M_VSCALEFPD = _FT("vscalefpd"); +extern const fcml_cstring M_VSCALEFPS = _FT("vscalefps"); +extern const fcml_cstring M_VSCALEFSD = _FT("vscalefsd"); +extern const fcml_cstring M_VSCALEFSS = _FT("vscalefss"); +extern const fcml_cstring M_VSCATTERDPD = _FT("vscatterdpd"); +extern const fcml_cstring M_VSCATTERDPS = _FT("vscatterdps"); +extern const fcml_cstring M_VSCATTERPF0DPD = _FT("vscatterpf0dpd"); +extern const fcml_cstring M_VSCATTERPF0DPS = _FT("vscatterpf0dps"); +extern const fcml_cstring M_VSCATTERPF0QPD = _FT("vscatterpf0qpd"); +extern const fcml_cstring M_VSCATTERPF0QPS = _FT("vscatterpf0qps"); +extern const fcml_cstring M_VSCATTERPF1DPD = _FT("vscatterpf1dpd"); +extern const fcml_cstring M_VSCATTERPF1DPS = _FT("vscatterpf1dps"); +extern const fcml_cstring M_VSCATTERPF1QPD = _FT("vscatterpf1qpd"); +extern const fcml_cstring M_VSCATTERPF1QPS = _FT("vscatterpf1qps"); +extern const fcml_cstring M_VSCATTERQPD = _FT("vscatterqpd"); +extern const fcml_cstring M_VSCATTERQPS = _FT("vscatterqps"); +extern const fcml_cstring M_VSHUFF32X4 = _FT("vshuff32x4"); +extern const fcml_cstring M_VSHUFF64X2 = _FT("vshuff64x2"); +extern const fcml_cstring M_VSHUFI32X4 = _FT("vshufi32x4"); +extern const fcml_cstring M_VSHUFI64X2 = _FT("vshufi64x2"); +extern const fcml_cstring M_VSHUFPD = _FT("vshufpd"); +extern const fcml_cstring M_VSHUFPS = _FT("vshufps"); +extern const fcml_cstring M_VSQRTPD = _FT("vsqrtpd"); +extern const fcml_cstring M_VSQRTPS = _FT("vsqrtps"); +extern const fcml_cstring M_VSQRTSD = _FT("vsqrtsd"); +extern const fcml_cstring M_VSQRTSS = _FT("vsqrtss"); +extern const fcml_cstring M_VSTMXCSR = _FT("vstmxcsr"); +extern const fcml_cstring M_VSUBPD = _FT("vsubpd"); +extern const fcml_cstring M_VSUBPS = _FT("vsubps"); +extern const fcml_cstring M_VSUBSD = _FT("vsubsd"); +extern const fcml_cstring M_VSUBSS = _FT("vsubss"); +extern const fcml_cstring M_VTESTPD = _FT("vtestpd"); +extern const fcml_cstring M_VTESTPS = _FT("vtestps"); +extern const fcml_cstring M_VUCOMISD = _FT("vucomisd"); +extern const fcml_cstring M_VUCOMISS = _FT("vucomiss"); +extern const fcml_cstring M_VUNPCKHPD = _FT("vunpckhpd"); +extern const fcml_cstring M_VUNPCKHPS = _FT("vunpckhps"); +extern const fcml_cstring M_VUNPCKLPD = _FT("vunpcklpd"); +extern const fcml_cstring M_VUNPCKLPS = _FT("vunpcklps"); +extern const fcml_cstring M_VXORPD = _FT("vxorpd"); +extern const fcml_cstring M_VXORPS = _FT("vxorps"); +extern const fcml_cstring M_VZEROALL = _FT("vzeroall"); +extern const fcml_cstring M_VZEROUPPER = _FT("vzeroupper"); +extern const fcml_cstring M_WAIT = _FT("wait"); +extern const fcml_cstring M_WBINVD = _FT("wbinvd"); +extern const fcml_cstring M_WRFSBASE = _FT("wrfsbase"); +extern const fcml_cstring M_WRGSBASE = _FT("wrgsbase"); +extern const fcml_cstring M_WRMSR = _FT("wrmsr"); +extern const fcml_cstring M_XABORT = _FT("xabort"); +extern const fcml_cstring M_XADD = _FT("xadd"); +extern const fcml_cstring M_XBEGIN = _FT("xbegin"); +extern const fcml_cstring M_XCHG = _FT("xchg"); +extern const fcml_cstring M_XEND = _FT("xend"); +extern const fcml_cstring M_XGETBV = _FT("xgetbv"); +extern const fcml_cstring M_XLAT = _FT("xlat"); +extern const fcml_cstring M_XLATB = _FT("xlatb"); +extern const fcml_cstring M_XOR = _FT("xor"); +extern const fcml_cstring M_XORPD = _FT("xorpd"); +extern const fcml_cstring M_XORPS = _FT("xorps"); +extern const fcml_cstring M_XRSTOR = _FT("xrstor"); +extern const fcml_cstring M_XRSTOR64 = _FT("xrstor64"); +extern const fcml_cstring M_XSAVE = _FT("xsave"); +extern const fcml_cstring M_XSAVE64 = _FT("xsave64"); +extern const fcml_cstring M_XSAVEOPT = _FT("xsaveopt"); +extern const fcml_cstring M_XSAVEOPT64 = _FT("xsaveopt64"); +extern const fcml_cstring M_XSETBV = _FT("xsetbv"); +extern const fcml_cstring M_XTEST = _FT("xtest"); + +} +} + diff --git a/dependencies/fcml/include/fcml_intel_mnemonics.h b/dependencies/fcml/include/fcml_intel_mnemonics.h new file mode 100644 index 0000000..44fdc6a --- /dev/null +++ b/dependencies/fcml/include/fcml_intel_mnemonics.h @@ -0,0 +1,1715 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_intel_mnemonics.h + * Declarations of Intel mnemonics for C. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_INTEL_MNEMONICS_H_ +#define FCML_INTEL_MNEMONICS_H_ + +#include "fcml_types.h" + +#define M_AAA FCML_TEXT("aaa") +#define M_AAD FCML_TEXT("aad") +#define M_AAM FCML_TEXT("aam") +#define M_AAS FCML_TEXT("aas") +#define M_ADC FCML_TEXT("adc") +#define M_ADCX FCML_TEXT("adcx") +#define M_ADD FCML_TEXT("add") +#define M_ADDPD FCML_TEXT("addpd") +#define M_ADDPS FCML_TEXT("addps") +#define M_ADDSD FCML_TEXT("addsd") +#define M_ADDSS FCML_TEXT("addss") +#define M_ADDSUBPD FCML_TEXT("addsubpd") +#define M_ADDSUBPS FCML_TEXT("addsubps") +#define M_ADOX FCML_TEXT("adox") +#define M_AESDEC FCML_TEXT("aesdec") +#define M_AESDECLAST FCML_TEXT("aesdeclast") +#define M_AESENC FCML_TEXT("aesenc") +#define M_AESENCLAST FCML_TEXT("aesenclast") +#define M_AESIMC FCML_TEXT("aesimc") +#define M_AESKEYGENASSIST FCML_TEXT("aeskeygenassist") +#define M_AND FCML_TEXT("and") +#define M_ANDN FCML_TEXT("andn") +#define M_ANDNPD FCML_TEXT("andnpd") +#define M_ANDNPS FCML_TEXT("andnps") +#define M_ANDPD FCML_TEXT("andpd") +#define M_ANDPS FCML_TEXT("andps") +#define M_ARPL FCML_TEXT("arpl") +#define M_BEXR FCML_TEXT("bexr") +#define M_BEXTR FCML_TEXT("bextr") +#define M_BLCFILL FCML_TEXT("blcfill") +#define M_BLCI FCML_TEXT("blci") +#define M_BLCIC FCML_TEXT("blcic") +#define M_BLCMSK FCML_TEXT("blcmsk") +#define M_BLCS FCML_TEXT("blcs") +#define M_BLENDPD FCML_TEXT("blendpd") +#define M_BLENDPS FCML_TEXT("blendps") +#define M_BLENDVPD FCML_TEXT("blendvpd") +#define M_BLENDVPS FCML_TEXT("blendvps") +#define M_BLSFILL FCML_TEXT("blsfill") +#define M_BLSI FCML_TEXT("blsi") +#define M_BLSIC FCML_TEXT("blsic") +#define M_BLSMSK FCML_TEXT("blsmsk") +#define M_BLSR FCML_TEXT("blsr") +#define M_BOUND FCML_TEXT("bound") +#define M_BSF FCML_TEXT("bsf") +#define M_BSR FCML_TEXT("bsr") +#define M_BSWAP FCML_TEXT("bswap") +#define M_BT FCML_TEXT("bt") +#define M_BTC FCML_TEXT("btc") +#define M_BTR FCML_TEXT("btr") +#define M_BTS FCML_TEXT("bts") +#define M_BZHI FCML_TEXT("bzhi") +#define M_CALL FCML_TEXT("call") +#define M_CBW FCML_TEXT("cbw") +#define M_CDQ FCML_TEXT("cdq") +#define M_CDQE FCML_TEXT("cdqe") +#define M_CLAC FCML_TEXT("clac") +#define M_CLC FCML_TEXT("clc") +#define M_CLD FCML_TEXT("cld") +#define M_CLFLUSH FCML_TEXT("clflush") +#define M_CLGI FCML_TEXT("clgi") +#define M_CLI FCML_TEXT("cli") +#define M_CLTS FCML_TEXT("clts") +#define M_CMC FCML_TEXT("cmc") +#define M_CMOVA FCML_TEXT("cmova") +#define M_CMOVAE FCML_TEXT("cmovae") +#define M_CMOVB FCML_TEXT("cmovb") +#define M_CMOVBE FCML_TEXT("cmovbe") +#define M_CMOVC FCML_TEXT("cmovc") +#define M_CMOVENE FCML_TEXT("cmovene") +#define M_CMOVG FCML_TEXT("cmovg") +#define M_CMOVGE FCML_TEXT("cmovge") +#define M_CMOVL FCML_TEXT("cmovl") +#define M_CMOVLE FCML_TEXT("cmovle") +#define M_CMOVNA FCML_TEXT("cmovna") +#define M_CMOVNAE FCML_TEXT("cmovnae") +#define M_CMOVNB FCML_TEXT("cmovnb") +#define M_CMOVNBE FCML_TEXT("cmovnbe") +#define M_CMOVNC FCML_TEXT("cmovnc") +#define M_CMOVNG FCML_TEXT("cmovng") +#define M_CMOVNGE FCML_TEXT("cmovnge") +#define M_CMOVNL FCML_TEXT("cmovnl") +#define M_CMOVNLE FCML_TEXT("cmovnle") +#define M_CMOVNO FCML_TEXT("cmovno") +#define M_CMOVNP FCML_TEXT("cmovnp") +#define M_CMOVNS FCML_TEXT("cmovns") +#define M_CMOVNZ FCML_TEXT("cmovnz") +#define M_CMOVO FCML_TEXT("cmovo") +#define M_CMOVP FCML_TEXT("cmovp") +#define M_CMOVPE FCML_TEXT("cmovpe") +#define M_CMOVPO FCML_TEXT("cmovpo") +#define M_CMOVS FCML_TEXT("cmovs") +#define M_CMOVZ FCML_TEXT("cmovz") +#define M_CMP FCML_TEXT("cmp") +#define M_CMPEQPD FCML_TEXT("cmpeqpd") +#define M_CMPEQPS FCML_TEXT("cmpeqps") +#define M_CMPEQSD FCML_TEXT("cmpeqsd") +#define M_CMPEQSS FCML_TEXT("cmpeqss") +#define M_CMPLEPD FCML_TEXT("cmplepd") +#define M_CMPLEPS FCML_TEXT("cmpleps") +#define M_CMPLESD FCML_TEXT("cmplesd") +#define M_CMPLESS FCML_TEXT("cmpless") +#define M_CMPLTPD FCML_TEXT("cmpltpd") +#define M_CMPLTPS FCML_TEXT("cmpltps") +#define M_CMPLTSD FCML_TEXT("cmpltsd") +#define M_CMPLTSS FCML_TEXT("cmpltss") +#define M_CMPNEQPD FCML_TEXT("cmpneqpd") +#define M_CMPNEQPS FCML_TEXT("cmpneqps") +#define M_CMPNEQSD FCML_TEXT("cmpneqsd") +#define M_CMPNEQSS FCML_TEXT("cmpneqss") +#define M_CMPNLEPD FCML_TEXT("cmpnlepd") +#define M_CMPNLEPS FCML_TEXT("cmpnleps") +#define M_CMPNLESD FCML_TEXT("cmpnlesd") +#define M_CMPNLESS FCML_TEXT("cmpnless") +#define M_CMPNLTPD FCML_TEXT("cmpnltpd") +#define M_CMPNLTPS FCML_TEXT("cmpnltps") +#define M_CMPNLTSD FCML_TEXT("cmpnltsd") +#define M_CMPNLTSS FCML_TEXT("cmpnltss") +#define M_CMPORDPD FCML_TEXT("cmpordpd") +#define M_CMPORDPS FCML_TEXT("cmpordps") +#define M_CMPORDSD FCML_TEXT("cmpordsd") +#define M_CMPORDSS FCML_TEXT("cmpordss") +#define M_CMPPD FCML_TEXT("cmppd") +#define M_CMPPS FCML_TEXT("cmpps") +#define M_CMPS FCML_TEXT("cmps") +#define M_CMPSB FCML_TEXT("cmpsb") +#define M_CMPSD FCML_TEXT("cmpsd") +#define M_CMPSQ FCML_TEXT("cmpsq") +#define M_CMPSS FCML_TEXT("cmpss") +#define M_CMPSW FCML_TEXT("cmpsw") +#define M_CMPUNORDPD FCML_TEXT("cmpunordpd") +#define M_CMPUNORDPS FCML_TEXT("cmpunordps") +#define M_CMPUNORDSD FCML_TEXT("cmpunordsd") +#define M_CMPUNORDSS FCML_TEXT("cmpunordss") +#define M_CMPXCHG FCML_TEXT("cmpxchg") +#define M_CMPXCHG16B FCML_TEXT("cmpxchg16b") +#define M_CMPXCHG8B FCML_TEXT("cmpxchg8b") +#define M_COMISD FCML_TEXT("comisd") +#define M_COMISS FCML_TEXT("comiss") +#define M_CPUID FCML_TEXT("cpuid") +#define M_CQO FCML_TEXT("cqo") +#define M_CRC32 FCML_TEXT("crc32") +#define M_CVTDQ2PD FCML_TEXT("cvtdq2pd") +#define M_CVTDQ2PS FCML_TEXT("cvtdq2ps") +#define M_CVTPD2DQ FCML_TEXT("cvtpd2dq") +#define M_CVTPD2PI FCML_TEXT("cvtpd2pi") +#define M_CVTPD2PS FCML_TEXT("cvtpd2ps") +#define M_CVTPI2PD FCML_TEXT("cvtpi2pd") +#define M_CVTPI2PS FCML_TEXT("cvtpi2ps") +#define M_CVTPS2DQ FCML_TEXT("cvtps2dq") +#define M_CVTPS2PD FCML_TEXT("cvtps2pd") +#define M_CVTPS2PI FCML_TEXT("cvtps2pi") +#define M_CVTSD2SI FCML_TEXT("cvtsd2si") +#define M_CVTSD2SS FCML_TEXT("cvtsd2ss") +#define M_CVTSI2SD FCML_TEXT("cvtsi2sd") +#define M_CVTSI2SS FCML_TEXT("cvtsi2ss") +#define M_CVTSS2SD FCML_TEXT("cvtss2sd") +#define M_CVTSS2SI FCML_TEXT("cvtss2si") +#define M_CVTTPD2DQ FCML_TEXT("cvttpd2dq") +#define M_CVTTPD2PI FCML_TEXT("cvttpd2pi") +#define M_CVTTPS2DQ FCML_TEXT("cvttps2dq") +#define M_CVTTPS2PI FCML_TEXT("cvttps2pi") +#define M_CVTTSD2SI FCML_TEXT("cvttsd2si") +#define M_CVTTSS2SI FCML_TEXT("cvttss2si") +#define M_CWD FCML_TEXT("cwd") +#define M_CWDE FCML_TEXT("cwde") +#define M_DAA FCML_TEXT("daa") +#define M_DAS FCML_TEXT("das") +#define M_DEC FCML_TEXT("dec") +#define M_DIV FCML_TEXT("div") +#define M_DIVPD FCML_TEXT("divpd") +#define M_DIVPS FCML_TEXT("divps") +#define M_DIVSD FCML_TEXT("divsd") +#define M_DIVSS FCML_TEXT("divss") +#define M_DPPD FCML_TEXT("dppd") +#define M_DPPS FCML_TEXT("dpps") +#define M_EMMS FCML_TEXT("emms") +#define M_ENTER FCML_TEXT("enter") +#define M_EXTRACTPS FCML_TEXT("extractps") +#define M_EXTRQ FCML_TEXT("extrq") +#define M_F2XM1 FCML_TEXT("f2xm1") +#define M_FABS FCML_TEXT("fabs") +#define M_FADD FCML_TEXT("fadd") +#define M_FADDP FCML_TEXT("faddp") +#define M_FBLD FCML_TEXT("fbld") +#define M_FBSTP FCML_TEXT("fbstp") +#define M_FCHS FCML_TEXT("fchs") +#define M_FCLEX FCML_TEXT("fclex") +#define M_FCMOVB FCML_TEXT("fcmovb") +#define M_FCMOVBE FCML_TEXT("fcmovbe") +#define M_FCMOVE FCML_TEXT("fcmove") +#define M_FCMOVNB FCML_TEXT("fcmovnb") +#define M_FCMOVNBE FCML_TEXT("fcmovnbe") +#define M_FCMOVNE FCML_TEXT("fcmovne") +#define M_FCMOVNU FCML_TEXT("fcmovnu") +#define M_FCMOVU FCML_TEXT("fcmovu") +#define M_FCOM FCML_TEXT("fcom") +#define M_FCOMI FCML_TEXT("fcomi") +#define M_FCOMIP FCML_TEXT("fcomip") +#define M_FCOMP FCML_TEXT("fcomp") +#define M_FCOMPP FCML_TEXT("fcompp") +#define M_FCOS FCML_TEXT("fcos") +#define M_FDECSTP FCML_TEXT("fdecstp") +#define M_FDIV FCML_TEXT("fdiv") +#define M_FDIVP FCML_TEXT("fdivp") +#define M_FDIVR FCML_TEXT("fdivr") +#define M_FDIVRP FCML_TEXT("fdivrp") +#define M_FEMMS FCML_TEXT("femms") +#define M_FFREE FCML_TEXT("ffree") +#define M_FIADD FCML_TEXT("fiadd") +#define M_FICOM FCML_TEXT("ficom") +#define M_FICOMP FCML_TEXT("ficomp") +#define M_FIDIV FCML_TEXT("fidiv") +#define M_FIDIVR FCML_TEXT("fidivr") +#define M_FILD FCML_TEXT("fild") +#define M_FIMUL FCML_TEXT("fimul") +#define M_FINCSTP FCML_TEXT("fincstp") +#define M_FINIT FCML_TEXT("finit") +#define M_FIST FCML_TEXT("fist") +#define M_FISTP FCML_TEXT("fistp") +#define M_FISTTP FCML_TEXT("fisttp") +#define M_FISUB FCML_TEXT("fisub") +#define M_FISUBR FCML_TEXT("fisubr") +#define M_FLD FCML_TEXT("fld") +#define M_FLD1 FCML_TEXT("fld1") +#define M_FLDCW FCML_TEXT("fldcw") +#define M_FLDENV FCML_TEXT("fldenv") +#define M_FLDL2E FCML_TEXT("fldl2e") +#define M_FLDL2T FCML_TEXT("fldl2t") +#define M_FLDLG2 FCML_TEXT("fldlg2") +#define M_FLDLN2 FCML_TEXT("fldln2") +#define M_FLDPI FCML_TEXT("fldpi") +#define M_FLDZ FCML_TEXT("fldz") +#define M_FMUL FCML_TEXT("fmul") +#define M_FMULP FCML_TEXT("fmulp") +#define M_FNCLEX FCML_TEXT("fnclex") +#define M_FNINIT FCML_TEXT("fninit") +#define M_FNOP FCML_TEXT("fnop") +#define M_FNSAVE FCML_TEXT("fnsave") +#define M_FNSTCW FCML_TEXT("fnstcw") +#define M_FNSTENV FCML_TEXT("fnstenv") +#define M_FNSTSW FCML_TEXT("fnstsw") +#define M_FPATAN FCML_TEXT("fpatan") +#define M_FPREM FCML_TEXT("fprem") +#define M_FPREM1 FCML_TEXT("fprem1") +#define M_FPTAN FCML_TEXT("fptan") +#define M_FRNDINT FCML_TEXT("frndint") +#define M_FRSTOR FCML_TEXT("frstor") +#define M_FSAVE FCML_TEXT("fsave") +#define M_FSCALE FCML_TEXT("fscale") +#define M_FSIN FCML_TEXT("fsin") +#define M_FSINCOS FCML_TEXT("fsincos") +#define M_FSQRT FCML_TEXT("fsqrt") +#define M_FST FCML_TEXT("fst") +#define M_FSTCW FCML_TEXT("fstcw") +#define M_FSTENV FCML_TEXT("fstenv") +#define M_FSTP FCML_TEXT("fstp") +#define M_FSTSW FCML_TEXT("fstsw") +#define M_FSUB FCML_TEXT("fsub") +#define M_FSUBP FCML_TEXT("fsubp") +#define M_FSUBR FCML_TEXT("fsubr") +#define M_FSUBRP FCML_TEXT("fsubrp") +#define M_FTST FCML_TEXT("ftst") +#define M_FUCOM FCML_TEXT("fucom") +#define M_FUCOMI FCML_TEXT("fucomi") +#define M_FUCOMIP FCML_TEXT("fucomip") +#define M_FUCOMP FCML_TEXT("fucomp") +#define M_FUCOMPP FCML_TEXT("fucompp") +#define M_FWAIT FCML_TEXT("fwait") +#define M_FXAM FCML_TEXT("fxam") +#define M_FXCH FCML_TEXT("fxch") +#define M_FXRSTOR FCML_TEXT("fxrstor") +#define M_FXRSTOR64 FCML_TEXT("fxrstor64") +#define M_FXSAVE FCML_TEXT("fxsave") +#define M_FXSAVE64 FCML_TEXT("fxsave64") +#define M_FXTRACT FCML_TEXT("fxtract") +#define M_FYL2X FCML_TEXT("fyl2x") +#define M_FYL2XP1 FCML_TEXT("fyl2xp1") +#define M_GETSEC FCML_TEXT("getsec") +#define M_HADDPD FCML_TEXT("haddpd") +#define M_HADDPS FCML_TEXT("haddps") +#define M_HLT FCML_TEXT("hlt") +#define M_HSUBPD FCML_TEXT("hsubpd") +#define M_HSUBPS FCML_TEXT("hsubps") +#define M_IDIV FCML_TEXT("idiv") +#define M_IMUL FCML_TEXT("imul") +#define M_IN FCML_TEXT("in") +#define M_INC FCML_TEXT("inc") +#define M_INS FCML_TEXT("ins") +#define M_INSB FCML_TEXT("insb") +#define M_INSD FCML_TEXT("insd") +#define M_INSERTPS FCML_TEXT("insertps") +#define M_INSERTQ FCML_TEXT("insertq") +#define M_INSW FCML_TEXT("insw") +#define M_INT FCML_TEXT("int") +#define M_INT3 FCML_TEXT("int3") +#define M_INTO FCML_TEXT("into") +#define M_INVD FCML_TEXT("invd") +#define M_INVEPT FCML_TEXT("invept") +#define M_INVLPG FCML_TEXT("invlpg") +#define M_INVLPGA FCML_TEXT("invlpga") +#define M_INVPCID FCML_TEXT("invpcid") +#define M_INVVPID FCML_TEXT("invvpid") +#define M_IRET FCML_TEXT("iret") +#define M_IRETD FCML_TEXT("iretd") +#define M_IRETQ FCML_TEXT("iretq") +#define M_JA FCML_TEXT("ja") +#define M_JAE FCML_TEXT("jae") +#define M_JB FCML_TEXT("jb") +#define M_JBE FCML_TEXT("jbe") +#define M_JC FCML_TEXT("jc") +#define M_JCXZ FCML_TEXT("jcxz") +#define M_JECXZ FCML_TEXT("jecxz") +#define M_JENE FCML_TEXT("jene") +#define M_JG FCML_TEXT("jg") +#define M_JGE FCML_TEXT("jge") +#define M_JL FCML_TEXT("jl") +#define M_JLE FCML_TEXT("jle") +#define M_JMP FCML_TEXT("jmp") +#define M_JNA FCML_TEXT("jna") +#define M_JNAE FCML_TEXT("jnae") +#define M_JNB FCML_TEXT("jnb") +#define M_JNBE FCML_TEXT("jnbe") +#define M_JNC FCML_TEXT("jnc") +#define M_JNG FCML_TEXT("jng") +#define M_JNGE FCML_TEXT("jnge") +#define M_JNL FCML_TEXT("jnl") +#define M_JNLE FCML_TEXT("jnle") +#define M_JNO FCML_TEXT("jno") +#define M_JNP FCML_TEXT("jnp") +#define M_JNS FCML_TEXT("jns") +#define M_JNZ FCML_TEXT("jnz") +#define M_JO FCML_TEXT("jo") +#define M_JP FCML_TEXT("jp") +#define M_JPE FCML_TEXT("jpe") +#define M_JPO FCML_TEXT("jpo") +#define M_JRCXZ FCML_TEXT("jrcxz") +#define M_JS FCML_TEXT("js") +#define M_JZ FCML_TEXT("jz") +#define M_KADDB FCML_TEXT("kaddb") +#define M_KADDD FCML_TEXT("kaddd") +#define M_KADDQ FCML_TEXT("kaddq") +#define M_KADDW FCML_TEXT("kaddw") +#define M_KANDB FCML_TEXT("kandb") +#define M_KANDD FCML_TEXT("kandd") +#define M_KANDNB FCML_TEXT("kandnb") +#define M_KANDND FCML_TEXT("kandnd") +#define M_KANDNQ FCML_TEXT("kandnq") +#define M_KANDNW FCML_TEXT("kandnw") +#define M_KANDQ FCML_TEXT("kandq") +#define M_KANDW FCML_TEXT("kandw") +#define M_KMOVB FCML_TEXT("kmovb") +#define M_KMOVD FCML_TEXT("kmovd") +#define M_KMOVQ FCML_TEXT("kmovq") +#define M_KMOVW FCML_TEXT("kmovw") +#define M_KNOTB FCML_TEXT("knotb") +#define M_KNOTD FCML_TEXT("knotd") +#define M_KNOTQ FCML_TEXT("knotq") +#define M_KNOTW FCML_TEXT("knotw") +#define M_KORB FCML_TEXT("korb") +#define M_KORD FCML_TEXT("kord") +#define M_KORQ FCML_TEXT("korq") +#define M_KORTESTB FCML_TEXT("kortestb") +#define M_KORTESTD FCML_TEXT("kortestd") +#define M_KORTESTQ FCML_TEXT("kortestq") +#define M_KORTESTW FCML_TEXT("kortestw") +#define M_KORW FCML_TEXT("korw") +#define M_KSHIFTLB FCML_TEXT("kshiftlb") +#define M_KSHIFTLD FCML_TEXT("kshiftld") +#define M_KSHIFTLQ FCML_TEXT("kshiftlq") +#define M_KSHIFTLW FCML_TEXT("kshiftlw") +#define M_KSHIFTRB FCML_TEXT("kshiftrb") +#define M_KSHIFTRD FCML_TEXT("kshiftrd") +#define M_KSHIFTRQ FCML_TEXT("kshiftrq") +#define M_KSHIFTRW FCML_TEXT("kshiftrw") +#define M_KTESTB FCML_TEXT("ktestb") +#define M_KTESTD FCML_TEXT("ktestd") +#define M_KTESTQ FCML_TEXT("ktestq") +#define M_KTESTW FCML_TEXT("ktestw") +#define M_KXNORB FCML_TEXT("kxnorb") +#define M_KXNORD FCML_TEXT("kxnord") +#define M_KXNORQ FCML_TEXT("kxnorq") +#define M_KXNORW FCML_TEXT("kxnorw") +#define M_KXORB FCML_TEXT("kxorb") +#define M_KXORD FCML_TEXT("kxord") +#define M_KXORQ FCML_TEXT("kxorq") +#define M_KXORW FCML_TEXT("kxorw") +#define M_LAHF FCML_TEXT("lahf") +#define M_LAR FCML_TEXT("lar") +#define M_LDDQU FCML_TEXT("lddqu") +#define M_LDMXCSR FCML_TEXT("ldmxcsr") +#define M_LDS FCML_TEXT("lds") +#define M_LEA FCML_TEXT("lea") +#define M_LEAVE FCML_TEXT("leave") +#define M_LES FCML_TEXT("les") +#define M_LFENCE FCML_TEXT("lfence") +#define M_LFS FCML_TEXT("lfs") +#define M_LGDT FCML_TEXT("lgdt") +#define M_LGS FCML_TEXT("lgs") +#define M_LIDT FCML_TEXT("lidt") +#define M_LLDT FCML_TEXT("lldt") +#define M_LLWPCB FCML_TEXT("llwpcb") +#define M_LMSW FCML_TEXT("lmsw") +#define M_LODS FCML_TEXT("lods") +#define M_LODSB FCML_TEXT("lodsb") +#define M_LODSD FCML_TEXT("lodsd") +#define M_LODSQ FCML_TEXT("lodsq") +#define M_LODSW FCML_TEXT("lodsw") +#define M_LOOP FCML_TEXT("loop") +#define M_LOOPE FCML_TEXT("loope") +#define M_LOOPNE FCML_TEXT("loopne") +#define M_LOOPNZ FCML_TEXT("loopnz") +#define M_LOOPZ FCML_TEXT("loopz") +#define M_LSL FCML_TEXT("lsl") +#define M_LSS FCML_TEXT("lss") +#define M_LTR FCML_TEXT("ltr") +#define M_LWPINS FCML_TEXT("lwpins") +#define M_LWPVAL FCML_TEXT("lwpval") +#define M_LZCNT FCML_TEXT("lzcnt") +#define M_MASKMOVDQU FCML_TEXT("maskmovdqu") +#define M_MASKMOVQ FCML_TEXT("maskmovq") +#define M_MAXPD FCML_TEXT("maxpd") +#define M_MAXPS FCML_TEXT("maxps") +#define M_MAXSD FCML_TEXT("maxsd") +#define M_MAXSS FCML_TEXT("maxss") +#define M_MFENCE FCML_TEXT("mfence") +#define M_MINPD FCML_TEXT("minpd") +#define M_MINPS FCML_TEXT("minps") +#define M_MINSD FCML_TEXT("minsd") +#define M_MINSS FCML_TEXT("minss") +#define M_MONITOR FCML_TEXT("monitor") +#define M_MOV FCML_TEXT("mov") +#define M_MOVAPD FCML_TEXT("movapd") +#define M_MOVAPS FCML_TEXT("movaps") +#define M_MOVBE FCML_TEXT("movbe") +#define M_MOVD FCML_TEXT("movd") +#define M_MOVDDUP FCML_TEXT("movddup") +#define M_MOVDQ2Q FCML_TEXT("movdq2q") +#define M_MOVDQA FCML_TEXT("movdqa") +#define M_MOVDQU FCML_TEXT("movdqu") +#define M_MOVHLPS FCML_TEXT("movhlps") +#define M_MOVHPD FCML_TEXT("movhpd") +#define M_MOVHPS FCML_TEXT("movhps") +#define M_MOVLHPS FCML_TEXT("movlhps") +#define M_MOVLPD FCML_TEXT("movlpd") +#define M_MOVLPS FCML_TEXT("movlps") +#define M_MOVMSKPD FCML_TEXT("movmskpd") +#define M_MOVMSKPS FCML_TEXT("movmskps") +#define M_MOVNTDQ FCML_TEXT("movntdq") +#define M_MOVNTDQA FCML_TEXT("movntdqa") +#define M_MOVNTI FCML_TEXT("movnti") +#define M_MOVNTPD FCML_TEXT("movntpd") +#define M_MOVNTPS FCML_TEXT("movntps") +#define M_MOVNTQ FCML_TEXT("movntq") +#define M_MOVNTSD FCML_TEXT("movntsd") +#define M_MOVNTSS FCML_TEXT("movntss") +#define M_MOVQ FCML_TEXT("movq") +#define M_MOVQ2DQ FCML_TEXT("movq2dq") +#define M_MOVS FCML_TEXT("movs") +#define M_MOVSB FCML_TEXT("movsb") +#define M_MOVSD FCML_TEXT("movsd") +#define M_MOVSHDUP FCML_TEXT("movshdup") +#define M_MOVSLDUP FCML_TEXT("movsldup") +#define M_MOVSQ FCML_TEXT("movsq") +#define M_MOVSS FCML_TEXT("movss") +#define M_MOVSW FCML_TEXT("movsw") +#define M_MOVSX FCML_TEXT("movsx") +#define M_MOVSXD FCML_TEXT("movsxd") +#define M_MOVUPD FCML_TEXT("movupd") +#define M_MOVUPS FCML_TEXT("movups") +#define M_MOVZX FCML_TEXT("movzx") +#define M_MPSADBW FCML_TEXT("mpsadbw") +#define M_MUL FCML_TEXT("mul") +#define M_MULPD FCML_TEXT("mulpd") +#define M_MULPS FCML_TEXT("mulps") +#define M_MULSD FCML_TEXT("mulsd") +#define M_MULSS FCML_TEXT("mulss") +#define M_MULX FCML_TEXT("mulx") +#define M_MWAIT FCML_TEXT("mwait") +#define M_NEG FCML_TEXT("neg") +#define M_NOP FCML_TEXT("nop") +#define M_NOT FCML_TEXT("not") +#define M_OR FCML_TEXT("or") +#define M_ORPD FCML_TEXT("orpd") +#define M_ORPS FCML_TEXT("orps") +#define M_OUT FCML_TEXT("out") +#define M_OUTS FCML_TEXT("outs") +#define M_OUTSB FCML_TEXT("outsb") +#define M_OUTSD FCML_TEXT("outsd") +#define M_OUTSW FCML_TEXT("outsw") +#define M_PABSB FCML_TEXT("pabsb") +#define M_PABSD FCML_TEXT("pabsd") +#define M_PABSW FCML_TEXT("pabsw") +#define M_PACKSSDW FCML_TEXT("packssdw") +#define M_PACKSSWB FCML_TEXT("packsswb") +#define M_PACKUSDW FCML_TEXT("packusdw") +#define M_PACKUSWB FCML_TEXT("packuswb") +#define M_PADDB FCML_TEXT("paddb") +#define M_PADDD FCML_TEXT("paddd") +#define M_PADDQ FCML_TEXT("paddq") +#define M_PADDSB FCML_TEXT("paddsb") +#define M_PADDSW FCML_TEXT("paddsw") +#define M_PADDUSB FCML_TEXT("paddusb") +#define M_PADDUSW FCML_TEXT("paddusw") +#define M_PADDW FCML_TEXT("paddw") +#define M_PALIGNR FCML_TEXT("palignr") +#define M_PAND FCML_TEXT("pand") +#define M_PANDN FCML_TEXT("pandn") +#define M_PAUSE FCML_TEXT("pause") +#define M_PAVGB FCML_TEXT("pavgb") +#define M_PAVGUSB FCML_TEXT("pavgusb") +#define M_PAVGW FCML_TEXT("pavgw") +#define M_PBLENDVB FCML_TEXT("pblendvb") +#define M_PBLENDW FCML_TEXT("pblendw") +#define M_PCLMULQDQ FCML_TEXT("pclmulqdq") +#define M_PCMPEQB FCML_TEXT("pcmpeqb") +#define M_PCMPEQD FCML_TEXT("pcmpeqd") +#define M_PCMPEQQ FCML_TEXT("pcmpeqq") +#define M_PCMPEQW FCML_TEXT("pcmpeqw") +#define M_PCMPESTRI FCML_TEXT("pcmpestri") +#define M_PCMPESTRM FCML_TEXT("pcmpestrm") +#define M_PCMPGTB FCML_TEXT("pcmpgtb") +#define M_PCMPGTD FCML_TEXT("pcmpgtd") +#define M_PCMPGTQ FCML_TEXT("pcmpgtq") +#define M_PCMPGTW FCML_TEXT("pcmpgtw") +#define M_PCMPISTRI FCML_TEXT("pcmpistri") +#define M_PCMPISTRM FCML_TEXT("pcmpistrm") +#define M_PDEP FCML_TEXT("pdep") +#define M_PEXT FCML_TEXT("pext") +#define M_PEXTRB FCML_TEXT("pextrb") +#define M_PEXTRD FCML_TEXT("pextrd") +#define M_PEXTRQ FCML_TEXT("pextrq") +#define M_PEXTRW FCML_TEXT("pextrw") +#define M_PF2ID FCML_TEXT("pf2id") +#define M_PF2IW FCML_TEXT("pf2iw") +#define M_PFACC FCML_TEXT("pfacc") +#define M_PFADD FCML_TEXT("pfadd") +#define M_PFCMPEQ FCML_TEXT("pfcmpeq") +#define M_PFCMPGE FCML_TEXT("pfcmpge") +#define M_PFCMPGT FCML_TEXT("pfcmpgt") +#define M_PFMAX FCML_TEXT("pfmax") +#define M_PFMIN FCML_TEXT("pfmin") +#define M_PFMUL FCML_TEXT("pfmul") +#define M_PFNACC FCML_TEXT("pfnacc") +#define M_PFPNACC FCML_TEXT("pfpnacc") +#define M_PFRCP FCML_TEXT("pfrcp") +#define M_PFRCPIT1 FCML_TEXT("pfrcpit1") +#define M_PFRCPIT2 FCML_TEXT("pfrcpit2") +#define M_PFRSQIT1 FCML_TEXT("pfrsqit1") +#define M_PFRSQRT FCML_TEXT("pfrsqrt") +#define M_PFSUB FCML_TEXT("pfsub") +#define M_PFSUBR FCML_TEXT("pfsubr") +#define M_PHADDD FCML_TEXT("phaddd") +#define M_PHADDSW FCML_TEXT("phaddsw") +#define M_PHADDW FCML_TEXT("phaddw") +#define M_PHMINPOSUW FCML_TEXT("phminposuw") +#define M_PHSUBD FCML_TEXT("phsubd") +#define M_PHSUBSW FCML_TEXT("phsubsw") +#define M_PHSUBW FCML_TEXT("phsubw") +#define M_PI2FD FCML_TEXT("pi2fd") +#define M_PI2FW FCML_TEXT("pi2fw") +#define M_PINSRB FCML_TEXT("pinsrb") +#define M_PINSRD FCML_TEXT("pinsrd") +#define M_PINSRQ FCML_TEXT("pinsrq") +#define M_PINSRW FCML_TEXT("pinsrw") +#define M_PMADDUBSW FCML_TEXT("pmaddubsw") +#define M_PMADDWD FCML_TEXT("pmaddwd") +#define M_PMAXSB FCML_TEXT("pmaxsb") +#define M_PMAXSD FCML_TEXT("pmaxsd") +#define M_PMAXSW FCML_TEXT("pmaxsw") +#define M_PMAXUB FCML_TEXT("pmaxub") +#define M_PMAXUD FCML_TEXT("pmaxud") +#define M_PMAXUW FCML_TEXT("pmaxuw") +#define M_PMINSB FCML_TEXT("pminsb") +#define M_PMINSD FCML_TEXT("pminsd") +#define M_PMINSW FCML_TEXT("pminsw") +#define M_PMINUB FCML_TEXT("pminub") +#define M_PMINUD FCML_TEXT("pminud") +#define M_PMINUW FCML_TEXT("pminuw") +#define M_PMOVMSKB FCML_TEXT("pmovmskb") +#define M_PMOVSXBD FCML_TEXT("pmovsxbd") +#define M_PMOVSXBQ FCML_TEXT("pmovsxbq") +#define M_PMOVSXBW FCML_TEXT("pmovsxbw") +#define M_PMOVSXDQ FCML_TEXT("pmovsxdq") +#define M_PMOVSXWD FCML_TEXT("pmovsxwd") +#define M_PMOVSXWQ FCML_TEXT("pmovsxwq") +#define M_PMOVZXBD FCML_TEXT("pmovzxbd") +#define M_PMOVZXBQ FCML_TEXT("pmovzxbq") +#define M_PMOVZXBW FCML_TEXT("pmovzxbw") +#define M_PMOVZXDQ FCML_TEXT("pmovzxdq") +#define M_PMOVZXWD FCML_TEXT("pmovzxwd") +#define M_PMOVZXWQ FCML_TEXT("pmovzxwq") +#define M_PMULDQ FCML_TEXT("pmuldq") +#define M_PMULHRSW FCML_TEXT("pmulhrsw") +#define M_PMULHRW FCML_TEXT("pmulhrw") +#define M_PMULHUW FCML_TEXT("pmulhuw") +#define M_PMULHW FCML_TEXT("pmulhw") +#define M_PMULLD FCML_TEXT("pmulld") +#define M_PMULLW FCML_TEXT("pmullw") +#define M_PMULUDQ FCML_TEXT("pmuludq") +#define M_POP FCML_TEXT("pop") +#define M_POPA FCML_TEXT("popa") +#define M_POPAD FCML_TEXT("popad") +#define M_POPCNT FCML_TEXT("popcnt") +#define M_POPF FCML_TEXT("popf") +#define M_POPFD FCML_TEXT("popfd") +#define M_POPFQ FCML_TEXT("popfq") +#define M_POR FCML_TEXT("por") +#define M_PREFETCH FCML_TEXT("prefetch") +#define M_PREFETCHNTA FCML_TEXT("prefetchnta") +#define M_PREFETCHT0 FCML_TEXT("prefetcht0") +#define M_PREFETCHT1 FCML_TEXT("prefetcht1") +#define M_PREFETCHT2 FCML_TEXT("prefetcht2") +#define M_PREFETCHW FCML_TEXT("prefetchw") +#define M_PREFETCHWT1 FCML_TEXT("prefetchwt1") +#define M_PSADBW FCML_TEXT("psadbw") +#define M_PSHUFB FCML_TEXT("pshufb") +#define M_PSHUFD FCML_TEXT("pshufd") +#define M_PSHUFHW FCML_TEXT("pshufhw") +#define M_PSHUFLW FCML_TEXT("pshuflw") +#define M_PSHUFW FCML_TEXT("pshufw") +#define M_PSIGNB FCML_TEXT("psignb") +#define M_PSIGND FCML_TEXT("psignd") +#define M_PSIGNW FCML_TEXT("psignw") +#define M_PSLLD FCML_TEXT("pslld") +#define M_PSLLDQ FCML_TEXT("pslldq") +#define M_PSLLQ FCML_TEXT("psllq") +#define M_PSLLW FCML_TEXT("psllw") +#define M_PSRAD FCML_TEXT("psrad") +#define M_PSRAW FCML_TEXT("psraw") +#define M_PSRLD FCML_TEXT("psrld") +#define M_PSRLDQ FCML_TEXT("psrldq") +#define M_PSRLQ FCML_TEXT("psrlq") +#define M_PSRLW FCML_TEXT("psrlw") +#define M_PSUBB FCML_TEXT("psubb") +#define M_PSUBD FCML_TEXT("psubd") +#define M_PSUBQ FCML_TEXT("psubq") +#define M_PSUBSB FCML_TEXT("psubsb") +#define M_PSUBSW FCML_TEXT("psubsw") +#define M_PSUBUSB FCML_TEXT("psubusb") +#define M_PSUBUSW FCML_TEXT("psubusw") +#define M_PSUBW FCML_TEXT("psubw") +#define M_PSWAPD FCML_TEXT("pswapd") +#define M_PTEST FCML_TEXT("ptest") +#define M_PUNPCKHBW FCML_TEXT("punpckhbw") +#define M_PUNPCKHDQ FCML_TEXT("punpckhdq") +#define M_PUNPCKHQDQ FCML_TEXT("punpckhqdq") +#define M_PUNPCKHWD FCML_TEXT("punpckhwd") +#define M_PUNPCKLBW FCML_TEXT("punpcklbw") +#define M_PUNPCKLDQ FCML_TEXT("punpckldq") +#define M_PUNPCKLQDQ FCML_TEXT("punpcklqdq") +#define M_PUNPCKLWD FCML_TEXT("punpcklwd") +#define M_PUSH FCML_TEXT("push") +#define M_PUSHA FCML_TEXT("pusha") +#define M_PUSHAD FCML_TEXT("pushad") +#define M_PUSHF FCML_TEXT("pushf") +#define M_PUSHFD FCML_TEXT("pushfd") +#define M_PUSHFQ FCML_TEXT("pushfq") +#define M_PXOR FCML_TEXT("pxor") +#define M_RCL FCML_TEXT("rcl") +#define M_RCPPS FCML_TEXT("rcpps") +#define M_RCPSS FCML_TEXT("rcpss") +#define M_RCR FCML_TEXT("rcr") +#define M_RDFSBASE FCML_TEXT("rdfsbase") +#define M_RDGSBASE FCML_TEXT("rdgsbase") +#define M_RDMSR FCML_TEXT("rdmsr") +#define M_RDPMC FCML_TEXT("rdpmc") +#define M_RDRAND FCML_TEXT("rdrand") +#define M_RDSEED FCML_TEXT("rdseed") +#define M_RDTSC FCML_TEXT("rdtsc") +#define M_RDTSCP FCML_TEXT("rdtscp") +#define M_RET FCML_TEXT("ret") +#define M_RETF FCML_TEXT("retf") +#define M_ROL FCML_TEXT("rol") +#define M_ROR FCML_TEXT("ror") +#define M_RORX FCML_TEXT("rorx") +#define M_ROUNDPD FCML_TEXT("roundpd") +#define M_ROUNDPS FCML_TEXT("roundps") +#define M_ROUNDSD FCML_TEXT("roundsd") +#define M_ROUNDSS FCML_TEXT("roundss") +#define M_RSM FCML_TEXT("rsm") +#define M_RSQRTPS FCML_TEXT("rsqrtps") +#define M_RSQRTSS FCML_TEXT("rsqrtss") +#define M_SAHF FCML_TEXT("sahf") +#define M_SAL FCML_TEXT("sal") +#define M_SAR FCML_TEXT("sar") +#define M_SARX FCML_TEXT("sarx") +#define M_SBB FCML_TEXT("sbb") +#define M_SCAS FCML_TEXT("scas") +#define M_SCASB FCML_TEXT("scasb") +#define M_SCASD FCML_TEXT("scasd") +#define M_SCASQ FCML_TEXT("scasq") +#define M_SCASW FCML_TEXT("scasw") +#define M_SETA FCML_TEXT("seta") +#define M_SETAE FCML_TEXT("setae") +#define M_SETB FCML_TEXT("setb") +#define M_SETBE FCML_TEXT("setbe") +#define M_SETC FCML_TEXT("setc") +#define M_SETENE FCML_TEXT("setene") +#define M_SETG FCML_TEXT("setg") +#define M_SETGE FCML_TEXT("setge") +#define M_SETL FCML_TEXT("setl") +#define M_SETLE FCML_TEXT("setle") +#define M_SETNA FCML_TEXT("setna") +#define M_SETNAE FCML_TEXT("setnae") +#define M_SETNB FCML_TEXT("setnb") +#define M_SETNBE FCML_TEXT("setnbe") +#define M_SETNC FCML_TEXT("setnc") +#define M_SETNG FCML_TEXT("setng") +#define M_SETNGE FCML_TEXT("setnge") +#define M_SETNL FCML_TEXT("setnl") +#define M_SETNLE FCML_TEXT("setnle") +#define M_SETNO FCML_TEXT("setno") +#define M_SETNP FCML_TEXT("setnp") +#define M_SETNS FCML_TEXT("setns") +#define M_SETNZ FCML_TEXT("setnz") +#define M_SETO FCML_TEXT("seto") +#define M_SETP FCML_TEXT("setp") +#define M_SETPE FCML_TEXT("setpe") +#define M_SETPO FCML_TEXT("setpo") +#define M_SETS FCML_TEXT("sets") +#define M_SETZ FCML_TEXT("setz") +#define M_SFENCE FCML_TEXT("sfence") +#define M_SGDT FCML_TEXT("sgdt") +#define M_SHL FCML_TEXT("shl") +#define M_SHLD FCML_TEXT("shld") +#define M_SHLX FCML_TEXT("shlx") +#define M_SHR FCML_TEXT("shr") +#define M_SHRD FCML_TEXT("shrd") +#define M_SHRX FCML_TEXT("shrx") +#define M_SHUFPD FCML_TEXT("shufpd") +#define M_SHUFPS FCML_TEXT("shufps") +#define M_SIDT FCML_TEXT("sidt") +#define M_SKINIT FCML_TEXT("skinit") +#define M_SLDT FCML_TEXT("sldt") +#define M_SLWPCB FCML_TEXT("slwpcb") +#define M_SMSW FCML_TEXT("smsw") +#define M_SQRTPD FCML_TEXT("sqrtpd") +#define M_SQRTPS FCML_TEXT("sqrtps") +#define M_SQRTSD FCML_TEXT("sqrtsd") +#define M_SQRTSS FCML_TEXT("sqrtss") +#define M_STAC FCML_TEXT("stac") +#define M_STC FCML_TEXT("stc") +#define M_STD FCML_TEXT("std") +#define M_STGI FCML_TEXT("stgi") +#define M_STI FCML_TEXT("sti") +#define M_STMXCSR FCML_TEXT("stmxcsr") +#define M_STOS FCML_TEXT("stos") +#define M_STOSB FCML_TEXT("stosb") +#define M_STOSD FCML_TEXT("stosd") +#define M_STOSQ FCML_TEXT("stosq") +#define M_STOSW FCML_TEXT("stosw") +#define M_STR FCML_TEXT("str") +#define M_SUB FCML_TEXT("sub") +#define M_SUBPD FCML_TEXT("subpd") +#define M_SUBPS FCML_TEXT("subps") +#define M_SUBSD FCML_TEXT("subsd") +#define M_SUBSS FCML_TEXT("subss") +#define M_SWAPGS FCML_TEXT("swapgs") +#define M_SYSCALL FCML_TEXT("syscall") +#define M_SYSENTER FCML_TEXT("sysenter") +#define M_SYSEXIT FCML_TEXT("sysexit") +#define M_SYSRET FCML_TEXT("sysret") +#define M_T1MSKC FCML_TEXT("t1mskc") +#define M_TEST FCML_TEXT("test") +#define M_TZCNT FCML_TEXT("tzcnt") +#define M_TZMSK FCML_TEXT("tzmsk") +#define M_UCOMISD FCML_TEXT("ucomisd") +#define M_UCOMISS FCML_TEXT("ucomiss") +#define M_UD2 FCML_TEXT("ud2") +#define M_UNPCKHPD FCML_TEXT("unpckhpd") +#define M_UNPCKHPS FCML_TEXT("unpckhps") +#define M_UNPCKLPD FCML_TEXT("unpcklpd") +#define M_UNPCKLPS FCML_TEXT("unpcklps") +#define M_V4FMADDPS FCML_TEXT("v4fmaddps") +#define M_V4FMADDSS FCML_TEXT("v4fmaddss") +#define M_V4FNMADDPS FCML_TEXT("v4fnmaddps") +#define M_V4FNMADDSS FCML_TEXT("v4fnmaddss") +#define M_VADDPD FCML_TEXT("vaddpd") +#define M_VADDPS FCML_TEXT("vaddps") +#define M_VADDSD FCML_TEXT("vaddsd") +#define M_VADDSS FCML_TEXT("vaddss") +#define M_VADDSUBPD FCML_TEXT("vaddsubpd") +#define M_VADDSUBPS FCML_TEXT("vaddsubps") +#define M_VAESDEC FCML_TEXT("vaesdec") +#define M_VAESDECLAST FCML_TEXT("vaesdeclast") +#define M_VAESENC FCML_TEXT("vaesenc") +#define M_VAESENCLAST FCML_TEXT("vaesenclast") +#define M_VAESIMC FCML_TEXT("vaesimc") +#define M_VAESKEYGENASSIST FCML_TEXT("vaeskeygenassist") +#define M_VALIGND FCML_TEXT("valignd") +#define M_VALIGNQ FCML_TEXT("valignq") +#define M_VANDNPD FCML_TEXT("vandnpd") +#define M_VANDNPS FCML_TEXT("vandnps") +#define M_VANDPD FCML_TEXT("vandpd") +#define M_VANDPS FCML_TEXT("vandps") +#define M_VBLENDMPD FCML_TEXT("vblendmpd") +#define M_VBLENDMPS FCML_TEXT("vblendmps") +#define M_VBLENDPD FCML_TEXT("vblendpd") +#define M_VBLENDPS FCML_TEXT("vblendps") +#define M_VBLENDVPD FCML_TEXT("vblendvpd") +#define M_VBLENDVPS FCML_TEXT("vblendvps") +#define M_VBROADCASTF128 FCML_TEXT("vbroadcastf128") +#define M_VBROADCASTF32X2 FCML_TEXT("vbroadcastf32x2") +#define M_VBROADCASTF32X4 FCML_TEXT("vbroadcastf32x4") +#define M_VBROADCASTF32X8 FCML_TEXT("vbroadcastf32x8") +#define M_VBROADCASTF64X2 FCML_TEXT("vbroadcastf64x2") +#define M_VBROADCASTF64X4 FCML_TEXT("vbroadcastf64x4") +#define M_VBROADCASTI128 FCML_TEXT("vbroadcasti128") +#define M_VBROADCASTI32X2 FCML_TEXT("vbroadcasti32x2") +#define M_VBROADCASTI32X4 FCML_TEXT("vbroadcasti32x4") +#define M_VBROADCASTI32X8 FCML_TEXT("vbroadcasti32x8") +#define M_VBROADCASTI64X2 FCML_TEXT("vbroadcasti64x2") +#define M_VBROADCASTI64X4 FCML_TEXT("vbroadcasti64x4") +#define M_VBROADCASTSD FCML_TEXT("vbroadcastsd") +#define M_VBROADCASTSS FCML_TEXT("vbroadcastss") +#define M_VCMPEQ_OSPD FCML_TEXT("vcmpeq_ospd") +#define M_VCMPEQ_OSPS FCML_TEXT("vcmpeq_osps") +#define M_VCMPEQ_OSSD FCML_TEXT("vcmpeq_ossd") +#define M_VCMPEQ_OSSS FCML_TEXT("vcmpeq_osss") +#define M_VCMPEQ_UQPD FCML_TEXT("vcmpeq_uqpd") +#define M_VCMPEQ_UQPS FCML_TEXT("vcmpeq_uqps") +#define M_VCMPEQ_UQSD FCML_TEXT("vcmpeq_uqsd") +#define M_VCMPEQ_UQSS FCML_TEXT("vcmpeq_uqss") +#define M_VCMPEQ_USPD FCML_TEXT("vcmpeq_uspd") +#define M_VCMPEQ_USPS FCML_TEXT("vcmpeq_usps") +#define M_VCMPEQ_USSD FCML_TEXT("vcmpeq_ussd") +#define M_VCMPEQ_USSS FCML_TEXT("vcmpeq_usss") +#define M_VCMPEQPD FCML_TEXT("vcmpeqpd") +#define M_VCMPEQPS FCML_TEXT("vcmpeqps") +#define M_VCMPEQSD FCML_TEXT("vcmpeqsd") +#define M_VCMPEQSS FCML_TEXT("vcmpeqss") +#define M_VCMPFALSE_OSPD FCML_TEXT("vcmpfalse_ospd") +#define M_VCMPFALSE_OSPS FCML_TEXT("vcmpfalse_osps") +#define M_VCMPFALSE_OSSD FCML_TEXT("vcmpfalse_ossd") +#define M_VCMPFALSE_OSSS FCML_TEXT("vcmpfalse_osss") +#define M_VCMPFALSEPD FCML_TEXT("vcmpfalsepd") +#define M_VCMPFALSEPS FCML_TEXT("vcmpfalseps") +#define M_VCMPFALSESD FCML_TEXT("vcmpfalsesd") +#define M_VCMPFALSESS FCML_TEXT("vcmpfalsess") +#define M_VCMPGE_OQPD FCML_TEXT("vcmpge_oqpd") +#define M_VCMPGE_OQPS FCML_TEXT("vcmpge_oqps") +#define M_VCMPGE_OQSD FCML_TEXT("vcmpge_oqsd") +#define M_VCMPGE_OQSS FCML_TEXT("vcmpge_oqss") +#define M_VCMPGEPD FCML_TEXT("vcmpgepd") +#define M_VCMPGEPS FCML_TEXT("vcmpgeps") +#define M_VCMPGESD FCML_TEXT("vcmpgesd") +#define M_VCMPGESS FCML_TEXT("vcmpgess") +#define M_VCMPGT_OQPD FCML_TEXT("vcmpgt_oqpd") +#define M_VCMPGT_OQPS FCML_TEXT("vcmpgt_oqps") +#define M_VCMPGT_OQSD FCML_TEXT("vcmpgt_oqsd") +#define M_VCMPGT_OQSS FCML_TEXT("vcmpgt_oqss") +#define M_VCMPGTPD FCML_TEXT("vcmpgtpd") +#define M_VCMPGTPS FCML_TEXT("vcmpgtps") +#define M_VCMPGTSD FCML_TEXT("vcmpgtsd") +#define M_VCMPGTSS FCML_TEXT("vcmpgtss") +#define M_VCMPLE_OQPD FCML_TEXT("vcmple_oqpd") +#define M_VCMPLE_OQPS FCML_TEXT("vcmple_oqps") +#define M_VCMPLE_OQSD FCML_TEXT("vcmple_oqsd") +#define M_VCMPLE_OQSS FCML_TEXT("vcmple_oqss") +#define M_VCMPLEPD FCML_TEXT("vcmplepd") +#define M_VCMPLEPS FCML_TEXT("vcmpleps") +#define M_VCMPLESD FCML_TEXT("vcmplesd") +#define M_VCMPLESS FCML_TEXT("vcmpless") +#define M_VCMPLT_OQPD FCML_TEXT("vcmplt_oqpd") +#define M_VCMPLT_OQPS FCML_TEXT("vcmplt_oqps") +#define M_VCMPLT_OQSD FCML_TEXT("vcmplt_oqsd") +#define M_VCMPLT_OQSS FCML_TEXT("vcmplt_oqss") +#define M_VCMPLTPD FCML_TEXT("vcmpltpd") +#define M_VCMPLTPS FCML_TEXT("vcmpltps") +#define M_VCMPLTSD FCML_TEXT("vcmpltsd") +#define M_VCMPLTSS FCML_TEXT("vcmpltss") +#define M_VCMPNEQ_OQPD FCML_TEXT("vcmpneq_oqpd") +#define M_VCMPNEQ_OQPS FCML_TEXT("vcmpneq_oqps") +#define M_VCMPNEQ_OQSD FCML_TEXT("vcmpneq_oqsd") +#define M_VCMPNEQ_OQSS FCML_TEXT("vcmpneq_oqss") +#define M_VCMPNEQ_OSPD FCML_TEXT("vcmpneq_ospd") +#define M_VCMPNEQ_OSPS FCML_TEXT("vcmpneq_osps") +#define M_VCMPNEQ_OSSD FCML_TEXT("vcmpneq_ossd") +#define M_VCMPNEQ_OSSS FCML_TEXT("vcmpneq_osss") +#define M_VCMPNEQ_USPD FCML_TEXT("vcmpneq_uspd") +#define M_VCMPNEQ_USPS FCML_TEXT("vcmpneq_usps") +#define M_VCMPNEQ_USSD FCML_TEXT("vcmpneq_ussd") +#define M_VCMPNEQ_USSS FCML_TEXT("vcmpneq_usss") +#define M_VCMPNEQPD FCML_TEXT("vcmpneqpd") +#define M_VCMPNEQPS FCML_TEXT("vcmpneqps") +#define M_VCMPNEQSD FCML_TEXT("vcmpneqsd") +#define M_VCMPNEQSS FCML_TEXT("vcmpneqss") +#define M_VCMPNGE_UQPD FCML_TEXT("vcmpnge_uqpd") +#define M_VCMPNGE_UQPS FCML_TEXT("vcmpnge_uqps") +#define M_VCMPNGE_UQSD FCML_TEXT("vcmpnge_uqsd") +#define M_VCMPNGE_UQSS FCML_TEXT("vcmpnge_uqss") +#define M_VCMPNGEPD FCML_TEXT("vcmpngepd") +#define M_VCMPNGEPS FCML_TEXT("vcmpngeps") +#define M_VCMPNGESD FCML_TEXT("vcmpngesd") +#define M_VCMPNGESS FCML_TEXT("vcmpngess") +#define M_VCMPNGT_UQPD FCML_TEXT("vcmpngt_uqpd") +#define M_VCMPNGT_UQPS FCML_TEXT("vcmpngt_uqps") +#define M_VCMPNGT_UQSD FCML_TEXT("vcmpngt_uqsd") +#define M_VCMPNGT_UQSS FCML_TEXT("vcmpngt_uqss") +#define M_VCMPNGTPD FCML_TEXT("vcmpngtpd") +#define M_VCMPNGTPS FCML_TEXT("vcmpngtps") +#define M_VCMPNGTSD FCML_TEXT("vcmpngtsd") +#define M_VCMPNGTSS FCML_TEXT("vcmpngtss") +#define M_VCMPNLE_UQPD FCML_TEXT("vcmpnle_uqpd") +#define M_VCMPNLE_UQPS FCML_TEXT("vcmpnle_uqps") +#define M_VCMPNLE_UQSD FCML_TEXT("vcmpnle_uqsd") +#define M_VCMPNLE_UQSS FCML_TEXT("vcmpnle_uqss") +#define M_VCMPNLEPD FCML_TEXT("vcmpnlepd") +#define M_VCMPNLEPS FCML_TEXT("vcmpnleps") +#define M_VCMPNLESD FCML_TEXT("vcmpnlesd") +#define M_VCMPNLESS FCML_TEXT("vcmpnless") +#define M_VCMPNLT_UQPD FCML_TEXT("vcmpnlt_uqpd") +#define M_VCMPNLT_UQPS FCML_TEXT("vcmpnlt_uqps") +#define M_VCMPNLT_UQSD FCML_TEXT("vcmpnlt_uqsd") +#define M_VCMPNLT_UQSS FCML_TEXT("vcmpnlt_uqss") +#define M_VCMPNLTPD FCML_TEXT("vcmpnltpd") +#define M_VCMPNLTPS FCML_TEXT("vcmpnltps") +#define M_VCMPNLTSD FCML_TEXT("vcmpnltsd") +#define M_VCMPNLTSS FCML_TEXT("vcmpnltss") +#define M_VCMPORD_SPD FCML_TEXT("vcmpord_spd") +#define M_VCMPORD_SPS FCML_TEXT("vcmpord_sps") +#define M_VCMPORD_SSD FCML_TEXT("vcmpord_ssd") +#define M_VCMPORD_SSS FCML_TEXT("vcmpord_sss") +#define M_VCMPORDPD FCML_TEXT("vcmpordpd") +#define M_VCMPORDPS FCML_TEXT("vcmpordps") +#define M_VCMPORDSD FCML_TEXT("vcmpordsd") +#define M_VCMPORDSS FCML_TEXT("vcmpordss") +#define M_VCMPPD FCML_TEXT("vcmppd") +#define M_VCMPPS FCML_TEXT("vcmpps") +#define M_VCMPSD FCML_TEXT("vcmpsd") +#define M_VCMPSS FCML_TEXT("vcmpss") +#define M_VCMPTRUE_USPD FCML_TEXT("vcmptrue_uspd") +#define M_VCMPTRUE_USPS FCML_TEXT("vcmptrue_usps") +#define M_VCMPTRUE_USSD FCML_TEXT("vcmptrue_ussd") +#define M_VCMPTRUE_USSS FCML_TEXT("vcmptrue_usss") +#define M_VCMPTRUEPD FCML_TEXT("vcmptruepd") +#define M_VCMPTRUEPS FCML_TEXT("vcmptrueps") +#define M_VCMPTRUESD FCML_TEXT("vcmptruesd") +#define M_VCMPTRUESS FCML_TEXT("vcmptruess") +#define M_VCMPUNORD_SPD FCML_TEXT("vcmpunord_spd") +#define M_VCMPUNORD_SPS FCML_TEXT("vcmpunord_sps") +#define M_VCMPUNORD_SSD FCML_TEXT("vcmpunord_ssd") +#define M_VCMPUNORD_SSS FCML_TEXT("vcmpunord_sss") +#define M_VCMPUNORDPD FCML_TEXT("vcmpunordpd") +#define M_VCMPUNORDPS FCML_TEXT("vcmpunordps") +#define M_VCMPUNORDSD FCML_TEXT("vcmpunordsd") +#define M_VCMPUNORDSS FCML_TEXT("vcmpunordss") +#define M_VCOMISD FCML_TEXT("vcomisd") +#define M_VCOMISS FCML_TEXT("vcomiss") +#define M_VCOMPRESSPD FCML_TEXT("vcompresspd") +#define M_VCOMPRESSPS FCML_TEXT("vcompressps") +#define M_VCVTDQ2PD FCML_TEXT("vcvtdq2pd") +#define M_VCVTDQ2PS FCML_TEXT("vcvtdq2ps") +#define M_VCVTPD2DQ FCML_TEXT("vcvtpd2dq") +#define M_VCVTPD2PS FCML_TEXT("vcvtpd2ps") +#define M_VCVTPD2QQ FCML_TEXT("vcvtpd2qq") +#define M_VCVTPD2UDQ FCML_TEXT("vcvtpd2udq") +#define M_VCVTPD2UQQ FCML_TEXT("vcvtpd2uqq") +#define M_VCVTPH2PS FCML_TEXT("vcvtph2ps") +#define M_VCVTPS2DQ FCML_TEXT("vcvtps2dq") +#define M_VCVTPS2PD FCML_TEXT("vcvtps2pd") +#define M_VCVTPS2PH FCML_TEXT("vcvtps2ph") +#define M_VCVTPS2QQ FCML_TEXT("vcvtps2qq") +#define M_VCVTPS2UDQ FCML_TEXT("vcvtps2udq") +#define M_VCVTPS2UQQ FCML_TEXT("vcvtps2uqq") +#define M_VCVTQQ2PD FCML_TEXT("vcvtqq2pd") +#define M_VCVTQQ2PS FCML_TEXT("vcvtqq2ps") +#define M_VCVTSD2SI FCML_TEXT("vcvtsd2si") +#define M_VCVTSD2SS FCML_TEXT("vcvtsd2ss") +#define M_VCVTSD2USI FCML_TEXT("vcvtsd2usi") +#define M_VCVTSI2SD FCML_TEXT("vcvtsi2sd") +#define M_VCVTSI2SS FCML_TEXT("vcvtsi2ss") +#define M_VCVTSS2SD FCML_TEXT("vcvtss2sd") +#define M_VCVTSS2SI FCML_TEXT("vcvtss2si") +#define M_VCVTSS2USI FCML_TEXT("vcvtss2usi") +#define M_VCVTTPD2DQ FCML_TEXT("vcvttpd2dq") +#define M_VCVTTPD2QQ FCML_TEXT("vcvttpd2qq") +#define M_VCVTTPD2UDQ FCML_TEXT("vcvttpd2udq") +#define M_VCVTTPD2UQQ FCML_TEXT("vcvttpd2uqq") +#define M_VCVTTPS2DQ FCML_TEXT("vcvttps2dq") +#define M_VCVTTPS2QQ FCML_TEXT("vcvttps2qq") +#define M_VCVTTPS2UDQ FCML_TEXT("vcvttps2udq") +#define M_VCVTTPS2UQQ FCML_TEXT("vcvttps2uqq") +#define M_VCVTTSD2SI FCML_TEXT("vcvttsd2si") +#define M_VCVTTSD2USI FCML_TEXT("vcvttsd2usi") +#define M_VCVTTSS2SI FCML_TEXT("vcvttss2si") +#define M_VCVTTSS2USI FCML_TEXT("vcvttss2usi") +#define M_VCVTUDQ2PD FCML_TEXT("vcvtudq2pd") +#define M_VCVTUDQ2PS FCML_TEXT("vcvtudq2ps") +#define M_VCVTUQQ2PD FCML_TEXT("vcvtuqq2pd") +#define M_VCVTUQQ2PS FCML_TEXT("vcvtuqq2ps") +#define M_VCVTUSI2SD FCML_TEXT("vcvtusi2sd") +#define M_VCVTUSI2SS FCML_TEXT("vcvtusi2ss") +#define M_VDBPSADBW FCML_TEXT("vdbpsadbw") +#define M_VDIVPD FCML_TEXT("vdivpd") +#define M_VDIVPS FCML_TEXT("vdivps") +#define M_VDIVSD FCML_TEXT("vdivsd") +#define M_VDIVSS FCML_TEXT("vdivss") +#define M_VDPPD FCML_TEXT("vdppd") +#define M_VDPPS FCML_TEXT("vdpps") +#define M_VERR FCML_TEXT("verr") +#define M_VERW FCML_TEXT("verw") +#define M_VEXP2PD FCML_TEXT("vexp2pd") +#define M_VEXP2PS FCML_TEXT("vexp2ps") +#define M_VEXPANDPD FCML_TEXT("vexpandpd") +#define M_VEXPANDPS FCML_TEXT("vexpandps") +#define M_VEXTRACTF128 FCML_TEXT("vextractf128") +#define M_VEXTRACTF32X4 FCML_TEXT("vextractf32x4") +#define M_VEXTRACTF32X8 FCML_TEXT("vextractf32x8") +#define M_VEXTRACTF64X2 FCML_TEXT("vextractf64x2") +#define M_VEXTRACTF64X4 FCML_TEXT("vextractf64x4") +#define M_VEXTRACTI128 FCML_TEXT("vextracti128") +#define M_VEXTRACTI32X4 FCML_TEXT("vextracti32x4") +#define M_VEXTRACTI32X8 FCML_TEXT("vextracti32x8") +#define M_VEXTRACTI64X2 FCML_TEXT("vextracti64x2") +#define M_VEXTRACTI64X4 FCML_TEXT("vextracti64x4") +#define M_VEXTRACTPS FCML_TEXT("vextractps") +#define M_VFIXUPIMMPD FCML_TEXT("vfixupimmpd") +#define M_VFIXUPIMMPS FCML_TEXT("vfixupimmps") +#define M_VFIXUPIMMSD FCML_TEXT("vfixupimmsd") +#define M_VFIXUPIMMSS FCML_TEXT("vfixupimmss") +#define M_VFMADD132PD FCML_TEXT("vfmadd132pd") +#define M_VFMADD132PS FCML_TEXT("vfmadd132ps") +#define M_VFMADD132SD FCML_TEXT("vfmadd132sd") +#define M_VFMADD132SS FCML_TEXT("vfmadd132ss") +#define M_VFMADD213PD FCML_TEXT("vfmadd213pd") +#define M_VFMADD213PS FCML_TEXT("vfmadd213ps") +#define M_VFMADD213SD FCML_TEXT("vfmadd213sd") +#define M_VFMADD213SS FCML_TEXT("vfmadd213ss") +#define M_VFMADD231PD FCML_TEXT("vfmadd231pd") +#define M_VFMADD231PS FCML_TEXT("vfmadd231ps") +#define M_VFMADD231SD FCML_TEXT("vfmadd231sd") +#define M_VFMADD231SS FCML_TEXT("vfmadd231ss") +#define M_VFMADDPD FCML_TEXT("vfmaddpd") +#define M_VFMADDPS FCML_TEXT("vfmaddps") +#define M_VFMADDSD FCML_TEXT("vfmaddsd") +#define M_VFMADDSS FCML_TEXT("vfmaddss") +#define M_VFMADDSUB132PD FCML_TEXT("vfmaddsub132pd") +#define M_VFMADDSUB132PS FCML_TEXT("vfmaddsub132ps") +#define M_VFMADDSUB213PD FCML_TEXT("vfmaddsub213pd") +#define M_VFMADDSUB213PS FCML_TEXT("vfmaddsub213ps") +#define M_VFMADDSUB231PD FCML_TEXT("vfmaddsub231pd") +#define M_VFMADDSUB231PS FCML_TEXT("vfmaddsub231ps") +#define M_VFMADDSUBPD FCML_TEXT("vfmaddsubpd") +#define M_VFMADDSUBPS FCML_TEXT("vfmaddsubps") +#define M_VFMSUB132PD FCML_TEXT("vfmsub132pd") +#define M_VFMSUB132PS FCML_TEXT("vfmsub132ps") +#define M_VFMSUB132SD FCML_TEXT("vfmsub132sd") +#define M_VFMSUB132SS FCML_TEXT("vfmsub132ss") +#define M_VFMSUB213PD FCML_TEXT("vfmsub213pd") +#define M_VFMSUB213PS FCML_TEXT("vfmsub213ps") +#define M_VFMSUB213SD FCML_TEXT("vfmsub213sd") +#define M_VFMSUB213SS FCML_TEXT("vfmsub213ss") +#define M_VFMSUB231PD FCML_TEXT("vfmsub231pd") +#define M_VFMSUB231PS FCML_TEXT("vfmsub231ps") +#define M_VFMSUB231SD FCML_TEXT("vfmsub231sd") +#define M_VFMSUB231SS FCML_TEXT("vfmsub231ss") +#define M_VFMSUBADD132PD FCML_TEXT("vfmsubadd132pd") +#define M_VFMSUBADD132PS FCML_TEXT("vfmsubadd132ps") +#define M_VFMSUBADD213PD FCML_TEXT("vfmsubadd213pd") +#define M_VFMSUBADD213PS FCML_TEXT("vfmsubadd213ps") +#define M_VFMSUBADD231PD FCML_TEXT("vfmsubadd231pd") +#define M_VFMSUBADD231PS FCML_TEXT("vfmsubadd231ps") +#define M_VFMSUBADDPD FCML_TEXT("vfmsubaddpd") +#define M_VFMSUBADDPS FCML_TEXT("vfmsubaddps") +#define M_VFMSUBPD FCML_TEXT("vfmsubpd") +#define M_VFMSUBPS FCML_TEXT("vfmsubps") +#define M_VFMSUBSD FCML_TEXT("vfmsubsd") +#define M_VFMSUBSS FCML_TEXT("vfmsubss") +#define M_VFNMADD132PD FCML_TEXT("vfnmadd132pd") +#define M_VFNMADD132PS FCML_TEXT("vfnmadd132ps") +#define M_VFNMADD132SD FCML_TEXT("vfnmadd132sd") +#define M_VFNMADD132SS FCML_TEXT("vfnmadd132ss") +#define M_VFNMADD213PD FCML_TEXT("vfnmadd213pd") +#define M_VFNMADD213PS FCML_TEXT("vfnmadd213ps") +#define M_VFNMADD213SD FCML_TEXT("vfnmadd213sd") +#define M_VFNMADD213SS FCML_TEXT("vfnmadd213ss") +#define M_VFNMADD231PD FCML_TEXT("vfnmadd231pd") +#define M_VFNMADD231PS FCML_TEXT("vfnmadd231ps") +#define M_VFNMADD231SD FCML_TEXT("vfnmadd231sd") +#define M_VFNMADD231SS FCML_TEXT("vfnmadd231ss") +#define M_VFNMADDPD FCML_TEXT("vfnmaddpd") +#define M_VFNMADDPS FCML_TEXT("vfnmaddps") +#define M_VFNMADDSD FCML_TEXT("vfnmaddsd") +#define M_VFNMADDSS FCML_TEXT("vfnmaddss") +#define M_VFNMSUB132PD FCML_TEXT("vfnmsub132pd") +#define M_VFNMSUB132PS FCML_TEXT("vfnmsub132ps") +#define M_VFNMSUB132SD FCML_TEXT("vfnmsub132sd") +#define M_VFNMSUB132SS FCML_TEXT("vfnmsub132ss") +#define M_VFNMSUB213PD FCML_TEXT("vfnmsub213pd") +#define M_VFNMSUB213PS FCML_TEXT("vfnmsub213ps") +#define M_VFNMSUB213SD FCML_TEXT("vfnmsub213sd") +#define M_VFNMSUB213SS FCML_TEXT("vfnmsub213ss") +#define M_VFNMSUB231PD FCML_TEXT("vfnmsub231pd") +#define M_VFNMSUB231PS FCML_TEXT("vfnmsub231ps") +#define M_VFNMSUB231SD FCML_TEXT("vfnmsub231sd") +#define M_VFNMSUB231SS FCML_TEXT("vfnmsub231ss") +#define M_VFNMSUBPD FCML_TEXT("vfnmsubpd") +#define M_VFNMSUBPS FCML_TEXT("vfnmsubps") +#define M_VFNMSUBSD FCML_TEXT("vfnmsubsd") +#define M_VFNMSUBSS FCML_TEXT("vfnmsubss") +#define M_VFPCLASSPD FCML_TEXT("vfpclasspd") +#define M_VFPCLASSPS FCML_TEXT("vfpclassps") +#define M_VFPCLASSSD FCML_TEXT("vfpclasssd") +#define M_VFPCLASSSS FCML_TEXT("vfpclassss") +#define M_VFRCZPD FCML_TEXT("vfrczpd") +#define M_VFRCZPS FCML_TEXT("vfrczps") +#define M_VFRCZSD FCML_TEXT("vfrczsd") +#define M_VFRCZSS FCML_TEXT("vfrczss") +#define M_VGATHERDPD FCML_TEXT("vgatherdpd") +#define M_VGATHERDPS FCML_TEXT("vgatherdps") +#define M_VGATHERPF0DPD FCML_TEXT("vgatherpf0dpd") +#define M_VGATHERPF0DPS FCML_TEXT("vgatherpf0dps") +#define M_VGATHERPF0QPD FCML_TEXT("vgatherpf0qpd") +#define M_VGATHERPF0QPS FCML_TEXT("vgatherpf0qps") +#define M_VGATHERPF1DPD FCML_TEXT("vgatherpf1dpd") +#define M_VGATHERPF1DPS FCML_TEXT("vgatherpf1dps") +#define M_VGATHERPF1QPD FCML_TEXT("vgatherpf1qpd") +#define M_VGATHERPF1QPS FCML_TEXT("vgatherpf1qps") +#define M_VGATHERQPD FCML_TEXT("vgatherqpd") +#define M_VGATHERQPS FCML_TEXT("vgatherqps") +#define M_VGETEXPPD FCML_TEXT("vgetexppd") +#define M_VGETEXPPS FCML_TEXT("vgetexpps") +#define M_VGETEXPSD FCML_TEXT("vgetexpsd") +#define M_VGETEXPSS FCML_TEXT("vgetexpss") +#define M_VGETMANTPD FCML_TEXT("vgetmantpd") +#define M_VGETMANTPS FCML_TEXT("vgetmantps") +#define M_VGETMANTSD FCML_TEXT("vgetmantsd") +#define M_VGETMANTSS FCML_TEXT("vgetmantss") +#define M_VHADDPD FCML_TEXT("vhaddpd") +#define M_VHADDPS FCML_TEXT("vhaddps") +#define M_VHSUBPD FCML_TEXT("vhsubpd") +#define M_VHSUBPS FCML_TEXT("vhsubps") +#define M_VINSERTF128 FCML_TEXT("vinsertf128") +#define M_VINSERTF32X4 FCML_TEXT("vinsertf32x4") +#define M_VINSERTF32X8 FCML_TEXT("vinsertf32x8") +#define M_VINSERTF64X2 FCML_TEXT("vinsertf64x2") +#define M_VINSERTF64X4 FCML_TEXT("vinsertf64x4") +#define M_VINSERTI128 FCML_TEXT("vinserti128") +#define M_VINSERTI32X4 FCML_TEXT("vinserti32x4") +#define M_VINSERTI32X8 FCML_TEXT("vinserti32x8") +#define M_VINSERTI64X2 FCML_TEXT("vinserti64x2") +#define M_VINSERTI64X4 FCML_TEXT("vinserti64x4") +#define M_VINSERTPS FCML_TEXT("vinsertps") +#define M_VLDDQU FCML_TEXT("vlddqu") +#define M_VLDMXCSR FCML_TEXT("vldmxcsr") +#define M_VMASKMOVDQU FCML_TEXT("vmaskmovdqu") +#define M_VMASKMOVPD FCML_TEXT("vmaskmovpd") +#define M_VMASKMOVPS FCML_TEXT("vmaskmovps") +#define M_VMAXPD FCML_TEXT("vmaxpd") +#define M_VMAXPS FCML_TEXT("vmaxps") +#define M_VMAXSD FCML_TEXT("vmaxsd") +#define M_VMAXSS FCML_TEXT("vmaxss") +#define M_VMCALL FCML_TEXT("vmcall") +#define M_VMCLEAR FCML_TEXT("vmclear") +#define M_VMFUNC FCML_TEXT("vmfunc") +#define M_VMINPD FCML_TEXT("vminpd") +#define M_VMINPS FCML_TEXT("vminps") +#define M_VMINSD FCML_TEXT("vminsd") +#define M_VMINSS FCML_TEXT("vminss") +#define M_VMLAUNCH FCML_TEXT("vmlaunch") +#define M_VMLOAD FCML_TEXT("vmload") +#define M_VMMCALL FCML_TEXT("vmmcall") +#define M_VMOVAPD FCML_TEXT("vmovapd") +#define M_VMOVAPS FCML_TEXT("vmovaps") +#define M_VMOVD FCML_TEXT("vmovd") +#define M_VMOVDDUP FCML_TEXT("vmovddup") +#define M_VMOVDQA FCML_TEXT("vmovdqa") +#define M_VMOVDQA32 FCML_TEXT("vmovdqa32") +#define M_VMOVDQA64 FCML_TEXT("vmovdqa64") +#define M_VMOVDQU FCML_TEXT("vmovdqu") +#define M_VMOVDQU16 FCML_TEXT("vmovdqu16") +#define M_VMOVDQU32 FCML_TEXT("vmovdqu32") +#define M_VMOVDQU64 FCML_TEXT("vmovdqu64") +#define M_VMOVDQU8 FCML_TEXT("vmovdqu8") +#define M_VMOVHLPS FCML_TEXT("vmovhlps") +#define M_VMOVHPD FCML_TEXT("vmovhpd") +#define M_VMOVHPS FCML_TEXT("vmovhps") +#define M_VMOVLHPS FCML_TEXT("vmovlhps") +#define M_VMOVLPD FCML_TEXT("vmovlpd") +#define M_VMOVLPS FCML_TEXT("vmovlps") +#define M_VMOVMSKPD FCML_TEXT("vmovmskpd") +#define M_VMOVMSKPS FCML_TEXT("vmovmskps") +#define M_VMOVNTDQ FCML_TEXT("vmovntdq") +#define M_VMOVNTDQA FCML_TEXT("vmovntdqa") +#define M_VMOVNTPD FCML_TEXT("vmovntpd") +#define M_VMOVNTPS FCML_TEXT("vmovntps") +#define M_VMOVQ FCML_TEXT("vmovq") +#define M_VMOVSD FCML_TEXT("vmovsd") +#define M_VMOVSHDUP FCML_TEXT("vmovshdup") +#define M_VMOVSLDUP FCML_TEXT("vmovsldup") +#define M_VMOVSS FCML_TEXT("vmovss") +#define M_VMOVUPD FCML_TEXT("vmovupd") +#define M_VMOVUPS FCML_TEXT("vmovups") +#define M_VMPSADBW FCML_TEXT("vmpsadbw") +#define M_VMPTRLD FCML_TEXT("vmptrld") +#define M_VMPTRST FCML_TEXT("vmptrst") +#define M_VMREAD FCML_TEXT("vmread") +#define M_VMRESUME FCML_TEXT("vmresume") +#define M_VMRUN FCML_TEXT("vmrun") +#define M_VMSAVE FCML_TEXT("vmsave") +#define M_VMULPD FCML_TEXT("vmulpd") +#define M_VMULPS FCML_TEXT("vmulps") +#define M_VMULSD FCML_TEXT("vmulsd") +#define M_VMULSS FCML_TEXT("vmulss") +#define M_VMWRITE FCML_TEXT("vmwrite") +#define M_VMXOFF FCML_TEXT("vmxoff") +#define M_VMXON FCML_TEXT("vmxon") +#define M_VORPD FCML_TEXT("vorpd") +#define M_VORPS FCML_TEXT("vorps") +#define M_VP4DPWSSD FCML_TEXT("vp4dpwssd") +#define M_VP4DPWSSDS FCML_TEXT("vp4dpwssds") +#define M_VPABSB FCML_TEXT("vpabsb") +#define M_VPABSD FCML_TEXT("vpabsd") +#define M_VPABSQ FCML_TEXT("vpabsq") +#define M_VPABSW FCML_TEXT("vpabsw") +#define M_VPACKSSDW FCML_TEXT("vpackssdw") +#define M_VPACKSSWB FCML_TEXT("vpacksswb") +#define M_VPACKUSDW FCML_TEXT("vpackusdw") +#define M_VPACKUSWB FCML_TEXT("vpackuswb") +#define M_VPADDB FCML_TEXT("vpaddb") +#define M_VPADDD FCML_TEXT("vpaddd") +#define M_VPADDQ FCML_TEXT("vpaddq") +#define M_VPADDSB FCML_TEXT("vpaddsb") +#define M_VPADDSW FCML_TEXT("vpaddsw") +#define M_VPADDUSB FCML_TEXT("vpaddusb") +#define M_VPADDUSW FCML_TEXT("vpaddusw") +#define M_VPADDW FCML_TEXT("vpaddw") +#define M_VPALIGNR FCML_TEXT("vpalignr") +#define M_VPAND FCML_TEXT("vpand") +#define M_VPANDD FCML_TEXT("vpandd") +#define M_VPANDN FCML_TEXT("vpandn") +#define M_VPANDND FCML_TEXT("vpandnd") +#define M_VPANDNQ FCML_TEXT("vpandnq") +#define M_VPANDQ FCML_TEXT("vpandq") +#define M_VPAVGB FCML_TEXT("vpavgb") +#define M_VPAVGW FCML_TEXT("vpavgw") +#define M_VPBLENDD FCML_TEXT("vpblendd") +#define M_VPBLENDMB FCML_TEXT("vpblendmb") +#define M_VPBLENDMD FCML_TEXT("vpblendmd") +#define M_VPBLENDMQ FCML_TEXT("vpblendmq") +#define M_VPBLENDMW FCML_TEXT("vpblendmw") +#define M_VPBLENDVB FCML_TEXT("vpblendvb") +#define M_VPBLENDW FCML_TEXT("vpblendw") +#define M_VPBROADCASTB FCML_TEXT("vpbroadcastb") +#define M_VPBROADCASTD FCML_TEXT("vpbroadcastd") +#define M_VPBROADCASTMB2Q FCML_TEXT("vpbroadcastmb2q") +#define M_VPBROADCASTMW2D FCML_TEXT("vpbroadcastmw2d") +#define M_VPBROADCASTQ FCML_TEXT("vpbroadcastq") +#define M_VPBROADCASTW FCML_TEXT("vpbroadcastw") +#define M_VPCLMULQDQ FCML_TEXT("vpclmulqdq") +#define M_VPCMOV FCML_TEXT("vpcmov") +#define M_VPCMPB FCML_TEXT("vpcmpb") +#define M_VPCMPD FCML_TEXT("vpcmpd") +#define M_VPCMPEQB FCML_TEXT("vpcmpeqb") +#define M_VPCMPEQD FCML_TEXT("vpcmpeqd") +#define M_VPCMPEQQ FCML_TEXT("vpcmpeqq") +#define M_VPCMPEQW FCML_TEXT("vpcmpeqw") +#define M_VPCMPESTRI FCML_TEXT("vpcmpestri") +#define M_VPCMPESTRM FCML_TEXT("vpcmpestrm") +#define M_VPCMPGTB FCML_TEXT("vpcmpgtb") +#define M_VPCMPGTD FCML_TEXT("vpcmpgtd") +#define M_VPCMPGTQ FCML_TEXT("vpcmpgtq") +#define M_VPCMPGTW FCML_TEXT("vpcmpgtw") +#define M_VPCMPISTRI FCML_TEXT("vpcmpistri") +#define M_VPCMPISTRM FCML_TEXT("vpcmpistrm") +#define M_VPCMPQ FCML_TEXT("vpcmpq") +#define M_VPCMPUB FCML_TEXT("vpcmpub") +#define M_VPCMPUD FCML_TEXT("vpcmpud") +#define M_VPCMPUQ FCML_TEXT("vpcmpuq") +#define M_VPCMPUW FCML_TEXT("vpcmpuw") +#define M_VPCMPW FCML_TEXT("vpcmpw") +#define M_VPCOMB FCML_TEXT("vpcomb") +#define M_VPCOMD FCML_TEXT("vpcomd") +#define M_VPCOMEQB FCML_TEXT("vpcomeqb") +#define M_VPCOMEQD FCML_TEXT("vpcomeqd") +#define M_VPCOMEQQ FCML_TEXT("vpcomeqq") +#define M_VPCOMEQUB FCML_TEXT("vpcomequb") +#define M_VPCOMEQUD FCML_TEXT("vpcomequd") +#define M_VPCOMEQUQ FCML_TEXT("vpcomequq") +#define M_VPCOMEQUW FCML_TEXT("vpcomequw") +#define M_VPCOMEQW FCML_TEXT("vpcomeqw") +#define M_VPCOMFALSEB FCML_TEXT("vpcomfalseb") +#define M_VPCOMFALSED FCML_TEXT("vpcomfalsed") +#define M_VPCOMFALSEQ FCML_TEXT("vpcomfalseq") +#define M_VPCOMFALSEUB FCML_TEXT("vpcomfalseub") +#define M_VPCOMFALSEUD FCML_TEXT("vpcomfalseud") +#define M_VPCOMFALSEUQ FCML_TEXT("vpcomfalseuq") +#define M_VPCOMFALSEUW FCML_TEXT("vpcomfalseuw") +#define M_VPCOMFALSEW FCML_TEXT("vpcomfalsew") +#define M_VPCOMGEB FCML_TEXT("vpcomgeb") +#define M_VPCOMGED FCML_TEXT("vpcomged") +#define M_VPCOMGEQ FCML_TEXT("vpcomgeq") +#define M_VPCOMGEUB FCML_TEXT("vpcomgeub") +#define M_VPCOMGEUD FCML_TEXT("vpcomgeud") +#define M_VPCOMGEUQ FCML_TEXT("vpcomgeuq") +#define M_VPCOMGEUW FCML_TEXT("vpcomgeuw") +#define M_VPCOMGEW FCML_TEXT("vpcomgew") +#define M_VPCOMGTB FCML_TEXT("vpcomgtb") +#define M_VPCOMGTD FCML_TEXT("vpcomgtd") +#define M_VPCOMGTQ FCML_TEXT("vpcomgtq") +#define M_VPCOMGTUB FCML_TEXT("vpcomgtub") +#define M_VPCOMGTUD FCML_TEXT("vpcomgtud") +#define M_VPCOMGTUQ FCML_TEXT("vpcomgtuq") +#define M_VPCOMGTUW FCML_TEXT("vpcomgtuw") +#define M_VPCOMGTW FCML_TEXT("vpcomgtw") +#define M_VPCOMLEB FCML_TEXT("vpcomleb") +#define M_VPCOMLED FCML_TEXT("vpcomled") +#define M_VPCOMLEQ FCML_TEXT("vpcomleq") +#define M_VPCOMLEUB FCML_TEXT("vpcomleub") +#define M_VPCOMLEUD FCML_TEXT("vpcomleud") +#define M_VPCOMLEUQ FCML_TEXT("vpcomleuq") +#define M_VPCOMLEUW FCML_TEXT("vpcomleuw") +#define M_VPCOMLEW FCML_TEXT("vpcomlew") +#define M_VPCOMLTB FCML_TEXT("vpcomltb") +#define M_VPCOMLTD FCML_TEXT("vpcomltd") +#define M_VPCOMLTQ FCML_TEXT("vpcomltq") +#define M_VPCOMLTUB FCML_TEXT("vpcomltub") +#define M_VPCOMLTUD FCML_TEXT("vpcomltud") +#define M_VPCOMLTUQ FCML_TEXT("vpcomltuq") +#define M_VPCOMLTUW FCML_TEXT("vpcomltuw") +#define M_VPCOMLTW FCML_TEXT("vpcomltw") +#define M_VPCOMNEQB FCML_TEXT("vpcomneqb") +#define M_VPCOMNEQD FCML_TEXT("vpcomneqd") +#define M_VPCOMNEQQ FCML_TEXT("vpcomneqq") +#define M_VPCOMNEQUB FCML_TEXT("vpcomnequb") +#define M_VPCOMNEQUD FCML_TEXT("vpcomnequd") +#define M_VPCOMNEQUQ FCML_TEXT("vpcomnequq") +#define M_VPCOMNEQUW FCML_TEXT("vpcomnequw") +#define M_VPCOMNEQW FCML_TEXT("vpcomneqw") +#define M_VPCOMPRESSD FCML_TEXT("vpcompressd") +#define M_VPCOMPRESSQ FCML_TEXT("vpcompressq") +#define M_VPCOMQ FCML_TEXT("vpcomq") +#define M_VPCOMTRUEB FCML_TEXT("vpcomtrueb") +#define M_VPCOMTRUED FCML_TEXT("vpcomtrued") +#define M_VPCOMTRUEQ FCML_TEXT("vpcomtrueq") +#define M_VPCOMTRUEUB FCML_TEXT("vpcomtrueub") +#define M_VPCOMTRUEUD FCML_TEXT("vpcomtrueud") +#define M_VPCOMTRUEUQ FCML_TEXT("vpcomtrueuq") +#define M_VPCOMTRUEUW FCML_TEXT("vpcomtrueuw") +#define M_VPCOMTRUEW FCML_TEXT("vpcomtruew") +#define M_VPCOMUB FCML_TEXT("vpcomub") +#define M_VPCOMUD FCML_TEXT("vpcomud") +#define M_VPCOMUQ FCML_TEXT("vpcomuq") +#define M_VPCOMUW FCML_TEXT("vpcomuw") +#define M_VPCOMW FCML_TEXT("vpcomw") +#define M_VPERM2F128 FCML_TEXT("vperm2f128") +#define M_VPERM2I128 FCML_TEXT("vperm2i128") +#define M_VPERMB FCML_TEXT("vpermb") +#define M_VPERMD FCML_TEXT("vpermd") +#define M_VPERMI2B FCML_TEXT("vpermi2b") +#define M_VPERMI2D FCML_TEXT("vpermi2d") +#define M_VPERMI2PD FCML_TEXT("vpermi2pd") +#define M_VPERMI2PS FCML_TEXT("vpermi2ps") +#define M_VPERMI2Q FCML_TEXT("vpermi2q") +#define M_VPERMI2W FCML_TEXT("vpermi2w") +#define M_VPERMIL2PD FCML_TEXT("vpermil2pd") +#define M_VPERMIL2PS FCML_TEXT("vpermil2ps") +#define M_VPERMILPD FCML_TEXT("vpermilpd") +#define M_VPERMILPS FCML_TEXT("vpermilps") +#define M_VPERMPD FCML_TEXT("vpermpd") +#define M_VPERMPS FCML_TEXT("vpermps") +#define M_VPERMQ FCML_TEXT("vpermq") +#define M_VPERMT2B FCML_TEXT("vpermt2b") +#define M_VPERMT2D FCML_TEXT("vpermt2d") +#define M_VPERMT2PD FCML_TEXT("vpermt2pd") +#define M_VPERMT2PS FCML_TEXT("vpermt2ps") +#define M_VPERMT2Q FCML_TEXT("vpermt2q") +#define M_VPERMT2W FCML_TEXT("vpermt2w") +#define M_VPERMW FCML_TEXT("vpermw") +#define M_VPEXPANDD FCML_TEXT("vpexpandd") +#define M_VPEXPANDQ FCML_TEXT("vpexpandq") +#define M_VPEXTRB FCML_TEXT("vpextrb") +#define M_VPEXTRD FCML_TEXT("vpextrd") +#define M_VPEXTRQ FCML_TEXT("vpextrq") +#define M_VPEXTRW FCML_TEXT("vpextrw") +#define M_VPGATHERDD FCML_TEXT("vpgatherdd") +#define M_VPGATHERDQ FCML_TEXT("vpgatherdq") +#define M_VPGATHERQD FCML_TEXT("vpgatherqd") +#define M_VPGATHERQQ FCML_TEXT("vpgatherqq") +#define M_VPHADDBD FCML_TEXT("vphaddbd") +#define M_VPHADDBQ FCML_TEXT("vphaddbq") +#define M_VPHADDBW FCML_TEXT("vphaddbw") +#define M_VPHADDD FCML_TEXT("vphaddd") +#define M_VPHADDDQ FCML_TEXT("vphadddq") +#define M_VPHADDSW FCML_TEXT("vphaddsw") +#define M_VPHADDUBD FCML_TEXT("vphaddubd") +#define M_VPHADDUBQ FCML_TEXT("vphaddubq") +#define M_VPHADDUBW FCML_TEXT("vphaddubw") +#define M_VPHADDUDQ FCML_TEXT("vphaddudq") +#define M_VPHADDUWD FCML_TEXT("vphadduwd") +#define M_VPHADDUWQ FCML_TEXT("vphadduwq") +#define M_VPHADDW FCML_TEXT("vphaddw") +#define M_VPHADDWD FCML_TEXT("vphaddwd") +#define M_VPHADDWQ FCML_TEXT("vphaddwq") +#define M_VPHMINPOSUW FCML_TEXT("vphminposuw") +#define M_VPHSUBBW FCML_TEXT("vphsubbw") +#define M_VPHSUBD FCML_TEXT("vphsubd") +#define M_VPHSUBDQ FCML_TEXT("vphsubdq") +#define M_VPHSUBSW FCML_TEXT("vphsubsw") +#define M_VPHSUBW FCML_TEXT("vphsubw") +#define M_VPHSUBWD FCML_TEXT("vphsubwd") +#define M_VPINSRB FCML_TEXT("vpinsrb") +#define M_VPINSRD FCML_TEXT("vpinsrd") +#define M_VPINSRQ FCML_TEXT("vpinsrq") +#define M_VPINSRW FCML_TEXT("vpinsrw") +#define M_VPLZCNTD FCML_TEXT("vplzcntd") +#define M_VPLZCNTQ FCML_TEXT("vplzcntq") +#define M_VPMACSDD FCML_TEXT("vpmacsdd") +#define M_VPMACSDQH FCML_TEXT("vpmacsdqh") +#define M_VPMACSDQL FCML_TEXT("vpmacsdql") +#define M_VPMACSSDD FCML_TEXT("vpmacssdd") +#define M_VPMACSSDQH FCML_TEXT("vpmacssdqh") +#define M_VPMACSSDQL FCML_TEXT("vpmacssdql") +#define M_VPMACSSWD FCML_TEXT("vpmacsswd") +#define M_VPMACSSWW FCML_TEXT("vpmacssww") +#define M_VPMACSWD FCML_TEXT("vpmacswd") +#define M_VPMACSWW FCML_TEXT("vpmacsww") +#define M_VPMADCSSWD FCML_TEXT("vpmadcsswd") +#define M_VPMADCSWD FCML_TEXT("vpmadcswd") +#define M_VPMADD52HUQ FCML_TEXT("vpmadd52huq") +#define M_VPMADD52LUQ FCML_TEXT("vpmadd52luq") +#define M_VPMADDUBSW FCML_TEXT("vpmaddubsw") +#define M_VPMADDWD FCML_TEXT("vpmaddwd") +#define M_VPMASKMOV FCML_TEXT("vpmaskmov") +#define M_VPMASKMOVD FCML_TEXT("vpmaskmovd") +#define M_VPMASKMOVQ FCML_TEXT("vpmaskmovq") +#define M_VPMAXSB FCML_TEXT("vpmaxsb") +#define M_VPMAXSD FCML_TEXT("vpmaxsd") +#define M_VPMAXSQ FCML_TEXT("vpmaxsq") +#define M_VPMAXSW FCML_TEXT("vpmaxsw") +#define M_VPMAXUB FCML_TEXT("vpmaxub") +#define M_VPMAXUD FCML_TEXT("vpmaxud") +#define M_VPMAXUQ FCML_TEXT("vpmaxuq") +#define M_VPMAXUW FCML_TEXT("vpmaxuw") +#define M_VPMINSB FCML_TEXT("vpminsb") +#define M_VPMINSD FCML_TEXT("vpminsd") +#define M_VPMINSQ FCML_TEXT("vpminsq") +#define M_VPMINSW FCML_TEXT("vpminsw") +#define M_VPMINUB FCML_TEXT("vpminub") +#define M_VPMINUD FCML_TEXT("vpminud") +#define M_VPMINUQ FCML_TEXT("vpminuq") +#define M_VPMINUW FCML_TEXT("vpminuw") +#define M_VPMOVB2M FCML_TEXT("vpmovb2m") +#define M_VPMOVD2M FCML_TEXT("vpmovd2m") +#define M_VPMOVDB FCML_TEXT("vpmovdb") +#define M_VPMOVDW FCML_TEXT("vpmovdw") +#define M_VPMOVM2B FCML_TEXT("vpmovm2b") +#define M_VPMOVM2D FCML_TEXT("vpmovm2d") +#define M_VPMOVM2Q FCML_TEXT("vpmovm2q") +#define M_VPMOVM2W FCML_TEXT("vpmovm2w") +#define M_VPMOVMSKB FCML_TEXT("vpmovmskb") +#define M_VPMOVQ2M FCML_TEXT("vpmovq2m") +#define M_VPMOVQB FCML_TEXT("vpmovqb") +#define M_VPMOVQD FCML_TEXT("vpmovqd") +#define M_VPMOVQW FCML_TEXT("vpmovqw") +#define M_VPMOVSDB FCML_TEXT("vpmovsdb") +#define M_VPMOVSDW FCML_TEXT("vpmovsdw") +#define M_VPMOVSQB FCML_TEXT("vpmovsqb") +#define M_VPMOVSQD FCML_TEXT("vpmovsqd") +#define M_VPMOVSQW FCML_TEXT("vpmovsqw") +#define M_VPMOVSWB FCML_TEXT("vpmovswb") +#define M_VPMOVSXBD FCML_TEXT("vpmovsxbd") +#define M_VPMOVSXBQ FCML_TEXT("vpmovsxbq") +#define M_VPMOVSXBW FCML_TEXT("vpmovsxbw") +#define M_VPMOVSXDQ FCML_TEXT("vpmovsxdq") +#define M_VPMOVSXWD FCML_TEXT("vpmovsxwd") +#define M_VPMOVSXWQ FCML_TEXT("vpmovsxwq") +#define M_VPMOVUSDB FCML_TEXT("vpmovusdb") +#define M_VPMOVUSDW FCML_TEXT("vpmovusdw") +#define M_VPMOVUSQB FCML_TEXT("vpmovusqb") +#define M_VPMOVUSQD FCML_TEXT("vpmovusqd") +#define M_VPMOVUSQW FCML_TEXT("vpmovusqw") +#define M_VPMOVUSWB FCML_TEXT("vpmovuswb") +#define M_VPMOVW2M FCML_TEXT("vpmovw2m") +#define M_VPMOVWB FCML_TEXT("vpmovwb") +#define M_VPMOVZXBD FCML_TEXT("vpmovzxbd") +#define M_VPMOVZXBQ FCML_TEXT("vpmovzxbq") +#define M_VPMOVZXBW FCML_TEXT("vpmovzxbw") +#define M_VPMOVZXDQ FCML_TEXT("vpmovzxdq") +#define M_VPMOVZXWD FCML_TEXT("vpmovzxwd") +#define M_VPMOVZXWQ FCML_TEXT("vpmovzxwq") +#define M_VPMULDQ FCML_TEXT("vpmuldq") +#define M_VPMULHRSW FCML_TEXT("vpmulhrsw") +#define M_VPMULHUW FCML_TEXT("vpmulhuw") +#define M_VPMULHW FCML_TEXT("vpmulhw") +#define M_VPMULLD FCML_TEXT("vpmulld") +#define M_VPMULLQ FCML_TEXT("vpmullq") +#define M_VPMULLW FCML_TEXT("vpmullw") +#define M_VPMULTISHIFTQB FCML_TEXT("vpmultishiftqb") +#define M_VPMULUDQ FCML_TEXT("vpmuludq") +#define M_VPOR FCML_TEXT("vpor") +#define M_VPORD FCML_TEXT("vpord") +#define M_VPORQ FCML_TEXT("vporq") +#define M_VPPERM FCML_TEXT("vpperm") +#define M_VPROLD FCML_TEXT("vprold") +#define M_VPROLQ FCML_TEXT("vprolq") +#define M_VPROLVD FCML_TEXT("vprolvd") +#define M_VPROLVQ FCML_TEXT("vprolvq") +#define M_VPRORD FCML_TEXT("vprord") +#define M_VPRORQ FCML_TEXT("vprorq") +#define M_VPRORVD FCML_TEXT("vprorvd") +#define M_VPRORVQ FCML_TEXT("vprorvq") +#define M_VPROTB FCML_TEXT("vprotb") +#define M_VPROTD FCML_TEXT("vprotd") +#define M_VPROTQ FCML_TEXT("vprotq") +#define M_VPROTW FCML_TEXT("vprotw") +#define M_VPSADBW FCML_TEXT("vpsadbw") +#define M_VPSCATTERDD FCML_TEXT("vpscatterdd") +#define M_VPSCATTERDQ FCML_TEXT("vpscatterdq") +#define M_VPSCATTERQD FCML_TEXT("vpscatterqd") +#define M_VPSCATTERQQ FCML_TEXT("vpscatterqq") +#define M_VPSHAB FCML_TEXT("vpshab") +#define M_VPSHAD FCML_TEXT("vpshad") +#define M_VPSHAQ FCML_TEXT("vpshaq") +#define M_VPSHAW FCML_TEXT("vpshaw") +#define M_VPSHLB FCML_TEXT("vpshlb") +#define M_VPSHLD FCML_TEXT("vpshld") +#define M_VPSHLQ FCML_TEXT("vpshlq") +#define M_VPSHLW FCML_TEXT("vpshlw") +#define M_VPSHUFB FCML_TEXT("vpshufb") +#define M_VPSHUFD FCML_TEXT("vpshufd") +#define M_VPSHUFHW FCML_TEXT("vpshufhw") +#define M_VPSHUFLW FCML_TEXT("vpshuflw") +#define M_VPSIGNB FCML_TEXT("vpsignb") +#define M_VPSIGND FCML_TEXT("vpsignd") +#define M_VPSIGNW FCML_TEXT("vpsignw") +#define M_VPSLLD FCML_TEXT("vpslld") +#define M_VPSLLDQ FCML_TEXT("vpslldq") +#define M_VPSLLQ FCML_TEXT("vpsllq") +#define M_VPSLLVD FCML_TEXT("vpsllvd") +#define M_VPSLLVQ FCML_TEXT("vpsllvq") +#define M_VPSLLVW FCML_TEXT("vpsllvw") +#define M_VPSLLW FCML_TEXT("vpsllw") +#define M_VPSRAD FCML_TEXT("vpsrad") +#define M_VPSRAQ FCML_TEXT("vpsraq") +#define M_VPSRAVD FCML_TEXT("vpsravd") +#define M_VPSRAVQ FCML_TEXT("vpsravq") +#define M_VPSRAVW FCML_TEXT("vpsravw") +#define M_VPSRAW FCML_TEXT("vpsraw") +#define M_VPSRLD FCML_TEXT("vpsrld") +#define M_VPSRLDQ FCML_TEXT("vpsrldq") +#define M_VPSRLQ FCML_TEXT("vpsrlq") +#define M_VPSRLVD FCML_TEXT("vpsrlvd") +#define M_VPSRLVQ FCML_TEXT("vpsrlvq") +#define M_VPSRLVW FCML_TEXT("vpsrlvw") +#define M_VPSRLW FCML_TEXT("vpsrlw") +#define M_VPSUBB FCML_TEXT("vpsubb") +#define M_VPSUBD FCML_TEXT("vpsubd") +#define M_VPSUBQ FCML_TEXT("vpsubq") +#define M_VPSUBSB FCML_TEXT("vpsubsb") +#define M_VPSUBSW FCML_TEXT("vpsubsw") +#define M_VPSUBUSB FCML_TEXT("vpsubusb") +#define M_VPSUBUSW FCML_TEXT("vpsubusw") +#define M_VPSUBW FCML_TEXT("vpsubw") +#define M_VPTERNLOGD FCML_TEXT("vpternlogd") +#define M_VPTERNLOGQ FCML_TEXT("vpternlogq") +#define M_VPTEST FCML_TEXT("vptest") +#define M_VPTESTMB FCML_TEXT("vptestmb") +#define M_VPTESTMD FCML_TEXT("vptestmd") +#define M_VPTESTMQ FCML_TEXT("vptestmq") +#define M_VPTESTMW FCML_TEXT("vptestmw") +#define M_VPTESTNMB FCML_TEXT("vptestnmb") +#define M_VPTESTNMD FCML_TEXT("vptestnmd") +#define M_VPTESTNMQ FCML_TEXT("vptestnmq") +#define M_VPTESTNMW FCML_TEXT("vptestnmw") +#define M_VPUNPCKHBW FCML_TEXT("vpunpckhbw") +#define M_VPUNPCKHDQ FCML_TEXT("vpunpckhdq") +#define M_VPUNPCKHQDQ FCML_TEXT("vpunpckhqdq") +#define M_VPUNPCKHWD FCML_TEXT("vpunpckhwd") +#define M_VPUNPCKLBW FCML_TEXT("vpunpcklbw") +#define M_VPUNPCKLDQ FCML_TEXT("vpunpckldq") +#define M_VPUNPCKLQDQ FCML_TEXT("vpunpcklqdq") +#define M_VPUNPCKLWD FCML_TEXT("vpunpcklwd") +#define M_VPXOR FCML_TEXT("vpxor") +#define M_VPXORD FCML_TEXT("vpxord") +#define M_VPXORQ FCML_TEXT("vpxorq") +#define M_VRANGEPD FCML_TEXT("vrangepd") +#define M_VRANGEPS FCML_TEXT("vrangeps") +#define M_VRANGESD FCML_TEXT("vrangesd") +#define M_VRANGESS FCML_TEXT("vrangess") +#define M_VRCP14PD FCML_TEXT("vrcp14pd") +#define M_VRCP14PS FCML_TEXT("vrcp14ps") +#define M_VRCP14SD FCML_TEXT("vrcp14sd") +#define M_VRCP14SS FCML_TEXT("vrcp14ss") +#define M_VRCP28PD FCML_TEXT("vrcp28pd") +#define M_VRCP28PS FCML_TEXT("vrcp28ps") +#define M_VRCP28SD FCML_TEXT("vrcp28sd") +#define M_VRCP28SS FCML_TEXT("vrcp28ss") +#define M_VRCPPS FCML_TEXT("vrcpps") +#define M_VRCPSS FCML_TEXT("vrcpss") +#define M_VREDUCEPD FCML_TEXT("vreducepd") +#define M_VREDUCEPS FCML_TEXT("vreduceps") +#define M_VREDUCESD FCML_TEXT("vreducesd") +#define M_VREDUCESS FCML_TEXT("vreducess") +#define M_VRNDSCALEPD FCML_TEXT("vrndscalepd") +#define M_VRNDSCALEPS FCML_TEXT("vrndscaleps") +#define M_VRNDSCALESD FCML_TEXT("vrndscalesd") +#define M_VRNDSCALESS FCML_TEXT("vrndscaless") +#define M_VROUNDPD FCML_TEXT("vroundpd") +#define M_VROUNDPS FCML_TEXT("vroundps") +#define M_VROUNDSD FCML_TEXT("vroundsd") +#define M_VROUNDSS FCML_TEXT("vroundss") +#define M_VRSQRT14PD FCML_TEXT("vrsqrt14pd") +#define M_VRSQRT14PS FCML_TEXT("vrsqrt14ps") +#define M_VRSQRT14SD FCML_TEXT("vrsqrt14sd") +#define M_VRSQRT14SS FCML_TEXT("vrsqrt14ss") +#define M_VRSQRT28PD FCML_TEXT("vrsqrt28pd") +#define M_VRSQRT28PS FCML_TEXT("vrsqrt28ps") +#define M_VRSQRT28SD FCML_TEXT("vrsqrt28sd") +#define M_VRSQRT28SS FCML_TEXT("vrsqrt28ss") +#define M_VRSQRTPS FCML_TEXT("vrsqrtps") +#define M_VRSQRTSS FCML_TEXT("vrsqrtss") +#define M_VSCALEFPD FCML_TEXT("vscalefpd") +#define M_VSCALEFPS FCML_TEXT("vscalefps") +#define M_VSCALEFSD FCML_TEXT("vscalefsd") +#define M_VSCALEFSS FCML_TEXT("vscalefss") +#define M_VSCATTERDPD FCML_TEXT("vscatterdpd") +#define M_VSCATTERDPS FCML_TEXT("vscatterdps") +#define M_VSCATTERPF0DPD FCML_TEXT("vscatterpf0dpd") +#define M_VSCATTERPF0DPS FCML_TEXT("vscatterpf0dps") +#define M_VSCATTERPF0QPD FCML_TEXT("vscatterpf0qpd") +#define M_VSCATTERPF0QPS FCML_TEXT("vscatterpf0qps") +#define M_VSCATTERPF1DPD FCML_TEXT("vscatterpf1dpd") +#define M_VSCATTERPF1DPS FCML_TEXT("vscatterpf1dps") +#define M_VSCATTERPF1QPD FCML_TEXT("vscatterpf1qpd") +#define M_VSCATTERPF1QPS FCML_TEXT("vscatterpf1qps") +#define M_VSCATTERQPD FCML_TEXT("vscatterqpd") +#define M_VSCATTERQPS FCML_TEXT("vscatterqps") +#define M_VSHUFF32X4 FCML_TEXT("vshuff32x4") +#define M_VSHUFF64X2 FCML_TEXT("vshuff64x2") +#define M_VSHUFI32X4 FCML_TEXT("vshufi32x4") +#define M_VSHUFI64X2 FCML_TEXT("vshufi64x2") +#define M_VSHUFPD FCML_TEXT("vshufpd") +#define M_VSHUFPS FCML_TEXT("vshufps") +#define M_VSQRTPD FCML_TEXT("vsqrtpd") +#define M_VSQRTPS FCML_TEXT("vsqrtps") +#define M_VSQRTSD FCML_TEXT("vsqrtsd") +#define M_VSQRTSS FCML_TEXT("vsqrtss") +#define M_VSTMXCSR FCML_TEXT("vstmxcsr") +#define M_VSUBPD FCML_TEXT("vsubpd") +#define M_VSUBPS FCML_TEXT("vsubps") +#define M_VSUBSD FCML_TEXT("vsubsd") +#define M_VSUBSS FCML_TEXT("vsubss") +#define M_VTESTPD FCML_TEXT("vtestpd") +#define M_VTESTPS FCML_TEXT("vtestps") +#define M_VUCOMISD FCML_TEXT("vucomisd") +#define M_VUCOMISS FCML_TEXT("vucomiss") +#define M_VUNPCKHPD FCML_TEXT("vunpckhpd") +#define M_VUNPCKHPS FCML_TEXT("vunpckhps") +#define M_VUNPCKLPD FCML_TEXT("vunpcklpd") +#define M_VUNPCKLPS FCML_TEXT("vunpcklps") +#define M_VXORPD FCML_TEXT("vxorpd") +#define M_VXORPS FCML_TEXT("vxorps") +#define M_VZEROALL FCML_TEXT("vzeroall") +#define M_VZEROUPPER FCML_TEXT("vzeroupper") +#define M_WAIT FCML_TEXT("wait") +#define M_WBINVD FCML_TEXT("wbinvd") +#define M_WRFSBASE FCML_TEXT("wrfsbase") +#define M_WRGSBASE FCML_TEXT("wrgsbase") +#define M_WRMSR FCML_TEXT("wrmsr") +#define M_XABORT FCML_TEXT("xabort") +#define M_XADD FCML_TEXT("xadd") +#define M_XBEGIN FCML_TEXT("xbegin") +#define M_XCHG FCML_TEXT("xchg") +#define M_XEND FCML_TEXT("xend") +#define M_XGETBV FCML_TEXT("xgetbv") +#define M_XLAT FCML_TEXT("xlat") +#define M_XLATB FCML_TEXT("xlatb") +#define M_XOR FCML_TEXT("xor") +#define M_XORPD FCML_TEXT("xorpd") +#define M_XORPS FCML_TEXT("xorps") +#define M_XRSTOR FCML_TEXT("xrstor") +#define M_XRSTOR64 FCML_TEXT("xrstor64") +#define M_XSAVE FCML_TEXT("xsave") +#define M_XSAVE64 FCML_TEXT("xsave64") +#define M_XSAVEOPT FCML_TEXT("xsaveopt") +#define M_XSAVEOPT64 FCML_TEXT("xsaveopt64") +#define M_XSETBV FCML_TEXT("xsetbv") +#define M_XTEST FCML_TEXT("xtest") + +#endif /* FCML_INTEL_MNEMONICS_H_ */ diff --git a/dependencies/fcml/include/fcml_intel_mnemonics.hpp b/dependencies/fcml/include/fcml_intel_mnemonics.hpp new file mode 100644 index 0000000..c3930e2 --- /dev/null +++ b/dependencies/fcml/include/fcml_intel_mnemonics.hpp @@ -0,0 +1,1724 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_intel_mnemonics.hpp + * Declarations of Intel mnemonics. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_INTEL_MNEMONICS_HPP_ +#define FCML_INTEL_MNEMONICS_HPP_ + +#include "fcml_types.h" + +#include "fcml_intel_mnemonics.hpp" +#include + +namespace fcml { +namespace intel { + +extern const fcml_cstring M_AAA; +extern const fcml_cstring M_AAD; +extern const fcml_cstring M_AAM; +extern const fcml_cstring M_AAS; +extern const fcml_cstring M_ADC; +extern const fcml_cstring M_ADCX; +extern const fcml_cstring M_ADD; +extern const fcml_cstring M_ADDPD; +extern const fcml_cstring M_ADDPS; +extern const fcml_cstring M_ADDSD; +extern const fcml_cstring M_ADDSS; +extern const fcml_cstring M_ADDSUBPD; +extern const fcml_cstring M_ADDSUBPS; +extern const fcml_cstring M_ADOX; +extern const fcml_cstring M_AESDEC; +extern const fcml_cstring M_AESDECLAST; +extern const fcml_cstring M_AESENC; +extern const fcml_cstring M_AESENCLAST; +extern const fcml_cstring M_AESIMC; +extern const fcml_cstring M_AESKEYGENASSIST; +extern const fcml_cstring M_AND; +extern const fcml_cstring M_ANDN; +extern const fcml_cstring M_ANDNPD; +extern const fcml_cstring M_ANDNPS; +extern const fcml_cstring M_ANDPD; +extern const fcml_cstring M_ANDPS; +extern const fcml_cstring M_ARPL; +extern const fcml_cstring M_BEXR; +extern const fcml_cstring M_BEXTR; +extern const fcml_cstring M_BLCFILL; +extern const fcml_cstring M_BLCI; +extern const fcml_cstring M_BLCIC; +extern const fcml_cstring M_BLCMSK; +extern const fcml_cstring M_BLCS; +extern const fcml_cstring M_BLENDPD; +extern const fcml_cstring M_BLENDPS; +extern const fcml_cstring M_BLENDVPD; +extern const fcml_cstring M_BLENDVPS; +extern const fcml_cstring M_BLSFILL; +extern const fcml_cstring M_BLSI; +extern const fcml_cstring M_BLSIC; +extern const fcml_cstring M_BLSMSK; +extern const fcml_cstring M_BLSR; +extern const fcml_cstring M_BOUND; +extern const fcml_cstring M_BSF; +extern const fcml_cstring M_BSR; +extern const fcml_cstring M_BSWAP; +extern const fcml_cstring M_BT; +extern const fcml_cstring M_BTC; +extern const fcml_cstring M_BTR; +extern const fcml_cstring M_BTS; +extern const fcml_cstring M_BZHI; +extern const fcml_cstring M_CALL; +extern const fcml_cstring M_CBW; +extern const fcml_cstring M_CDQ; +extern const fcml_cstring M_CDQE; +extern const fcml_cstring M_CLAC; +extern const fcml_cstring M_CLC; +extern const fcml_cstring M_CLD; +extern const fcml_cstring M_CLFLUSH; +extern const fcml_cstring M_CLGI; +extern const fcml_cstring M_CLI; +extern const fcml_cstring M_CLTS; +extern const fcml_cstring M_CMC; +extern const fcml_cstring M_CMOVA; +extern const fcml_cstring M_CMOVAE; +extern const fcml_cstring M_CMOVB; +extern const fcml_cstring M_CMOVBE; +extern const fcml_cstring M_CMOVC; +extern const fcml_cstring M_CMOVENE; +extern const fcml_cstring M_CMOVG; +extern const fcml_cstring M_CMOVGE; +extern const fcml_cstring M_CMOVL; +extern const fcml_cstring M_CMOVLE; +extern const fcml_cstring M_CMOVNA; +extern const fcml_cstring M_CMOVNAE; +extern const fcml_cstring M_CMOVNB; +extern const fcml_cstring M_CMOVNBE; +extern const fcml_cstring M_CMOVNC; +extern const fcml_cstring M_CMOVNG; +extern const fcml_cstring M_CMOVNGE; +extern const fcml_cstring M_CMOVNL; +extern const fcml_cstring M_CMOVNLE; +extern const fcml_cstring M_CMOVNO; +extern const fcml_cstring M_CMOVNP; +extern const fcml_cstring M_CMOVNS; +extern const fcml_cstring M_CMOVNZ; +extern const fcml_cstring M_CMOVO; +extern const fcml_cstring M_CMOVP; +extern const fcml_cstring M_CMOVPE; +extern const fcml_cstring M_CMOVPO; +extern const fcml_cstring M_CMOVS; +extern const fcml_cstring M_CMOVZ; +extern const fcml_cstring M_CMP; +extern const fcml_cstring M_CMPEQPD; +extern const fcml_cstring M_CMPEQPS; +extern const fcml_cstring M_CMPEQSD; +extern const fcml_cstring M_CMPEQSS; +extern const fcml_cstring M_CMPLEPD; +extern const fcml_cstring M_CMPLEPS; +extern const fcml_cstring M_CMPLESD; +extern const fcml_cstring M_CMPLESS; +extern const fcml_cstring M_CMPLTPD; +extern const fcml_cstring M_CMPLTPS; +extern const fcml_cstring M_CMPLTSD; +extern const fcml_cstring M_CMPLTSS; +extern const fcml_cstring M_CMPNEQPD; +extern const fcml_cstring M_CMPNEQPS; +extern const fcml_cstring M_CMPNEQSD; +extern const fcml_cstring M_CMPNEQSS; +extern const fcml_cstring M_CMPNLEPD; +extern const fcml_cstring M_CMPNLEPS; +extern const fcml_cstring M_CMPNLESD; +extern const fcml_cstring M_CMPNLESS; +extern const fcml_cstring M_CMPNLTPD; +extern const fcml_cstring M_CMPNLTPS; +extern const fcml_cstring M_CMPNLTSD; +extern const fcml_cstring M_CMPNLTSS; +extern const fcml_cstring M_CMPORDPD; +extern const fcml_cstring M_CMPORDPS; +extern const fcml_cstring M_CMPORDSD; +extern const fcml_cstring M_CMPORDSS; +extern const fcml_cstring M_CMPPD; +extern const fcml_cstring M_CMPPS; +extern const fcml_cstring M_CMPS; +extern const fcml_cstring M_CMPSB; +extern const fcml_cstring M_CMPSD; +extern const fcml_cstring M_CMPSQ; +extern const fcml_cstring M_CMPSS; +extern const fcml_cstring M_CMPSW; +extern const fcml_cstring M_CMPUNORDPD; +extern const fcml_cstring M_CMPUNORDPS; +extern const fcml_cstring M_CMPUNORDSD; +extern const fcml_cstring M_CMPUNORDSS; +extern const fcml_cstring M_CMPXCHG; +extern const fcml_cstring M_CMPXCHG16B; +extern const fcml_cstring M_CMPXCHG8B; +extern const fcml_cstring M_COMISD; +extern const fcml_cstring M_COMISS; +extern const fcml_cstring M_CPUID; +extern const fcml_cstring M_CQO; +extern const fcml_cstring M_CRC32; +extern const fcml_cstring M_CVTDQ2PD; +extern const fcml_cstring M_CVTDQ2PS; +extern const fcml_cstring M_CVTPD2DQ; +extern const fcml_cstring M_CVTPD2PI; +extern const fcml_cstring M_CVTPD2PS; +extern const fcml_cstring M_CVTPI2PD; +extern const fcml_cstring M_CVTPI2PS; +extern const fcml_cstring M_CVTPS2DQ; +extern const fcml_cstring M_CVTPS2PD; +extern const fcml_cstring M_CVTPS2PI; +extern const fcml_cstring M_CVTSD2SI; +extern const fcml_cstring M_CVTSD2SS; +extern const fcml_cstring M_CVTSI2SD; +extern const fcml_cstring M_CVTSI2SS; +extern const fcml_cstring M_CVTSS2SD; +extern const fcml_cstring M_CVTSS2SI; +extern const fcml_cstring M_CVTTPD2DQ; +extern const fcml_cstring M_CVTTPD2PI; +extern const fcml_cstring M_CVTTPS2DQ; +extern const fcml_cstring M_CVTTPS2PI; +extern const fcml_cstring M_CVTTSD2SI; +extern const fcml_cstring M_CVTTSS2SI; +extern const fcml_cstring M_CWD; +extern const fcml_cstring M_CWDE; +extern const fcml_cstring M_DAA; +extern const fcml_cstring M_DAS; +extern const fcml_cstring M_DEC; +extern const fcml_cstring M_DIV; +extern const fcml_cstring M_DIVPD; +extern const fcml_cstring M_DIVPS; +extern const fcml_cstring M_DIVSD; +extern const fcml_cstring M_DIVSS; +extern const fcml_cstring M_DPPD; +extern const fcml_cstring M_DPPS; +extern const fcml_cstring M_EMMS; +extern const fcml_cstring M_ENTER; +extern const fcml_cstring M_EXTRACTPS; +extern const fcml_cstring M_EXTRQ; +extern const fcml_cstring M_F2XM1; +extern const fcml_cstring M_FABS; +extern const fcml_cstring M_FADD; +extern const fcml_cstring M_FADDP; +extern const fcml_cstring M_FBLD; +extern const fcml_cstring M_FBSTP; +extern const fcml_cstring M_FCHS; +extern const fcml_cstring M_FCLEX; +extern const fcml_cstring M_FCMOVB; +extern const fcml_cstring M_FCMOVBE; +extern const fcml_cstring M_FCMOVE; +extern const fcml_cstring M_FCMOVNB; +extern const fcml_cstring M_FCMOVNBE; +extern const fcml_cstring M_FCMOVNE; +extern const fcml_cstring M_FCMOVNU; +extern const fcml_cstring M_FCMOVU; +extern const fcml_cstring M_FCOM; +extern const fcml_cstring M_FCOMI; +extern const fcml_cstring M_FCOMIP; +extern const fcml_cstring M_FCOMP; +extern const fcml_cstring M_FCOMPP; +extern const fcml_cstring M_FCOS; +extern const fcml_cstring M_FDECSTP; +extern const fcml_cstring M_FDIV; +extern const fcml_cstring M_FDIVP; +extern const fcml_cstring M_FDIVR; +extern const fcml_cstring M_FDIVRP; +extern const fcml_cstring M_FEMMS; +extern const fcml_cstring M_FFREE; +extern const fcml_cstring M_FIADD; +extern const fcml_cstring M_FICOM; +extern const fcml_cstring M_FICOMP; +extern const fcml_cstring M_FIDIV; +extern const fcml_cstring M_FIDIVR; +extern const fcml_cstring M_FILD; +extern const fcml_cstring M_FIMUL; +extern const fcml_cstring M_FINCSTP; +extern const fcml_cstring M_FINIT; +extern const fcml_cstring M_FIST; +extern const fcml_cstring M_FISTP; +extern const fcml_cstring M_FISTTP; +extern const fcml_cstring M_FISUB; +extern const fcml_cstring M_FISUBR; +extern const fcml_cstring M_FLD; +extern const fcml_cstring M_FLD1; +extern const fcml_cstring M_FLDCW; +extern const fcml_cstring M_FLDENV; +extern const fcml_cstring M_FLDL2E; +extern const fcml_cstring M_FLDL2T; +extern const fcml_cstring M_FLDLG2; +extern const fcml_cstring M_FLDLN2; +extern const fcml_cstring M_FLDPI; +extern const fcml_cstring M_FLDZ; +extern const fcml_cstring M_FMUL; +extern const fcml_cstring M_FMULP; +extern const fcml_cstring M_FNCLEX; +extern const fcml_cstring M_FNINIT; +extern const fcml_cstring M_FNOP; +extern const fcml_cstring M_FNSAVE; +extern const fcml_cstring M_FNSTCW; +extern const fcml_cstring M_FNSTENV; +extern const fcml_cstring M_FNSTSW; +extern const fcml_cstring M_FPATAN; +extern const fcml_cstring M_FPREM; +extern const fcml_cstring M_FPREM1; +extern const fcml_cstring M_FPTAN; +extern const fcml_cstring M_FRNDINT; +extern const fcml_cstring M_FRSTOR; +extern const fcml_cstring M_FSAVE; +extern const fcml_cstring M_FSCALE; +extern const fcml_cstring M_FSIN; +extern const fcml_cstring M_FSINCOS; +extern const fcml_cstring M_FSQRT; +extern const fcml_cstring M_FST; +extern const fcml_cstring M_FSTCW; +extern const fcml_cstring M_FSTENV; +extern const fcml_cstring M_FSTP; +extern const fcml_cstring M_FSTSW; +extern const fcml_cstring M_FSUB; +extern const fcml_cstring M_FSUBP; +extern const fcml_cstring M_FSUBR; +extern const fcml_cstring M_FSUBRP; +extern const fcml_cstring M_FTST; +extern const fcml_cstring M_FUCOM; +extern const fcml_cstring M_FUCOMI; +extern const fcml_cstring M_FUCOMIP; +extern const fcml_cstring M_FUCOMP; +extern const fcml_cstring M_FUCOMPP; +extern const fcml_cstring M_FWAIT; +extern const fcml_cstring M_FXAM; +extern const fcml_cstring M_FXCH; +extern const fcml_cstring M_FXRSTOR; +extern const fcml_cstring M_FXRSTOR64; +extern const fcml_cstring M_FXSAVE; +extern const fcml_cstring M_FXSAVE64; +extern const fcml_cstring M_FXTRACT; +extern const fcml_cstring M_FYL2X; +extern const fcml_cstring M_FYL2XP1; +extern const fcml_cstring M_GETSEC; +extern const fcml_cstring M_HADDPD; +extern const fcml_cstring M_HADDPS; +extern const fcml_cstring M_HLT; +extern const fcml_cstring M_HSUBPD; +extern const fcml_cstring M_HSUBPS; +extern const fcml_cstring M_IDIV; +extern const fcml_cstring M_IMUL; +extern const fcml_cstring M_IN; +extern const fcml_cstring M_INC; +extern const fcml_cstring M_INS; +extern const fcml_cstring M_INSB; +extern const fcml_cstring M_INSD; +extern const fcml_cstring M_INSERTPS; +extern const fcml_cstring M_INSERTQ; +extern const fcml_cstring M_INSW; +extern const fcml_cstring M_INT; +extern const fcml_cstring M_INT3; +extern const fcml_cstring M_INTO; +extern const fcml_cstring M_INVD; +extern const fcml_cstring M_INVEPT; +extern const fcml_cstring M_INVLPG; +extern const fcml_cstring M_INVLPGA; +extern const fcml_cstring M_INVPCID; +extern const fcml_cstring M_INVVPID; +extern const fcml_cstring M_IRET; +extern const fcml_cstring M_IRETD; +extern const fcml_cstring M_IRETQ; +extern const fcml_cstring M_JA; +extern const fcml_cstring M_JAE; +extern const fcml_cstring M_JB; +extern const fcml_cstring M_JBE; +extern const fcml_cstring M_JC; +extern const fcml_cstring M_JCXZ; +extern const fcml_cstring M_JECXZ; +extern const fcml_cstring M_JENE; +extern const fcml_cstring M_JG; +extern const fcml_cstring M_JGE; +extern const fcml_cstring M_JL; +extern const fcml_cstring M_JLE; +extern const fcml_cstring M_JMP; +extern const fcml_cstring M_JNA; +extern const fcml_cstring M_JNAE; +extern const fcml_cstring M_JNB; +extern const fcml_cstring M_JNBE; +extern const fcml_cstring M_JNC; +extern const fcml_cstring M_JNG; +extern const fcml_cstring M_JNGE; +extern const fcml_cstring M_JNL; +extern const fcml_cstring M_JNLE; +extern const fcml_cstring M_JNO; +extern const fcml_cstring M_JNP; +extern const fcml_cstring M_JNS; +extern const fcml_cstring M_JNZ; +extern const fcml_cstring M_JO; +extern const fcml_cstring M_JP; +extern const fcml_cstring M_JPE; +extern const fcml_cstring M_JPO; +extern const fcml_cstring M_JRCXZ; +extern const fcml_cstring M_JS; +extern const fcml_cstring M_JZ; +extern const fcml_cstring M_KADDB; +extern const fcml_cstring M_KADDD; +extern const fcml_cstring M_KADDQ; +extern const fcml_cstring M_KADDW; +extern const fcml_cstring M_KANDB; +extern const fcml_cstring M_KANDD; +extern const fcml_cstring M_KANDNB; +extern const fcml_cstring M_KANDND; +extern const fcml_cstring M_KANDNQ; +extern const fcml_cstring M_KANDNW; +extern const fcml_cstring M_KANDQ; +extern const fcml_cstring M_KANDW; +extern const fcml_cstring M_KMOVB; +extern const fcml_cstring M_KMOVD; +extern const fcml_cstring M_KMOVQ; +extern const fcml_cstring M_KMOVW; +extern const fcml_cstring M_KNOTB; +extern const fcml_cstring M_KNOTD; +extern const fcml_cstring M_KNOTQ; +extern const fcml_cstring M_KNOTW; +extern const fcml_cstring M_KORB; +extern const fcml_cstring M_KORD; +extern const fcml_cstring M_KORQ; +extern const fcml_cstring M_KORTESTB; +extern const fcml_cstring M_KORTESTD; +extern const fcml_cstring M_KORTESTQ; +extern const fcml_cstring M_KORTESTW; +extern const fcml_cstring M_KORW; +extern const fcml_cstring M_KSHIFTLB; +extern const fcml_cstring M_KSHIFTLD; +extern const fcml_cstring M_KSHIFTLQ; +extern const fcml_cstring M_KSHIFTLW; +extern const fcml_cstring M_KSHIFTRB; +extern const fcml_cstring M_KSHIFTRD; +extern const fcml_cstring M_KSHIFTRQ; +extern const fcml_cstring M_KSHIFTRW; +extern const fcml_cstring M_KTESTB; +extern const fcml_cstring M_KTESTD; +extern const fcml_cstring M_KTESTQ; +extern const fcml_cstring M_KTESTW; +extern const fcml_cstring M_KXNORB; +extern const fcml_cstring M_KXNORD; +extern const fcml_cstring M_KXNORQ; +extern const fcml_cstring M_KXNORW; +extern const fcml_cstring M_KXORB; +extern const fcml_cstring M_KXORD; +extern const fcml_cstring M_KXORQ; +extern const fcml_cstring M_KXORW; +extern const fcml_cstring M_LAHF; +extern const fcml_cstring M_LAR; +extern const fcml_cstring M_LDDQU; +extern const fcml_cstring M_LDMXCSR; +extern const fcml_cstring M_LDS; +extern const fcml_cstring M_LEA; +extern const fcml_cstring M_LEAVE; +extern const fcml_cstring M_LES; +extern const fcml_cstring M_LFENCE; +extern const fcml_cstring M_LFS; +extern const fcml_cstring M_LGDT; +extern const fcml_cstring M_LGS; +extern const fcml_cstring M_LIDT; +extern const fcml_cstring M_LLDT; +extern const fcml_cstring M_LLWPCB; +extern const fcml_cstring M_LMSW; +extern const fcml_cstring M_LODS; +extern const fcml_cstring M_LODSB; +extern const fcml_cstring M_LODSD; +extern const fcml_cstring M_LODSQ; +extern const fcml_cstring M_LODSW; +extern const fcml_cstring M_LOOP; +extern const fcml_cstring M_LOOPE; +extern const fcml_cstring M_LOOPNE; +extern const fcml_cstring M_LOOPNZ; +extern const fcml_cstring M_LOOPZ; +extern const fcml_cstring M_LSL; +extern const fcml_cstring M_LSS; +extern const fcml_cstring M_LTR; +extern const fcml_cstring M_LWPINS; +extern const fcml_cstring M_LWPVAL; +extern const fcml_cstring M_LZCNT; +extern const fcml_cstring M_MASKMOVDQU; +extern const fcml_cstring M_MASKMOVQ; +extern const fcml_cstring M_MAXPD; +extern const fcml_cstring M_MAXPS; +extern const fcml_cstring M_MAXSD; +extern const fcml_cstring M_MAXSS; +extern const fcml_cstring M_MFENCE; +extern const fcml_cstring M_MINPD; +extern const fcml_cstring M_MINPS; +extern const fcml_cstring M_MINSD; +extern const fcml_cstring M_MINSS; +extern const fcml_cstring M_MONITOR; +extern const fcml_cstring M_MOV; +extern const fcml_cstring M_MOVAPD; +extern const fcml_cstring M_MOVAPS; +extern const fcml_cstring M_MOVBE; +extern const fcml_cstring M_MOVD; +extern const fcml_cstring M_MOVDDUP; +extern const fcml_cstring M_MOVDQ2Q; +extern const fcml_cstring M_MOVDQA; +extern const fcml_cstring M_MOVDQU; +extern const fcml_cstring M_MOVHLPS; +extern const fcml_cstring M_MOVHPD; +extern const fcml_cstring M_MOVHPS; +extern const fcml_cstring M_MOVLHPS; +extern const fcml_cstring M_MOVLPD; +extern const fcml_cstring M_MOVLPS; +extern const fcml_cstring M_MOVMSKPD; +extern const fcml_cstring M_MOVMSKPS; +extern const fcml_cstring M_MOVNTDQ; +extern const fcml_cstring M_MOVNTDQA; +extern const fcml_cstring M_MOVNTI; +extern const fcml_cstring M_MOVNTPD; +extern const fcml_cstring M_MOVNTPS; +extern const fcml_cstring M_MOVNTQ; +extern const fcml_cstring M_MOVNTSD; +extern const fcml_cstring M_MOVNTSS; +extern const fcml_cstring M_MOVQ; +extern const fcml_cstring M_MOVQ2DQ; +extern const fcml_cstring M_MOVS; +extern const fcml_cstring M_MOVSB; +extern const fcml_cstring M_MOVSD; +extern const fcml_cstring M_MOVSHDUP; +extern const fcml_cstring M_MOVSLDUP; +extern const fcml_cstring M_MOVSQ; +extern const fcml_cstring M_MOVSS; +extern const fcml_cstring M_MOVSW; +extern const fcml_cstring M_MOVSX; +extern const fcml_cstring M_MOVSXD; +extern const fcml_cstring M_MOVUPD; +extern const fcml_cstring M_MOVUPS; +extern const fcml_cstring M_MOVZX; +extern const fcml_cstring M_MPSADBW; +extern const fcml_cstring M_MUL; +extern const fcml_cstring M_MULPD; +extern const fcml_cstring M_MULPS; +extern const fcml_cstring M_MULSD; +extern const fcml_cstring M_MULSS; +extern const fcml_cstring M_MULX; +extern const fcml_cstring M_MWAIT; +extern const fcml_cstring M_NEG; +extern const fcml_cstring M_NOP; +extern const fcml_cstring M_NOT; +extern const fcml_cstring M_OR; +extern const fcml_cstring M_ORPD; +extern const fcml_cstring M_ORPS; +extern const fcml_cstring M_OUT; +extern const fcml_cstring M_OUTS; +extern const fcml_cstring M_OUTSB; +extern const fcml_cstring M_OUTSD; +extern const fcml_cstring M_OUTSW; +extern const fcml_cstring M_PABSB; +extern const fcml_cstring M_PABSD; +extern const fcml_cstring M_PABSW; +extern const fcml_cstring M_PACKSSDW; +extern const fcml_cstring M_PACKSSWB; +extern const fcml_cstring M_PACKUSDW; +extern const fcml_cstring M_PACKUSWB; +extern const fcml_cstring M_PADDB; +extern const fcml_cstring M_PADDD; +extern const fcml_cstring M_PADDQ; +extern const fcml_cstring M_PADDSB; +extern const fcml_cstring M_PADDSW; +extern const fcml_cstring M_PADDUSB; +extern const fcml_cstring M_PADDUSW; +extern const fcml_cstring M_PADDW; +extern const fcml_cstring M_PALIGNR; +extern const fcml_cstring M_PAND; +extern const fcml_cstring M_PANDN; +extern const fcml_cstring M_PAUSE; +extern const fcml_cstring M_PAVGB; +extern const fcml_cstring M_PAVGUSB; +extern const fcml_cstring M_PAVGW; +extern const fcml_cstring M_PBLENDVB; +extern const fcml_cstring M_PBLENDW; +extern const fcml_cstring M_PCLMULQDQ; +extern const fcml_cstring M_PCMPEQB; +extern const fcml_cstring M_PCMPEQD; +extern const fcml_cstring M_PCMPEQQ; +extern const fcml_cstring M_PCMPEQW; +extern const fcml_cstring M_PCMPESTRI; +extern const fcml_cstring M_PCMPESTRM; +extern const fcml_cstring M_PCMPGTB; +extern const fcml_cstring M_PCMPGTD; +extern const fcml_cstring M_PCMPGTQ; +extern const fcml_cstring M_PCMPGTW; +extern const fcml_cstring M_PCMPISTRI; +extern const fcml_cstring M_PCMPISTRM; +extern const fcml_cstring M_PDEP; +extern const fcml_cstring M_PEXT; +extern const fcml_cstring M_PEXTRB; +extern const fcml_cstring M_PEXTRD; +extern const fcml_cstring M_PEXTRQ; +extern const fcml_cstring M_PEXTRW; +extern const fcml_cstring M_PF2ID; +extern const fcml_cstring M_PF2IW; +extern const fcml_cstring M_PFACC; +extern const fcml_cstring M_PFADD; +extern const fcml_cstring M_PFCMPEQ; +extern const fcml_cstring M_PFCMPGE; +extern const fcml_cstring M_PFCMPGT; +extern const fcml_cstring M_PFMAX; +extern const fcml_cstring M_PFMIN; +extern const fcml_cstring M_PFMUL; +extern const fcml_cstring M_PFNACC; +extern const fcml_cstring M_PFPNACC; +extern const fcml_cstring M_PFRCP; +extern const fcml_cstring M_PFRCPIT1; +extern const fcml_cstring M_PFRCPIT2; +extern const fcml_cstring M_PFRSQIT1; +extern const fcml_cstring M_PFRSQRT; +extern const fcml_cstring M_PFSUB; +extern const fcml_cstring M_PFSUBR; +extern const fcml_cstring M_PHADDD; +extern const fcml_cstring M_PHADDSW; +extern const fcml_cstring M_PHADDW; +extern const fcml_cstring M_PHMINPOSUW; +extern const fcml_cstring M_PHSUBD; +extern const fcml_cstring M_PHSUBSW; +extern const fcml_cstring M_PHSUBW; +extern const fcml_cstring M_PI2FD; +extern const fcml_cstring M_PI2FW; +extern const fcml_cstring M_PINSRB; +extern const fcml_cstring M_PINSRD; +extern const fcml_cstring M_PINSRQ; +extern const fcml_cstring M_PINSRW; +extern const fcml_cstring M_PMADDUBSW; +extern const fcml_cstring M_PMADDWD; +extern const fcml_cstring M_PMAXSB; +extern const fcml_cstring M_PMAXSD; +extern const fcml_cstring M_PMAXSW; +extern const fcml_cstring M_PMAXUB; +extern const fcml_cstring M_PMAXUD; +extern const fcml_cstring M_PMAXUW; +extern const fcml_cstring M_PMINSB; +extern const fcml_cstring M_PMINSD; +extern const fcml_cstring M_PMINSW; +extern const fcml_cstring M_PMINUB; +extern const fcml_cstring M_PMINUD; +extern const fcml_cstring M_PMINUW; +extern const fcml_cstring M_PMOVMSKB; +extern const fcml_cstring M_PMOVSXBD; +extern const fcml_cstring M_PMOVSXBQ; +extern const fcml_cstring M_PMOVSXBW; +extern const fcml_cstring M_PMOVSXDQ; +extern const fcml_cstring M_PMOVSXWD; +extern const fcml_cstring M_PMOVSXWQ; +extern const fcml_cstring M_PMOVZXBD; +extern const fcml_cstring M_PMOVZXBQ; +extern const fcml_cstring M_PMOVZXBW; +extern const fcml_cstring M_PMOVZXDQ; +extern const fcml_cstring M_PMOVZXWD; +extern const fcml_cstring M_PMOVZXWQ; +extern const fcml_cstring M_PMULDQ; +extern const fcml_cstring M_PMULHRSW; +extern const fcml_cstring M_PMULHRW; +extern const fcml_cstring M_PMULHUW; +extern const fcml_cstring M_PMULHW; +extern const fcml_cstring M_PMULLD; +extern const fcml_cstring M_PMULLW; +extern const fcml_cstring M_PMULUDQ; +extern const fcml_cstring M_POP; +extern const fcml_cstring M_POPA; +extern const fcml_cstring M_POPAD; +extern const fcml_cstring M_POPCNT; +extern const fcml_cstring M_POPF; +extern const fcml_cstring M_POPFD; +extern const fcml_cstring M_POPFQ; +extern const fcml_cstring M_POR; +extern const fcml_cstring M_PREFETCH; +extern const fcml_cstring M_PREFETCHNTA; +extern const fcml_cstring M_PREFETCHT0; +extern const fcml_cstring M_PREFETCHT1; +extern const fcml_cstring M_PREFETCHT2; +extern const fcml_cstring M_PREFETCHW; +extern const fcml_cstring M_PREFETCHWT1; +extern const fcml_cstring M_PSADBW; +extern const fcml_cstring M_PSHUFB; +extern const fcml_cstring M_PSHUFD; +extern const fcml_cstring M_PSHUFHW; +extern const fcml_cstring M_PSHUFLW; +extern const fcml_cstring M_PSHUFW; +extern const fcml_cstring M_PSIGNB; +extern const fcml_cstring M_PSIGND; +extern const fcml_cstring M_PSIGNW; +extern const fcml_cstring M_PSLLD; +extern const fcml_cstring M_PSLLDQ; +extern const fcml_cstring M_PSLLQ; +extern const fcml_cstring M_PSLLW; +extern const fcml_cstring M_PSRAD; +extern const fcml_cstring M_PSRAW; +extern const fcml_cstring M_PSRLD; +extern const fcml_cstring M_PSRLDQ; +extern const fcml_cstring M_PSRLQ; +extern const fcml_cstring M_PSRLW; +extern const fcml_cstring M_PSUBB; +extern const fcml_cstring M_PSUBD; +extern const fcml_cstring M_PSUBQ; +extern const fcml_cstring M_PSUBSB; +extern const fcml_cstring M_PSUBSW; +extern const fcml_cstring M_PSUBUSB; +extern const fcml_cstring M_PSUBUSW; +extern const fcml_cstring M_PSUBW; +extern const fcml_cstring M_PSWAPD; +extern const fcml_cstring M_PTEST; +extern const fcml_cstring M_PUNPCKHBW; +extern const fcml_cstring M_PUNPCKHDQ; +extern const fcml_cstring M_PUNPCKHQDQ; +extern const fcml_cstring M_PUNPCKHWD; +extern const fcml_cstring M_PUNPCKLBW; +extern const fcml_cstring M_PUNPCKLDQ; +extern const fcml_cstring M_PUNPCKLQDQ; +extern const fcml_cstring M_PUNPCKLWD; +extern const fcml_cstring M_PUSH; +extern const fcml_cstring M_PUSHA; +extern const fcml_cstring M_PUSHAD; +extern const fcml_cstring M_PUSHF; +extern const fcml_cstring M_PUSHFD; +extern const fcml_cstring M_PUSHFQ; +extern const fcml_cstring M_PXOR; +extern const fcml_cstring M_RCL; +extern const fcml_cstring M_RCPPS; +extern const fcml_cstring M_RCPSS; +extern const fcml_cstring M_RCR; +extern const fcml_cstring M_RDFSBASE; +extern const fcml_cstring M_RDGSBASE; +extern const fcml_cstring M_RDMSR; +extern const fcml_cstring M_RDPMC; +extern const fcml_cstring M_RDRAND; +extern const fcml_cstring M_RDSEED; +extern const fcml_cstring M_RDTSC; +extern const fcml_cstring M_RDTSCP; +extern const fcml_cstring M_RET; +extern const fcml_cstring M_RETF; +extern const fcml_cstring M_ROL; +extern const fcml_cstring M_ROR; +extern const fcml_cstring M_RORX; +extern const fcml_cstring M_ROUNDPD; +extern const fcml_cstring M_ROUNDPS; +extern const fcml_cstring M_ROUNDSD; +extern const fcml_cstring M_ROUNDSS; +extern const fcml_cstring M_RSM; +extern const fcml_cstring M_RSQRTPS; +extern const fcml_cstring M_RSQRTSS; +extern const fcml_cstring M_SAHF; +extern const fcml_cstring M_SAL; +extern const fcml_cstring M_SAR; +extern const fcml_cstring M_SARX; +extern const fcml_cstring M_SBB; +extern const fcml_cstring M_SCAS; +extern const fcml_cstring M_SCASB; +extern const fcml_cstring M_SCASD; +extern const fcml_cstring M_SCASQ; +extern const fcml_cstring M_SCASW; +extern const fcml_cstring M_SETA; +extern const fcml_cstring M_SETAE; +extern const fcml_cstring M_SETB; +extern const fcml_cstring M_SETBE; +extern const fcml_cstring M_SETC; +extern const fcml_cstring M_SETENE; +extern const fcml_cstring M_SETG; +extern const fcml_cstring M_SETGE; +extern const fcml_cstring M_SETL; +extern const fcml_cstring M_SETLE; +extern const fcml_cstring M_SETNA; +extern const fcml_cstring M_SETNAE; +extern const fcml_cstring M_SETNB; +extern const fcml_cstring M_SETNBE; +extern const fcml_cstring M_SETNC; +extern const fcml_cstring M_SETNG; +extern const fcml_cstring M_SETNGE; +extern const fcml_cstring M_SETNL; +extern const fcml_cstring M_SETNLE; +extern const fcml_cstring M_SETNO; +extern const fcml_cstring M_SETNP; +extern const fcml_cstring M_SETNS; +extern const fcml_cstring M_SETNZ; +extern const fcml_cstring M_SETO; +extern const fcml_cstring M_SETP; +extern const fcml_cstring M_SETPE; +extern const fcml_cstring M_SETPO; +extern const fcml_cstring M_SETS; +extern const fcml_cstring M_SETZ; +extern const fcml_cstring M_SFENCE; +extern const fcml_cstring M_SGDT; +extern const fcml_cstring M_SHL; +extern const fcml_cstring M_SHLD; +extern const fcml_cstring M_SHLX; +extern const fcml_cstring M_SHR; +extern const fcml_cstring M_SHRD; +extern const fcml_cstring M_SHRX; +extern const fcml_cstring M_SHUFPD; +extern const fcml_cstring M_SHUFPS; +extern const fcml_cstring M_SIDT; +extern const fcml_cstring M_SKINIT; +extern const fcml_cstring M_SLDT; +extern const fcml_cstring M_SLWPCB; +extern const fcml_cstring M_SMSW; +extern const fcml_cstring M_SQRTPD; +extern const fcml_cstring M_SQRTPS; +extern const fcml_cstring M_SQRTSD; +extern const fcml_cstring M_SQRTSS; +extern const fcml_cstring M_STAC; +extern const fcml_cstring M_STC; +extern const fcml_cstring M_STD; +extern const fcml_cstring M_STGI; +extern const fcml_cstring M_STI; +extern const fcml_cstring M_STMXCSR; +extern const fcml_cstring M_STOS; +extern const fcml_cstring M_STOSB; +extern const fcml_cstring M_STOSD; +extern const fcml_cstring M_STOSQ; +extern const fcml_cstring M_STOSW; +extern const fcml_cstring M_STR; +extern const fcml_cstring M_SUB; +extern const fcml_cstring M_SUBPD; +extern const fcml_cstring M_SUBPS; +extern const fcml_cstring M_SUBSD; +extern const fcml_cstring M_SUBSS; +extern const fcml_cstring M_SWAPGS; +extern const fcml_cstring M_SYSCALL; +extern const fcml_cstring M_SYSENTER; +extern const fcml_cstring M_SYSEXIT; +extern const fcml_cstring M_SYSRET; +extern const fcml_cstring M_T1MSKC; +extern const fcml_cstring M_TEST; +extern const fcml_cstring M_TZCNT; +extern const fcml_cstring M_TZMSK; +extern const fcml_cstring M_UCOMISD; +extern const fcml_cstring M_UCOMISS; +extern const fcml_cstring M_UD2; +extern const fcml_cstring M_UNPCKHPD; +extern const fcml_cstring M_UNPCKHPS; +extern const fcml_cstring M_UNPCKLPD; +extern const fcml_cstring M_UNPCKLPS; +extern const fcml_cstring M_V4FMADDPS; +extern const fcml_cstring M_V4FMADDSS; +extern const fcml_cstring M_V4FNMADDPS; +extern const fcml_cstring M_V4FNMADDSS; +extern const fcml_cstring M_VADDPD; +extern const fcml_cstring M_VADDPS; +extern const fcml_cstring M_VADDSD; +extern const fcml_cstring M_VADDSS; +extern const fcml_cstring M_VADDSUBPD; +extern const fcml_cstring M_VADDSUBPS; +extern const fcml_cstring M_VAESDEC; +extern const fcml_cstring M_VAESDECLAST; +extern const fcml_cstring M_VAESENC; +extern const fcml_cstring M_VAESENCLAST; +extern const fcml_cstring M_VAESIMC; +extern const fcml_cstring M_VAESKEYGENASSIST; +extern const fcml_cstring M_VALIGND; +extern const fcml_cstring M_VALIGNQ; +extern const fcml_cstring M_VANDNPD; +extern const fcml_cstring M_VANDNPS; +extern const fcml_cstring M_VANDPD; +extern const fcml_cstring M_VANDPS; +extern const fcml_cstring M_VBLENDMPD; +extern const fcml_cstring M_VBLENDMPS; +extern const fcml_cstring M_VBLENDPD; +extern const fcml_cstring M_VBLENDPS; +extern const fcml_cstring M_VBLENDVPD; +extern const fcml_cstring M_VBLENDVPS; +extern const fcml_cstring M_VBROADCASTF128; +extern const fcml_cstring M_VBROADCASTF32X2; +extern const fcml_cstring M_VBROADCASTF32X4; +extern const fcml_cstring M_VBROADCASTF32X8; +extern const fcml_cstring M_VBROADCASTF64X2; +extern const fcml_cstring M_VBROADCASTF64X4; +extern const fcml_cstring M_VBROADCASTI128; +extern const fcml_cstring M_VBROADCASTI32X2; +extern const fcml_cstring M_VBROADCASTI32X4; +extern const fcml_cstring M_VBROADCASTI32X8; +extern const fcml_cstring M_VBROADCASTI64X2; +extern const fcml_cstring M_VBROADCASTI64X4; +extern const fcml_cstring M_VBROADCASTSD; +extern const fcml_cstring M_VBROADCASTSS; +extern const fcml_cstring M_VCMPEQ_OSPD; +extern const fcml_cstring M_VCMPEQ_OSPS; +extern const fcml_cstring M_VCMPEQ_OSSD; +extern const fcml_cstring M_VCMPEQ_OSSS; +extern const fcml_cstring M_VCMPEQ_UQPD; +extern const fcml_cstring M_VCMPEQ_UQPS; +extern const fcml_cstring M_VCMPEQ_UQSD; +extern const fcml_cstring M_VCMPEQ_UQSS; +extern const fcml_cstring M_VCMPEQ_USPD; +extern const fcml_cstring M_VCMPEQ_USPS; +extern const fcml_cstring M_VCMPEQ_USSD; +extern const fcml_cstring M_VCMPEQ_USSS; +extern const fcml_cstring M_VCMPEQPD; +extern const fcml_cstring M_VCMPEQPS; +extern const fcml_cstring M_VCMPEQSD; +extern const fcml_cstring M_VCMPEQSS; +extern const fcml_cstring M_VCMPFALSE_OSPD; +extern const fcml_cstring M_VCMPFALSE_OSPS; +extern const fcml_cstring M_VCMPFALSE_OSSD; +extern const fcml_cstring M_VCMPFALSE_OSSS; +extern const fcml_cstring M_VCMPFALSEPD; +extern const fcml_cstring M_VCMPFALSEPS; +extern const fcml_cstring M_VCMPFALSESD; +extern const fcml_cstring M_VCMPFALSESS; +extern const fcml_cstring M_VCMPGE_OQPD; +extern const fcml_cstring M_VCMPGE_OQPS; +extern const fcml_cstring M_VCMPGE_OQSD; +extern const fcml_cstring M_VCMPGE_OQSS; +extern const fcml_cstring M_VCMPGEPD; +extern const fcml_cstring M_VCMPGEPS; +extern const fcml_cstring M_VCMPGESD; +extern const fcml_cstring M_VCMPGESS; +extern const fcml_cstring M_VCMPGT_OQPD; +extern const fcml_cstring M_VCMPGT_OQPS; +extern const fcml_cstring M_VCMPGT_OQSD; +extern const fcml_cstring M_VCMPGT_OQSS; +extern const fcml_cstring M_VCMPGTPD; +extern const fcml_cstring M_VCMPGTPS; +extern const fcml_cstring M_VCMPGTSD; +extern const fcml_cstring M_VCMPGTSS; +extern const fcml_cstring M_VCMPLE_OQPD; +extern const fcml_cstring M_VCMPLE_OQPS; +extern const fcml_cstring M_VCMPLE_OQSD; +extern const fcml_cstring M_VCMPLE_OQSS; +extern const fcml_cstring M_VCMPLEPD; +extern const fcml_cstring M_VCMPLEPS; +extern const fcml_cstring M_VCMPLESD; +extern const fcml_cstring M_VCMPLESS; +extern const fcml_cstring M_VCMPLT_OQPD; +extern const fcml_cstring M_VCMPLT_OQPS; +extern const fcml_cstring M_VCMPLT_OQSD; +extern const fcml_cstring M_VCMPLT_OQSS; +extern const fcml_cstring M_VCMPLTPD; +extern const fcml_cstring M_VCMPLTPS; +extern const fcml_cstring M_VCMPLTSD; +extern const fcml_cstring M_VCMPLTSS; +extern const fcml_cstring M_VCMPNEQ_OQPD; +extern const fcml_cstring M_VCMPNEQ_OQPS; +extern const fcml_cstring M_VCMPNEQ_OQSD; +extern const fcml_cstring M_VCMPNEQ_OQSS; +extern const fcml_cstring M_VCMPNEQ_OSPD; +extern const fcml_cstring M_VCMPNEQ_OSPS; +extern const fcml_cstring M_VCMPNEQ_OSSD; +extern const fcml_cstring M_VCMPNEQ_OSSS; +extern const fcml_cstring M_VCMPNEQ_USPD; +extern const fcml_cstring M_VCMPNEQ_USPS; +extern const fcml_cstring M_VCMPNEQ_USSD; +extern const fcml_cstring M_VCMPNEQ_USSS; +extern const fcml_cstring M_VCMPNEQPD; +extern const fcml_cstring M_VCMPNEQPS; +extern const fcml_cstring M_VCMPNEQSD; +extern const fcml_cstring M_VCMPNEQSS; +extern const fcml_cstring M_VCMPNGE_UQPD; +extern const fcml_cstring M_VCMPNGE_UQPS; +extern const fcml_cstring M_VCMPNGE_UQSD; +extern const fcml_cstring M_VCMPNGE_UQSS; +extern const fcml_cstring M_VCMPNGEPD; +extern const fcml_cstring M_VCMPNGEPS; +extern const fcml_cstring M_VCMPNGESD; +extern const fcml_cstring M_VCMPNGESS; +extern const fcml_cstring M_VCMPNGT_UQPD; +extern const fcml_cstring M_VCMPNGT_UQPS; +extern const fcml_cstring M_VCMPNGT_UQSD; +extern const fcml_cstring M_VCMPNGT_UQSS; +extern const fcml_cstring M_VCMPNGTPD; +extern const fcml_cstring M_VCMPNGTPS; +extern const fcml_cstring M_VCMPNGTSD; +extern const fcml_cstring M_VCMPNGTSS; +extern const fcml_cstring M_VCMPNLE_UQPD; +extern const fcml_cstring M_VCMPNLE_UQPS; +extern const fcml_cstring M_VCMPNLE_UQSD; +extern const fcml_cstring M_VCMPNLE_UQSS; +extern const fcml_cstring M_VCMPNLEPD; +extern const fcml_cstring M_VCMPNLEPS; +extern const fcml_cstring M_VCMPNLESD; +extern const fcml_cstring M_VCMPNLESS; +extern const fcml_cstring M_VCMPNLT_UQPD; +extern const fcml_cstring M_VCMPNLT_UQPS; +extern const fcml_cstring M_VCMPNLT_UQSD; +extern const fcml_cstring M_VCMPNLT_UQSS; +extern const fcml_cstring M_VCMPNLTPD; +extern const fcml_cstring M_VCMPNLTPS; +extern const fcml_cstring M_VCMPNLTSD; +extern const fcml_cstring M_VCMPNLTSS; +extern const fcml_cstring M_VCMPORD_SPD; +extern const fcml_cstring M_VCMPORD_SPS; +extern const fcml_cstring M_VCMPORD_SSD; +extern const fcml_cstring M_VCMPORD_SSS; +extern const fcml_cstring M_VCMPORDPD; +extern const fcml_cstring M_VCMPORDPS; +extern const fcml_cstring M_VCMPORDSD; +extern const fcml_cstring M_VCMPORDSS; +extern const fcml_cstring M_VCMPPD; +extern const fcml_cstring M_VCMPPS; +extern const fcml_cstring M_VCMPSD; +extern const fcml_cstring M_VCMPSS; +extern const fcml_cstring M_VCMPTRUE_USPD; +extern const fcml_cstring M_VCMPTRUE_USPS; +extern const fcml_cstring M_VCMPTRUE_USSD; +extern const fcml_cstring M_VCMPTRUE_USSS; +extern const fcml_cstring M_VCMPTRUEPD; +extern const fcml_cstring M_VCMPTRUEPS; +extern const fcml_cstring M_VCMPTRUESD; +extern const fcml_cstring M_VCMPTRUESS; +extern const fcml_cstring M_VCMPUNORD_SPD; +extern const fcml_cstring M_VCMPUNORD_SPS; +extern const fcml_cstring M_VCMPUNORD_SSD; +extern const fcml_cstring M_VCMPUNORD_SSS; +extern const fcml_cstring M_VCMPUNORDPD; +extern const fcml_cstring M_VCMPUNORDPS; +extern const fcml_cstring M_VCMPUNORDSD; +extern const fcml_cstring M_VCMPUNORDSS; +extern const fcml_cstring M_VCOMISD; +extern const fcml_cstring M_VCOMISS; +extern const fcml_cstring M_VCOMPRESSPD; +extern const fcml_cstring M_VCOMPRESSPS; +extern const fcml_cstring M_VCVTDQ2PD; +extern const fcml_cstring M_VCVTDQ2PS; +extern const fcml_cstring M_VCVTPD2DQ; +extern const fcml_cstring M_VCVTPD2PS; +extern const fcml_cstring M_VCVTPD2QQ; +extern const fcml_cstring M_VCVTPD2UDQ; +extern const fcml_cstring M_VCVTPD2UQQ; +extern const fcml_cstring M_VCVTPH2PS; +extern const fcml_cstring M_VCVTPS2DQ; +extern const fcml_cstring M_VCVTPS2PD; +extern const fcml_cstring M_VCVTPS2PH; +extern const fcml_cstring M_VCVTPS2QQ; +extern const fcml_cstring M_VCVTPS2UDQ; +extern const fcml_cstring M_VCVTPS2UQQ; +extern const fcml_cstring M_VCVTQQ2PD; +extern const fcml_cstring M_VCVTQQ2PS; +extern const fcml_cstring M_VCVTSD2SI; +extern const fcml_cstring M_VCVTSD2SS; +extern const fcml_cstring M_VCVTSD2USI; +extern const fcml_cstring M_VCVTSI2SD; +extern const fcml_cstring M_VCVTSI2SS; +extern const fcml_cstring M_VCVTSS2SD; +extern const fcml_cstring M_VCVTSS2SI; +extern const fcml_cstring M_VCVTSS2USI; +extern const fcml_cstring M_VCVTTPD2DQ; +extern const fcml_cstring M_VCVTTPD2QQ; +extern const fcml_cstring M_VCVTTPD2UDQ; +extern const fcml_cstring M_VCVTTPD2UQQ; +extern const fcml_cstring M_VCVTTPS2DQ; +extern const fcml_cstring M_VCVTTPS2QQ; +extern const fcml_cstring M_VCVTTPS2UDQ; +extern const fcml_cstring M_VCVTTPS2UQQ; +extern const fcml_cstring M_VCVTTSD2SI; +extern const fcml_cstring M_VCVTTSD2USI; +extern const fcml_cstring M_VCVTTSS2SI; +extern const fcml_cstring M_VCVTTSS2USI; +extern const fcml_cstring M_VCVTUDQ2PD; +extern const fcml_cstring M_VCVTUDQ2PS; +extern const fcml_cstring M_VCVTUQQ2PD; +extern const fcml_cstring M_VCVTUQQ2PS; +extern const fcml_cstring M_VCVTUSI2SD; +extern const fcml_cstring M_VCVTUSI2SS; +extern const fcml_cstring M_VDBPSADBW; +extern const fcml_cstring M_VDIVPD; +extern const fcml_cstring M_VDIVPS; +extern const fcml_cstring M_VDIVSD; +extern const fcml_cstring M_VDIVSS; +extern const fcml_cstring M_VDPPD; +extern const fcml_cstring M_VDPPS; +extern const fcml_cstring M_VERR; +extern const fcml_cstring M_VERW; +extern const fcml_cstring M_VEXP2PD; +extern const fcml_cstring M_VEXP2PS; +extern const fcml_cstring M_VEXPANDPD; +extern const fcml_cstring M_VEXPANDPS; +extern const fcml_cstring M_VEXTRACTF128; +extern const fcml_cstring M_VEXTRACTF32X4; +extern const fcml_cstring M_VEXTRACTF32X8; +extern const fcml_cstring M_VEXTRACTF64X2; +extern const fcml_cstring M_VEXTRACTF64X4; +extern const fcml_cstring M_VEXTRACTI128; +extern const fcml_cstring M_VEXTRACTI32X4; +extern const fcml_cstring M_VEXTRACTI32X8; +extern const fcml_cstring M_VEXTRACTI64X2; +extern const fcml_cstring M_VEXTRACTI64X4; +extern const fcml_cstring M_VEXTRACTPS; +extern const fcml_cstring M_VFIXUPIMMPD; +extern const fcml_cstring M_VFIXUPIMMPS; +extern const fcml_cstring M_VFIXUPIMMSD; +extern const fcml_cstring M_VFIXUPIMMSS; +extern const fcml_cstring M_VFMADD132PD; +extern const fcml_cstring M_VFMADD132PS; +extern const fcml_cstring M_VFMADD132SD; +extern const fcml_cstring M_VFMADD132SS; +extern const fcml_cstring M_VFMADD213PD; +extern const fcml_cstring M_VFMADD213PS; +extern const fcml_cstring M_VFMADD213SD; +extern const fcml_cstring M_VFMADD213SS; +extern const fcml_cstring M_VFMADD231PD; +extern const fcml_cstring M_VFMADD231PS; +extern const fcml_cstring M_VFMADD231SD; +extern const fcml_cstring M_VFMADD231SS; +extern const fcml_cstring M_VFMADDPD; +extern const fcml_cstring M_VFMADDPS; +extern const fcml_cstring M_VFMADDSD; +extern const fcml_cstring M_VFMADDSS; +extern const fcml_cstring M_VFMADDSUB132PD; +extern const fcml_cstring M_VFMADDSUB132PS; +extern const fcml_cstring M_VFMADDSUB213PD; +extern const fcml_cstring M_VFMADDSUB213PS; +extern const fcml_cstring M_VFMADDSUB231PD; +extern const fcml_cstring M_VFMADDSUB231PS; +extern const fcml_cstring M_VFMADDSUBPD; +extern const fcml_cstring M_VFMADDSUBPS; +extern const fcml_cstring M_VFMSUB132PD; +extern const fcml_cstring M_VFMSUB132PS; +extern const fcml_cstring M_VFMSUB132SD; +extern const fcml_cstring M_VFMSUB132SS; +extern const fcml_cstring M_VFMSUB213PD; +extern const fcml_cstring M_VFMSUB213PS; +extern const fcml_cstring M_VFMSUB213SD; +extern const fcml_cstring M_VFMSUB213SS; +extern const fcml_cstring M_VFMSUB231PD; +extern const fcml_cstring M_VFMSUB231PS; +extern const fcml_cstring M_VFMSUB231SD; +extern const fcml_cstring M_VFMSUB231SS; +extern const fcml_cstring M_VFMSUBADD132PD; +extern const fcml_cstring M_VFMSUBADD132PS; +extern const fcml_cstring M_VFMSUBADD213PD; +extern const fcml_cstring M_VFMSUBADD213PS; +extern const fcml_cstring M_VFMSUBADD231PD; +extern const fcml_cstring M_VFMSUBADD231PS; +extern const fcml_cstring M_VFMSUBADDPD; +extern const fcml_cstring M_VFMSUBADDPS; +extern const fcml_cstring M_VFMSUBPD; +extern const fcml_cstring M_VFMSUBPS; +extern const fcml_cstring M_VFMSUBSD; +extern const fcml_cstring M_VFMSUBSS; +extern const fcml_cstring M_VFNMADD132PD; +extern const fcml_cstring M_VFNMADD132PS; +extern const fcml_cstring M_VFNMADD132SD; +extern const fcml_cstring M_VFNMADD132SS; +extern const fcml_cstring M_VFNMADD213PD; +extern const fcml_cstring M_VFNMADD213PS; +extern const fcml_cstring M_VFNMADD213SD; +extern const fcml_cstring M_VFNMADD213SS; +extern const fcml_cstring M_VFNMADD231PD; +extern const fcml_cstring M_VFNMADD231PS; +extern const fcml_cstring M_VFNMADD231SD; +extern const fcml_cstring M_VFNMADD231SS; +extern const fcml_cstring M_VFNMADDPD; +extern const fcml_cstring M_VFNMADDPS; +extern const fcml_cstring M_VFNMADDSD; +extern const fcml_cstring M_VFNMADDSS; +extern const fcml_cstring M_VFNMSUB132PD; +extern const fcml_cstring M_VFNMSUB132PS; +extern const fcml_cstring M_VFNMSUB132SD; +extern const fcml_cstring M_VFNMSUB132SS; +extern const fcml_cstring M_VFNMSUB213PD; +extern const fcml_cstring M_VFNMSUB213PS; +extern const fcml_cstring M_VFNMSUB213SD; +extern const fcml_cstring M_VFNMSUB213SS; +extern const fcml_cstring M_VFNMSUB231PD; +extern const fcml_cstring M_VFNMSUB231PS; +extern const fcml_cstring M_VFNMSUB231SD; +extern const fcml_cstring M_VFNMSUB231SS; +extern const fcml_cstring M_VFNMSUBPD; +extern const fcml_cstring M_VFNMSUBPS; +extern const fcml_cstring M_VFNMSUBSD; +extern const fcml_cstring M_VFNMSUBSS; +extern const fcml_cstring M_VFPCLASSPD; +extern const fcml_cstring M_VFPCLASSPS; +extern const fcml_cstring M_VFPCLASSSD; +extern const fcml_cstring M_VFPCLASSSS; +extern const fcml_cstring M_VFRCZPD; +extern const fcml_cstring M_VFRCZPS; +extern const fcml_cstring M_VFRCZSD; +extern const fcml_cstring M_VFRCZSS; +extern const fcml_cstring M_VGATHERDPD; +extern const fcml_cstring M_VGATHERDPS; +extern const fcml_cstring M_VGATHERPF0DPD; +extern const fcml_cstring M_VGATHERPF0DPS; +extern const fcml_cstring M_VGATHERPF0QPD; +extern const fcml_cstring M_VGATHERPF0QPS; +extern const fcml_cstring M_VGATHERPF1DPD; +extern const fcml_cstring M_VGATHERPF1DPS; +extern const fcml_cstring M_VGATHERPF1QPD; +extern const fcml_cstring M_VGATHERPF1QPS; +extern const fcml_cstring M_VGATHERQPD; +extern const fcml_cstring M_VGATHERQPS; +extern const fcml_cstring M_VGETEXPPD; +extern const fcml_cstring M_VGETEXPPS; +extern const fcml_cstring M_VGETEXPSD; +extern const fcml_cstring M_VGETEXPSS; +extern const fcml_cstring M_VGETMANTPD; +extern const fcml_cstring M_VGETMANTPS; +extern const fcml_cstring M_VGETMANTSD; +extern const fcml_cstring M_VGETMANTSS; +extern const fcml_cstring M_VHADDPD; +extern const fcml_cstring M_VHADDPS; +extern const fcml_cstring M_VHSUBPD; +extern const fcml_cstring M_VHSUBPS; +extern const fcml_cstring M_VINSERTF128; +extern const fcml_cstring M_VINSERTF32X4; +extern const fcml_cstring M_VINSERTF32X8; +extern const fcml_cstring M_VINSERTF64X2; +extern const fcml_cstring M_VINSERTF64X4; +extern const fcml_cstring M_VINSERTI128; +extern const fcml_cstring M_VINSERTI32X4; +extern const fcml_cstring M_VINSERTI32X8; +extern const fcml_cstring M_VINSERTI64X2; +extern const fcml_cstring M_VINSERTI64X4; +extern const fcml_cstring M_VINSERTPS; +extern const fcml_cstring M_VLDDQU; +extern const fcml_cstring M_VLDMXCSR; +extern const fcml_cstring M_VMASKMOVDQU; +extern const fcml_cstring M_VMASKMOVPD; +extern const fcml_cstring M_VMASKMOVPS; +extern const fcml_cstring M_VMAXPD; +extern const fcml_cstring M_VMAXPS; +extern const fcml_cstring M_VMAXSD; +extern const fcml_cstring M_VMAXSS; +extern const fcml_cstring M_VMCALL; +extern const fcml_cstring M_VMCLEAR; +extern const fcml_cstring M_VMFUNC; +extern const fcml_cstring M_VMINPD; +extern const fcml_cstring M_VMINPS; +extern const fcml_cstring M_VMINSD; +extern const fcml_cstring M_VMINSS; +extern const fcml_cstring M_VMLAUNCH; +extern const fcml_cstring M_VMLOAD; +extern const fcml_cstring M_VMMCALL; +extern const fcml_cstring M_VMOVAPD; +extern const fcml_cstring M_VMOVAPS; +extern const fcml_cstring M_VMOVD; +extern const fcml_cstring M_VMOVDDUP; +extern const fcml_cstring M_VMOVDQA; +extern const fcml_cstring M_VMOVDQA32; +extern const fcml_cstring M_VMOVDQA64; +extern const fcml_cstring M_VMOVDQU; +extern const fcml_cstring M_VMOVDQU16; +extern const fcml_cstring M_VMOVDQU32; +extern const fcml_cstring M_VMOVDQU64; +extern const fcml_cstring M_VMOVDQU8; +extern const fcml_cstring M_VMOVHLPS; +extern const fcml_cstring M_VMOVHPD; +extern const fcml_cstring M_VMOVHPS; +extern const fcml_cstring M_VMOVLHPS; +extern const fcml_cstring M_VMOVLPD; +extern const fcml_cstring M_VMOVLPS; +extern const fcml_cstring M_VMOVMSKPD; +extern const fcml_cstring M_VMOVMSKPS; +extern const fcml_cstring M_VMOVNTDQ; +extern const fcml_cstring M_VMOVNTDQA; +extern const fcml_cstring M_VMOVNTPD; +extern const fcml_cstring M_VMOVNTPS; +extern const fcml_cstring M_VMOVQ; +extern const fcml_cstring M_VMOVSD; +extern const fcml_cstring M_VMOVSHDUP; +extern const fcml_cstring M_VMOVSLDUP; +extern const fcml_cstring M_VMOVSS; +extern const fcml_cstring M_VMOVUPD; +extern const fcml_cstring M_VMOVUPS; +extern const fcml_cstring M_VMPSADBW; +extern const fcml_cstring M_VMPTRLD; +extern const fcml_cstring M_VMPTRST; +extern const fcml_cstring M_VMREAD; +extern const fcml_cstring M_VMRESUME; +extern const fcml_cstring M_VMRUN; +extern const fcml_cstring M_VMSAVE; +extern const fcml_cstring M_VMULPD; +extern const fcml_cstring M_VMULPS; +extern const fcml_cstring M_VMULSD; +extern const fcml_cstring M_VMULSS; +extern const fcml_cstring M_VMWRITE; +extern const fcml_cstring M_VMXOFF; +extern const fcml_cstring M_VMXON; +extern const fcml_cstring M_VORPD; +extern const fcml_cstring M_VORPS; +extern const fcml_cstring M_VP4DPWSSD; +extern const fcml_cstring M_VP4DPWSSDS; +extern const fcml_cstring M_VPABSB; +extern const fcml_cstring M_VPABSD; +extern const fcml_cstring M_VPABSQ; +extern const fcml_cstring M_VPABSW; +extern const fcml_cstring M_VPACKSSDW; +extern const fcml_cstring M_VPACKSSWB; +extern const fcml_cstring M_VPACKUSDW; +extern const fcml_cstring M_VPACKUSWB; +extern const fcml_cstring M_VPADDB; +extern const fcml_cstring M_VPADDD; +extern const fcml_cstring M_VPADDQ; +extern const fcml_cstring M_VPADDSB; +extern const fcml_cstring M_VPADDSW; +extern const fcml_cstring M_VPADDUSB; +extern const fcml_cstring M_VPADDUSW; +extern const fcml_cstring M_VPADDW; +extern const fcml_cstring M_VPALIGNR; +extern const fcml_cstring M_VPAND; +extern const fcml_cstring M_VPANDD; +extern const fcml_cstring M_VPANDN; +extern const fcml_cstring M_VPANDND; +extern const fcml_cstring M_VPANDNQ; +extern const fcml_cstring M_VPANDQ; +extern const fcml_cstring M_VPAVGB; +extern const fcml_cstring M_VPAVGW; +extern const fcml_cstring M_VPBLENDD; +extern const fcml_cstring M_VPBLENDMB; +extern const fcml_cstring M_VPBLENDMD; +extern const fcml_cstring M_VPBLENDMQ; +extern const fcml_cstring M_VPBLENDMW; +extern const fcml_cstring M_VPBLENDVB; +extern const fcml_cstring M_VPBLENDW; +extern const fcml_cstring M_VPBROADCASTB; +extern const fcml_cstring M_VPBROADCASTD; +extern const fcml_cstring M_VPBROADCASTMB2Q; +extern const fcml_cstring M_VPBROADCASTMW2D; +extern const fcml_cstring M_VPBROADCASTQ; +extern const fcml_cstring M_VPBROADCASTW; +extern const fcml_cstring M_VPCLMULQDQ; +extern const fcml_cstring M_VPCMOV; +extern const fcml_cstring M_VPCMPB; +extern const fcml_cstring M_VPCMPD; +extern const fcml_cstring M_VPCMPEQB; +extern const fcml_cstring M_VPCMPEQD; +extern const fcml_cstring M_VPCMPEQQ; +extern const fcml_cstring M_VPCMPEQW; +extern const fcml_cstring M_VPCMPESTRI; +extern const fcml_cstring M_VPCMPESTRM; +extern const fcml_cstring M_VPCMPGTB; +extern const fcml_cstring M_VPCMPGTD; +extern const fcml_cstring M_VPCMPGTQ; +extern const fcml_cstring M_VPCMPGTW; +extern const fcml_cstring M_VPCMPISTRI; +extern const fcml_cstring M_VPCMPISTRM; +extern const fcml_cstring M_VPCMPQ; +extern const fcml_cstring M_VPCMPUB; +extern const fcml_cstring M_VPCMPUD; +extern const fcml_cstring M_VPCMPUQ; +extern const fcml_cstring M_VPCMPUW; +extern const fcml_cstring M_VPCMPW; +extern const fcml_cstring M_VPCOMB; +extern const fcml_cstring M_VPCOMD; +extern const fcml_cstring M_VPCOMEQB; +extern const fcml_cstring M_VPCOMEQD; +extern const fcml_cstring M_VPCOMEQQ; +extern const fcml_cstring M_VPCOMEQUB; +extern const fcml_cstring M_VPCOMEQUD; +extern const fcml_cstring M_VPCOMEQUQ; +extern const fcml_cstring M_VPCOMEQUW; +extern const fcml_cstring M_VPCOMEQW; +extern const fcml_cstring M_VPCOMFALSEB; +extern const fcml_cstring M_VPCOMFALSED; +extern const fcml_cstring M_VPCOMFALSEQ; +extern const fcml_cstring M_VPCOMFALSEUB; +extern const fcml_cstring M_VPCOMFALSEUD; +extern const fcml_cstring M_VPCOMFALSEUQ; +extern const fcml_cstring M_VPCOMFALSEUW; +extern const fcml_cstring M_VPCOMFALSEW; +extern const fcml_cstring M_VPCOMGEB; +extern const fcml_cstring M_VPCOMGED; +extern const fcml_cstring M_VPCOMGEQ; +extern const fcml_cstring M_VPCOMGEUB; +extern const fcml_cstring M_VPCOMGEUD; +extern const fcml_cstring M_VPCOMGEUQ; +extern const fcml_cstring M_VPCOMGEUW; +extern const fcml_cstring M_VPCOMGEW; +extern const fcml_cstring M_VPCOMGTB; +extern const fcml_cstring M_VPCOMGTD; +extern const fcml_cstring M_VPCOMGTQ; +extern const fcml_cstring M_VPCOMGTUB; +extern const fcml_cstring M_VPCOMGTUD; +extern const fcml_cstring M_VPCOMGTUQ; +extern const fcml_cstring M_VPCOMGTUW; +extern const fcml_cstring M_VPCOMGTW; +extern const fcml_cstring M_VPCOMLEB; +extern const fcml_cstring M_VPCOMLED; +extern const fcml_cstring M_VPCOMLEQ; +extern const fcml_cstring M_VPCOMLEUB; +extern const fcml_cstring M_VPCOMLEUD; +extern const fcml_cstring M_VPCOMLEUQ; +extern const fcml_cstring M_VPCOMLEUW; +extern const fcml_cstring M_VPCOMLEW; +extern const fcml_cstring M_VPCOMLTB; +extern const fcml_cstring M_VPCOMLTD; +extern const fcml_cstring M_VPCOMLTQ; +extern const fcml_cstring M_VPCOMLTUB; +extern const fcml_cstring M_VPCOMLTUD; +extern const fcml_cstring M_VPCOMLTUQ; +extern const fcml_cstring M_VPCOMLTUW; +extern const fcml_cstring M_VPCOMLTW; +extern const fcml_cstring M_VPCOMNEQB; +extern const fcml_cstring M_VPCOMNEQD; +extern const fcml_cstring M_VPCOMNEQQ; +extern const fcml_cstring M_VPCOMNEQUB; +extern const fcml_cstring M_VPCOMNEQUD; +extern const fcml_cstring M_VPCOMNEQUQ; +extern const fcml_cstring M_VPCOMNEQUW; +extern const fcml_cstring M_VPCOMNEQW; +extern const fcml_cstring M_VPCOMPRESSD; +extern const fcml_cstring M_VPCOMPRESSQ; +extern const fcml_cstring M_VPCOMQ; +extern const fcml_cstring M_VPCOMTRUEB; +extern const fcml_cstring M_VPCOMTRUED; +extern const fcml_cstring M_VPCOMTRUEQ; +extern const fcml_cstring M_VPCOMTRUEUB; +extern const fcml_cstring M_VPCOMTRUEUD; +extern const fcml_cstring M_VPCOMTRUEUQ; +extern const fcml_cstring M_VPCOMTRUEUW; +extern const fcml_cstring M_VPCOMTRUEW; +extern const fcml_cstring M_VPCOMUB; +extern const fcml_cstring M_VPCOMUD; +extern const fcml_cstring M_VPCOMUQ; +extern const fcml_cstring M_VPCOMUW; +extern const fcml_cstring M_VPCOMW; +extern const fcml_cstring M_VPERM2F128; +extern const fcml_cstring M_VPERM2I128; +extern const fcml_cstring M_VPERMB; +extern const fcml_cstring M_VPERMD; +extern const fcml_cstring M_VPERMI2B; +extern const fcml_cstring M_VPERMI2D; +extern const fcml_cstring M_VPERMI2PD; +extern const fcml_cstring M_VPERMI2PS; +extern const fcml_cstring M_VPERMI2Q; +extern const fcml_cstring M_VPERMI2W; +extern const fcml_cstring M_VPERMIL2PD; +extern const fcml_cstring M_VPERMIL2PS; +extern const fcml_cstring M_VPERMILPD; +extern const fcml_cstring M_VPERMILPS; +extern const fcml_cstring M_VPERMPD; +extern const fcml_cstring M_VPERMPS; +extern const fcml_cstring M_VPERMQ; +extern const fcml_cstring M_VPERMT2B; +extern const fcml_cstring M_VPERMT2D; +extern const fcml_cstring M_VPERMT2PD; +extern const fcml_cstring M_VPERMT2PS; +extern const fcml_cstring M_VPERMT2Q; +extern const fcml_cstring M_VPERMT2W; +extern const fcml_cstring M_VPERMW; +extern const fcml_cstring M_VPEXPANDD; +extern const fcml_cstring M_VPEXPANDQ; +extern const fcml_cstring M_VPEXTRB; +extern const fcml_cstring M_VPEXTRD; +extern const fcml_cstring M_VPEXTRQ; +extern const fcml_cstring M_VPEXTRW; +extern const fcml_cstring M_VPGATHERDD; +extern const fcml_cstring M_VPGATHERDQ; +extern const fcml_cstring M_VPGATHERQD; +extern const fcml_cstring M_VPGATHERQQ; +extern const fcml_cstring M_VPHADDBD; +extern const fcml_cstring M_VPHADDBQ; +extern const fcml_cstring M_VPHADDBW; +extern const fcml_cstring M_VPHADDD; +extern const fcml_cstring M_VPHADDDQ; +extern const fcml_cstring M_VPHADDSW; +extern const fcml_cstring M_VPHADDUBD; +extern const fcml_cstring M_VPHADDUBQ; +extern const fcml_cstring M_VPHADDUBW; +extern const fcml_cstring M_VPHADDUDQ; +extern const fcml_cstring M_VPHADDUWD; +extern const fcml_cstring M_VPHADDUWQ; +extern const fcml_cstring M_VPHADDW; +extern const fcml_cstring M_VPHADDWD; +extern const fcml_cstring M_VPHADDWQ; +extern const fcml_cstring M_VPHMINPOSUW; +extern const fcml_cstring M_VPHSUBBW; +extern const fcml_cstring M_VPHSUBD; +extern const fcml_cstring M_VPHSUBDQ; +extern const fcml_cstring M_VPHSUBSW; +extern const fcml_cstring M_VPHSUBW; +extern const fcml_cstring M_VPHSUBWD; +extern const fcml_cstring M_VPINSRB; +extern const fcml_cstring M_VPINSRD; +extern const fcml_cstring M_VPINSRQ; +extern const fcml_cstring M_VPINSRW; +extern const fcml_cstring M_VPLZCNTD; +extern const fcml_cstring M_VPLZCNTQ; +extern const fcml_cstring M_VPMACSDD; +extern const fcml_cstring M_VPMACSDQH; +extern const fcml_cstring M_VPMACSDQL; +extern const fcml_cstring M_VPMACSSDD; +extern const fcml_cstring M_VPMACSSDQH; +extern const fcml_cstring M_VPMACSSDQL; +extern const fcml_cstring M_VPMACSSWD; +extern const fcml_cstring M_VPMACSSWW; +extern const fcml_cstring M_VPMACSWD; +extern const fcml_cstring M_VPMACSWW; +extern const fcml_cstring M_VPMADCSSWD; +extern const fcml_cstring M_VPMADCSWD; +extern const fcml_cstring M_VPMADD52HUQ; +extern const fcml_cstring M_VPMADD52LUQ; +extern const fcml_cstring M_VPMADDUBSW; +extern const fcml_cstring M_VPMADDWD; +extern const fcml_cstring M_VPMASKMOV; +extern const fcml_cstring M_VPMASKMOVD; +extern const fcml_cstring M_VPMASKMOVQ; +extern const fcml_cstring M_VPMAXSB; +extern const fcml_cstring M_VPMAXSD; +extern const fcml_cstring M_VPMAXSQ; +extern const fcml_cstring M_VPMAXSW; +extern const fcml_cstring M_VPMAXUB; +extern const fcml_cstring M_VPMAXUD; +extern const fcml_cstring M_VPMAXUQ; +extern const fcml_cstring M_VPMAXUW; +extern const fcml_cstring M_VPMINSB; +extern const fcml_cstring M_VPMINSD; +extern const fcml_cstring M_VPMINSQ; +extern const fcml_cstring M_VPMINSW; +extern const fcml_cstring M_VPMINUB; +extern const fcml_cstring M_VPMINUD; +extern const fcml_cstring M_VPMINUQ; +extern const fcml_cstring M_VPMINUW; +extern const fcml_cstring M_VPMOVB2M; +extern const fcml_cstring M_VPMOVD2M; +extern const fcml_cstring M_VPMOVDB; +extern const fcml_cstring M_VPMOVDW; +extern const fcml_cstring M_VPMOVM2B; +extern const fcml_cstring M_VPMOVM2D; +extern const fcml_cstring M_VPMOVM2Q; +extern const fcml_cstring M_VPMOVM2W; +extern const fcml_cstring M_VPMOVMSKB; +extern const fcml_cstring M_VPMOVQ2M; +extern const fcml_cstring M_VPMOVQB; +extern const fcml_cstring M_VPMOVQD; +extern const fcml_cstring M_VPMOVQW; +extern const fcml_cstring M_VPMOVSDB; +extern const fcml_cstring M_VPMOVSDW; +extern const fcml_cstring M_VPMOVSQB; +extern const fcml_cstring M_VPMOVSQD; +extern const fcml_cstring M_VPMOVSQW; +extern const fcml_cstring M_VPMOVSWB; +extern const fcml_cstring M_VPMOVSXBD; +extern const fcml_cstring M_VPMOVSXBQ; +extern const fcml_cstring M_VPMOVSXBW; +extern const fcml_cstring M_VPMOVSXDQ; +extern const fcml_cstring M_VPMOVSXWD; +extern const fcml_cstring M_VPMOVSXWQ; +extern const fcml_cstring M_VPMOVUSDB; +extern const fcml_cstring M_VPMOVUSDW; +extern const fcml_cstring M_VPMOVUSQB; +extern const fcml_cstring M_VPMOVUSQD; +extern const fcml_cstring M_VPMOVUSQW; +extern const fcml_cstring M_VPMOVUSWB; +extern const fcml_cstring M_VPMOVW2M; +extern const fcml_cstring M_VPMOVWB; +extern const fcml_cstring M_VPMOVZXBD; +extern const fcml_cstring M_VPMOVZXBQ; +extern const fcml_cstring M_VPMOVZXBW; +extern const fcml_cstring M_VPMOVZXDQ; +extern const fcml_cstring M_VPMOVZXWD; +extern const fcml_cstring M_VPMOVZXWQ; +extern const fcml_cstring M_VPMULDQ; +extern const fcml_cstring M_VPMULHRSW; +extern const fcml_cstring M_VPMULHUW; +extern const fcml_cstring M_VPMULHW; +extern const fcml_cstring M_VPMULLD; +extern const fcml_cstring M_VPMULLQ; +extern const fcml_cstring M_VPMULLW; +extern const fcml_cstring M_VPMULTISHIFTQB; +extern const fcml_cstring M_VPMULUDQ; +extern const fcml_cstring M_VPOR; +extern const fcml_cstring M_VPORD; +extern const fcml_cstring M_VPORQ; +extern const fcml_cstring M_VPPERM; +extern const fcml_cstring M_VPROLD; +extern const fcml_cstring M_VPROLQ; +extern const fcml_cstring M_VPROLVD; +extern const fcml_cstring M_VPROLVQ; +extern const fcml_cstring M_VPRORD; +extern const fcml_cstring M_VPRORQ; +extern const fcml_cstring M_VPRORVD; +extern const fcml_cstring M_VPRORVQ; +extern const fcml_cstring M_VPROTB; +extern const fcml_cstring M_VPROTD; +extern const fcml_cstring M_VPROTQ; +extern const fcml_cstring M_VPROTW; +extern const fcml_cstring M_VPSADBW; +extern const fcml_cstring M_VPSCATTERDD; +extern const fcml_cstring M_VPSCATTERDQ; +extern const fcml_cstring M_VPSCATTERQD; +extern const fcml_cstring M_VPSCATTERQQ; +extern const fcml_cstring M_VPSHAB; +extern const fcml_cstring M_VPSHAD; +extern const fcml_cstring M_VPSHAQ; +extern const fcml_cstring M_VPSHAW; +extern const fcml_cstring M_VPSHLB; +extern const fcml_cstring M_VPSHLD; +extern const fcml_cstring M_VPSHLQ; +extern const fcml_cstring M_VPSHLW; +extern const fcml_cstring M_VPSHUFB; +extern const fcml_cstring M_VPSHUFD; +extern const fcml_cstring M_VPSHUFHW; +extern const fcml_cstring M_VPSHUFLW; +extern const fcml_cstring M_VPSIGNB; +extern const fcml_cstring M_VPSIGND; +extern const fcml_cstring M_VPSIGNW; +extern const fcml_cstring M_VPSLLD; +extern const fcml_cstring M_VPSLLDQ; +extern const fcml_cstring M_VPSLLQ; +extern const fcml_cstring M_VPSLLVD; +extern const fcml_cstring M_VPSLLVQ; +extern const fcml_cstring M_VPSLLVW; +extern const fcml_cstring M_VPSLLW; +extern const fcml_cstring M_VPSRAD; +extern const fcml_cstring M_VPSRAQ; +extern const fcml_cstring M_VPSRAVD; +extern const fcml_cstring M_VPSRAVQ; +extern const fcml_cstring M_VPSRAVW; +extern const fcml_cstring M_VPSRAW; +extern const fcml_cstring M_VPSRLD; +extern const fcml_cstring M_VPSRLDQ; +extern const fcml_cstring M_VPSRLQ; +extern const fcml_cstring M_VPSRLVD; +extern const fcml_cstring M_VPSRLVQ; +extern const fcml_cstring M_VPSRLVW; +extern const fcml_cstring M_VPSRLW; +extern const fcml_cstring M_VPSUBB; +extern const fcml_cstring M_VPSUBD; +extern const fcml_cstring M_VPSUBQ; +extern const fcml_cstring M_VPSUBSB; +extern const fcml_cstring M_VPSUBSW; +extern const fcml_cstring M_VPSUBUSB; +extern const fcml_cstring M_VPSUBUSW; +extern const fcml_cstring M_VPSUBW; +extern const fcml_cstring M_VPTERNLOGD; +extern const fcml_cstring M_VPTERNLOGQ; +extern const fcml_cstring M_VPTEST; +extern const fcml_cstring M_VPTESTMB; +extern const fcml_cstring M_VPTESTMD; +extern const fcml_cstring M_VPTESTMQ; +extern const fcml_cstring M_VPTESTMW; +extern const fcml_cstring M_VPTESTNMB; +extern const fcml_cstring M_VPTESTNMD; +extern const fcml_cstring M_VPTESTNMQ; +extern const fcml_cstring M_VPTESTNMW; +extern const fcml_cstring M_VPUNPCKHBW; +extern const fcml_cstring M_VPUNPCKHDQ; +extern const fcml_cstring M_VPUNPCKHQDQ; +extern const fcml_cstring M_VPUNPCKHWD; +extern const fcml_cstring M_VPUNPCKLBW; +extern const fcml_cstring M_VPUNPCKLDQ; +extern const fcml_cstring M_VPUNPCKLQDQ; +extern const fcml_cstring M_VPUNPCKLWD; +extern const fcml_cstring M_VPXOR; +extern const fcml_cstring M_VPXORD; +extern const fcml_cstring M_VPXORQ; +extern const fcml_cstring M_VRANGEPD; +extern const fcml_cstring M_VRANGEPS; +extern const fcml_cstring M_VRANGESD; +extern const fcml_cstring M_VRANGESS; +extern const fcml_cstring M_VRCP14PD; +extern const fcml_cstring M_VRCP14PS; +extern const fcml_cstring M_VRCP14SD; +extern const fcml_cstring M_VRCP14SS; +extern const fcml_cstring M_VRCP28PD; +extern const fcml_cstring M_VRCP28PS; +extern const fcml_cstring M_VRCP28SD; +extern const fcml_cstring M_VRCP28SS; +extern const fcml_cstring M_VRCPPS; +extern const fcml_cstring M_VRCPSS; +extern const fcml_cstring M_VREDUCEPD; +extern const fcml_cstring M_VREDUCEPS; +extern const fcml_cstring M_VREDUCESD; +extern const fcml_cstring M_VREDUCESS; +extern const fcml_cstring M_VRNDSCALEPD; +extern const fcml_cstring M_VRNDSCALEPS; +extern const fcml_cstring M_VRNDSCALESD; +extern const fcml_cstring M_VRNDSCALESS; +extern const fcml_cstring M_VROUNDPD; +extern const fcml_cstring M_VROUNDPS; +extern const fcml_cstring M_VROUNDSD; +extern const fcml_cstring M_VROUNDSS; +extern const fcml_cstring M_VRSQRT14PD; +extern const fcml_cstring M_VRSQRT14PS; +extern const fcml_cstring M_VRSQRT14SD; +extern const fcml_cstring M_VRSQRT14SS; +extern const fcml_cstring M_VRSQRT28PD; +extern const fcml_cstring M_VRSQRT28PS; +extern const fcml_cstring M_VRSQRT28SD; +extern const fcml_cstring M_VRSQRT28SS; +extern const fcml_cstring M_VRSQRTPS; +extern const fcml_cstring M_VRSQRTSS; +extern const fcml_cstring M_VSCALEFPD; +extern const fcml_cstring M_VSCALEFPS; +extern const fcml_cstring M_VSCALEFSD; +extern const fcml_cstring M_VSCALEFSS; +extern const fcml_cstring M_VSCATTERDPD; +extern const fcml_cstring M_VSCATTERDPS; +extern const fcml_cstring M_VSCATTERPF0DPD; +extern const fcml_cstring M_VSCATTERPF0DPS; +extern const fcml_cstring M_VSCATTERPF0QPD; +extern const fcml_cstring M_VSCATTERPF0QPS; +extern const fcml_cstring M_VSCATTERPF1DPD; +extern const fcml_cstring M_VSCATTERPF1DPS; +extern const fcml_cstring M_VSCATTERPF1QPD; +extern const fcml_cstring M_VSCATTERPF1QPS; +extern const fcml_cstring M_VSCATTERQPD; +extern const fcml_cstring M_VSCATTERQPS; +extern const fcml_cstring M_VSHUFF32X4; +extern const fcml_cstring M_VSHUFF64X2; +extern const fcml_cstring M_VSHUFI32X4; +extern const fcml_cstring M_VSHUFI64X2; +extern const fcml_cstring M_VSHUFPD; +extern const fcml_cstring M_VSHUFPS; +extern const fcml_cstring M_VSQRTPD; +extern const fcml_cstring M_VSQRTPS; +extern const fcml_cstring M_VSQRTSD; +extern const fcml_cstring M_VSQRTSS; +extern const fcml_cstring M_VSTMXCSR; +extern const fcml_cstring M_VSUBPD; +extern const fcml_cstring M_VSUBPS; +extern const fcml_cstring M_VSUBSD; +extern const fcml_cstring M_VSUBSS; +extern const fcml_cstring M_VTESTPD; +extern const fcml_cstring M_VTESTPS; +extern const fcml_cstring M_VUCOMISD; +extern const fcml_cstring M_VUCOMISS; +extern const fcml_cstring M_VUNPCKHPD; +extern const fcml_cstring M_VUNPCKHPS; +extern const fcml_cstring M_VUNPCKLPD; +extern const fcml_cstring M_VUNPCKLPS; +extern const fcml_cstring M_VXORPD; +extern const fcml_cstring M_VXORPS; +extern const fcml_cstring M_VZEROALL; +extern const fcml_cstring M_VZEROUPPER; +extern const fcml_cstring M_WAIT; +extern const fcml_cstring M_WBINVD; +extern const fcml_cstring M_WRFSBASE; +extern const fcml_cstring M_WRGSBASE; +extern const fcml_cstring M_WRMSR; +extern const fcml_cstring M_XABORT; +extern const fcml_cstring M_XADD; +extern const fcml_cstring M_XBEGIN; +extern const fcml_cstring M_XCHG; +extern const fcml_cstring M_XEND; +extern const fcml_cstring M_XGETBV; +extern const fcml_cstring M_XLAT; +extern const fcml_cstring M_XLATB; +extern const fcml_cstring M_XOR; +extern const fcml_cstring M_XORPD; +extern const fcml_cstring M_XORPS; +extern const fcml_cstring M_XRSTOR; +extern const fcml_cstring M_XRSTOR64; +extern const fcml_cstring M_XSAVE; +extern const fcml_cstring M_XSAVE64; +extern const fcml_cstring M_XSAVEOPT; +extern const fcml_cstring M_XSAVEOPT64; +extern const fcml_cstring M_XSETBV; +extern const fcml_cstring M_XTEST; + +} +} + +#endif /* FCML_INTEL_MNEMONICS_HPP_ */ + diff --git a/dependencies/fcml/include/fcml_lag_assembler.h b/dependencies/fcml/include/fcml_lag_assembler.h new file mode 100644 index 0000000..760347a --- /dev/null +++ b/dependencies/fcml/include/fcml_lag_assembler.h @@ -0,0 +1,121 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_lag_assembler.h + * Experimental multiline load-and-go assembler implementation. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_LAG_ASSEMBLER_H_ +#define FCML_LAG_ASSEMBLER_H_ + +#include "fcml_symbols.h" +#include "fcml_assembler.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Result holder for load-and-go assembler. */ +typedef struct fcml_st_lag_assembler_result { + /** Error and warning messages from one-line assembler. */ + fcml_st_ceh_error_container errors; + /** Number of line where assembler failed. */ + fcml_int error_line; + /** Chain of assembled instructions.*/ + fcml_st_assembled_instruction *instructions; +} fcml_st_lag_assembler_result; + +/** Load-and-go assembler runtime context. */ +typedef struct fcml_st_lag_assembler_context { + /** Assembler instance that should be used to assemble instructions. */ + fcml_st_assembler *assembler; + /** Assembler behavior can be configured here.*/ + fcml_st_assembler_conf configuration; + /** Instruction entry point configuration. */ + fcml_st_entry_point entry_point; + /** Symbols table. */ + fcml_st_symbol_table symbol_table; +} fcml_st_lag_assembler_context; + +/** + * Multipass load-and-go assembler. + * Assembles all instructions given in the NULL terminated source_code + * array of strings. Every instruction has to be represented as one string + * in the source array. Like every multipass assembler implementation it + * passes through the source code multiple times in order to generate optimal + * code. Assembler also supports symbols that can be provided using symbol + * table available in the context. Context should be initialized the same way + * as in case of one line assembler. The only difference here is the symbol + * table itself which can be initialized using fcml_fn_symbol_table_alloc() + * function. Symbols can be also declared directly in the source code and + * accessed through the same symbols table when processing is done (Only if + * you provide valid symbol table through the context). Reusable result holder + * has to be prepared using fcml_fn_lag_assembler_result_prepare() function. + * As long as the context and the result holder are not shared across multiple + * calls function is thread safe. + * + * @param context Assembler context. + * @param source_code NULL terminated array of the instructions. + * @param result Reusable result holder. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @warning This is an experimental implementation and it still needs + * some testing. + * @see fcml_fn_lag_assembler_result_prepare + * @see fcml_fn_symbol_table_alloc + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_lag_assemble( + fcml_st_lag_assembler_context *context, const fcml_string *source_code, + fcml_st_lag_assembler_result *result); + +/** + * Prepares reusable result holder for assembler. + * Every instance of fcml_st_lag_assembler_result structure is reusable from + * the assembler's point of view, so it has to be prepared in the right way in + * order to allow assembler to reuse it correctly. It is up to the library user + * to allocate space for the holder itself. This function is only responsible + * for cleaning the structure correctly and preparing it for first assembling + * process. Notice that assembler has to clean the result holder at the + * beginning so you can not pass an uninitialized memory block because it can + * even cause a crash due to illegal memory access. + * + * @param result Result holder instance to be prepared. + */ +LIB_EXPORT void LIB_CALL fcml_fn_lag_assembler_result_prepare( + fcml_st_lag_assembler_result *result); + +/** + * Cleans result holder. + * Frees all memory blocks allocated by the assembler and held inside the + * result holder (Instructions, errors etc.). Notice that result holder itself + * is not freed and can be even safety reused after call to this function. In + * fact this function is also called internally by assembler in order to clean + * result holder before + * reusing it. + * @param result Result holder to clean. + */ +LIB_EXPORT void LIB_CALL fcml_fn_lag_assembler_result_free( + fcml_st_lag_assembler_result *result); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_LAG_ASSEMBLER_H_ */ diff --git a/dependencies/fcml/include/fcml_lag_assembler.hpp b/dependencies/fcml/include/fcml_lag_assembler.hpp new file mode 100644 index 0000000..62a03fe --- /dev/null +++ b/dependencies/fcml/include/fcml_lag_assembler.hpp @@ -0,0 +1,479 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_lag_assembler.hpp + * C++ wrapper for the Multi-pass FCML assembler. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_LAG_ASSEMBLER_HPP_ +#define FCML_LAG_ASSEMBLER_HPP_ + +#include "fcml_assembler.hpp" +#include "fcml_symbols.hpp" + +#include "fcml_lag_assembler.h" + +namespace fcml { + +/** Assembler result which contains all assembled instructions. */ +class MultiPassAssemblerResult { +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + MultiPassAssemblerResult() { + } + + /** + * Virtual destructor. + * @since 1.1.0 + */ + virtual ~MultiPassAssemblerResult() { + } + +public: + + /** + * Gets error container. + * + * @return Error container. + * @since 1.1.0 + */ + const ErrorContainer& getErrorContainer() const { + return _errorContainer; + } + + /** + * Gets number of assembled instructions. + * @return Number of assembled instructions. + * @since 1.1.0 + */ + fcml_usize getSize() const { + return static_cast(_assembledInstructions.size()); + } + + /** + * Gets one assembled instruction by its index. + * + * @param index The index of the assembled instruction. + * @return One assembled instruction at given index. + * @throw BadArgumentException + * @since 1.1.0 + */ + const AssembledInstruction& operator[](fcml_usize index) const { + if (index > _assembledInstructions.size()) { + throw BadArgumentException(FCML_TEXT("Array index out of bound."), + FCML_CEH_GEC_VALUE_OUT_OF_RANGE); + } + return _assembledInstructions[index]; + } + + /** + * Gets constant vector of all assembled instructions. + * + * @return Assembled instructions. + * @since 1.1.0 + */ + const std::vector& getAssembledInstructions() const { + return _assembledInstructions; + } + + /** + * Gets iterator which allows to iterate through the whole machine code + * byte by byte. + * + * @return Iterator instance. + * @since 1.1.0 + */ + CodeIterator getCodeIterator() { + return CodeIterator(_assembledInstructions); + } + + /** + * Clears the result. Remember not to use the CodeIterator after the + * result is cleared up. + * @since 1.1.0 + */ + void clear() { + _errorContainer.clean(); + _assembledInstructions.clear(); + } + +protected: + + /** Only the assembler can modify these objects. */ + friend class MultiPassAssembler; + + /** + * Gets vector of all assembled instructions. + * + * @return Assembled instructions. + * @since 1.1.0 + */ + std::vector& getAssembledInstructions() { + return _assembledInstructions; + } + + /** + * Sets new error container for the result. + * + * @param errorContainer The new error container to be set. + * @since 1.1.0 + */ + void setErrorContainer(const ErrorContainer &errorContainer) { + _errorContainer = errorContainer; + } + +private: + + /** Errors container. */ + ErrorContainer _errorContainer; + /** Vector of all assembled instructions. */ + std::vector _assembledInstructions; + +}; + +/** Assembler context. + * @since 1.1.0 + */ +class MultiPassAssemblerContext { + +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + MultiPassAssemblerContext() : + _symbolTable( NULL) { + } + + /** + * Creates assembler context for given operating mode and instruction pointer. + * @param operatingMode The operating mode. + * @param ip The instruction pointer. + * @since 1.1.0 + */ + MultiPassAssemblerContext(EntryPoint::OperatingMode operatingMode, + fcml_ip ip = 0) : + _entryPoint(operatingMode, ip), _symbolTable( NULL) { + } + +public: + + /** + * Gets constant reference to assembler configuration. + * + * @return Assembler configuration. + * @since 1.1.0 + */ + const AssemblerConf& getConfig() const { + return _config; + } + + /** + * Gets reference to the assembler configuration. + * + * @return Assembler configuration. + * @since 1.1.0 + */ + AssemblerConf& getConfig() { + return _config; + } + + /** + * Sets a new assembler configuration. + * + * @return Assembler configuration. + * @since 1.1.0 + */ + void setConfig(const AssemblerConf &config) { + _config = config; + } + + /** + * Gets constant reference to the entry point. + * + * @return Entry point. + * @since 1.1.0 + */ + const EntryPoint& getEntryPoint() const { + return _entryPoint; + } + + /** + * Gets reference to the entry point. + * + * @return Entry point. + * @since 1.1.0 + */ + EntryPoint& getEntryPoint() { + return _entryPoint; + } + + /** + * Sets a new entry point. + * + * @param entryPoint Entry point to be set. + * @since 1.1.0 + */ + void setEntryPoint(const EntryPoint &entryPoint) { + _entryPoint = entryPoint; + } + + /** + * Sets a new instruction pointer. + * + * @param ip A new instruction pointer. + * @since 1.1.0 + */ + void setIP(fcml_ip ip) { + _entryPoint.setIP(ip); + } + + /** + * Increments the instruction pointer by given number of bytes. + * + * @param ip The number of bytes the instruction pointer should + * be incremented by. + * @since 1.1.0 + */ + void incrementIP(fcml_ip ip) { + _entryPoint.incrementIP(ip); + } + + /** + * Sets a new processor operating mode for the entry point. + * + * @param operatingMode The new operating mode. + * @since 1.1.0 + */ + void setOperatingMode(EntryPoint::OperatingMode operatingMode) { + _entryPoint.setOpMode(operatingMode); + } + + /** + * Sets a new address size attribute for the entry point. + * + * @param addressSizeAttribute The address size attribute. + * @since 1.1.0 + */ + void setAddressSizeAttribute(fcml_usize addressSizeAttribute) { + _entryPoint.setAddressSizeAttribute(addressSizeAttribute); + } + + /** + * Sets a new operand size attribute for the entry point. + * + * @param operandSizeAttribute The operand size attribute. + * @since 1.1.0 + */ + void setOperandSizeAttribute(fcml_usize operandSizeAttribute) { + _entryPoint.setOperandSizeAttribute(operandSizeAttribute); + } + + /** + * Gets a pointer to the constant symbol table stored in the context. + * + * @return The pointer to the symbol table. + * @since 1.1.0 + */ + const SymbolTable* getSymbolTable() const { + return _symbolTable; + } + + /** + * Gets a pointer to the symbol table stored in the context. + * + * @return The pointer to the symbol table. + * @since 1.1.0 + */ + SymbolTable* getSymbolTable() { + return _symbolTable; + } + + /** + * Sets a new symbol table for the context. + * + * @param symbolTable The new symbol table to be set. + * @since 1.1.0 + */ + void setSymbolTable(SymbolTable *symbolTable) { + _symbolTable = symbolTable; + } + +private: + /** The entry point. */ + EntryPoint _entryPoint; + /** The assembler configuration. */ + AssemblerConf _config; + /** The symbol table assigned to the context. */ + SymbolTable *_symbolTable; +}; + +/** + * An assembler wrapper, as you can see the assembler context is + * managed internally and + * is not exposed outside. + */ +class MultiPassAssembler: public NonCopyable, + protected DialectAware, + protected SymbolTableAware { +public: + + /** + * Creates multi-pass assembler for a dialect. + * @param dialect The dialect for the assembler. + * @throw InitException Cannot initialize the assembler. + * @since 1.1.0 + */ + MultiPassAssembler(Dialect &dialect) : + _dialect(dialect) { + fcml_ceh_error error = ::fcml_fn_assembler_init(extractDialect(dialect), + &_assembler); + if (error) { + throw InitException(FCML_TEXT("Cannot initialize the assembler."), + error); + } + } + + /** + * Virtual destructor. + * @since 1.1.0 + */ + virtual ~MultiPassAssembler() { + if (_assembler) { + ::fcml_fn_assembler_free(_assembler); + _assembler = NULL; + } + } + +public: + + /** + * Assembles given instruction model. + * + * @param ctx Assembler context. + * @param instructions A pointer to the NULL terminated array of + * the instructions. + * @param[out] result Assembler result. + * @throw AssemblingFailedException Assembler failed. + * @return Error code. + * @since 1.1.0 + */ + fcml_ceh_error assemble(MultiPassAssemblerContext &ctx, + const fcml_string *instructions, MultiPassAssemblerResult &result) { + + /* Prepare assembler context. */ + fcml_st_lag_assembler_context context = { 0 }; + + AssemblerTypeConverter::convert(ctx.getConfig(), context.configuration); + TypeConverter::convert(ctx.getEntryPoint(), context.entry_point); + + SymbolTable *symbolTable = ctx.getSymbolTable(); + context.symbol_table = + symbolTable ? extractSymbolTable(*symbolTable) : NULL; + context.assembler = _assembler; + + /* Prepare assembler result. */ + fcml_st_lag_assembler_result res; + ::fcml_fn_lag_assembler_result_prepare(&res); + + fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR; + + try { + + result.clear(); + + error = ::fcml_fn_lag_assemble(&context, instructions, &res); + + /* Failed or not, convert assembler errors. */ + + ErrorContainer errorContainer; + ErrorTypeConverter::convert(res.errors, errorContainer); + + /* Prepares assembler result. */ + + result.setErrorContainer(errorContainer); + + if (error && ctx.getConfig().isThrowExceptionOnError()) { + ::fcml_fn_lag_assembler_result_free(&res); + throw AssemblingFailedException( + errorContainer.prepareErrorMessage( + FCML_TEXT("Assembling failed")), errorContainer, + error); + } + + if (!error) { + + std::vector &assembledInstructions = + result.getAssembledInstructions(); + + assembledInstructions.clear(); + + ErrorContainer instructionWarnings; + fcml_st_assembled_instruction *next_instruction = + res.instructions; + while (next_instruction) { + fcml_st_ceh_error_container &instruction_warnings = + next_instruction->warnings; + ErrorTypeConverter::convert(instruction_warnings, + instructionWarnings); + const AssembledInstruction assembledInstruction( + next_instruction->code, + next_instruction->code_length, instructionWarnings); + assembledInstructions.push_back(assembledInstruction); + next_instruction = next_instruction->next; + } + + // Convert it back to the context because it might have been + // modified during assembling process (IP incrementation etc). + TypeConverter::convert(context.entry_point, + ctx.getEntryPoint()); + + } + + ::fcml_fn_lag_assembler_result_free(&res); + + } catch (std::exception &exc) { + // If anything failed, free assembler results. + ::fcml_fn_lag_assembler_result_free(&res); + throw exc; + } + + return error; + } + +private: + + // The dialect used by the assembler. + Dialect &_dialect; + // The initialized assembler instance used by the wrapper. + fcml_st_assembler *_assembler; + +}; + +} + +#endif /* FCML_LAG_ASSEMBLER_HPP_ */ diff --git a/dependencies/fcml/include/fcml_lib_export.h b/dependencies/fcml/include/fcml_lib_export.h new file mode 100644 index 0000000..3390cda --- /dev/null +++ b/dependencies/fcml/include/fcml_lib_export.h @@ -0,0 +1,63 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_lib_export.h + * Handles Win32 DLL symbols importing/exporting. + * The only interesting thing here is the LIBFCML_DLL_IMPORT symbol which has to + * be always defined in order to use dynamic DLL under Windows. You can achieve it + * by declaring the symbol before this header file is included. For example: + * @code + * #define LIBFCML_DLL_IMPORT + * #include + * @endcode + * Take into account that this header file is included by every FCML public header, so + * in fact you should define the symbol before including anything from the FCML library. + * This declaration can be omitted as long as you use undecorated symbol names. + * + * @copyright Copyright (C) 2010-2019 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_LIB_EXPORT_H_ +#define FCML_LIB_EXPORT_H_ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#if _WIN32 || __CYGWIN__ +#define LIB_CALL __stdcall +#ifdef DLL_EXPORT +#define LIB_EXPORT __declspec(dllexport) +#else +#ifdef LIBFCML_DLL_IMPORT +#define LIB_EXPORT __declspec(dllimport) +#endif +#endif +#endif + +#ifndef LIB_EXPORT +#define LIB_EXPORT +#endif + +#ifndef LIB_CALL +#define LIB_CALL +#endif + +#endif /* FCML_LIB_EXPORT_H_ */ diff --git a/dependencies/fcml/include/fcml_optimizers.h b/dependencies/fcml/include/fcml_optimizers.h new file mode 100644 index 0000000..9c3dbfd --- /dev/null +++ b/dependencies/fcml/include/fcml_optimizers.h @@ -0,0 +1,144 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_optimizers.h + * API for assembler optimizers. For more details about optimizers see + * FCML manual. + * + * @copyright Copyright (C) 2010-2020 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ +#ifndef FCML_OPTIMIZERS_H_ +#define FCML_OPTIMIZERS_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" +#include "fcml_errors.h" +#include "fcml_common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Optimizer context used as a connector with the environment. */ +typedef struct fcml_st_asm_optimizer_context { + /** Optimizer flags passed through the assembler context. + * @see fcml_st_assembler_conf + */ + fcml_uint16_t optimizer_flags; + /** Processor operating mode 16/32/64-bit. */ + fcml_en_operating_mode op_mode; + /** Default address size attribute not modified by prefixes yet. + * (See 'D' flag of segment descriptor.) + */ + fcml_usize asa; + /** Default operand size attribute not modified by prefixes yet. + * (See 'D' flag of segment descriptor.) + */ + fcml_usize osa; +} fcml_st_asm_optimizer_context; + +/** Processing details for optimizers. */ +typedef struct fcml_st_asm_optimizer_processing_details { + /** Allowed values of the operand size attribute calculated by the + * assembler engine. + * It is the optimizer who decides which one should be finally used. + */ + fcml_st_nullable_size_flags allowed_eosa; + /** Allowed values of the address size attribute calculated by the + * assembler engine. + * It is optimizer who decides which one should be finally used. + */ + fcml_st_nullable_size_flags allowed_easa; + /** Effective address size attribute chosen for currently processed + * instruction form. + * If it is set it can not be changed anymore. It has + * higher priority than flags above. Take into account that it is + * effective attribute size attribute so it can be forced using instruction + * prefixes to override the default attribute size. + */ + fcml_usize easa; + /** Effective operand size attribute chosen for currently processed + * instruction form. + * If it is set it can not be changed anymore. It has higher priority than + * flags above. Take into account that it is effective operand size + * attribute so it can be forced using instruction prefixes to override + * the default attribute size. + */ + fcml_usize eosa; + /** Vector length of AVX instructions. Set to FCML_DS_UNDEF if not used. */ + fcml_usize vector_length; + /** Set to true in order to break optimization process immediately. */ + fcml_bool break_optimization; +} fcml_st_asm_optimizer_processing_details; + +/** + * Callback used to invoke encoding process for given processing details + * configuration. + * @param args Arguments from optimizer. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + */ +typedef fcml_ceh_error (*fcml_fnp_asm_optimizer_callback)(fcml_ptr args); + +/** + * Function pointer declaration for optimizers. + * @param context Optimizer context. + * @param ds_flags Current instruction processing details. + * @param callback Callback used to continue processing for configuration + * prepared by optimizer. + * @param args Arguments that should be passed to the callback. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + */ +typedef fcml_ceh_error (LIB_CALL *fcml_fnp_asm_optimizer)( + fcml_st_asm_optimizer_context *context, + fcml_st_asm_optimizer_processing_details *ds_flags, + fcml_fnp_asm_optimizer_callback callback, fcml_ptr args); + +/* Optimizers flags that can be used to configure optimization process. */ +#define FCML_OPTF_ASA_16 0x01 +#define FCML_OPTF_ASA_32 0x02 +#define FCML_OPTF_ASA_64 0x03 +#define FCML_OPTF_OSA_16 0x10 +#define FCML_OPTF_OSA_32 0x20 +#define FCML_OPTF_OSA_64 0x30 +/* Do not choose the optimal form, but return all possibilities. */ +#define FCML_OPTF_ALL_FORMS 0xFF + +/** + * Default optimizer implementation. + * This implementation chooses the best combination of attributes for + * current processor operating mode. + * @param context Optimizer context. + * @param ds_flags Current instruction processing details. + * @param callback Callback used to continue processing for configuration + * prepared by optimizer. + * @param callback_args Arguments that should be passed to the callback. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_asm_default_optimizer( + fcml_st_asm_optimizer_context *context, + fcml_st_asm_optimizer_processing_details *ds_flags, + fcml_fnp_asm_optimizer_callback callback, fcml_ptr callback_args); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_OPTIMIZERS_H_ */ diff --git a/dependencies/fcml/include/fcml_parser.h b/dependencies/fcml/include/fcml_parser.h new file mode 100644 index 0000000..450a966 --- /dev/null +++ b/dependencies/fcml/include/fcml_parser.h @@ -0,0 +1,166 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_parser.h + * Structures and functions declarations related to FCML parsers + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_PARSER_H_ +#define FCML_PARSER_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" +#include "fcml_errors.h" +#include "fcml_common.h" +#include "fcml_dialect.h" +#include "fcml_symbols.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Maximal number of character for parsed instruction. */ +#define FCML_PARSER_MAX_INSTRUCTION_LEN 1024 + +/** Parser configuration. */ +typedef struct fcml_st_parser_config { + /** Set to true in order to ignore all undefined symbols. + * In such a case every unknown symbol is treated as 0. + */ + fcml_bool ignore_undefined_symbols; + /** Disables symbols support. + * It set to true every defined label will cause an error. + */ + fcml_bool disable_symbols_declaration; + /** Set to true in order to allow overriding existing labels. + * If set to false parser returns "Symbol already exists" error when + * symbol already exists. + */ + fcml_bool override_labels; + /** By default parser ignores all symbol declarations + * if there is no symbol table provided in the parser + * context. By setting this value to true you can force + * the parser to allocate new symbol table when needed. + * Remember that you are then responsible for freeing it, + * so this functionality can be a bit dangerous because + * you have to check the existence of the symbol table + * every time it should be deallocated. + */ + fcml_bool alloc_symbol_table_if_needed; + // TODO: Support has to be implemented yet. + /** Enables textual error messages. */ + fcml_bool enable_error_messages; +} fcml_st_parser_config; + +/** Parser runtime context. */ +typedef struct fcml_st_parser_context { + /** Dialect to be used by parser. Defines supported instructions syntax. */ + fcml_st_dialect *dialect; + /** Parser configuration. */ + fcml_st_parser_config configuration; + /** Instruction pointer. RIP/EIP register value used as a value for + * newly declared symbols. + * This value is never changed by the parser. + */ + fcml_ip ip; + /** Symbol table. It holds symbols added by the user as + * well as symbols allocated by the parsers (labels). It is + * very important to free this container on your own + * because even if it is not allocated by the user it can be + * set by the parser when the first symbol definition is found. + * So the most safe way to manage it is to always use + * "fcml_fn_symbol_table_free" function as soon as context + * if going to be freed. + */ + fcml_st_symbol_table symbol_table; +} fcml_st_parser_context; + +/** Reusable result holder */ +typedef struct fcml_st_parser_result { + /** Parsing errors and warnings going here. */ + fcml_st_ceh_error_container errors; + /** Defined symbol if there is any. + * Remember that this symbol is also stored in the context's symbol table. + * It is the symbol table that is the owner and that is responsible + * for freeing it. + */ + fcml_st_symbol *symbol; + /** Parsed instruction as generic instruction model. */ + fcml_st_instruction *instruction; +} fcml_st_parser_result; + +/** + * Parses given instruction into the generic instruction model. + * Parses the textual representation of the instruction using dialect and + * configuration provided by the parser context. Parsed instruction is returned in the + * reusable result holder. Result holder has to be allocated by the + * user and appropriately prepared using fcml_fn_parser_result_prepare() + * function. As long as the instruction context and the result holder + * are not shared across multiple function calls parsing process is + * thread safe. + * + * Remember that textual representation of the instruction has to be written + * using syntax supported by the dialect parser is going to use. + * + * @param context Parser runtime context. + * @param instruction textual representation of the instruction to be parsed. + * @param result Reusable result holder. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_parse( + fcml_st_parser_context *context, const fcml_string instruction, + fcml_st_parser_result *result); + +/** + * Prepares reusable result holder for parser. + * Every instance of fcml_st_parser_result structure is reusable from the + * parser's point of view, so it has to be prepared in the right way in order + * to allow parser to reuse it correctly. It is up to the library user to + * allocate space for the holder itself. This function is only responsible + * for cleaning the structure correctly and preparing it for the first parsing + * process. Notice that parser has to clean the result holder at the beginning + * so you can not pass an uninitialized memory block because it can even cause + * a crash due to illegal memory access. + * + * @param result Result holder instance to be prepared. + */ +LIB_EXPORT void LIB_CALL fcml_fn_parser_result_prepare( + fcml_st_parser_result *result); + +/** + * Cleans result holder. + * Frees all memory blocks allocated by the parser and held inside the result + * holder (Instructions, errors etc.). Notice that result holder itself is + * not freed and can be even safety reused after call to this function. In fact + * this function is also called internally by the parser in order to clean + * result holder before reusing it. + * @param result Result holder to clean. + */ +LIB_EXPORT void LIB_CALL fcml_fn_parser_result_free( + fcml_st_parser_result *result); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_PARSER_H_ */ diff --git a/dependencies/fcml/include/fcml_parser.hpp b/dependencies/fcml/include/fcml_parser.hpp new file mode 100644 index 0000000..f8d8e15 --- /dev/null +++ b/dependencies/fcml/include/fcml_parser.hpp @@ -0,0 +1,486 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_parser.hpp + * C++ wrapper for instruction parser. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_PARSER_HPP_ +#define FCML_PARSER_HPP_ + +#include "fcml_common.hpp" +#include "fcml_symbols.hpp" +#include "fcml_errors.hpp" +#include "fcml_dialect.hpp" + +#include "fcml_parser.h" + +namespace fcml { + +/** + * Something failed while parsing. + * @since 1.1.0 + */ +class ParsingFailedException: public ErrorContainerAwareException { +public: + ParsingFailedException(const fcml_cstring msg, + ErrorContainer &errorContainer, + fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR) : + ErrorContainerAwareException(msg, errorContainer, error) { + } +}; + +/** Parser configuration. + * @since 1.1.0 + */ +class ParserConfig { +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + ParserConfig() : + _throwExceptionOnError(true), + _ignoreUndefinedSymbols(false), + _disableSymbolsDeclaration(true), + _overrideLabels(false), + _allocSymbolTableIfNeeded(false), + _enableErrorMessages(true) { + } + + /** @since 1.1.0 */ + bool isAllocSymbolTableIfNeeded() const { + return _allocSymbolTableIfNeeded; + } + + /** @since 1.1.0 */ + void setAllocSymbolTableIfNeeded(bool allocSymbolTableIfNeeded) { + _allocSymbolTableIfNeeded = allocSymbolTableIfNeeded; + } + + /** @since 1.1.0 */ + bool isDisableSymbolsDeclaration() const { + return _disableSymbolsDeclaration; + } + + /** @since 1.1.0 */ + void setDisableSymbolsDeclaration(bool disableSymbolsDeclaration) { + _disableSymbolsDeclaration = disableSymbolsDeclaration; + } + + /** @since 1.1.0 */ + bool isEnableErrorMessages() const { + return _enableErrorMessages; + } + + /** @since 1.1.0 */ + void setEnableErrorMessages(bool enableErrorMessages) { + _enableErrorMessages = enableErrorMessages; + } + + /** @since 1.1.0 */ + bool isIgnoreUndefinedSymbols() const { + return _ignoreUndefinedSymbols; + } + + /** @since 1.1.0 */ + void setIgnoreUndefinedSymbols(bool ignoreUndefinedSymbols) { + _ignoreUndefinedSymbols = ignoreUndefinedSymbols; + } + + /** @since 1.1.0 */ + bool isOverrideLabels() const { + return _overrideLabels; + } + + /** @since 1.1.0 */ + void setOverrideLabels(bool overrideLabels) { + _overrideLabels = overrideLabels; + } + + /** + * Gets true if exception should be thrown in case of error. + * @return True if exception should be thrown in case of error. + * @since 1.1.0 + */ + bool isThrowExceptionOnError() const { + return _throwExceptionOnError; + } + + /** + * Sets exception on error flag. Has to be set to true if exception + * should be thrown in case of error. + * @param throwExceptionOnError True if exception should be thrown + * in case of error. + * @since 1.1.0 + */ + void setThrowExceptionOnError(bool throwExceptionOnError) { + _throwExceptionOnError = throwExceptionOnError; + } + +private: + bool _throwExceptionOnError; + bool _ignoreUndefinedSymbols; + bool _disableSymbolsDeclaration; + bool _overrideLabels; + bool _allocSymbolTableIfNeeded; + bool _enableErrorMessages; +}; + +/** Parser context. + * @since 1.1.0 + */ +class ParserContext { +public: + + /** + * Creates a parser context instance for optional instruction pointer. + * + * @param ip The instruction pointer. + * @since 1.1.0 + */ + ParserContext(fcml_ip ip = 0) : + _ip(ip), _symbolTable(NULL) { + } + + /** + * Creates a parser context for given symbol table and optional + * instruction pointer. + * + * @param symbolTable The symbol table. + * @param ip The instruction pointer. + * @since 1.1.0 + */ + ParserContext(SymbolTable *symbolTable, fcml_ip ip = 0) : + _ip(ip), _symbolTable(symbolTable) { + } + +public: + + /** + * Gets the parser configuration associated with the context. + * + * @return The parser configuration associated with the context. + * @since 1.1.0 + */ + const ParserConfig& getConfig() const { + return _config; + } + + /** + * Gets the parser configuration associated with the context. + * + * @return The parser configuration associated with the context. + * @since 1.1.0 + */ + ParserConfig& getConfig() { + return _config; + } + + /** + * Gets the instruction pointer. + * + * @return The instruction pointer. + * @since 1.1.0 + */ + fcml_ip getIp() const { + return _ip; + } + + /** + * Gets a new instruction pointer. + * + * @param ip The new instruction pointer. + * @since 1.1.0 + */ + void setIp(fcml_ip ip) { + _ip = ip; + } + + /** + * Increments instruction pointer by given number of bytes. + * + * @param ip The number of bytes the instruction pointer has + * to be incremented by. + * @since 1.1.0 + */ + void incrementIP(fcml_ip ip) { + _ip += ip; + } + + /** + * Gets the symbol table associated with the context. + * + * @return The symbol table. + * @since 1.1.0 + */ + const SymbolTable* getSymbolTable() const { + return _symbolTable; + } + + /** + * Gets the symbol table associated with the context. + * + * @return The symbol table. + * @since 1.1.0 + */ + SymbolTable* getSymbolTable() { + return _symbolTable; + } + + /** + * Sets a symbol table for the instruction. + * + * @param symbolTable The symbol table for the parser context. + * @since 1.1.0 + */ + void setSymbolTable(SymbolTable *symbolTable) { + _symbolTable = symbolTable; + } + +private: + + /** The instruction pointer used by declared labels. */ + fcml_ip _ip; + /** The parser configuration. */ + ParserConfig _config; + /** The symbol table. */ + SymbolTable *_symbolTable; + +}; + +/** Parser result. + * @since 1.1.0 + */ +class ParserResult { +public: + + /** + * Creates an empty parser result. + * @since 1.1.0 + */ + ParserResult() { + } + + /** + * Gets errors container with parsing errors. + * + * @return Errors container. + * @since 1.1.0 + */ + const ErrorContainer& getErrors() const { + return _errors; + } + + /** + * Gets the parsed instruction. + * + * @return The parsed instruction. + * @since 1.1.0 + */ + const Instruction& getInstruction() const { + return _instruction; + } + + /** + * Gets declared symbol is there is any. + * @return Gets symbol if there is any. + * @since 1.1.0 + */ + const Nullable& getSymbol() const { + return _symbol; + } + + /** + * Cleans the parser result. + * @since 1.1.0 + */ + void clean() { + _errors.clean(); + _symbol.setNotNull(false); + _symbol.setValue(Symbol()); + } + +protected: + + friend class Parser; + + /** + * Sets error container for the context. + * @param errors A new error container. + * @since 1.1.0 + */ + void setErrors(const ErrorContainer &errors) { + _errors = errors; + } + + /** + * Sets an instruction for the container. + * @param instruction The instruction. + * @since 1.1.0 + */ + void setInstruction(const Instruction &instruction) { + _instruction = instruction; + } + + /** + * Sets symbol. + * @param symbol The symbol. + * @since 1.1.0 + */ + void setSymbol(const Nullable &symbol) { + _symbol = symbol; + } + +private: + + /** Errors container. */ + ErrorContainer _errors; + /** Gets declared symbol. Take into account that it can be 'empty'. */ + Nullable _symbol; + /** The parsed instruction. */ + Instruction _instruction; + +}; + +/** + * Converts objects to their structures counterparts. + * @since 1.1.0 + * @remarks Internal API, not intended to be used outside. + */ +class ParserTypeConverter { +public: + + static void convert(ParserConfig &src, fcml_st_parser_config &dest) { + dest.alloc_symbol_table_if_needed = src.isAllocSymbolTableIfNeeded(); + dest.disable_symbols_declaration = src.isDisableSymbolsDeclaration(); + dest.enable_error_messages = src.isEnableErrorMessages(); + dest.ignore_undefined_symbols = src.isIgnoreUndefinedSymbols(); + dest.override_labels = src.isOverrideLabels(); + } + +}; + +/** Parser wrapper. + * @since 1.1.0 + */ +class Parser: protected DialectAware, protected SymbolTableAware { +public: + + /** + * Creates a parser instance for the given dialect. + * + * @param dialect The dialect instance. + * @since 1.1.0 + */ + Parser(const Dialect &dialect) : + _dialect(dialect) { + } + + /** + * Parses instruction given in the parameters. + * + * @param ctx Parser context. + * @param instruction Instruction mnemonic. + * @param[out] parserResult Instruction result. + * @return Error code. + * @throw ParsingFailedException Parsing failed. + * @since 1.1.0 + */ + fcml_ceh_error parse(ParserContext &ctx, const fcml_cstring &instruction, + ParserResult &parserResult) { + + // Prepare parser context. + fcml_st_parser_context context = { 0 }; + ParserTypeConverter::convert(ctx.getConfig(), context.configuration); + context.ip = ctx.getIp(); + SymbolTable *symbolTable = ctx.getSymbolTable(); + context.symbol_table = + (symbolTable) ? extractSymbolTable(*symbolTable) : NULL; + context.dialect = extractDialect(_dialect); + + fcml_st_parser_result parser_result; + ::fcml_fn_parser_result_prepare(&parser_result); + + try { + + parserResult.clean(); + + // Prepare instruction. + fcml_ceh_error error = ::fcml_fn_parse(&context, + instruction.c_str(), &parser_result); + + ErrorContainer errorContainer; + ErrorTypeConverter::convert(parser_result.errors, errorContainer); + + parserResult.setErrors(errorContainer); + + if (!error && !parser_result.instruction) { + // Just in case, it should never happen. + error = FCML_CEH_GEC_INTERNAL_ERROR; + } + + if (error && ctx.getConfig().isThrowExceptionOnError()) { + ::fcml_fn_parser_result_free(&parser_result); + throw ParsingFailedException( + errorContainer.prepareErrorMessage( + FCML_TEXT("Parsing failed")), errorContainer, + error); + } + + if (!error) { + + Instruction parsedInstruction; + TypeConverter::convert(*(parser_result.instruction), + parsedInstruction); + + parserResult.setInstruction(parsedInstruction); + parserResult.setSymbol( + parser_result.symbol ? + Symbol(parser_result.symbol->symbol, + parser_result.symbol->value) : + Symbol()); + + } + + ::fcml_fn_parser_result_free(&parser_result); + + } catch (std::exception &exc) { + // If anything failed, free assembler results. + ::fcml_fn_parser_result_free(&parser_result); + throw exc; + } + + return FCML_CEH_GEC_NO_ERROR; + } + +private: + + /** The dialect for the parser. */ + const Dialect &_dialect; + +}; + +} + +#endif /* FCML_PARSER_HPP_ */ diff --git a/dependencies/fcml/include/fcml_registers.cpp b/dependencies/fcml/include/fcml_registers.cpp new file mode 100644 index 0000000..c9c25e6 --- /dev/null +++ b/dependencies/fcml/include/fcml_registers.cpp @@ -0,0 +1,288 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2015 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_registers.cpp + * C++ registers definitions. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + * + * @since 1.1.0 + */ + +#ifndef _FCML_CPP_REGISTERS +#define _FCML_CPP_REGISTERS + +#include "fcml_registers.hpp" + +namespace fcml { + + const Register UNDEF( 0, 0, Register::REG_UNDEFINED, FCML_FALSE ); + + const Register AL( ::fcml_reg_AL ); + const Register AX( ::fcml_reg_AX ); + const Register EAX( ::fcml_reg_EAX ); + const Register RAX( ::fcml_reg_RAX ); + const Register MM0( ::fcml_reg_MM0 ); + const Register XMM0( ::fcml_reg_XMM0 ); + const Register YMM0( ::fcml_reg_YMM0 ); + const Register ZMM0( ::fcml_reg_ZMM0 ); + + const Register CL( ::fcml_reg_CL ); + const Register CX( ::fcml_reg_CX ); + const Register ECX( ::fcml_reg_ECX ); + const Register RCX( ::fcml_reg_RCX ); + const Register MM1( ::fcml_reg_MM1 ); + const Register XMM1( ::fcml_reg_XMM1 ); + const Register YMM1( ::fcml_reg_YMM1 ); + const Register ZMM1( ::fcml_reg_ZMM1 ); + + const Register DL( ::fcml_reg_DL ); + const Register DX( ::fcml_reg_DX ); + const Register EDX( ::fcml_reg_EDX ); + const Register RDX( ::fcml_reg_RDX ); + const Register MM2( ::fcml_reg_MM2 ); + const Register XMM2( ::fcml_reg_XMM2 ); + const Register YMM2( ::fcml_reg_YMM2 ); + const Register ZMM2( ::fcml_reg_ZMM2 ); + + const Register BL( ::fcml_reg_BL ); + const Register BX( ::fcml_reg_BX ); + const Register EBX( ::fcml_reg_EBX ); + const Register RBX( ::fcml_reg_RBX ); + const Register MM3( ::fcml_reg_MM3 ); + const Register XMM3( ::fcml_reg_XMM3 ); + const Register YMM3( ::fcml_reg_YMM3 ); + const Register ZMM3( ::fcml_reg_ZMM3 ); + + const Register AH( ::fcml_reg_AH ); + const Register SPL( ::fcml_reg_SPL ); + const Register SP( ::fcml_reg_SP ); + const Register ESP( ::fcml_reg_ESP ); + const Register RSP( ::fcml_reg_RSP ); + const Register MM4( ::fcml_reg_MM4 ); + const Register XMM4( ::fcml_reg_XMM4 ); + const Register YMM4( ::fcml_reg_YMM4 ); + const Register ZMM4( ::fcml_reg_ZMM4 ); + + const Register CH( ::fcml_reg_CH ); + const Register BPL( ::fcml_reg_BPL ); + const Register BP( ::fcml_reg_BP ); + const Register EBP( ::fcml_reg_EBP ); + const Register RBP( ::fcml_reg_RBP ); + const Register MM5( ::fcml_reg_MM5 ); + const Register XMM5( ::fcml_reg_XMM5 ); + const Register YMM5( ::fcml_reg_YMM5 ); + const Register ZMM5( ::fcml_reg_ZMM5 ); + + const Register DH( ::fcml_reg_DH ); + const Register SIL( ::fcml_reg_SIL ); + const Register SI( ::fcml_reg_SI ); + const Register ESI( ::fcml_reg_ESI ); + const Register RSI( ::fcml_reg_RSI ); + const Register MM6( ::fcml_reg_MM6 ); + const Register XMM6( ::fcml_reg_XMM6 ); + const Register YMM6( ::fcml_reg_YMM6 ); + const Register ZMM6( ::fcml_reg_ZMM6 ); + + const Register BH( ::fcml_reg_BH ); + const Register DIL( ::fcml_reg_DIL ); + const Register DI( ::fcml_reg_DI ); + const Register EDI( ::fcml_reg_EDI ); + const Register RDI( ::fcml_reg_RDI ); + const Register MM7( ::fcml_reg_MM7 ); + const Register XMM7( ::fcml_reg_XMM7 ); + const Register YMM7( ::fcml_reg_YMM7 ); + const Register ZMM7( ::fcml_reg_ZMM7 ); + + const Register R8L( ::fcml_reg_R8L ); + const Register R8W( ::fcml_reg_R8W ); + const Register R8D( ::fcml_reg_R8D ); + const Register R8( ::fcml_reg_R8 ); + const Register XMM8( ::fcml_reg_XMM8 ); + const Register YMM8( ::fcml_reg_YMM8 ); + const Register ZMM8( ::fcml_reg_ZMM8 ); + + const Register R9L( ::fcml_reg_R9L ); + const Register R9W( ::fcml_reg_R9W ); + const Register R9D( ::fcml_reg_R9D ); + const Register R9( ::fcml_reg_R9 ); + const Register XMM9( ::fcml_reg_XMM9 ); + const Register YMM9( ::fcml_reg_YMM9 ); + const Register ZMM9( ::fcml_reg_ZMM9 ); + + const Register R10L( ::fcml_reg_R10L ); + const Register R10W( ::fcml_reg_R10W ); + const Register R10D( ::fcml_reg_R10D ); + const Register R10( ::fcml_reg_R10 ); + const Register XMM10( ::fcml_reg_XMM10 ); + const Register YMM10( ::fcml_reg_YMM10 ); + const Register ZMM10( ::fcml_reg_ZMM10 ); + + const Register R11L( ::fcml_reg_R11L ); + const Register R11W( ::fcml_reg_R11W ); + const Register R11D( ::fcml_reg_R11D ); + const Register R11( ::fcml_reg_R11 ); + const Register XMM11( ::fcml_reg_XMM11 ); + const Register YMM11( ::fcml_reg_YMM11 ); + const Register ZMM11( ::fcml_reg_ZMM11 ); + + const Register R12L( ::fcml_reg_R12L ); + const Register R12W( ::fcml_reg_R12W ); + const Register R12D( ::fcml_reg_R12D ); + const Register R12( ::fcml_reg_R12 ); + const Register XMM12( ::fcml_reg_XMM12 ); + const Register YMM12( ::fcml_reg_YMM12 ); + const Register ZMM12( ::fcml_reg_ZMM12 ); + + const Register R13L( ::fcml_reg_R13L ); + const Register R13W( ::fcml_reg_R13W ); + const Register R13D( ::fcml_reg_R13D ); + const Register R13( ::fcml_reg_R13 ); + const Register XMM13( ::fcml_reg_XMM13 ); + const Register YMM13( ::fcml_reg_YMM13 ); + const Register ZMM13( ::fcml_reg_ZMM13 ); + + const Register R14L( ::fcml_reg_R14L ); + const Register R14W( ::fcml_reg_R14W ); + const Register R14D( ::fcml_reg_R14D ); + const Register R14( ::fcml_reg_R14 ); + const Register XMM14( ::fcml_reg_XMM14 ); + const Register YMM14( ::fcml_reg_YMM14 ); + const Register ZMM14( ::fcml_reg_ZMM14 ); + + const Register R15L( ::fcml_reg_R15L ); + const Register R15W( ::fcml_reg_R15W ); + const Register R15D( ::fcml_reg_R15D ); + const Register R15( ::fcml_reg_R15 ); + const Register XMM15( ::fcml_reg_XMM15 ); + const Register YMM15( ::fcml_reg_YMM15 ); + const Register ZMM15( ::fcml_reg_ZMM15 ); + + const Register XMM16( ::fcml_reg_XMM16 ); + const Register YMM16( ::fcml_reg_YMM16 ); + const Register ZMM16( ::fcml_reg_ZMM16 ); + + const Register XMM17( ::fcml_reg_XMM17 ); + const Register YMM17( ::fcml_reg_YMM17 ); + const Register ZMM17( ::fcml_reg_ZMM17 ); + + const Register XMM18( ::fcml_reg_XMM18 ); + const Register YMM18( ::fcml_reg_YMM18 ); + const Register ZMM18( ::fcml_reg_ZMM18 ); + + const Register XMM19( ::fcml_reg_XMM19 ); + const Register YMM19( ::fcml_reg_YMM19 ); + const Register ZMM19( ::fcml_reg_ZMM19 ); + + const Register XMM20( ::fcml_reg_XMM20 ); + const Register YMM20( ::fcml_reg_YMM20 ); + const Register ZMM20( ::fcml_reg_ZMM20 ); + + const Register XMM21( ::fcml_reg_XMM21 ); + const Register YMM21( ::fcml_reg_YMM21 ); + const Register ZMM21( ::fcml_reg_ZMM21 ); + + const Register XMM22( ::fcml_reg_XMM22 ); + const Register YMM22( ::fcml_reg_YMM22 ); + const Register ZMM22( ::fcml_reg_ZMM22 ); + + const Register XMM23( ::fcml_reg_XMM23 ); + const Register YMM23( ::fcml_reg_YMM23 ); + const Register ZMM23( ::fcml_reg_ZMM23 ); + + const Register XMM24( ::fcml_reg_XMM24 ); + const Register YMM24( ::fcml_reg_YMM24 ); + const Register ZMM24( ::fcml_reg_ZMM24 ); + + const Register XMM25( ::fcml_reg_XMM25 ); + const Register YMM25( ::fcml_reg_YMM25 ); + const Register ZMM25( ::fcml_reg_ZMM25 ); + + const Register XMM26( ::fcml_reg_XMM26 ); + const Register YMM26( ::fcml_reg_YMM26 ); + const Register ZMM26( ::fcml_reg_ZMM26 ); + + const Register XMM27( ::fcml_reg_XMM27 ); + const Register YMM27( ::fcml_reg_YMM27 ); + const Register ZMM27( ::fcml_reg_ZMM27 ); + + const Register XMM28( ::fcml_reg_XMM28 ); + const Register YMM28( ::fcml_reg_YMM28 ); + const Register ZMM28( ::fcml_reg_ZMM28 ); + + const Register XMM29( ::fcml_reg_XMM29 ); + const Register YMM29( ::fcml_reg_YMM29 ); + const Register ZMM29( ::fcml_reg_ZMM29 ); + + const Register XMM30( ::fcml_reg_XMM30 ); + const Register YMM30( ::fcml_reg_YMM30 ); + const Register ZMM30( ::fcml_reg_ZMM30 ); + + const Register XMM31( ::fcml_reg_XMM31 ); + const Register YMM31( ::fcml_reg_YMM31 ); + const Register ZMM31( ::fcml_reg_ZMM31 ); + + const Register ES( ::fcml_reg_ES ); + const Register CS( ::fcml_reg_CS ); + const Register SS( ::fcml_reg_SS ); + const Register DS( ::fcml_reg_DS ); + const Register FS( ::fcml_reg_FS ); + const Register GS( ::fcml_reg_GS ); + + const Register ST0( ::fcml_reg_ST0 ); + const Register ST1( ::fcml_reg_ST1 ); + const Register ST2( ::fcml_reg_ST2 ); + const Register ST3( ::fcml_reg_ST3 ); + const Register ST4( ::fcml_reg_ST4 ); + const Register ST5( ::fcml_reg_ST5 ); + const Register ST6( ::fcml_reg_ST6 ); + const Register ST7( ::fcml_reg_ST7 ); + + const Register CR0( ::fcml_reg_CR0 ); + const Register CR2( ::fcml_reg_CR2 ); + const Register CR3( ::fcml_reg_CR3 ); + const Register CR4( ::fcml_reg_CR4 ); + const Register CR8( ::fcml_reg_CR8 ); + + const Register DR0( ::fcml_reg_DR0 ); + const Register DR1( ::fcml_reg_DR1 ); + const Register DR2( ::fcml_reg_DR2 ); + const Register DR3( ::fcml_reg_DR3 ); + const Register DR4( ::fcml_reg_DR4 ); + const Register DR5( ::fcml_reg_DR5 ); + const Register DR6( ::fcml_reg_DR6 ); + const Register DR7( ::fcml_reg_DR7 ); + + const Register K0( ::fcml_reg_K0 ); + const Register K1( ::fcml_reg_K1 ); + const Register K2( ::fcml_reg_K2 ); + const Register K3( ::fcml_reg_K3 ); + const Register K4( ::fcml_reg_K4 ); + const Register K5( ::fcml_reg_K5 ); + const Register K6( ::fcml_reg_K6 ); + const Register K7( ::fcml_reg_K7 ); + + const Register IP( ::fcml_reg_IP ); + const Register EIP( ::fcml_reg_EIP ); + const Register RIP( ::fcml_reg_RIP ); + +} + +#endif diff --git a/dependencies/fcml/include/fcml_registers.hpp b/dependencies/fcml/include/fcml_registers.hpp new file mode 100644 index 0000000..4bc76b2 --- /dev/null +++ b/dependencies/fcml/include/fcml_registers.hpp @@ -0,0 +1,288 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_registers.hpp + * C++ registers declarations. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + * + * @since 1.1.0 + */ + +#ifndef FCML_REGISTERS_HPP_ +#define FCML_REGISTERS_HPP_ + +#include "fcml_common.hpp" + +namespace fcml { + + extern const Register UNDEF; + + extern const Register AL; + extern const Register AX; + extern const Register EAX; + extern const Register RAX; + extern const Register MM0; + extern const Register XMM0; + extern const Register YMM0; + extern const Register ZMM0; + + extern const Register CL; + extern const Register CX; + extern const Register ECX; + extern const Register RCX; + extern const Register MM1; + extern const Register XMM1; + extern const Register YMM1; + extern const Register ZMM1; + + extern const Register DL; + extern const Register DX; + extern const Register EDX; + extern const Register RDX; + extern const Register MM2; + extern const Register XMM2; + extern const Register YMM2; + extern const Register ZMM2; + + extern const Register BL; + extern const Register BX; + extern const Register EBX; + extern const Register RBX; + extern const Register MM3; + extern const Register XMM3; + extern const Register YMM3; + extern const Register ZMM3; + + extern const Register AH; + extern const Register SPL; + extern const Register SP; + extern const Register ESP; + extern const Register RSP; + extern const Register MM4; + extern const Register XMM4; + extern const Register YMM4; + extern const Register ZMM4; + + extern const Register CH; + extern const Register BPL; + extern const Register BP; + extern const Register EBP; + extern const Register RBP; + extern const Register MM5; + extern const Register XMM5; + extern const Register YMM5; + extern const Register ZMM5; + + extern const Register DH; + extern const Register SIL; + extern const Register SI; + extern const Register ESI; + extern const Register RSI; + extern const Register MM6; + extern const Register XMM6; + extern const Register YMM5; + extern const Register ZMM5; + + extern const Register BH; + extern const Register DIL; + extern const Register DI; + extern const Register EDI; + extern const Register RDI; + extern const Register MM7; + extern const Register XMM7; + extern const Register YMM7; + extern const Register ZMM7; + + extern const Register R8L; + extern const Register R8W; + extern const Register R8D; + extern const Register R8; + extern const Register XMM8; + extern const Register YMM8; + extern const Register ZMM8; + + extern const Register R9L; + extern const Register R9W; + extern const Register R9D; + extern const Register R9; + extern const Register XMM9; + extern const Register YMM9; + extern const Register ZMM9; + + extern const Register R10L; + extern const Register R10W; + extern const Register R10D; + extern const Register R10; + extern const Register XMM10; + extern const Register YMM10; + extern const Register ZMM10; + + extern const Register R11L; + extern const Register R11W; + extern const Register R11D; + extern const Register R11; + extern const Register XMM11; + extern const Register YMM10; + extern const Register ZMM10; + + extern const Register R12L; + extern const Register R12W; + extern const Register R12D; + extern const Register R12; + extern const Register XMM12; + extern const Register YMM12; + extern const Register ZMM12; + + extern const Register R13L; + extern const Register R13W; + extern const Register R13D; + extern const Register R13; + extern const Register XMM13; + extern const Register YMM13; + extern const Register ZMM13; + + extern const Register R14L; + extern const Register R14W; + extern const Register R14D; + extern const Register R14; + extern const Register XMM14; + extern const Register YMM14; + extern const Register ZMM14; + + extern const Register R15L; + extern const Register R15W; + extern const Register R15D; + extern const Register R15; + extern const Register XMM15; + extern const Register YMM15; + extern const Register ZMM15; + + extern const Register XMM16; + extern const Register YMM16; + extern const Register ZMM16; + + extern const Register XMM17; + extern const Register YMM17; + extern const Register ZMM17; + + extern const Register XMM18; + extern const Register YMM18; + extern const Register ZMM18; + + extern const Register XMM19; + extern const Register YMM19; + extern const Register ZMM19; + + extern const Register XMM20; + extern const Register YMM20; + extern const Register ZMM20; + + extern const Register XMM21; + extern const Register YMM21; + extern const Register ZMM21; + + extern const Register XMM22; + extern const Register YMM22; + extern const Register ZMM22; + + extern const Register XMM23; + extern const Register YMM23; + extern const Register ZMM23; + + extern const Register XMM24; + extern const Register YMM24; + extern const Register ZMM24; + + extern const Register XMM25; + extern const Register YMM25; + extern const Register ZMM25; + + extern const Register XMM26; + extern const Register YMM26; + extern const Register ZMM26; + + extern const Register XMM27; + extern const Register YMM27; + extern const Register ZMM27; + + extern const Register XMM28; + extern const Register YMM28; + extern const Register ZMM28; + + extern const Register XMM29; + extern const Register YMM29; + extern const Register ZMM29; + + extern const Register XMM30; + extern const Register YMM30; + extern const Register ZMM30; + + extern const Register XMM31; + extern const Register YMM31; + extern const Register ZMM31; + + extern const Register ES; + extern const Register CS; + extern const Register SS; + extern const Register DS; + extern const Register FS; + extern const Register GS; + + extern const Register ST0; + extern const Register ST1; + extern const Register ST2; + extern const Register ST3; + extern const Register ST4; + extern const Register ST5; + extern const Register ST6; + extern const Register ST7; + + extern const Register CR0; + extern const Register CR2; + extern const Register CR3; + extern const Register CR4; + extern const Register CR8; + + extern const Register DR0; + extern const Register DR1; + extern const Register DR2; + extern const Register DR3; + extern const Register DR4; + extern const Register DR5; + extern const Register DR6; + extern const Register DR7; + + extern const Register K0; + extern const Register K1; + extern const Register K2; + extern const Register K3; + extern const Register K4; + extern const Register K5; + extern const Register K6; + extern const Register K7; + + extern const Register IP; + extern const Register EIP; + extern const Register RIP; + +} + +#endif /* FCML_REGISTERS_HPP_ */ diff --git a/dependencies/fcml/include/fcml_renderer.h b/dependencies/fcml/include/fcml_renderer.h new file mode 100644 index 0000000..bb5a124 --- /dev/null +++ b/dependencies/fcml/include/fcml_renderer.h @@ -0,0 +1,124 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_renderer.h + * Structures and functions declarations related to FCML renderers + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_REND_H_ +#define FCML_REND_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" +#include "fcml_errors.h" +#include "fcml_dialect.h" +#include "fcml_disassembler.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** The rendered instruction size can not exceed this value. */ +#define FCML_REND_MAX_BUFF_LEN 512 + +/** + * @defgroup RENDERER_FLAGS_GROUP Flags configuring rendering process. + * @{ + */ + +/** Render the instruction code as HEX string. */ +#define FCML_REND_FLAG_RENDER_CODE 0x00000001 +/** Render the immediate operand as HEX integer. */ +#define FCML_REND_FLAG_HEX_IMM 0x00000002 +/** Render the segment code register even if it is a default one. */ +#define FCML_REND_FLAG_RENDER_DEFAULT_SEG 0x00000004 +/** Render the displacement value as HEX integer. */ +#define FCML_REND_FLAG_HEX_DISPLACEMENT 0x00000008 +/** Render the conditional mnemonics using suffixes from first group. */ +#define FCML_REND_FLAG_COND_GROUP_1 0x00000010 +/** Render the conditional mnemonics using suffixes from second group. */ +#define FCML_REND_FLAG_COND_GROUP_2 0x00000020 +/** Render the conditional mnemonics using suffixes for 'carry'. */ +#define FCML_REND_FLAG_COND_SHOW_CARRY 0x00000040 +/** Render SIB operand hints. */ +#define FCML_REND_FLAG_RENDER_SIB_HINT 0x00000080 +/** Render ABS (Absolute offset) operand hints. */ +#define FCML_REND_FLAG_RENDER_ABS_HINT 0x00000100 +/** Render REL (Relative offset) operand hints. */ +#define FCML_REND_FLAG_RENDER_REL_HINT 0x00000200 +/** Render hints for absolute addressing. */ +#define FCML_REND_FLAG_RENDER_INDIRECT_HINT 0x00000400 +/** Renders repetition prefixes using the first group (repe,repne). */ +#define FCML_REND_FLAG_REP_PREFIX_GROUP_1 0x00000800 +/** Renders repetition prefixes using the second group (repz,repnz). */ +#define FCML_REND_FLAG_REP_PREFIX_GROUP_2 0x00001000 +/** Renders the code padding between the instruction code and the mnemonic. */ +#define FCML_REND_FLAG_CODE_PADDING 0x00002000 +/** Renders the mnemonic padding between the mnemonic and the operands. */ +#define FCML_REND_FLAG_MNEMONIC_PADDING 0x00004000 +/** Should be used only with FCML_REND_FLAG_HEX_IMM and FCML_REND_FLAG_ + * HEX_DISPLACEMENT flags. */ +#define FCML_REND_FLAG_REMOVE_LEADING_ZEROS 0x00008000 + +/** Default set of the rendering flags. */ +#define FCML_REND_DEFAULT_FLAGS 0 +/** Default number of characters used as code padding. */ +#define FCML_REND_DEFAULT_CODE_PADDING 8 +/** Default number of characters used as mnemonic padding. */ +#define FCML_REND_DEFAULT_MNEMONIC_PADDING 8 + +/** @} */ + +/** Renderer configuration. */ +typedef struct fcml_st_render_config { + /** Flags which allows to control rendering process. */ + fcml_uint32_t render_flags; + /** Preferred mnemonic padding in characters. */ + fcml_uint16_t prefered_mnemonic_padding; + /** Preferred code padding in HEX bytes (2 characters on one byte.). */ + fcml_uint16_t prefered_code_padding; +} fcml_st_render_config; + +/** + * Renders the disassembled instruction into its textual representation. + * Prepares textual representation of the disassembled code using syntax + * based on the provided dialect. + * + * @param dialect Dialect instance. + * @param config Renderer configuration. + * @param[out] buffer Destination buffer for the generated instruction. + * @param buffer_len Size of the destination buffer. + * @param result Disassembled instruction. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_render( + const fcml_st_dialect *dialect, const fcml_st_render_config *config, + fcml_char *buffer, fcml_usize buffer_len, + const fcml_st_disassembler_result *result); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_REND_H_ */ diff --git a/dependencies/fcml/include/fcml_renderer.hpp b/dependencies/fcml/include/fcml_renderer.hpp new file mode 100644 index 0000000..962b966 --- /dev/null +++ b/dependencies/fcml/include/fcml_renderer.hpp @@ -0,0 +1,226 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_renderer.hpp + * C++ wrapper for FCML renderer. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_RENDERER_HPP_ +#define FCML_RENDERER_HPP_ + +#include "fcml_common.hpp" +#include "fcml_disassembler.hpp" +#include "fcml_renderer.h" + +namespace fcml { + +/** + * Component can not be initialized correctly. + */ +class RenderingFailedException: public BaseException { +public: + RenderingFailedException(const fcml_cstring &msg, fcml_ceh_error error = + FCML_CEH_GEC_NO_ERROR) : + BaseException(msg, error) { + } +}; + +/** Renderer configuration. + * + * It's a counterpart to the fcml_st_render_config structure. + * @since 1.1.0 + */ +class RenderConfig { +public: + + /** + * Creates an empty renderer configuration. + * @since 1.1.0 + */ + RenderConfig() : + _throwExceptionOnError(true), + _renderFlags(0), + _preferedMnemonicPadding(FCML_REND_DEFAULT_MNEMONIC_PADDING), + _preferedCodePadding(FCML_REND_DEFAULT_CODE_PADDING) { + } + + /** + * Creates a renderer configuration for given renderer flags. + * + * @param renderFlags The renderer flags. + * @since 1.1.0 + */ + RenderConfig(fcml_uint32_t renderFlags) : + _throwExceptionOnError(true), + _renderFlags(renderFlags), + _preferedMnemonicPadding(0), + _preferedCodePadding(0) { + } + + /** @since 1.1.0 */ + fcml_uint16_t getPreferedCodePadding() const { + return _preferedCodePadding; + } + + /** @since 1.1.0 */ + void setPreferedCodePadding(fcml_uint16_t preferedCodePadding) { + _preferedCodePadding = preferedCodePadding; + } + + /** @since 1.1.0 */ + fcml_uint16_t getPreferedMnemonicPadding() const { + return _preferedMnemonicPadding; + } + + /** @since 1.1.0 */ + void setPreferedMnemonicPadding(fcml_uint16_t preferedMnemonicPadding) { + _preferedMnemonicPadding = preferedMnemonicPadding; + } + + /** @since 1.1.0 */ + fcml_uint32_t getRenderFlags() const { + return _renderFlags; + } + + /** @since 1.1.0 */ + void setRenderFlags(fcml_uint32_t renderFlags) { + _renderFlags = renderFlags; + } + + /** + * Returns true if exception should be thrown when disassembling fails. + * + * @return True if exception is the preferred way of error handling + * in case of failure. + * @since 1.1.0 + */ + bool isThrowExceptionOnError() const { + return _throwExceptionOnError; + } + + /** + * Sets the way how the error handling is done. + * + * @param throwExceptionOnError True if exception should be thrown + * in case of failure. + * @since 1.1.0 + */ + void setThrowExceptionOnError(bool throwExceptionOnError) { + _throwExceptionOnError = throwExceptionOnError; + } + +private: + + /** Throws exception in case of error. */ + bool _throwExceptionOnError; + /** Flags which allows to control rendering process. */ + fcml_uint32_t _renderFlags; + /** Preferred mnemonic padding in characters. */ + fcml_uint16_t _preferedMnemonicPadding; + /** Preferred code padding in HEX bytes (2 characters on one byte.). */ + fcml_uint16_t _preferedCodePadding; + +}; + +/** + * Converts objects to their structures counterparts. + * @since 1.1.0 + * @remarks Internal API, not intended to be used outside. + */ +class RenderTypeConverter { +public: + + static void convert(const RenderConfig &src, fcml_st_render_config &dest) { + dest.prefered_code_padding = src.getPreferedCodePadding(); + dest.prefered_mnemonic_padding = src.getPreferedMnemonicPadding(); + dest.render_flags = src.getRenderFlags(); + } + +}; + +/** Renderer wrapper. + * @since 1.1.0 + */ +class Renderer: protected DialectAware { +public: + + /** + * Creates a renderer instance for the given dialect. + * + * @param dialect The dialect instance. + * @since 1.1.0 + */ + Renderer(Dialect &dialect) : + _dialect(dialect) { + } + + /** + * Renders a disassembled instruction. + * + * @param renderConfig A renderer configuration. + * @param assemblerResult The disassembler result. + * @param[out] result The rendered instruction. + * @throw RenderingFailedException Rendering failed. + * @return The error code. + */ + fcml_ceh_error render(const RenderConfig &renderConfig, + DisassemblerResult &assemblerResult, fcml_cstring &result) { + + result.clear(); + + fcml_st_render_config render_config; + RenderTypeConverter::convert(renderConfig, render_config); + + fcml_st_disassembler_result disassembler_result; + fcml_fn_disassembler_result_prepare(&disassembler_result); + + DisassemblerTypeConverter::convert(assemblerResult, + disassembler_result); + + fcml_char buffer[FCML_REND_MAX_BUFF_LEN]; + + fcml_ceh_error error = ::fcml_fn_render(extractDialect(_dialect), + &render_config, buffer, FCML_REND_MAX_BUFF_LEN, + &disassembler_result); + + DisassemblerTypeConverter::free(disassembler_result); + + if (error && renderConfig.isThrowExceptionOnError()) { + throw RenderingFailedException( + FCML_TEXT("Can not render instruction."), error); + } + + result = buffer; + + return error; + } + +private: + + /** The dialect instance associated with the renderer. */ + Dialect &_dialect; + +}; + +} + +#endif /* FCML_RENDERER_HPP_ */ diff --git a/dependencies/fcml/include/fcml_stateful_assembler.hpp b/dependencies/fcml/include/fcml_stateful_assembler.hpp new file mode 100644 index 0000000..b87cc00 --- /dev/null +++ b/dependencies/fcml/include/fcml_stateful_assembler.hpp @@ -0,0 +1,554 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_stateful_assembler.hpp + * Stateful FCML assembler implementation. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_STATEFUL_ASSEMBLER_HPP_ +#define FCML_STATEFUL_ASSEMBLER_HPP_ + +#include + +#include "fcml_assembler.hpp" +#include "fcml_parser.hpp" + +namespace fcml { + +/** + * It's a stateful assembler which can be used to assemble instructions one by + * one on the fly. By default is works with the general instruction models as + * well as with instruction builders, but it can be also configured to parse + * whole statements using internally managed parser. It holds it's own state, + * so it's not necessary to update instruction pointer etc while it's working. + * Assembled instructions are placed inside a dedicated vector, but generated + * machine code is accessing + * directly by the dedicated CodeIterator. + * + * @since 1.1.0 + * @remarks This class isn't thread-safe. + */ +class StatefulAssembler { +public: + + /** Used only to indicate the need of the flush operation. */ + class SAFlush { + }; + + /** + * Creates a stateful assembler for the given assembler and assembler + * context. Bear in mind that assembler and context are not copied in + * any way and have to be valid as long as the stateful assembler in in + * use. Parsing support can be enabled optionally using the third parameter. + * + * @param assembler The assembled that will be used to assemble the code. + * @param context The assembler context. + * @param enableParser Enables parsing support. + * @since 1.1.0 + */ + StatefulAssembler(Assembler &assembler, AssemblerContext &context, + bool enableParser = false) : + _instructionBuilder(IB(FCML_TEXT("")), false), + _assembler(assembler), + _context(context), + _codeLength(0) { + // Create parser if needed. + _parser = enableParser ? new Parser(assembler.getDialect()) : NULL; + } + + /** Destructor. + * @since 1.1.0 + */ + virtual ~StatefulAssembler() { + if (_parser) { + delete _parser; + } + } + + /** + * Adds instruction builder to the stateful assembler. Such a instruction + * builder will be used then to assemble an instruction it represents. + * Before any operation is performed, pending instruction is flushed if + * there is any available. + * + * @param ib The instruction builder to be flushed. + * @return The stateful assembler itself. + * @throw AssemblingFailedException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const IB &ib) { + return add(ib); + } + + /** + * Adds instruction builder to the stateful assembler. Such a instruction + * builder will be used then to assemble an instruction it represents. + * Before any operation is performed, pending instruction is flushed if + * there is any available. + * + * @param ib The instruction builder to be flushed. + * @return The stateful assembler itself. + * @throw AssemblingFailedException + * @since 1.1.0 + */ + StatefulAssembler& add(const IB &ib) { + flush(); + _instructionBuilder.setNotNull(true); + _instructionBuilder.setValue(ib); + return *this; + } + + /** + * Creates an instruction builder for the given mnemonic. + * + * @param mnemonic The instruction mnemonic. + * @return The stateful assembler itself. + * @throw AssemblingFailedException, ParsingFailedException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const fcml_cstring &mnemonic) { + return inst(mnemonic); + } + + /** + * Creates an instruction builder for the given mnemonic. + * + * @param mnemonic The instruction mnemonic. + * @return The stateful assembler itself. + * @throw AssemblingFailedException, ParsingFailedException + * @since 1.1.0 + */ + StatefulAssembler& inst(const fcml_cstring &mnemonic) { + flush(); + if (_parser) { + // Parse instruction and then pass it to the assembler. + _parserContext.setIp(_context.getEntryPoint().getIP()); + ParserConfig &config = _parserContext.getConfig(); + config.setThrowExceptionOnError(true); + _parser->parse(_parserContext, mnemonic, _parserResult); + *this << _parserResult.getInstruction(); + } else { + // Parser is not available, so treat this string as a full + // instruction which have to be parsed. + _instructionBuilder.setNotNull(true); + _instructionBuilder.setValue(IB(mnemonic)); + } + return *this; + } + + /** + * Adds the new register operand to the instruction builder associated + * with the buffer. + * + * @param reg The register. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const Register ®) { + return op(Operand(reg)); + } + + /** + * Adds the new immediate operand to the instruction builder associated + * with the buffer. + * + * @param imm The immediate value. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const Integer &imm) { + return op(Operand(imm)); + } + + /** + * Adds the new address operand to the instruction builder associated + * with the buffer. + * + * @param address The address. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const Address &address) { + return op(Operand(address)); + } + + /** + * Adds the new far pointer operand to the instruction builder associated + * with the buffer. + * + * @param pointer The far pointer. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const FarPointer &pointer) { + return op(Operand(pointer)); + } + + /** + * Adds an operand to the instruction builder associated with the buffer. + * + * @param operand The operand to be added. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const Operand &operand) { + return op(operand); + } + + /** + * Adds an operand to the instruction builder associated with the buffer. + * + * @param operand The operand to be added.. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& op(const Operand &operand) { + if (!_instructionBuilder.isNotNull()) { + throw IllegalStateException( + FCML_TEXT("No instruction builder available.")); + } + IB &ib = _instructionBuilder.getValue(); + ib.op(operand); + return *this; + } + + /** + * Adds the new register operand to the instruction builder associated + * with the buffer. + * + * @param reg The register. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& op(const Register ®) { + return op(Operand(reg)); + } + + /** + * Adds the new immediate operand to the instruction builder associated + * with the buffer. + * + * @param imm The immediate value. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& op(const Integer &imm) { + return op(Operand(imm)); + } + + /** + * Adds the new address operand to the instruction builder associated + * with the buffer. + * + * @param address The address. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& op(const Address &address) { + return op(Operand(address)); + } + + /** + * Adds the new far pointer operand to the instruction builder associated + * with the buffer. + * + * @param pointer The far pointer. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& op(const FarPointer &pointer) { + return op(Operand(pointer)); + } + + /** + * Flushes the instruction builder. + * @param indic Flush indicator. + * @return The stateful assembler itself. + * @throw AssemblingFailedException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const SAFlush &indic) { + flush(); + return *this; + } + + /** + * Assembles an instruction in the given instruction builder. + * + * @param instruction Instruction to be assembled. + * @return Stateful assembler. + * @throw AssemblingFailedException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const Instruction &instruction) { + return inst(instruction); + } + + /** + * Adds a prefix to the instruction being built. + * @param prefix The prefix to be added. + * @return The instruction builder with the new prefix set for it. + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const InstructionPrefix &prefix) { + return set(prefix); + } + + /** + * Adds an instruction level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const InstructionHint &hint) { + return set(hint); + } + + /** + * Adds an operand level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const OperandHint &hint) { + return set(hint); + } + + /** + * Adds a prefix to the instruction being built. + * @param prefix The prefix to be added. + * @return The instruction builder with the new prefix set for it. + * @since 1.1.0 + */ + StatefulAssembler& set(const InstructionPrefix &prefix) { + if (!_instructionBuilder.isNotNull()) { + throw IllegalStateException( + FCML_TEXT("No instruction builder available.")); + } + _instructionBuilder.getValue() << prefix; + return *this; + } + + /** + * Adds an instruction level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + StatefulAssembler& set(const InstructionHint &hint) { + if (!_instructionBuilder.isNotNull()) { + throw IllegalStateException( + FCML_TEXT("No instruction builder available.")); + } + _instructionBuilder.getValue() << hint; + return *this; + } + + /** + * Adds an operand level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + StatefulAssembler& set(const OperandHint &hint) { + if (!_instructionBuilder.isNotNull()) { + throw IllegalStateException( + FCML_TEXT("No instruction builder available.")); + } + _instructionBuilder.getValue() << hint; + return *this; + } + + /** + * Assembles an instruction in the given instruction builder. + * + * @param instruction Instruction to be assembled. + * @return Stateful assembler. + * @throw AssemblingFailedException + * @since 1.1.0 + */ + StatefulAssembler& inst(const Instruction &instruction) { + + // Flush pending instruction if there is any. + flush(); + + // Just in case. + AssemblerConf &config = _context.getConfig(); + config.setIncrementIp(true); + config.setThrowExceptionOnError(true); + + // Assembler the instruction. + _assembler.assemble(_context, instruction, _result); + + // Store the chosen assembled instruction for future use. + const AssembledInstruction *assembledInstruction = + _result.getChosenInstruction(); + if (assembledInstruction) { + _assembledInstructions.push_back(*assembledInstruction); + _codeLength += assembledInstruction->getCodeLength(); + } else { + throw AssemblingFailedException( + FCML_TEXT("Chosen instruction hasn't been set. It seems " + "that the instruction chooser isn't working " + "correctly.")); + } + + return *this; + } + + /** + * Gets iterator which allows to iterate through the whole machine + * code byte by byte. + * + * @return Iterator instance. + * @since 1.1.0 + */ + CodeIterator getCodeIterator() { + flush(); + return CodeIterator(_assembledInstructions); + } + + /** + * Gets all chosen assembled instructions. + * + * @return All assembled instructions available in the buffer. + * @since 1.1.0 + */ + std::vector& getAssembledInstructions() { + flush(); + return _assembledInstructions; + } + + /** + * Gets the code length of all assembled instructions available. + * + * @return The code length. + * @since 1.1.0 + */ + fcml_usize getCodeLength() { + flush(); + return _codeLength; + } + + /** + * Assembles all pending instructions. + * @since 1.1.0 + * @throw AssemblingFailedException + */ + void flush() { + if (_instructionBuilder.isNotNull()) { + // Build an instruction using the instruction builder. + Instruction instruction = _instructionBuilder.getValue().build(); + // And clean the builder, is everything succeed. + _instructionBuilder.setNotNull(false); + // Assemble the instruction. + *this << instruction; + } + } + + /** + * Creates flush indicated for "shift" operators. + * @return Flush indicator. + * @since 1.1.0 + */ + static SAFlush FLUSH() { + return SAFlush(); + } + + /** Gets configuration used by parser if parsing is supported. + * @return Parser configuration. + */ + const ParserConfig& getParserConfig() const { + return _parserContext.getConfig(); + } + + /** Gets configuration used by parser if parsing is supported. + * @return Parser configuration. + * @since 1.1.0 + */ + ParserConfig& getParserConfig() { + return _parserContext.getConfig(); + } + + /** + * Gets symbol table used together with the parser. + * @return The symbol table used by the parser. + * @since 1.1.0 + */ + const SymbolTable* getSymbolTable() const { + return _parserContext.getSymbolTable(); + } + + /** + * Gets symbol table used together with the parser. + * @return The symbol table used by the parser. + * @since 1.1.0 + */ + SymbolTable* getSymbolTable() { + return _parserContext.getSymbolTable(); + } + + /** + * Sets a new symbol table for the parser. + * @param symbolTable The new symbol table. + * @since 1.1.0 + */ + void setSymbolTable(SymbolTable *symbolTable) { + _parserContext.setSymbolTable(symbolTable); + } + +private: + + /** An instruction parser. */ + Parser *_parser; + /** Parser result used when parsing is supported. */ + ParserResult _parserResult; + /** Parser context. */ + ParserContext _parserContext; + /** A disassembled result used by the assembler when needed. */ + AssemblerResult _result; + /** Currently used instruction builder. */ + Nullable _instructionBuilder; + /* Assembler used to assemble code. */ + Assembler &_assembler; + /** Assembler context. */ + AssemblerContext &_context; + // Assembled instructions. + std::vector _assembledInstructions; + /** Length of the code assembled so far. */ + fcml_usize _codeLength; + +}; + +} + +#endif /* FCML_STATEFUL_ASSEMBLER_HPP_ */ diff --git a/dependencies/fcml/include/fcml_stateful_disassembler.hpp b/dependencies/fcml/include/fcml_stateful_disassembler.hpp new file mode 100644 index 0000000..83c6e54 --- /dev/null +++ b/dependencies/fcml/include/fcml_stateful_disassembler.hpp @@ -0,0 +1,210 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_stateful_disassembler.hpp + * Stateful FCML disassembler implementation. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_STATEFUL_DISASSEMBLER_HPP_ +#define FCML_STATEFUL_DISASSEMBLER_HPP_ + +#include "fcml_disassembler.hpp" +#include "fcml_renderer.hpp" + +namespace fcml { + +/** Stateful disassembler can be used when you have to disassemble a larger + * piece of code one instruction by one. + * It also supports rendering directly using internally managed renderer. + * + * @since 1.1.0 + * @remarks This class isn't thread-safe. + */ +class StatefulDisassembler { +public: + + /** Creates a stateful disassembler for given FCML disassembler and context. + * Rendering support can be enabled optionally. + * @param disassembler The classic FCML disassembler used to + * disassemble instructions. + * @param context The disassembler context. + * @param enableRendering Enables instruction rendering, which is + * disabled by default. + */ + StatefulDisassembler(Disassembler &disassembler, + DisassemblerContext &context, bool enableRendering = false) : + _disassembler(disassembler), + _disassemblerContext(context) { + _renderer = enableRendering ? + new Renderer(disassembler.getDialect()) : NULL; + // End of line characters to be used when instructions are + // rendered directly to the output stream. +#if defined(_WIN32) + _endOfLine = FCML_TEXT( "\r\n" ); +#else + _endOfLine = FCML_TEXT("\n"); +#endif + } + + /** Destructor. */ + virtual ~StatefulDisassembler() { + if (_renderer) { + delete _renderer; + } + } + + /** + * Disassembles the next instruction pointed by the disassembler state. + * @param[out] instruction The destination instruction model. + * @return A reference to the stateful disassembler. + * @throws DisassemblingFailedException + * @since 1.1.0 + */ + StatefulDisassembler& operator >>(Instruction &instruction) { + + // IP has to be incremented automatically, instruction by instruction. + DisassemblerConf &config = _disassemblerContext.getDisassemblerConf(); + config.setIncrementIp(true); + config.setThrowExceptionOnError(true); + + // We don't care about error handling here, because it's disassembler + // who is responsible for correctly handling it. + _disassembler.disassemble(_disassemblerContext, _disassemblerResult); + + instruction = _disassemblerResult.getInstruction(); + + return *this; + + } + + /** + * Disassembles the next instruction from the buffer and renders it. + * @param[out] instruction Destination string for the instruction. + * @return A reference to the stateful disassembler. + * @throws DisassemblingFailedException, + * IllegalStateException, + * RenderingFailedException + * @since 1.1.0 + */ + StatefulDisassembler& operator >>(fcml_cstring &instruction) { + + if (!_renderer) { + throw IllegalStateException(FCML_TEXT("Rendering is disabled.")); + } + + // IP has to be incremented automatically, instruction by instruction. + DisassemblerConf &config = _disassemblerContext.getDisassemblerConf(); + config.setIncrementIp(true); + config.setThrowExceptionOnError(true); + + _disassembler.disassemble(_disassemblerContext, _disassemblerResult); + + _rendererConfig.setThrowExceptionOnError(true); + _renderer->render(_rendererConfig, _disassemblerResult, instruction); + + return *this; + + } + + /** + * Disassembles the next instruction from the buffer and renders it + * directly into the output stream. + * @param[out] ostream The output stream. + * @return A reference to the stateful disassembler. + * @throws DisassemblingFailedException, + * IllegalStateException, + * RenderingFailedException + * @since 1.1.0 + */ + StatefulDisassembler& operator >>(fcml_costream &ostream) { + + fcml_cstring instruction; + + // Render the next instruction into a string. + *this >> instruction; + + // Appends the instruction into an output stream. + ostream << instruction << _endOfLine; + + return *this; + + } + + /** + * Gets renderer configuration used by the instruction buffer. + * @return The renderer configuration. + * @since 1.1.0 + */ + RenderConfig& getRendererConfig() { + return _rendererConfig; + } + + /** + * Gets renderer configuration used by the internally managed + * instruction renderer. + * @return The renderer configuration. + * @since 1.1.0 + */ + const RenderConfig& getRendererConfig() const { + return _rendererConfig; + } + + /** + * Gets end of line characters sequence used by the renderer. + * + * @return End of line characters sequence used by the renderer. + * @since 1.1.0 + */ + const fcml_cstring& getEndOfLine() const { + return _endOfLine; + } + + /** + * Sets dedicated end of line characters. + * + * @param endOfLine A sequence of characters used as line ending. + * @since 1.1.0 + */ + void setEndOfLine(const fcml_cstring &endOfLine) { + _endOfLine = endOfLine; + } + +private: + + /** End of line character sequence. */ + fcml_cstring _endOfLine; + /** Disassembler result used when disassembling instructions. */ + DisassemblerResult _disassemblerResult; + /** The disassembler used to disassemble the code. */ + Disassembler &_disassembler; + /** Disassembler context pointing to the machine code. */ + DisassemblerContext &_disassemblerContext; + /** Renderer configuration used when instructions have to be rendered. */ + RenderConfig _rendererConfig; + /** Optional renderer used only when instructions are rendered. */ + Renderer *_renderer; + +}; + +} + +#endif /* FCML_STATEFUL_DISASSEMBLER_HPP_ */ diff --git a/dependencies/fcml/include/fcml_symbols.h b/dependencies/fcml/include/fcml_symbols.h new file mode 100644 index 0000000..68fa5a6 --- /dev/null +++ b/dependencies/fcml/include/fcml_symbols.h @@ -0,0 +1,149 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_symbols.h + * API for symbols handling. Currently used only by parsers. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_SYMBOLS_H_ +#define FCML_SYMBOLS_H_ + +#include "fcml_lib_export.h" +#include "fcml_common.h" +#include "fcml_errors.h" + +/** Type for symbol tables. */ +typedef fcml_ptr fcml_st_symbol_table; + +/********************************* + * Symbols. + *********************************/ + +/** Represents one named symbol with associated value. */ +typedef struct fcml_st_symbol { + /* The symbol name. */ + fcml_string symbol; + /* The symbol value. */ + fcml_int64_t value; +} fcml_st_symbol; + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Allocates new symbol on FCML library heap. + * This function should be always used when symbols + * are added using fcml_fn_symbol_add() function. + * @return Allocated symbol or NULL if allocation failed. + */ +LIB_EXPORT fcml_st_symbol* LIB_CALL fcml_fn_symbol_alloc( + const fcml_string symbol, fcml_int64_t value); + +/** + * Frees symbol allocated by FCML library. + * @param symbol The symbol to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_symbol_free(fcml_st_symbol *symbol); + +/** + * Allocates new symbol table. + * @return The allocated symbol table or NULL if something failed. + */ +LIB_EXPORT fcml_st_symbol_table LIB_CALL fcml_fn_symbol_table_alloc(); + +/** + * Adds new symbol to the symbol table. + * This function is more secure than fcml_fn_symbol_add() because it + * always allocates new symbol instance internally, so you do not have + * to pay attention not to pass the symbol allocated on the different heap + * to the symbol table. After the symbol has been properly added you can + * safely free the name because this function duplicates the name + * to the symbol needs. Of course the symbol as well as the duplicated name + * are freed by fcml_fn_symbol_table_free() function. You can also + * free it on your own if the symbol is not managed by symbol table + * using fcml_fn_symbol_free() function. + * @param symbol_table The symbol table. + * @param symbol The symbol name. + * @param value The symbol value. + * @see fcml_fn_symbol_table_free + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_symbol_add_raw( + fcml_st_symbol_table symbol_table, const fcml_string symbol, + fcml_int64_t value); + +/** + * Adds existing symbol to the symbol table. + * Remember that only symbols allocated on FCML heap should be + * added there. Of course in some cases heaps are shared so + * it will works without any problems but even if they are you + * should use fcml_fn_symbol_table_alloc() function to allocate + * every symbol. + * + * @param symbol_table The symbol table where new symbol should be placed. + * @param symbol The symbol to be added. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_symbol_add( + fcml_st_symbol_table symbol_table, const fcml_st_symbol *symbol); + +/** + * Removes the symbol from the symbol table. + * The removed symbol is automatically freed. + * @param symbol_table The symbol table. + * @param symbol The name of the symbol to remove. + */ +LIB_EXPORT void LIB_CALL fcml_fn_symbol_remove( + fcml_st_symbol_table symbol_table, const fcml_string symbol); + +/** + * Gets the symbol with the given name from the symbol table. + * @param symbol_table The symbol table. + * @param symbol The name of the symbol to get from the table. + * @return The pointer to the symbol or NULL if there is no such symbol + * in the symbol table. + */ +LIB_EXPORT fcml_st_symbol* LIB_CALL fcml_fn_symbol_get( + fcml_st_symbol_table symbol_table, const fcml_string symbol); + +/** + * Removes all symbols from the symbol table. + * Removes and frees all symbols from the given symbol table + * but does not free the symbol table itself. + * @param symbol_table The symbol table to be cleared. + */ +LIB_EXPORT void LIB_CALL fcml_fn_symbol_remove_all( + fcml_st_symbol_table symbol_table); + +/** + * Frees a symbol table. + * Frees all symbols as well as the symbol table itself. + * @param symbol_table A symbol table to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_symbol_table_free( + fcml_st_symbol_table symbol_table); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_SYMBOLS_H_ */ diff --git a/dependencies/fcml/include/fcml_symbols.hpp b/dependencies/fcml/include/fcml_symbols.hpp new file mode 100644 index 0000000..2ec3049 --- /dev/null +++ b/dependencies/fcml/include/fcml_symbols.hpp @@ -0,0 +1,265 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_symbols.hpp + * C++ API for symbols handling. Currently used only by parsers. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_SYMBOLS_HPP_ +#define FCML_SYMBOLS_HPP_ + +#include + +#include "fcml_common.hpp" +#include "fcml_symbols.h" + +namespace fcml { + +/** + * Represents one named symbol with associated value. + * @since 1.1.0 + */ +class Symbol { +public: + + /** + * Creates an empty symbol. + * @since 1.1.0 + */ + Symbol() : + _value(0) { + } + + /** + * Creates a symbol instance for the given name and value. + * + * @param name The symbol name. + * @param value The symbol value. + * @since 1.1.0 + */ + Symbol(const fcml_cstring &name, fcml_int64_t value) : + _name(name), _value(value) { + } + + /** + * Gets symbol value. + * @since 1.1.0 + */ + operator fcml_uint64_t() const { + return _value; + } + + /** + * Gets symbol value. + * @since 1.1.0 + */ + operator fcml_int64_t() const { + return static_cast(_value); + } + + /** + * Gets true if symbol is empty. + * + * @return True if symbol is empty. + * @since 1.1.0 + */ + bool isEmpty() const { + return _name.empty(); + } + + /** + * Gets the symbol name. + * + * @return The symbol name. + * @since 1.1.0 + */ + const fcml_cstring& getName() const { + return _name; + } + + /** + * Gets the symbol value. + * + * @return The symbol value. + * @since 1.1.0 + */ + fcml_uint64_t getValue() const { + return _value; + } + + /** + * Sets a new symbol name. + * + * @param name The symbol name. + * @since 1.1.0 + */ + void setName(const fcml_cstring &name) { + _name = name; + } + + /** + * Sets a new symbol value. + * + * @param value The symbol value. + * @since 1.1.0 + */ + void setValue(fcml_uint64_t value) { + _value = value; + } + +private: + + // Symbol name. + fcml_cstring _name; + // Symbol value. + fcml_uint64_t _value; + +}; + +/* Due to the performance purposes and the way symbol table is managed + * internally, it has to be wrapped directly without doing any conversions + * when needed. + * @since 1.1.0 + */ +class SymbolTable: public NonCopyable { +public: + + /** + * Creates an empty symbol table. + * @throw InitException The symbol table can't be allocated. + * @since 1.1.0 + */ + SymbolTable() : + _symbolTable(NULL) { + _symbolTable = ::fcml_fn_symbol_table_alloc(); + if (!_symbolTable) { + throw InitException( + FCML_TEXT( + "Symbol table can not be initialized correctly.")); + } + } + + /** + * Destructor. + * @since 1.1.0 + */ + virtual ~SymbolTable() { + if (_symbolTable) { + ::fcml_fn_symbol_table_free(_symbolTable); + _symbolTable = NULL; + } + } + +protected: + + friend class SymbolTableAware; + + /** + * Gets native FCML symbol table. + * @return The native symbol table. + * @since 1.1.0 + */ + fcml_st_symbol_table& getSymbolTable() { + return _symbolTable; + } + +public: + + /** + * Adds a new symbol to the table. + * + * @param symbolName The symbol name. + * @param value The symbol value. + * @since 1.1.0 + */ + void add(const fcml_cstring &symbolName, fcml_int64_t value) { + if (::fcml_fn_symbol_add_raw(_symbolTable, symbolName.c_str(), value) + == FCML_CEH_GEC_OUT_OF_MEMORY) { + throw std::bad_alloc(); + } + } + + /** + * Removes symbol from the table. + * + * @param symbolName The symbol name. + * @since 1.1.0 + */ + void remove(const fcml_cstring &symbolName) { + const fcml_string key = symbolName.c_str(); + ::fcml_fn_symbol_remove(_symbolTable, key); + } + + /** + * Gets true if there is a symbol for the given name in the table. + * + * @param symbolName The symbol name. + * @return true If symbol of the name exists in the table. + * @since 1.1.0 + */ + bool contains(const fcml_cstring &symbolName) const { + return ::fcml_fn_symbol_get(_symbolTable, symbolName.c_str()) != NULL; + } + + /** + * Gets the symbol of the given name. Checks Symbol.isEmpty method of the + * returned symbol to check if there is such a symbol. + * + * @param symbolName The symbol name. + * @return The found symbol. + * @since 1.1.0 + */ + Symbol get(const fcml_cstring &symbolName) const { + Symbol symbol; + fcml_st_symbol *found_symbol = ::fcml_fn_symbol_get(_symbolTable, + symbolName.c_str()); + if (found_symbol) { + symbol.setName(found_symbol->symbol); + symbol.setValue(found_symbol->value); + } + return symbol; + } + +private: + /** The native FCML symbol table. */ + fcml_st_symbol_table _symbolTable; +}; + +/** + * Derive from this class if you really need access to the native symbol table. + * @since 1.1.0 + */ +class SymbolTableAware { +public: + + /** + * Extracts the native symbol table for the given symbol table wrapper. + * @param symbolTable The symbol table wrapper. + * @since 1.1.0 + */ + fcml_st_symbol_table& extractSymbolTable(SymbolTable &symbolTable) { + return symbolTable.getSymbolTable(); + } +}; + +} +#endif /* FCML_SYMBOLS_HPP_ */ diff --git a/dependencies/fcml/include/fcml_types.h b/dependencies/fcml/include/fcml_types.h new file mode 100644 index 0000000..fe9ecd8 --- /dev/null +++ b/dependencies/fcml/include/fcml_types.h @@ -0,0 +1,271 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2015 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_types.h + * Types declarations. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_TYPES_H_ +#define FCML_TYPES_H_ + +/* If config.h is available, we depend on it; otherwise we give + * the responsibility to handle headers appropriately to the compiler runtime. + **/ +#ifdef HAVE_CONFIG_H +#include +#ifdef HAVE_STDDEF_H +#include +#endif +#if HAVE_STDINT_H +#include +#endif +#if HAVE_INTTYPES_H +#include +#endif +#else +#if defined(_MSC_VER) && defined(_WIN32) +#include +#define FCML_MSCC +/* Disable unit specific lexer features. */ +#define YY_NO_INPUT 1 +#define YY_NO_UNISTD_H 1 +#else +#include +#include +#include +#endif +#endif + +#include "fcml_lib_export.h" + +/** Used to code literal strings. It will be useful if FCML supports UNICODE in the future. */ +#define FCML_TEXT(x) x +#define _FT(x) FCML_TEXT(x) + +#ifdef FCML_MSCC + +#define FCML_PRI_INT8_DEC "%d" +#define FCML_PRI_INT16_DEC "%d" +#define FCML_PRI_INT32_DEC "%d" +#define FCML_PRI_INT64_DEC "%lld" + +#define FCML_PRI_UINT8_DEC "%u" +#define FCML_PRI_UINT16_DEC "%u" +#define FCML_PRI_UINT32_DEC "%u" +#define FCML_PRI_UINT64_DEC "%llu" + +#define FCML_PRI_INT8_HEX "%02x" +#define FCML_PRI_INT16_HEX "%04x" +#define FCML_PRI_INT32_HEX "%08x" +#define FCML_PRI_INT64_HEX "%016llx" + +#define FCML_PRI_INT8_HEX_NO_ZEROS "%x" +#define FCML_PRI_INT16_HEX_NO_ZEROS "%x" +#define FCML_PRI_INT32_HEX_NO_ZEROS "%x" +#define FCML_PRI_INT64_HEX_NO_ZEROS "%llx" + +typedef int fcml_int; +typedef int fcml_bool; +typedef __int8 fcml_int8_t; +typedef unsigned __int8 fcml_uint8_t; +typedef __int16 fcml_int16_t; +typedef unsigned __int16 fcml_uint16_t; +typedef __int32 fcml_int32_t; +typedef unsigned __int32 fcml_uint32_t; +typedef __int64 fcml_int64_t; +typedef unsigned __int64 fcml_uint64_t; + +/* Signed integers. */ +#define FCML_INT64_MAX _I64_MAX +#define FCML_INT64_MIN _I64_MIN +#define FCML_INT32_MAX INT_MAX +#define FCML_INT32_MIN INT_MIN +#define FCML_INT16_MAX SHRT_MAX +#define FCML_INT16_MIN SHRT_MIN +#define FCML_INT8_MAX SCHAR_MAX +#define FCML_INT8_MIN SCHAR_MIN + +/* Unsigned integers. */ +#define FCML_UINT8_MAX UCHAR_MAX +#define FCML_UINT16_MAX USHRT_MAX +#define FCML_UINT32_MAX UINT_MAX +#define FCML_UINT64_MAX _UI64_MAX + +#else + +#ifdef PRId8 +#define FCML_PRI_INT8_DEC "%" PRId8 +#endif +#ifdef PRId16 +#define FCML_PRI_INT16_DEC "%" PRId16 +#endif +#ifdef PRId32 +#define FCML_PRI_INT32_DEC "%" PRId32 +#endif +#ifdef PRId64 +#define FCML_PRI_INT64_DEC "%" PRId64 +#endif + +#ifdef PRIu8 +#define FCML_PRI_UINT8_DEC "%" PRIu8 +#endif +#ifdef PRIu16 +#define FCML_PRI_UINT16_DEC "%" PRIu16 +#endif +#ifdef PRIu32 +#define FCML_PRI_UINT32_DEC "%" PRIu32 +#endif +#ifdef PRIu64 +#define FCML_PRI_UINT64_DEC "%" PRIu64 +#endif + +#ifdef PRIx8 +#define FCML_PRI_INT8_HEX "%02" PRIx8 +#endif +#ifdef PRIx16 +#define FCML_PRI_INT16_HEX "%04" PRIx16 +#endif +#ifdef PRIx32 +#define FCML_PRI_INT32_HEX "%08" PRIx32 +#endif +#ifdef PRIx64 +#define FCML_PRI_INT64_HEX "%016" PRIx64 +#endif + +#ifdef PRIx8 +#define FCML_PRI_INT8_HEX_NO_ZEROS "%" PRIx8 +#endif +#ifdef PRIx16 +#define FCML_PRI_INT16_HEX_NO_ZEROS "%" PRIx16 +#endif +#ifdef PRIx32 +#define FCML_PRI_INT32_HEX_NO_ZEROS "%" PRIx32 +#endif +#ifdef PRIx64 +#define FCML_PRI_INT64_HEX_NO_ZEROS "%" PRIx64 +#endif + +typedef int fcml_int; +typedef unsigned int fcml_uint; +typedef int fcml_bool; +typedef int8_t fcml_int8_t; +typedef uint8_t fcml_uint8_t; +typedef int16_t fcml_int16_t; +typedef uint16_t fcml_uint16_t; +typedef int32_t fcml_int32_t; +typedef uint32_t fcml_uint32_t; +typedef int64_t fcml_int64_t; +typedef uint64_t fcml_uint64_t; + +/* Signed integers. */ +#define FCML_INT64_MAX INT64_MAX +#define FCML_INT64_MIN INT64_MIN +#define FCML_INT32_MAX INT32_MAX +#define FCML_INT32_MIN INT32_MIN +#define FCML_INT16_MAX INT16_MAX +#define FCML_INT16_MIN INT16_MIN +#define FCML_INT8_MAX INT8_MAX +#define FCML_INT8_MIN INT8_MIN + +/* Unsigned integers. */ +#define FCML_UINT8_MAX UINT8_MAX +#define FCML_UINT16_MAX UINT16_MAX +#define FCML_UINT32_MAX UINT32_MAX +#define FCML_UINT64_MAX UINT64_MAX + +#endif + +typedef char fcml_char; +#define fcml_string char* +typedef float fcml_float; +typedef void* fcml_ptr; +typedef fcml_uint32_t fcml_flags; + +typedef fcml_uint32_t fcml_usize; +typedef fcml_int32_t fcml_size; + +#define FCML_TRUE 1 +#define FCML_FALSE 0 + +/* Macro for bit manipulations. */ + +#define FCML_TP_SET_BIT(x,y) ( ( x ) | ( 0x01 << ( y ) ) ) +#define FCML_TP_GET_BIT(x,y) ( ( x >> y ) & 0x01 ) +#define FCML_TP_CLEAR_BIT(x,y) ( ( x ) &= ~( 1 << ( y ) ) ) + +/* Nulleable types. */ + +typedef struct fcml_nuint8_t { + fcml_uint8_t value; + fcml_bool is_not_null; +} fcml_nuint8_t; + +typedef struct fcml_nuint16_t { + fcml_uint16_t value; + fcml_bool is_not_null; +} fcml_nuint16_t; + +typedef struct fcml_nuint32_t { + fcml_uint32_t value; + fcml_bool is_not_null; +} fcml_nuint32_t; + +typedef struct fcml_nuint64_t { + fcml_uint64_t value; + fcml_bool is_not_null; +} fcml_nuint64_t; + +typedef struct fcml_nint8_t { + fcml_int8_t value; + fcml_bool is_not_null; +} fcml_nint8_t; + +typedef struct fcml_nint16_t { + fcml_int16_t value; + fcml_bool is_not_null; +} fcml_nint16_t; + +typedef struct fcml_nint32_t { + fcml_int32_t value; + fcml_bool is_not_null; +} fcml_nint32_t; + +typedef struct fcml_nint64_t { + fcml_int64_t value; + fcml_bool is_not_null; +} fcml_nint64_t; + +typedef struct fcml_st_integer { + fcml_usize size; + fcml_bool is_signed; + // Data fields. + fcml_int8_t int8; + fcml_int16_t int16; + fcml_int32_t int32; + fcml_int64_t int64; +} fcml_st_integer; + +#define FCML_SET_VALUE(x, y) x.value = y; x.is_not_null = FCML_TRUE; +#define FCML_SET_NULL(x) x.value = 0; x.is_not_null = FCML_FALSE; +#define FCML_IS_NULL(x) ((x).is_not_null == FCML_FALSE) + +#endif /* FCML_TYPES_H_ */ diff --git a/include/llodctor_pe.hpp b/include/llodctor_pe.hpp index 6501d5f..18bd51d 100644 --- a/include/llodctor_pe.hpp +++ b/include/llodctor_pe.hpp @@ -1,5 +1,5 @@ #pragma once -#include "llodctor_base.hpp" +#include namespace llo::s1 { diff --git a/include/lloiff.hpp b/include/lloiff.hpp index 5d40296..a412e12 100644 --- a/include/lloiff.hpp +++ b/include/lloiff.hpp @@ -37,11 +37,6 @@ namespace llo std::vector< std::uint8_t > section_raw; }; - static std::shared_ptr< lloiff_t > begin( std::string &file_name ) - { - return std::make_shared< lloiff_t >( file_name ); - } - llo::utils::hash_t< std::string > get_name() const { return file_name; diff --git a/llo-s1.vcxproj b/llo-s1.vcxproj index 85ff895..f963414 100644 --- a/llo-s1.vcxproj +++ b/llo-s1.vcxproj @@ -11,6 +11,42 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -20,6 +56,9 @@ + + + @@ -58,9 +97,11 @@ true + $(ProjectDir)include;$(IncludePath);$(ProjectDir)include;$(ProjectDir)dependencies\fcml\include\ false + $(VC_IncludePath);$(WindowsSDK_IncludePath);;$(ProjectDir)include;$(ProjectDir)dependencies\fcml\include\ @@ -73,6 +114,7 @@ Console true + $(ProjectDir)dependencies\fcml\fcml.lib;%(AdditionalDependencies) @@ -90,6 +132,7 @@ true true true + $(ProjectDir)dependencies\fcml\fcml.lib;%(AdditionalDependencies) diff --git a/llo-s1.vcxproj.filters b/llo-s1.vcxproj.filters index 880198a..00bdcd7 100644 --- a/llo-s1.vcxproj.filters +++ b/llo-s1.vcxproj.filters @@ -12,6 +12,9 @@ {f02de5e5-e0f4-4244-a05f-45e095918bff} + + {2d5f480f-e425-4a2c-a285-81d679b2250d} + @@ -26,6 +29,114 @@ Header Files + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + @@ -39,5 +150,14 @@ Source Files + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index 7fcf1da..56f7bb2 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,7 +1,10 @@ -#include "../include/llodctor_pe.hpp" -#include "../include/lloiff.hpp" +#define NOMINMAX +#include +#include +#include +#include -int main() +int __cdecl main( int argc, const char *argv[] ) { std::string file_name = "test.exe"; std::vector< std::uint8_t > image; @@ -9,8 +12,17 @@ int main() llo::lloiff_t iff( file_name ); llo::s1::dctor_pe_t pe_dctor( image ); - std::printf( "> iff name = %s, hash = 0x%p\n", - iff.get_name().get_data().c_str(), iff.get_name().get_hash() ); + std::printf( "> iff name = %s, hash = 0x%p\n", iff.get_name().get_data().c_str(), iff.get_name().get_hash() ); + + fcml_st_dialect *dialect; + fcml_fn_dialect_init_intel( FCML_INTEL_DIALECT_CF_DEFAULT, &dialect ); + + fcml_st_disassembler *disassembler; + fcml_fn_disassembler_init( dialect, &disassembler ); + + fcml_st_disassembler_result result; + fcml_st_disassembler_context context = { 0 }; + fcml_fn_disassembler_result_prepare( &result ); if ( !pe_dctor.generate( iff ) ) {