- Main Page
- Modules
- Data Structures
- Files

- Search for |

- File List
- Globals

# xed-inst.h

Go to the documentation of this file.

    00001 /*BEGIN_LEGAL
    00002 Intel Open Source License
    00003
    00004 Copyright (c) 2002-2014 Intel Corporation. All rights reserved.
    00005
    00006 Redistribution and use in source and binary forms, with or without
    00007 modification, are permitted provided that the following conditions are
    00008 met:
    00009
    00010 Redistributions of source code must retain the above copyright notice,
    00011 this list of conditions and the following disclaimer.  Redistributions
    00012 in binary form must reproduce the above copyright notice, this list of
    00013 conditions and the following disclaimer in the documentation and/or
    00014 other materials provided with the distribution.  Neither the name of
    00015 the Intel Corporation nor the names of its contributors may be used to
    00016 endorse or promote products derived from this software without
    00017 specific prior written permission.
    00018
    00019 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    00020 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    00021 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    00022 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
    00023 ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    00024 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    00025 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    00026 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    00027 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    00028 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    00029 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    00030 END_LEGAL */
    00032
    00033
    00034 #if !defined(_XED_INST_H_)
    00035 # define _XED_INST_H_
    00036
    00037 #include "xed-util.h"
    00038 #include "xed-portability.h"
    00039 #include "xed-category-enum.h" // generated
    00040 #include "xed-extension-enum.h" //generated
    00041 #include "xed-iclass-enum.h" //generated
    00042 #include "xed-operand-enum.h" // generated
    00043 #include "xed-operand-visibility-enum.h" //generated
    00044 #include "xed-operand-action-enum.h" // generated
    00045 #include "xed-operand-convert-enum.h" // generated
    00046 #include "xed-operand-type-enum.h" // generated
    00047 #include "xed-nonterminal-enum.h" // a generated file
    00048 #include "xed-operand-width-enum.h" // a generated file
    00049 #include "xed-operand-element-xtype-enum.h" // a generated file
    00050 #include "xed-reg-enum.h" // a generated file
    00051 #include "xed-attribute-enum.h" // a generated file
    00052 #include "xed-exception-enum.h" // a generated file
    00053 #include "xed-iform-enum.h" // a generated file
    00054 #include "xed-iform-map.h"
    00055 #include "xed-attributes.h"
    00056
    00057 struct xed_decoded_inst_s; //fwd-decl
    00058
    00059 typedef void (*xed_operand_extractor_fn_t)(struct xed_decoded_inst_s* xds);
    00060 //typedef xed_bool_t (*xed_instruction_fixed_bit_confirmer_fn_t)(struct xed_decoded_inst_s* xds);
    00061
    00062
    00067 typedef struct xed_operand_s
    00068 {
    00069     xed_operand_enum_t               _name;
    00070     xed_operand_visibility_enum_t    _operand_visibility;  // implicit, explicit, suppressed
    00071     xed_operand_action_enum_t        _rw;   // read or written
    00072     xed_operand_width_enum_t         _oc2;  // width code, could be invalid (then use register name)
    00073     xed_operand_type_enum_t          _type; // IMM, IMM_CONST, NT_LOOKUP_FN, REG, ERROR
    00074     xed_operand_element_xtype_enum_t _xtype; // xed data type: u32, f32, etc.
    00075     xed_uint8_t                      _cvt_idx; //  decoration index
    00076     union {
    00077         xed_uint32_t                 _imm;  // value for some constant immediates
    00078         xed_nonterminal_enum_t       _nt;   // for nt_lookup_fn's
    00079         xed_reg_enum_t               _reg;  // register name
    00080     } _u;
    00081 }  xed_operand_t;
    00082
    00084
    00085
    00086 static XED_INLINE xed_operand_enum_t xed_operand_name(const xed_operand_t* p)  {
    00087     return p->_name;
    00088 }
    00089
    00090
    00092 static XED_INLINE xed_operand_visibility_enum_t
    00093 xed_operand_operand_visibility( const xed_operand_t* p) {
    00094     return p->_operand_visibility;
    00095 }
    00096
    00097
    00101 static XED_INLINE xed_operand_type_enum_t xed_operand_type(const xed_operand_t* p)  {
    00102     return p->_type;
    00103 }
    00104
    00108 static XED_INLINE xed_operand_element_xtype_enum_t xed_operand_xtype(const xed_operand_t* p)  {
    00109     return p->_xtype;
    00110 }
    00111
    00112
    00114 static XED_INLINE xed_operand_width_enum_t xed_operand_width(const xed_operand_t* p)  {
    00115     return p->_oc2;
    00116 }
    00117
    00123 XED_DLL_EXPORT xed_uint32_t xed_operand_width_bits(const xed_operand_t* p,
    00124                                                    const xed_uint32_t eosz);
    00125
    00127 static XED_INLINE
    00128 xed_nonterminal_enum_t xed_operand_nonterminal_name(const xed_operand_t* p)  {
    00129     return p->_u._nt;
    00130 }
    00131
    00141 static XED_INLINE xed_reg_enum_t xed_operand_reg(const xed_operand_t* p) {
    00142     return p->_u._reg;
    00143 }
    00144
    00145
    00146
    00157 static XED_INLINE xed_uint_t xed_operand_template_is_register(const xed_operand_t* p) {
    00158     return p->_type == XED_OPERAND_TYPE_NT_LOOKUP_FN || p->_type == XED_OPERAND_TYPE_REG;
    00159 }
    00160
    00164 static XED_INLINE xed_uint32_t xed_operand_imm(const xed_operand_t* p) {
    00165     return p->_u._imm;
    00166 }
    00167
    00173 XED_DLL_EXPORT void    xed_operand_print(const xed_operand_t* p, char* buf, int buflen);
    00175
    00176
    00177
    00178
    00179
    00180
    00181
    00182
    00183
    00184 static XED_INLINE xed_uint_t xed_operand_is_register(xed_operand_enum_t name) {
    00185     return name >= XED_OPERAND_REG0 && name <= XED_OPERAND_REG8;
    00186 }
    00192 static XED_INLINE xed_uint_t xed_operand_is_memory_addressing_register(xed_operand_enum_t name) {
    00193     return  ( name == XED_OPERAND_BASE0 ||
    00194               name == XED_OPERAND_INDEX ||
    00195               name == XED_OPERAND_SEG0  ||
    00196               name == XED_OPERAND_BASE1 ||
    00197               name == XED_OPERAND_SEG1 );
    00198 }
    00199
    00201
    00203
    00204
    00205
    00206
    00207 static XED_INLINE xed_operand_action_enum_t xed_operand_rw(const xed_operand_t* p)  {
    00208     return p->_rw;
    00209 }
    00210
    00213 XED_DLL_EXPORT xed_uint_t xed_operand_read(const xed_operand_t* p);
    00216 XED_DLL_EXPORT xed_uint_t xed_operand_read_only(const xed_operand_t* p);
    00219 XED_DLL_EXPORT xed_uint_t xed_operand_written(const xed_operand_t* p);
    00222 XED_DLL_EXPORT xed_uint_t xed_operand_written_only(const xed_operand_t* p);
    00225 XED_DLL_EXPORT xed_uint_t xed_operand_read_and_written(const xed_operand_t* p);
    00228 XED_DLL_EXPORT xed_uint_t xed_operand_conditional_read(const xed_operand_t* p);
    00231 XED_DLL_EXPORT xed_uint_t xed_operand_conditional_write(const xed_operand_t* p);
    00233
    00234
    00239 typedef struct xed_inst_s {
    00240
    00241
    00242     // rflags info -- index in to the 2 tables of flags information.
    00243     // If _flag_complex is true, then the data are in the
    00244     // xed_flags_complex_table[]. Otherwise, the data are in the
    00245     // xed_flags_simple_table[].
    00246
    00247     //xed_instruction_fixed_bit_confirmer_fn_t _confirmer;
    00248
    00249     // number of operands in the operands array
    00250     xed_uint8_t _noperands;
    00251     xed_uint8_t _cpl;  // the nominal CPL for the instruction.
    00252     xed_uint16_t _flag_info_index;
    00253
    00254     xed_iform_enum_t _iform_enum;
    00255     // index into the xed_operand[] array of xed_operand_t structures
    00256     xed_uint16_t _operand_base;
    00257     xed_uint16_t _flag_complex; /* 1/0 valued, bool type */
    00258
    00259     // index to table of xed_attributes_t structures
    00260     xed_uint16_t _attributes;
    00261     xed_exception_enum_t _exceptions;
    00262 }  xed_inst_t;
    00263
    00265
    00266
    00267
    00268
    00269
    00270
    00271
    00272 XED_DLL_EXPORT unsigned int xed_inst_cpl(const xed_inst_t* p) ;
    00273
    00274
    00275 //These next few are not doxygen commented because I want people to use the higher
    00276 //level interface in xed-decoded-inst.h.
    00277 static XED_INLINE xed_iclass_enum_t xed_inst_iclass(const xed_inst_t* p) {
    00278     return xed_iform_to_iclass(p->_iform_enum);
    00279 }
    00280
    00281 static XED_INLINE xed_category_enum_t xed_inst_category(const xed_inst_t* p) {
    00282     return xed_iform_to_category(p->_iform_enum);
    00283 }
    00284
    00285 static XED_INLINE xed_extension_enum_t xed_inst_extension(const xed_inst_t* p) {
    00286     return xed_iform_to_extension(p->_iform_enum);
    00287 }
    00288 static XED_INLINE xed_isa_set_enum_t xed_inst_isa_set(const xed_inst_t* p) {
    00289     return xed_iform_to_isa_set(p->_iform_enum);
    00290 }
    00291
    00292 static XED_INLINE xed_iform_enum_t xed_inst_iform_enum(const xed_inst_t* p) {
    00293     return p->_iform_enum;
    00294 }
    00295
    00296
    00299 static XED_INLINE unsigned int xed_inst_noperands(const xed_inst_t* p) {
    00300     return p->_noperands;
    00301 }
    00302
    00305 XED_DLL_EXPORT const xed_operand_t*
    00306 xed_inst_operand(const xed_inst_t* p, unsigned int i);
    00307
    00308
    00309
    00310 XED_DLL_EXPORT xed_uint32_t xed_inst_flag_info_index(const xed_inst_t* p);
    00311
    00313
    00315
    00316
    00317
    00318 XED_DLL_EXPORT xed_uint32_t
    00319 xed_inst_get_attribute(const xed_inst_t* p,
    00320                        xed_attribute_enum_t attr);
    00321
    00324 XED_DLL_EXPORT xed_attributes_t
    00325 xed_inst_get_attributes(const xed_inst_t* p);
    00326
    00327
    00330 XED_DLL_EXPORT unsigned int xed_attribute_max(void);
    00331
    00335 XED_DLL_EXPORT xed_attribute_enum_t xed_attribute(unsigned int i);
    00336
    00338
    00340
    00341
    00342
    00343
    00344 static XED_INLINE  xed_exception_enum_t xed_inst_exception(const xed_inst_t* p) {
    00345     return p->_exceptions;
    00346 }
    00347
    00349
    00350
    00351 XED_DLL_EXPORT const xed_inst_t* xed_inst_table_base(void);
    00352
    00353 #endif