X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?p=palacios.git;a=blobdiff_plain;f=palacios%2Finclude%2Fxed%2Fxed-operand-values-interface.h;fp=palacios%2Finclude%2Fxed%2Fxed-operand-values-interface.h;h=bce7bdcc0b7268beb05f832fcf431143b7d81607;hp=0000000000000000000000000000000000000000;hb=ddc16b0737cf58f7aa90a69c6652cdf4090aec51;hpb=626595465a2c6987606a6bc697df65130ad8c2d3 diff --git a/palacios/include/xed/xed-operand-values-interface.h b/palacios/include/xed/xed-operand-values-interface.h new file mode 100644 index 0000000..bce7bdc --- /dev/null +++ b/palacios/include/xed/xed-operand-values-interface.h @@ -0,0 +1,431 @@ +/*BEGIN_LEGAL +Intel Open Source License + +Copyright (c) 2002-2007 Intel Corporation +All rights reserved. +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +Redistributions of source code must retain the above copyright notice, +this list of conditions and the following disclaimer. Redistributions +in binary form must reproduce the above copyright notice, this list of +conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. Neither the name of +the Intel Corporation nor the names of its contributors may be used to +endorse or promote products derived from this software without +specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR +ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +END_LEGAL */ +/// @file xed-operand-values-interface.h +/// @author Mark Charney + +#if !defined(_XED_OPERAND_VALUES_INTERFACE_H_) +# define _XED_OPERAND_VALUES_INTERFACE_H_ + +#include +#include +#include +#include +#include +#include // a generated file +#include // a generated file +#include +#include // generated +#include // generated +/// @name Initialization +//@{ +/// @ingroup OPERANDS +/// Initializes operand structure +XED_DLL_EXPORT void xed_operand_values_init(xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Initializes operand structure and sets state values +XED_DLL_EXPORT void xed_operand_values_init_set_mode(xed_operand_values_t* p, + const xed_state_t* dstate); +/// @ingroup OPERANDS +/// Initializes dst operand structure but preserves the existing +/// MODE/SMODE/AMODE values from the src operand structure. +XED_DLL_EXPORT void xed_operand_values_init_keep_mode( xed_operand_values_t* dst, + const xed_operand_values_t* src ); +//@} + +// Returns the raw operand fields. Do not use this. +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_operand_decider(const xed_operand_values_t* p, + xed_operand_enum_t operand_decider_index) ; + + +/////////////////////////////////////////////////////////// +/// @name String output +//@{ +/// @ingroup OPERANDS +/// Dump all the information about the operands to buf. +XED_DLL_EXPORT void xed_operand_values_dump(const xed_operand_values_t* ov, char* buf, int buflen); +/// @ingroup OPERANDS +/// More tersely dump all the information about the operands to buf. +XED_DLL_EXPORT void xed_operand_values_print_short(const xed_operand_values_t* ov, char* buf, int buflen); +//@} + +/// @name REP/REPNE Prefixes +//@{ +/// @ingroup OPERANDS +/// True if the instruction has a real REP prefix. This returns false if +/// there is no F2/F3 prefix or the F2/F3 prefix is used to refine the +/// opcode as in some SSE operations. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_real_rep(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// True if the instruction as a real F3 REP prefix. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_rep_prefix(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// True if the instruction as a real F2 REP prefix. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_repne_prefix(const xed_operand_values_t* p); +//@} + +/// @ingroup OPERANDS +/// Returns true if the memory operation has atomic read-modify-write +/// semantics. An XCHG accessing memory is atomic with or without a +/// LOCK prefix. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_get_atomic(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Returns true if the memory operatoin has a valid lock prefix. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_lock_prefix(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Indicates if the default segment is being used. +/// @param[in] p the pointer to the #xed_operand_values_t structure. +/// @param[in] i 0 or 1, indicating which memory operation. +/// @return true if the memory operation is using the default segment for the associated addressing mode base register. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_using_default_segment(const xed_operand_values_t* p, unsigned int i); + + + +/// @ingroup OPERANDS +/// Returns The effective operand width in bits: 16/32/64. Note this is not +/// the same as the width of the operand! For 8 bit operations, the +/// effective operand width is the machine mode's default width. +XED_DLL_EXPORT xed_uint32_t xed_operand_values_get_effective_operand_width(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// Returns The effective address width in bits: 16/32/64. +XED_DLL_EXPORT xed_uint32_t xed_operand_values_get_effective_address_width(const xed_operand_values_t* p); + + +/// @ingroup OPERANDS +/// True if there is a memory displacement +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_memory_displacement(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// True if there is a branch displacement +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_branch_displacement(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// True if there is a memory or branch displacement +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_displacement(const xed_operand_values_t* p); + + +/// @ingroup OPERANDS +/// Deprecated. Compatibility function for XED0. See has_memory_displacement(). +XED_DLL_EXPORT xed_bool_t +xed_operand_values_get_displacement_for_memop(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Return true if there is an immediate operand +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_immediate(const xed_operand_values_t* p); + + +/// @ingroup OPERANDS +/// ALIAS for has_displacement(). +/// Deprecated. See has_memory_displacement() and +/// has_branch_displacement(). +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_disp(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_address_size_prefix(const xed_operand_values_t* p); +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_operand_size_prefix(const xed_operand_values_t* p); + +#if 0 +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_refining_66_prefix(const xed_operand_values_t* p); +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_refining_f2_prefix(const xed_operand_values_t* p); +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_refining_f3_prefix(const xed_operand_values_t* p); +#endif + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_segment_prefix(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Return the segment prefix, if any, as a #xed_reg_enum_t value. +XED_DLL_EXPORT xed_reg_enum_t +xed_operand_values_segment_prefix(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_is_prefetch(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t xed_operand_values_get_long_mode(const xed_operand_values_t* p); + +/// @name Memory Addressing +//@{ +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_accesses_memory(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT unsigned int +xed_operand_values_number_of_memory_operands(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT unsigned int +xed_operand_values_get_memory_operand_length(const xed_operand_values_t* p, + unsigned int memop_idx); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_reg_enum_t +xed_operand_values_get_base_reg(const xed_operand_values_t* p,unsigned int memop_idx); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_reg_enum_t +xed_operand_values_get_index_reg(const xed_operand_values_t* p,unsigned int memop_idx); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_reg_enum_t +xed_operand_values_get_seg_reg(const xed_operand_values_t* p,unsigned int memop_idx); + +/// @ingroup OPERANDS +XED_DLL_EXPORT unsigned int +xed_operand_values_get_scale(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Returns true if the instruction access memory but without using a MODRM +/// byte limiting its addressing modes. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_memop_without_modrm(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// Returns true if the instruction has a MODRM byte. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_modrm_byte(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Returns true if the instruction has a SIB byte. +XED_DLL_EXPORT xed_bool_t +xed_operand_values_has_sib_byte(const xed_operand_values_t* p); +//@} + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_branch_not_taken_hint(const xed_operand_values_t* p); +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_branch_taken_hint(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_bool_t +xed_operand_values_is_nop(const xed_operand_values_t* p); + + +/// @name Immediates +//@{ +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_int64_t +xed_operand_values_get_immediate_int64(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_uint64_t +xed_operand_values_get_immediate_uint64(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Return true if the first immediate (IMM0) is signed +XED_DLL_EXPORT xed_uint_t xed_operand_values_get_immediate_is_signed(const xed_operand_values_t* p); + + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_uint8_t +xed_operand_values_get_immediate_byte(const xed_operand_values_t* p,unsigned int i); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_uint8_t +xed_operand_values_get_second_immediate(const xed_operand_values_t* p); +//@} + +/// @name Memory Displacements +//@{ +/// @ingroup OPERANDS +/// Return the memory displacement width in BYTES +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_memory_displacement_length(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// Return the memory displacement width in BITS +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_memory_displacement_length_bits(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_int64_t +xed_operand_values_get_memory_displacement_int64(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_uint8_t +xed_operand_values_get_memory_displacement_byte(const xed_operand_values_t* p,unsigned int i); +//@} + +/// @name Branch Displacements +//@{ +/// @ingroup OPERANDS +/// Return the branch displacement width in bytes +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_branch_displacement_length(const xed_operand_values_t* p); +/// @ingroup OPERANDS +/// Return the branch displacement width in bits +XED_DLL_EXPORT xed_uint32_t +xed_operand_values_get_branch_displacement_length_bits(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_int32_t +xed_operand_values_get_branch_displacement_int32(const xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_uint8_t +xed_operand_values_get_branch_displacement_byte(const xed_operand_values_t* p,unsigned int i); +//@} + + +/// @ingroup OPERANDS +XED_DLL_EXPORT xed_iclass_enum_t +xed_operand_values_get_iclass(const xed_operand_values_t* p); + +//////////////////////////////////////////////////// +// ENCODE API +//////////////////////////////////////////////////// +/// @name Encoding +//@{ +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_zero_immediate(xed_operand_values_t* p); +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_zero_branch_displacement(xed_operand_values_t* p); +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_zero_memory_displacement(xed_operand_values_t* p); + +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_set_lock(xed_operand_values_t* p); +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_zero_segment_override(xed_operand_values_t* p); + + +/// @ingroup OPERANDS +XED_DLL_EXPORT void +xed_operand_values_set_iclass(xed_operand_values_t* p,xed_iclass_enum_t iclass); + +/// @ingroup OPERANDS +XED_DLL_EXPORT void +xed_operand_values_set_effective_operand_width(xed_operand_values_t* p,unsigned int width); + +/// @ingroup OPERANDS +XED_DLL_EXPORT void +xed_operand_values_set_memory_operand_length(xed_operand_values_t* p,unsigned int memop_length); + + +/// @ingroup OPERANDS +/// Set the memory displacement using a BYTES length +XED_DLL_EXPORT void +xed_operand_values_set_memory_displacement(xed_operand_values_t* p,xed_int64_t x, unsigned int len); +/// @ingroup OPERANDS +/// Set the memory displacement using a BITS length +XED_DLL_EXPORT void +xed_operand_values_set_memory_displacement_bits(xed_operand_values_t* p,xed_int64_t x, unsigned int len_bits); + +/// @ingroup OPERANDS +/// Indicate that we have a relative branch. +XED_DLL_EXPORT void xed_operand_values_set_relbr(xed_operand_values_t* p); + +/// @ingroup OPERANDS +/// Set the branch displacement using a BYTES length +XED_DLL_EXPORT void +xed_operand_values_set_branch_displacement(xed_operand_values_t* p,xed_int32_t x, unsigned int len); +/// @ingroup OPERANDS +/// Set the branch displacement using a BITS length +XED_DLL_EXPORT void +xed_operand_values_set_branch_displacement_bits(xed_operand_values_t* p,xed_int32_t x, unsigned int len_bits); + +/// @ingroup OPERANDS +/// Set the signed immediate using a BYTES length +XED_DLL_EXPORT void +xed_operand_values_set_immediate_signed(xed_operand_values_t* p,xed_int32_t x, unsigned int bytes); +/// @ingroup OPERANDS +/// Set the signed immediate using a BITS length +XED_DLL_EXPORT void +xed_operand_values_set_immediate_signed_bits(xed_operand_values_t* p,xed_int32_t x, unsigned int bits); + + +/// @ingroup OPERANDS +/// Set the unsigned immediate using a BYTE length. +XED_DLL_EXPORT void +xed_operand_values_set_immediate_unsigned(xed_operand_values_t* p,xed_uint64_t x, unsigned int bytes); +/// @ingroup OPERANDS +/// Set the unsigned immediate using a BIT length. +XED_DLL_EXPORT void +xed_operand_values_set_immediate_unsigned_bits(xed_operand_values_t* p,xed_uint64_t x, unsigned int bits); + + + +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_set_base_reg(xed_operand_values_t* p, + unsigned int memop_idx, + xed_reg_enum_t new_base); + +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_set_seg_reg(xed_operand_values_t* p, + unsigned int memop_idx, + xed_reg_enum_t new_seg); + +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_set_index_reg(xed_operand_values_t* p, + unsigned int memop_idx, + xed_reg_enum_t new_index); + +/// @ingroup OPERANDS +XED_DLL_EXPORT void xed_operand_values_set_scale(xed_operand_values_t* p, + xed_uint_t memop_idx, + xed_uint_t new_scale); + + +/// @ingroup OPERANDS +/// Set the operand storage field entry named 'operand_name' to the +/// register value specified by 'reg_name'. +XED_DLL_EXPORT void +xed_operand_values_set_operand_reg(xed_operand_values_t* p, + xed_operand_enum_t operand_name, + xed_reg_enum_t reg_name); + +//@} +#endif + +//Local Variables: +//pref: "../../xed-operand-values-interface.c" +//End: