2 Intel Open Source License
4 Copyright (c) 2002-2007 Intel Corporation
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are
10 Redistributions of source code must retain the above copyright notice,
11 this list of conditions and the following disclaimer. Redistributions
12 in binary form must reproduce the above copyright notice, this list of
13 conditions and the following disclaimer in the documentation and/or
14 other materials provided with the distribution. Neither the name of
15 the Intel Corporation nor the names of its contributors may be used to
16 endorse or promote products derived from this software without
17 specific prior written permission.
19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
23 ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 /// @file xed-operand-values-interface.h
32 /// @author Mark Charney <mark.charney@intel.com>
34 #if !defined(_XED_OPERAND_VALUES_INTERFACE_H_)
35 # define _XED_OPERAND_VALUES_INTERFACE_H_
37 #include <xed/xed-common-hdrs.h>
38 #include <xed/xed-common-defs.h>
39 #include <xed/xed-portability.h>
40 #include <xed/xed-util.h>
41 #include <xed/xed-types.h>
42 #include <xed/xed-state.h> // a generated file
43 #include <xed/xed-operand-enum.h> // a generated file
44 #include <xed/xed-operand-storage.h>
45 #include <xed/xed-reg-enum.h> // generated
46 #include <xed/xed-iclass-enum.h> // generated
47 /// @name Initialization
50 /// Initializes operand structure
51 XED_DLL_EXPORT void xed_operand_values_init(xed_operand_values_t* p);
54 /// Initializes operand structure and sets state values
55 XED_DLL_EXPORT void xed_operand_values_init_set_mode(xed_operand_values_t* p,
56 const xed_state_t* dstate);
58 /// Initializes dst operand structure but preserves the existing
59 /// MODE/SMODE/AMODE values from the src operand structure.
60 XED_DLL_EXPORT void xed_operand_values_init_keep_mode( xed_operand_values_t* dst,
61 const xed_operand_values_t* src );
64 // Returns the raw operand fields. Do not use this.
65 XED_DLL_EXPORT xed_uint32_t
66 xed_operand_values_get_operand_decider(const xed_operand_values_t* p,
67 xed_operand_enum_t operand_decider_index) ;
70 ///////////////////////////////////////////////////////////
71 /// @name String output
74 /// Dump all the information about the operands to buf.
75 XED_DLL_EXPORT void xed_operand_values_dump(const xed_operand_values_t* ov, char* buf, int buflen);
77 /// More tersely dump all the information about the operands to buf.
78 XED_DLL_EXPORT void xed_operand_values_print_short(const xed_operand_values_t* ov, char* buf, int buflen);
81 /// @name REP/REPNE Prefixes
84 /// True if the instruction has a real REP prefix. This returns false if
85 /// there is no F2/F3 prefix or the F2/F3 prefix is used to refine the
86 /// opcode as in some SSE operations.
87 XED_DLL_EXPORT xed_bool_t
88 xed_operand_values_has_real_rep(const xed_operand_values_t* p);
90 /// True if the instruction as a real F3 REP prefix.
91 XED_DLL_EXPORT xed_bool_t
92 xed_operand_values_has_rep_prefix(const xed_operand_values_t* p);
94 /// True if the instruction as a real F2 REP prefix.
95 XED_DLL_EXPORT xed_bool_t
96 xed_operand_values_has_repne_prefix(const xed_operand_values_t* p);
100 /// Returns true if the memory operation has atomic read-modify-write
101 /// semantics. An XCHG accessing memory is atomic with or without a
103 XED_DLL_EXPORT xed_bool_t
104 xed_operand_values_get_atomic(const xed_operand_values_t* p);
106 /// @ingroup OPERANDS
107 /// Returns true if the memory operatoin has a valid lock prefix.
108 XED_DLL_EXPORT xed_bool_t
109 xed_operand_values_has_lock_prefix(const xed_operand_values_t* p);
111 /// @ingroup OPERANDS
112 /// Indicates if the default segment is being used.
113 /// @param[in] p the pointer to the #xed_operand_values_t structure.
114 /// @param[in] i 0 or 1, indicating which memory operation.
115 /// @return true if the memory operation is using the default segment for the associated addressing mode base register.
116 XED_DLL_EXPORT xed_bool_t
117 xed_operand_values_using_default_segment(const xed_operand_values_t* p, unsigned int i);
121 /// @ingroup OPERANDS
122 /// Returns The effective operand width in bits: 16/32/64. Note this is not
123 /// the same as the width of the operand! For 8 bit operations, the
124 /// effective operand width is the machine mode's default width.
125 XED_DLL_EXPORT xed_uint32_t xed_operand_values_get_effective_operand_width(const xed_operand_values_t* p);
126 /// @ingroup OPERANDS
127 /// Returns The effective address width in bits: 16/32/64.
128 XED_DLL_EXPORT xed_uint32_t xed_operand_values_get_effective_address_width(const xed_operand_values_t* p);
131 /// @ingroup OPERANDS
132 /// True if there is a memory displacement
133 XED_DLL_EXPORT xed_bool_t
134 xed_operand_values_has_memory_displacement(const xed_operand_values_t* p);
135 /// @ingroup OPERANDS
136 /// True if there is a branch displacement
137 XED_DLL_EXPORT xed_bool_t
138 xed_operand_values_has_branch_displacement(const xed_operand_values_t* p);
139 /// @ingroup OPERANDS
140 /// True if there is a memory or branch displacement
141 XED_DLL_EXPORT xed_bool_t
142 xed_operand_values_has_displacement(const xed_operand_values_t* p);
145 /// @ingroup OPERANDS
146 /// Deprecated. Compatibility function for XED0. See has_memory_displacement().
147 XED_DLL_EXPORT xed_bool_t
148 xed_operand_values_get_displacement_for_memop(const xed_operand_values_t* p);
150 /// @ingroup OPERANDS
151 /// Return true if there is an immediate operand
152 XED_DLL_EXPORT xed_bool_t
153 xed_operand_values_has_immediate(const xed_operand_values_t* p);
156 /// @ingroup OPERANDS
157 /// ALIAS for has_displacement().
158 /// Deprecated. See has_memory_displacement() and
159 /// has_branch_displacement().
160 XED_DLL_EXPORT xed_bool_t
161 xed_operand_values_has_disp(const xed_operand_values_t* p);
163 /// @ingroup OPERANDS
164 XED_DLL_EXPORT xed_bool_t
165 xed_operand_values_has_address_size_prefix(const xed_operand_values_t* p);
166 /// @ingroup OPERANDS
167 XED_DLL_EXPORT xed_bool_t
168 xed_operand_values_has_operand_size_prefix(const xed_operand_values_t* p);
171 XED_DLL_EXPORT xed_bool_t
172 xed_operand_values_has_refining_66_prefix(const xed_operand_values_t* p);
173 XED_DLL_EXPORT xed_bool_t
174 xed_operand_values_has_refining_f2_prefix(const xed_operand_values_t* p);
175 XED_DLL_EXPORT xed_bool_t
176 xed_operand_values_has_refining_f3_prefix(const xed_operand_values_t* p);
179 /// @ingroup OPERANDS
180 XED_DLL_EXPORT xed_bool_t
181 xed_operand_values_has_segment_prefix(const xed_operand_values_t* p);
183 /// @ingroup OPERANDS
184 /// Return the segment prefix, if any, as a #xed_reg_enum_t value.
185 XED_DLL_EXPORT xed_reg_enum_t
186 xed_operand_values_segment_prefix(const xed_operand_values_t* p);
188 /// @ingroup OPERANDS
189 XED_DLL_EXPORT xed_bool_t
190 xed_operand_values_is_prefetch(const xed_operand_values_t* p);
192 /// @ingroup OPERANDS
193 XED_DLL_EXPORT xed_bool_t xed_operand_values_get_long_mode(const xed_operand_values_t* p);
195 /// @name Memory Addressing
197 /// @ingroup OPERANDS
198 XED_DLL_EXPORT xed_bool_t
199 xed_operand_values_accesses_memory(const xed_operand_values_t* p);
201 /// @ingroup OPERANDS
202 XED_DLL_EXPORT unsigned int
203 xed_operand_values_number_of_memory_operands(const xed_operand_values_t* p);
205 /// @ingroup OPERANDS
206 XED_DLL_EXPORT unsigned int
207 xed_operand_values_get_memory_operand_length(const xed_operand_values_t* p,
208 unsigned int memop_idx);
210 /// @ingroup OPERANDS
211 XED_DLL_EXPORT xed_reg_enum_t
212 xed_operand_values_get_base_reg(const xed_operand_values_t* p,unsigned int memop_idx);
214 /// @ingroup OPERANDS
215 XED_DLL_EXPORT xed_reg_enum_t
216 xed_operand_values_get_index_reg(const xed_operand_values_t* p,unsigned int memop_idx);
218 /// @ingroup OPERANDS
219 XED_DLL_EXPORT xed_reg_enum_t
220 xed_operand_values_get_seg_reg(const xed_operand_values_t* p,unsigned int memop_idx);
222 /// @ingroup OPERANDS
223 XED_DLL_EXPORT unsigned int
224 xed_operand_values_get_scale(const xed_operand_values_t* p);
226 /// @ingroup OPERANDS
227 /// Returns true if the instruction access memory but without using a MODRM
228 /// byte limiting its addressing modes.
229 XED_DLL_EXPORT xed_bool_t
230 xed_operand_values_memop_without_modrm(const xed_operand_values_t* p);
231 /// @ingroup OPERANDS
232 /// Returns true if the instruction has a MODRM byte.
233 XED_DLL_EXPORT xed_bool_t
234 xed_operand_values_has_modrm_byte(const xed_operand_values_t* p);
236 /// @ingroup OPERANDS
237 /// Returns true if the instruction has a SIB byte.
238 XED_DLL_EXPORT xed_bool_t
239 xed_operand_values_has_sib_byte(const xed_operand_values_t* p);
242 /// @ingroup OPERANDS
243 XED_DLL_EXPORT xed_bool_t
244 xed_operand_values_branch_not_taken_hint(const xed_operand_values_t* p);
245 /// @ingroup OPERANDS
246 XED_DLL_EXPORT xed_bool_t
247 xed_operand_values_branch_taken_hint(const xed_operand_values_t* p);
249 /// @ingroup OPERANDS
250 XED_DLL_EXPORT xed_bool_t
251 xed_operand_values_is_nop(const xed_operand_values_t* p);
256 /// @ingroup OPERANDS
257 XED_DLL_EXPORT xed_int64_t
258 xed_operand_values_get_immediate_int64(const xed_operand_values_t* p);
260 /// @ingroup OPERANDS
261 XED_DLL_EXPORT xed_uint64_t
262 xed_operand_values_get_immediate_uint64(const xed_operand_values_t* p);
264 /// @ingroup OPERANDS
265 /// Return true if the first immediate (IMM0) is signed
266 XED_DLL_EXPORT xed_uint_t xed_operand_values_get_immediate_is_signed(const xed_operand_values_t* p);
269 /// @ingroup OPERANDS
270 XED_DLL_EXPORT xed_uint8_t
271 xed_operand_values_get_immediate_byte(const xed_operand_values_t* p,unsigned int i);
273 /// @ingroup OPERANDS
274 XED_DLL_EXPORT xed_uint8_t
275 xed_operand_values_get_second_immediate(const xed_operand_values_t* p);
278 /// @name Memory Displacements
280 /// @ingroup OPERANDS
281 /// Return the memory displacement width in BYTES
282 XED_DLL_EXPORT xed_uint32_t
283 xed_operand_values_get_memory_displacement_length(const xed_operand_values_t* p);
284 /// @ingroup OPERANDS
285 /// Return the memory displacement width in BITS
286 XED_DLL_EXPORT xed_uint32_t
287 xed_operand_values_get_memory_displacement_length_bits(const xed_operand_values_t* p);
289 /// @ingroup OPERANDS
290 XED_DLL_EXPORT xed_int64_t
291 xed_operand_values_get_memory_displacement_int64(const xed_operand_values_t* p);
293 /// @ingroup OPERANDS
294 XED_DLL_EXPORT xed_uint8_t
295 xed_operand_values_get_memory_displacement_byte(const xed_operand_values_t* p,unsigned int i);
298 /// @name Branch Displacements
300 /// @ingroup OPERANDS
301 /// Return the branch displacement width in bytes
302 XED_DLL_EXPORT xed_uint32_t
303 xed_operand_values_get_branch_displacement_length(const xed_operand_values_t* p);
304 /// @ingroup OPERANDS
305 /// Return the branch displacement width in bits
306 XED_DLL_EXPORT xed_uint32_t
307 xed_operand_values_get_branch_displacement_length_bits(const xed_operand_values_t* p);
309 /// @ingroup OPERANDS
310 XED_DLL_EXPORT xed_int32_t
311 xed_operand_values_get_branch_displacement_int32(const xed_operand_values_t* p);
313 /// @ingroup OPERANDS
314 XED_DLL_EXPORT xed_uint8_t
315 xed_operand_values_get_branch_displacement_byte(const xed_operand_values_t* p,unsigned int i);
319 /// @ingroup OPERANDS
320 XED_DLL_EXPORT xed_iclass_enum_t
321 xed_operand_values_get_iclass(const xed_operand_values_t* p);
323 ////////////////////////////////////////////////////
325 ////////////////////////////////////////////////////
328 /// @ingroup OPERANDS
329 XED_DLL_EXPORT void xed_operand_values_zero_immediate(xed_operand_values_t* p);
330 /// @ingroup OPERANDS
331 XED_DLL_EXPORT void xed_operand_values_zero_branch_displacement(xed_operand_values_t* p);
332 /// @ingroup OPERANDS
333 XED_DLL_EXPORT void xed_operand_values_zero_memory_displacement(xed_operand_values_t* p);
335 /// @ingroup OPERANDS
336 XED_DLL_EXPORT void xed_operand_values_set_lock(xed_operand_values_t* p);
337 /// @ingroup OPERANDS
338 XED_DLL_EXPORT void xed_operand_values_zero_segment_override(xed_operand_values_t* p);
341 /// @ingroup OPERANDS
343 xed_operand_values_set_iclass(xed_operand_values_t* p,xed_iclass_enum_t iclass);
345 /// @ingroup OPERANDS
347 xed_operand_values_set_effective_operand_width(xed_operand_values_t* p,unsigned int width);
349 /// @ingroup OPERANDS
351 xed_operand_values_set_memory_operand_length(xed_operand_values_t* p,unsigned int memop_length);
354 /// @ingroup OPERANDS
355 /// Set the memory displacement using a BYTES length
357 xed_operand_values_set_memory_displacement(xed_operand_values_t* p,xed_int64_t x, unsigned int len);
358 /// @ingroup OPERANDS
359 /// Set the memory displacement using a BITS length
361 xed_operand_values_set_memory_displacement_bits(xed_operand_values_t* p,xed_int64_t x, unsigned int len_bits);
363 /// @ingroup OPERANDS
364 /// Indicate that we have a relative branch.
365 XED_DLL_EXPORT void xed_operand_values_set_relbr(xed_operand_values_t* p);
367 /// @ingroup OPERANDS
368 /// Set the branch displacement using a BYTES length
370 xed_operand_values_set_branch_displacement(xed_operand_values_t* p,xed_int32_t x, unsigned int len);
371 /// @ingroup OPERANDS
372 /// Set the branch displacement using a BITS length
374 xed_operand_values_set_branch_displacement_bits(xed_operand_values_t* p,xed_int32_t x, unsigned int len_bits);
376 /// @ingroup OPERANDS
377 /// Set the signed immediate using a BYTES length
379 xed_operand_values_set_immediate_signed(xed_operand_values_t* p,xed_int32_t x, unsigned int bytes);
380 /// @ingroup OPERANDS
381 /// Set the signed immediate using a BITS length
383 xed_operand_values_set_immediate_signed_bits(xed_operand_values_t* p,xed_int32_t x, unsigned int bits);
386 /// @ingroup OPERANDS
387 /// Set the unsigned immediate using a BYTE length.
389 xed_operand_values_set_immediate_unsigned(xed_operand_values_t* p,xed_uint64_t x, unsigned int bytes);
390 /// @ingroup OPERANDS
391 /// Set the unsigned immediate using a BIT length.
393 xed_operand_values_set_immediate_unsigned_bits(xed_operand_values_t* p,xed_uint64_t x, unsigned int bits);
397 /// @ingroup OPERANDS
398 XED_DLL_EXPORT void xed_operand_values_set_base_reg(xed_operand_values_t* p,
399 unsigned int memop_idx,
400 xed_reg_enum_t new_base);
402 /// @ingroup OPERANDS
403 XED_DLL_EXPORT void xed_operand_values_set_seg_reg(xed_operand_values_t* p,
404 unsigned int memop_idx,
405 xed_reg_enum_t new_seg);
407 /// @ingroup OPERANDS
408 XED_DLL_EXPORT void xed_operand_values_set_index_reg(xed_operand_values_t* p,
409 unsigned int memop_idx,
410 xed_reg_enum_t new_index);
412 /// @ingroup OPERANDS
413 XED_DLL_EXPORT void xed_operand_values_set_scale(xed_operand_values_t* p,
414 xed_uint_t memop_idx,
415 xed_uint_t new_scale);
418 /// @ingroup OPERANDS
419 /// Set the operand storage field entry named 'operand_name' to the
420 /// register value specified by 'reg_name'.
422 xed_operand_values_set_operand_reg(xed_operand_values_t* p,
423 xed_operand_enum_t operand_name,
424 xed_reg_enum_t reg_name);
430 //pref: "../../xed-operand-values-interface.c"