VirtualBox

source: vbox/trunk/include/VBox/dis.h@ 52664

Last change on this file since 52664 was 47412, checked in by vboxsync, 11 years ago

PMOVSKB -> PMOVMSKB; DISOPTYPE_SSE/MMX/FPU.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 34.6 KB
Line 
1/** @file
2 * DIS - The VirtualBox Disassembler.
3 */
4
5/*
6 * Copyright (C) 2006-2012 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * The contents of this file may alternatively be used under the terms
17 * of the Common Development and Distribution License Version 1.0
18 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19 * VirtualBox OSE distribution, in which case the provisions of the
20 * CDDL are applicable instead of those of the GPL.
21 *
22 * You may elect to license modified versions of this file under the
23 * terms and conditions of either the GPL or the CDDL or both.
24 */
25
26#ifndef ___VBox_dis_h
27#define ___VBox_dis_h
28
29#include <VBox/types.h>
30#include <VBox/disopcode.h>
31#include <iprt/assert.h>
32
33
34RT_C_DECLS_BEGIN
35
36
37/** @name Prefix byte flags (DISSTATE::fPrefix).
38 * @{
39 */
40#define DISPREFIX_NONE UINT8_C(0x00)
41/** non-default address size. */
42#define DISPREFIX_ADDRSIZE UINT8_C(0x01)
43/** non-default operand size. */
44#define DISPREFIX_OPSIZE UINT8_C(0x02)
45/** lock prefix. */
46#define DISPREFIX_LOCK UINT8_C(0x04)
47/** segment prefix. */
48#define DISPREFIX_SEG UINT8_C(0x08)
49/** rep(e) prefix (not a prefix, but we'll treat is as one). */
50#define DISPREFIX_REP UINT8_C(0x10)
51/** rep(e) prefix (not a prefix, but we'll treat is as one). */
52#define DISPREFIX_REPNE UINT8_C(0x20)
53/** REX prefix (64 bits) */
54#define DISPREFIX_REX UINT8_C(0x40)
55/** @} */
56
57/** @name 64 bits prefix byte flags (DISSTATE::fRexPrefix).
58 * Requires VBox/disopcode.h.
59 * @{
60 */
61#define DISPREFIX_REX_OP_2_FLAGS(a) (a - OP_PARM_REX_START)
62/*#define DISPREFIX_REX_FLAGS DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX) - 0, which is no flag */
63#define DISPREFIX_REX_FLAGS_B DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_B)
64#define DISPREFIX_REX_FLAGS_X DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_X)
65#define DISPREFIX_REX_FLAGS_XB DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_XB)
66#define DISPREFIX_REX_FLAGS_R DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_R)
67#define DISPREFIX_REX_FLAGS_RB DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_RB)
68#define DISPREFIX_REX_FLAGS_RX DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_RX)
69#define DISPREFIX_REX_FLAGS_RXB DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_RXB)
70#define DISPREFIX_REX_FLAGS_W DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_W)
71#define DISPREFIX_REX_FLAGS_WB DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_WB)
72#define DISPREFIX_REX_FLAGS_WX DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_WX)
73#define DISPREFIX_REX_FLAGS_WXB DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_WXB)
74#define DISPREFIX_REX_FLAGS_WR DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_WR)
75#define DISPREFIX_REX_FLAGS_WRB DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_WRB)
76#define DISPREFIX_REX_FLAGS_WRX DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_WRX)
77#define DISPREFIX_REX_FLAGS_WRXB DISPREFIX_REX_OP_2_FLAGS(OP_PARM_REX_WRXB)
78/** @} */
79AssertCompile(RT_IS_POWER_OF_TWO(DISPREFIX_REX_FLAGS_B));
80AssertCompile(RT_IS_POWER_OF_TWO(DISPREFIX_REX_FLAGS_X));
81AssertCompile(RT_IS_POWER_OF_TWO(DISPREFIX_REX_FLAGS_W));
82AssertCompile(RT_IS_POWER_OF_TWO(DISPREFIX_REX_FLAGS_R));
83
84/** @name Operand type (DISOPCODE::fOpType).
85 * @{
86 */
87#define DISOPTYPE_INVALID RT_BIT_32(0)
88#define DISOPTYPE_HARMLESS RT_BIT_32(1)
89#define DISOPTYPE_CONTROLFLOW RT_BIT_32(2)
90#define DISOPTYPE_POTENTIALLY_DANGEROUS RT_BIT_32(3)
91#define DISOPTYPE_DANGEROUS RT_BIT_32(4)
92#define DISOPTYPE_PORTIO RT_BIT_32(5)
93#define DISOPTYPE_PRIVILEGED RT_BIT_32(6)
94#define DISOPTYPE_PRIVILEGED_NOTRAP RT_BIT_32(7)
95#define DISOPTYPE_UNCOND_CONTROLFLOW RT_BIT_32(8)
96#define DISOPTYPE_RELATIVE_CONTROLFLOW RT_BIT_32(9)
97#define DISOPTYPE_COND_CONTROLFLOW RT_BIT_32(10)
98#define DISOPTYPE_INTERRUPT RT_BIT_32(11)
99#define DISOPTYPE_ILLEGAL RT_BIT_32(12)
100#define DISOPTYPE_RRM_DANGEROUS RT_BIT_32(14) /**< Some additional dangerous ones when recompiling raw r0. */
101#define DISOPTYPE_RRM_DANGEROUS_16 RT_BIT_32(15) /**< Some additional dangerous ones when recompiling 16-bit raw r0. */
102#define DISOPTYPE_RRM_MASK (DISOPTYPE_RRM_DANGEROUS | DISOPTYPE_RRM_DANGEROUS_16)
103#define DISOPTYPE_INHIBIT_IRQS RT_BIT_32(16) /**< Will or can inhibit irqs (sti, pop ss, mov ss) */
104#define DISOPTYPE_PORTIO_READ RT_BIT_32(17)
105#define DISOPTYPE_PORTIO_WRITE RT_BIT_32(18)
106#define DISOPTYPE_INVALID_64 RT_BIT_32(19) /**< Invalid in 64 bits mode */
107#define DISOPTYPE_ONLY_64 RT_BIT_32(20) /**< Only valid in 64 bits mode */
108#define DISOPTYPE_DEFAULT_64_OP_SIZE RT_BIT_32(21) /**< Default 64 bits operand size */
109#define DISOPTYPE_FORCED_64_OP_SIZE RT_BIT_32(22) /**< Forced 64 bits operand size; regardless of prefix bytes */
110#define DISOPTYPE_REXB_EXTENDS_OPREG RT_BIT_32(23) /**< REX.B extends the register field in the opcode byte */
111#define DISOPTYPE_MOD_FIXED_11 RT_BIT_32(24) /**< modrm.mod is always 11b */
112#define DISOPTYPE_FORCED_32_OP_SIZE_X86 RT_BIT_32(25) /**< Forced 32 bits operand size; regardless of prefix bytes (only in 16 & 32 bits mode!) */
113#define DISOPTYPE_SSE RT_BIT_32(29) /**< SSE,SSE2,SSE3,AVX,++ instruction. Not implemented yet! */
114#define DISOPTYPE_MMX RT_BIT_32(30) /**< MMX,MMXExt,3DNow,++ instruction. Not implemented yet! */
115#define DISOPTYPE_FPU RT_BIT_32(31) /**< FPU instruction. Not implemented yet! */
116#define DISOPTYPE_ALL UINT32_C(0xffffffff)
117/** @} */
118
119/** @name Parameter usage flags.
120 * @{
121 */
122#define DISUSE_BASE RT_BIT_64(0)
123#define DISUSE_INDEX RT_BIT_64(1)
124#define DISUSE_SCALE RT_BIT_64(2)
125#define DISUSE_REG_GEN8 RT_BIT_64(3)
126#define DISUSE_REG_GEN16 RT_BIT_64(4)
127#define DISUSE_REG_GEN32 RT_BIT_64(5)
128#define DISUSE_REG_GEN64 RT_BIT_64(6)
129#define DISUSE_REG_FP RT_BIT_64(7)
130#define DISUSE_REG_MMX RT_BIT_64(8)
131#define DISUSE_REG_XMM RT_BIT_64(9)
132#define DISUSE_REG_CR RT_BIT_64(10)
133#define DISUSE_REG_DBG RT_BIT_64(11)
134#define DISUSE_REG_SEG RT_BIT_64(12)
135#define DISUSE_REG_TEST RT_BIT_64(13)
136#define DISUSE_DISPLACEMENT8 RT_BIT_64(14)
137#define DISUSE_DISPLACEMENT16 RT_BIT_64(15)
138#define DISUSE_DISPLACEMENT32 RT_BIT_64(16)
139#define DISUSE_DISPLACEMENT64 RT_BIT_64(17)
140#define DISUSE_RIPDISPLACEMENT32 RT_BIT_64(18)
141#define DISUSE_IMMEDIATE8 RT_BIT_64(19)
142#define DISUSE_IMMEDIATE8_REL RT_BIT_64(20)
143#define DISUSE_IMMEDIATE16 RT_BIT_64(21)
144#define DISUSE_IMMEDIATE16_REL RT_BIT_64(22)
145#define DISUSE_IMMEDIATE32 RT_BIT_64(23)
146#define DISUSE_IMMEDIATE32_REL RT_BIT_64(24)
147#define DISUSE_IMMEDIATE64 RT_BIT_64(25)
148#define DISUSE_IMMEDIATE64_REL RT_BIT_64(26)
149#define DISUSE_IMMEDIATE_ADDR_0_32 RT_BIT_64(27)
150#define DISUSE_IMMEDIATE_ADDR_16_32 RT_BIT_64(28)
151#define DISUSE_IMMEDIATE_ADDR_0_16 RT_BIT_64(29)
152#define DISUSE_IMMEDIATE_ADDR_16_16 RT_BIT_64(30)
153/** DS:ESI */
154#define DISUSE_POINTER_DS_BASED RT_BIT_64(31)
155/** ES:EDI */
156#define DISUSE_POINTER_ES_BASED RT_BIT_64(32)
157#define DISUSE_IMMEDIATE16_SX8 RT_BIT_64(33)
158#define DISUSE_IMMEDIATE32_SX8 RT_BIT_64(34)
159#define DISUSE_IMMEDIATE64_SX8 RT_BIT_64(36)
160
161/** Mask of immediate use flags. */
162#define DISUSE_IMMEDIATE ( DISUSE_IMMEDIATE8 \
163 | DISUSE_IMMEDIATE16 \
164 | DISUSE_IMMEDIATE32 \
165 | DISUSE_IMMEDIATE64 \
166 | DISUSE_IMMEDIATE8_REL \
167 | DISUSE_IMMEDIATE16_REL \
168 | DISUSE_IMMEDIATE32_REL \
169 | DISUSE_IMMEDIATE64_REL \
170 | DISUSE_IMMEDIATE_ADDR_0_32 \
171 | DISUSE_IMMEDIATE_ADDR_16_32 \
172 | DISUSE_IMMEDIATE_ADDR_0_16 \
173 | DISUSE_IMMEDIATE_ADDR_16_16 \
174 | DISUSE_IMMEDIATE16_SX8 \
175 | DISUSE_IMMEDIATE32_SX8 \
176 | DISUSE_IMMEDIATE64_SX8)
177/** Check if the use flags indicates an effective address. */
178#define DISUSE_IS_EFFECTIVE_ADDR(a_fUseFlags) (!!( (a_fUseFlags) \
179 & ( DISUSE_BASE \
180 | DISUSE_INDEX \
181 | DISUSE_DISPLACEMENT32 \
182 | DISUSE_DISPLACEMENT64 \
183 | DISUSE_DISPLACEMENT16 \
184 | DISUSE_DISPLACEMENT8 \
185 | DISUSE_RIPDISPLACEMENT32) ))
186/** @} */
187
188/** @name 64-bit general register indexes.
189 * This matches the AMD64 register encoding. It is found used in
190 * DISOPPARAM::Base.idxGenReg and DISOPPARAM::Index.idxGenReg.
191 * @note Safe to assume same values as the 16-bit and 32-bit general registers.
192 * @{
193 */
194#define DISGREG_RAX UINT8_C(0)
195#define DISGREG_RCX UINT8_C(1)
196#define DISGREG_RDX UINT8_C(2)
197#define DISGREG_RBX UINT8_C(3)
198#define DISGREG_RSP UINT8_C(4)
199#define DISGREG_RBP UINT8_C(5)
200#define DISGREG_RSI UINT8_C(6)
201#define DISGREG_RDI UINT8_C(7)
202#define DISGREG_R8 UINT8_C(8)
203#define DISGREG_R9 UINT8_C(9)
204#define DISGREG_R10 UINT8_C(10)
205#define DISGREG_R11 UINT8_C(11)
206#define DISGREG_R12 UINT8_C(12)
207#define DISGREG_R13 UINT8_C(13)
208#define DISGREG_R14 UINT8_C(14)
209#define DISGREG_R15 UINT8_C(15)
210/** @} */
211
212/** @name 32-bit general register indexes.
213 * This matches the AMD64 register encoding. It is found used in
214 * DISOPPARAM::Base.idxGenReg and DISOPPARAM::Index.idxGenReg.
215 * @note Safe to assume same values as the 16-bit and 64-bit general registers.
216 * @{
217 */
218#define DISGREG_EAX UINT8_C(0)
219#define DISGREG_ECX UINT8_C(1)
220#define DISGREG_EDX UINT8_C(2)
221#define DISGREG_EBX UINT8_C(3)
222#define DISGREG_ESP UINT8_C(4)
223#define DISGREG_EBP UINT8_C(5)
224#define DISGREG_ESI UINT8_C(6)
225#define DISGREG_EDI UINT8_C(7)
226#define DISGREG_R8D UINT8_C(8)
227#define DISGREG_R9D UINT8_C(9)
228#define DISGREG_R10D UINT8_C(10)
229#define DISGREG_R11D UINT8_C(11)
230#define DISGREG_R12D UINT8_C(12)
231#define DISGREG_R13D UINT8_C(13)
232#define DISGREG_R14D UINT8_C(14)
233#define DISGREG_R15D UINT8_C(15)
234/** @} */
235
236/** @name 16-bit general register indexes.
237 * This matches the AMD64 register encoding. It is found used in
238 * DISOPPARAM::Base.idxGenReg and DISOPPARAM::Index.idxGenReg.
239 * @note Safe to assume same values as the 32-bit and 64-bit general registers.
240 * @{
241 */
242#define DISGREG_AX UINT8_C(0)
243#define DISGREG_CX UINT8_C(1)
244#define DISGREG_DX UINT8_C(2)
245#define DISGREG_BX UINT8_C(3)
246#define DISGREG_SP UINT8_C(4)
247#define DISGREG_BP UINT8_C(5)
248#define DISGREG_SI UINT8_C(6)
249#define DISGREG_DI UINT8_C(7)
250#define DISGREG_R8W UINT8_C(8)
251#define DISGREG_R9W UINT8_C(9)
252#define DISGREG_R10W UINT8_C(10)
253#define DISGREG_R11W UINT8_C(11)
254#define DISGREG_R12W UINT8_C(12)
255#define DISGREG_R13W UINT8_C(13)
256#define DISGREG_R14W UINT8_C(14)
257#define DISGREG_R15W UINT8_C(15)
258/** @} */
259
260/** @name 8-bit general register indexes.
261 * This mostly (?) matches the AMD64 register encoding. It is found used in
262 * DISOPPARAM::Base.idxGenReg and DISOPPARAM::Index.idxGenReg.
263 * @{
264 */
265#define DISGREG_AL UINT8_C(0)
266#define DISGREG_CL UINT8_C(1)
267#define DISGREG_DL UINT8_C(2)
268#define DISGREG_BL UINT8_C(3)
269#define DISGREG_AH UINT8_C(4)
270#define DISGREG_CH UINT8_C(5)
271#define DISGREG_DH UINT8_C(6)
272#define DISGREG_BH UINT8_C(7)
273#define DISGREG_R8B UINT8_C(8)
274#define DISGREG_R9B UINT8_C(9)
275#define DISGREG_R10B UINT8_C(10)
276#define DISGREG_R11B UINT8_C(11)
277#define DISGREG_R12B UINT8_C(12)
278#define DISGREG_R13B UINT8_C(13)
279#define DISGREG_R14B UINT8_C(14)
280#define DISGREG_R15B UINT8_C(15)
281#define DISGREG_SPL UINT8_C(16)
282#define DISGREG_BPL UINT8_C(17)
283#define DISGREG_SIL UINT8_C(18)
284#define DISGREG_DIL UINT8_C(19)
285/** @} */
286
287/** @name Segment registerindexes.
288 * This matches the AMD64 register encoding. It is found used in
289 * DISOPPARAM::Base.idxSegReg.
290 * @{
291 */
292typedef enum
293{
294 DISSELREG_ES = 0,
295 DISSELREG_CS = 1,
296 DISSELREG_SS = 2,
297 DISSELREG_DS = 3,
298 DISSELREG_FS = 4,
299 DISSELREG_GS = 5,
300 /** End of the valid register index values. */
301 DISSELREG_END,
302 /** The usual 32-bit paranoia. */
303 DIS_SEGREG_32BIT_HACK = 0x7fffffff
304} DISSELREG;
305/** @} */
306
307/** @name FPU register indexes.
308 * This matches the AMD64 register encoding. It is found used in
309 * DISOPPARAM::Base.idxFpuReg.
310 * @{
311 */
312#define DISFPREG_ST0 UINT8_C(0)
313#define DISFPREG_ST1 UINT8_C(1)
314#define DISFPREG_ST2 UINT8_C(2)
315#define DISFPREG_ST3 UINT8_C(3)
316#define DISFPREG_ST4 UINT8_C(4)
317#define DISFPREG_ST5 UINT8_C(5)
318#define DISFPREG_ST6 UINT8_C(6)
319#define DISFPREG_ST7 UINT8_C(7)
320/** @} */
321
322/** @name Control register indexes.
323 * This matches the AMD64 register encoding. It is found used in
324 * DISOPPARAM::Base.idxCtrlReg.
325 * @{
326 */
327#define DISCREG_CR0 UINT8_C(0)
328#define DISCREG_CR1 UINT8_C(1)
329#define DISCREG_CR2 UINT8_C(2)
330#define DISCREG_CR3 UINT8_C(3)
331#define DISCREG_CR4 UINT8_C(4)
332#define DISCREG_CR8 UINT8_C(8)
333/** @} */
334
335/** @name Debug register indexes.
336 * This matches the AMD64 register encoding. It is found used in
337 * DISOPPARAM::Base.idxDbgReg.
338 * @{
339 */
340#define DISDREG_DR0 UINT8_C(0)
341#define DISDREG_DR1 UINT8_C(1)
342#define DISDREG_DR2 UINT8_C(2)
343#define DISDREG_DR3 UINT8_C(3)
344#define DISDREG_DR4 UINT8_C(4)
345#define DISDREG_DR5 UINT8_C(5)
346#define DISDREG_DR6 UINT8_C(6)
347#define DISDREG_DR7 UINT8_C(7)
348/** @} */
349
350/** @name MMX register indexes.
351 * This matches the AMD64 register encoding. It is found used in
352 * DISOPPARAM::Base.idxMmxReg.
353 * @{
354 */
355#define DISMREG_MMX0 UINT8_C(0)
356#define DISMREG_MMX1 UINT8_C(1)
357#define DISMREG_MMX2 UINT8_C(2)
358#define DISMREG_MMX3 UINT8_C(3)
359#define DISMREG_MMX4 UINT8_C(4)
360#define DISMREG_MMX5 UINT8_C(5)
361#define DISMREG_MMX6 UINT8_C(6)
362#define DISMREG_MMX7 UINT8_C(7)
363/** @} */
364
365/** @name SSE register indexes.
366 * This matches the AMD64 register encoding. It is found used in
367 * DISOPPARAM::Base.idxXmmReg.
368 * @{
369 */
370#define DISXREG_XMM0 UINT8_C(0)
371#define DISXREG_XMM1 UINT8_C(1)
372#define DISXREG_XMM2 UINT8_C(2)
373#define DISXREG_XMM3 UINT8_C(3)
374#define DISXREG_XMM4 UINT8_C(4)
375#define DISXREG_XMM5 UINT8_C(5)
376#define DISXREG_XMM6 UINT8_C(6)
377#define DISXREG_XMM7 UINT8_C(7)
378/** @} */
379
380
381/**
382 * Opcode parameter (operand) details.
383 */
384typedef struct DISOPPARAM
385{
386 /** A combination of DISUSE_XXX. */
387 uint64_t fUse;
388 /** Immediate value or address, applicable if any of the flags included in
389 * DISUSE_IMMEDIATE are set in fUse. */
390 uint64_t uValue;
391 /** Disposition. */
392 union
393 {
394 /** 64-bit displacement, applicable if DISUSE_DISPLACEMENT64 is set in fUse. */
395 int64_t i64;
396 uint64_t u64;
397 /** 32-bit displacement, applicable if DISUSE_DISPLACEMENT32 or
398 * DISUSE_RIPDISPLACEMENT32 is set in fUse. */
399 int32_t i32;
400 uint32_t u32;
401 /** 16-bit displacement, applicable if DISUSE_DISPLACEMENT16 is set in fUse. */
402 int32_t i16;
403 uint32_t u16;
404 /** 8-bit displacement, applicable if DISUSE_DISPLACEMENT8 is set in fUse. */
405 int32_t i8;
406 uint32_t u8;
407 } uDisp;
408 /** The base register from ModR/M or SIB, applicable if DISUSE_BASE is
409 * set in fUse. */
410 union
411 {
412 /** General register index (DISGREG_XXX), applicable if DISUSE_REG_GEN8,
413 * DISUSE_REG_GEN16, DISUSE_REG_GEN32 or DISUSE_REG_GEN64 is set in fUse. */
414 uint8_t idxGenReg;
415 /** FPU stack register index (DISFPREG_XXX), applicable if DISUSE_REG_FP is
416 * set in fUse. 1:1 indexes. */
417 uint8_t idxFpuReg;
418 /** MMX register index (DISMREG_XXX), applicable if DISUSE_REG_MMX is
419 * set in fUse. 1:1 indexes. */
420 uint8_t idxMmxReg;
421 /** SSE register index (DISXREG_XXX), applicable if DISUSE_REG_XMM is
422 * set in fUse. 1:1 indexes. */
423 uint8_t idxXmmReg;
424 /** Segment register index (DISSELREG_XXX), applicable if DISUSE_REG_SEG is
425 * set in fUse. */
426 uint8_t idxSegReg;
427 /** Test register, TR0-TR7, present on early IA32 CPUs, applicable if
428 * DISUSE_REG_TEST is set in fUse. No index defines for these. */
429 uint8_t idxTestReg;
430 /** Control register index (DISCREG_XXX), applicable if DISUSE_REG_CR is
431 * set in fUse. 1:1 indexes. */
432 uint8_t idxCtrlReg;
433 /** Debug register index (DISDREG_XXX), applicable if DISUSE_REG_DBG is
434 * set in fUse. 1:1 indexes. */
435 uint8_t idxDbgReg;
436 } Base;
437 /** The SIB index register meaning, applicable if DISUSE_INDEX is
438 * set in fUse. */
439 union
440 {
441 /** General register index (DISGREG_XXX), applicable if DISUSE_REG_GEN8,
442 * DISUSE_REG_GEN16, DISUSE_REG_GEN32 or DISUSE_REG_GEN64 is set in fUse. */
443 uint8_t idxGenReg;
444 } Index;
445 /** 2, 4 or 8, if DISUSE_SCALE is set in fUse. */
446 uint8_t uScale;
447 /** Parameter size. */
448 uint8_t cb;
449 /** Copy of the corresponding DISOPCODE::fParam1 / DISOPCODE::fParam2 /
450 * DISOPCODE::fParam3. */
451 uint32_t fParam;
452} DISOPPARAM;
453AssertCompileSize(DISOPPARAM, 32);
454/** Pointer to opcode parameter. */
455typedef DISOPPARAM *PDISOPPARAM;
456/** Pointer to opcode parameter. */
457typedef const DISOPPARAM *PCDISOPPARAM;
458
459
460/**
461 * Opcode descriptor.
462 */
463typedef struct DISOPCODE
464{
465#ifndef DIS_CORE_ONLY
466 const char *pszOpcode;
467#endif
468 /** Parameter \#1 parser index. */
469 uint8_t idxParse1;
470 /** Parameter \#2 parser index. */
471 uint8_t idxParse2;
472 /** Parameter \#3 parser index. */
473 uint8_t idxParse3;
474 /** Unused padding. */
475 uint8_t uUnused;
476 /** The opcode identifier. This DIS specific, @see grp_dis_opcodes and
477 * VBox/disopcode.h. */
478 uint16_t uOpcode;
479 /** Parameter \#1 info, @see grp_dis_opparam. */
480 uint16_t fParam1;
481 /** Parameter \#2 info, @see grp_dis_opparam. */
482 uint16_t fParam2;
483 /** Parameter \#3 info, @see grp_dis_opparam. */
484 uint16_t fParam3;
485 /** Operand type flags, DISOPTYPE_XXX. */
486 uint32_t fOpType;
487} DISOPCODE;
488/** Pointer to const opcode. */
489typedef const struct DISOPCODE *PCDISOPCODE;
490
491
492/**
493 * Callback for reading instruction bytes.
494 *
495 * @returns VBox status code, bytes in DISSTATE::abInstr and byte count in
496 * DISSTATE::cbCachedInstr.
497 * @param pDis Pointer to the disassembler state. The user
498 * argument can be found in DISSTATE::pvUser if needed.
499 * @param offInstr The offset relative to the start of the instruction.
500 *
501 * To get the source address, add this to
502 * DISSTATE::uInstrAddr.
503 *
504 * To calculate the destination buffer address, use it
505 * as an index into DISSTATE::abInstr.
506 *
507 * @param cbMinRead The minimum number of bytes to read.
508 * @param cbMaxRead The maximum number of bytes that may be read.
509 */
510typedef DECLCALLBACK(int) FNDISREADBYTES(PDISSTATE pDis, uint8_t offInstr, uint8_t cbMinRead, uint8_t cbMaxRead);
511/** Pointer to a opcode byte reader. */
512typedef FNDISREADBYTES *PFNDISREADBYTES;
513
514/** Parser callback.
515 * @remark no DECLCALLBACK() here because it's considered to be internal and
516 * there is no point in enforcing CDECL. */
517typedef size_t FNDISPARSE(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam);
518/** Pointer to a disassembler parser function. */
519typedef FNDISPARSE *PFNDISPARSE;
520/** Pointer to a const disassembler parser function pointer. */
521typedef PFNDISPARSE const *PCPFNDISPARSE;
522
523/**
524 * The diassembler state and result.
525 */
526typedef struct DISSTATE
527{
528 /** The number of valid bytes in abInstr. */
529 uint8_t cbCachedInstr;
530 /** SIB fields. */
531 union
532 {
533 /** Bitfield view */
534 struct
535 {
536 uint8_t Base;
537 uint8_t Index;
538 uint8_t Scale;
539 } Bits;
540 } SIB;
541 /** ModRM fields. */
542 union
543 {
544 /** Bitfield view */
545 struct
546 {
547 uint8_t Rm;
548 uint8_t Reg;
549 uint8_t Mod;
550 } Bits;
551 } ModRM;
552 /** The CPU mode (DISCPUMODE). */
553 uint8_t uCpuMode;
554 /** The addressing mode (DISCPUMODE). */
555 uint8_t uAddrMode;
556 /** The operand mode (DISCPUMODE). */
557 uint8_t uOpMode;
558 /** Per instruction prefix settings. */
559 uint8_t fPrefix;
560 /** REX prefix value (64 bits only). */
561 uint8_t fRexPrefix;
562 /** Segment prefix value (DISSELREG). */
563 uint8_t idxSegPrefix;
564 /** Last prefix byte (for SSE2 extension tables). */
565 uint8_t bLastPrefix;
566 /** Last significan opcode byte of instruction. */
567 uint8_t bOpCode;
568 /** The size of the prefix bytes. */
569 uint8_t cbPrefix;
570 /** The instruction size. */
571 uint8_t cbInstr;
572 /** Unused bytes. */
573 uint8_t abUnused[3];
574 /** Internal: instruction filter */
575 uint32_t fFilter;
576 /** Internal: pointer to disassembly function table */
577 PCPFNDISPARSE pfnDisasmFnTable;
578#if ARCH_BITS == 32
579 uint32_t uPtrPadding1;
580#endif
581 /** Pointer to the current instruction. */
582 PCDISOPCODE pCurInstr;
583#if ARCH_BITS == 32
584 uint32_t uPtrPadding2;
585#endif
586 /** The instruction bytes. */
587 uint8_t abInstr[16];
588 /** SIB displacment. */
589 int32_t i32SibDisp;
590
591 /** Return code set by a worker function like the opcode bytes readers. */
592 int32_t rc;
593 /** The address of the instruction. */
594 RTUINTPTR uInstrAddr;
595 /** Optional read function */
596 PFNDISREADBYTES pfnReadBytes;
597#if ARCH_BITS == 32
598 uint32_t uPadding3;
599#endif
600 /** User data supplied as an argument to the APIs. */
601 void *pvUser;
602#if ARCH_BITS == 32
603 uint32_t uPadding4;
604#endif
605 /** Parameters. */
606 DISOPPARAM Param1;
607 DISOPPARAM Param2;
608 DISOPPARAM Param3;
609} DISSTATE;
610AssertCompileSize(DISSTATE, 0xb8);
611
612/** @deprecated Use DISSTATE and change Cpu and DisState to Dis. */
613typedef DISSTATE DISCPUSTATE;
614
615
616
617DISDECL(int) DISInstrToStr(void const *pvInstr, DISCPUMODE enmCpuMode,
618 PDISSTATE pDis, uint32_t *pcbInstr, char *pszOutput, size_t cbOutput);
619DISDECL(int) DISInstrToStrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
620 PDISSTATE pDis, uint32_t *pcbInstr, char *pszOutput, size_t cbOutput);
621DISDECL(int) DISInstrToStrEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode,
622 PFNDISREADBYTES pfnReadBytes, void *pvUser, uint32_t uFilter,
623 PDISSTATE pDis, uint32_t *pcbInstr, char *pszOutput, size_t cbOutput);
624
625DISDECL(int) DISInstr(void const *pvInstr, DISCPUMODE enmCpuMode, PDISSTATE pDis, uint32_t *pcbInstr);
626DISDECL(int) DISInstrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
627 PDISSTATE pDis, uint32_t *pcbInstr);
628DISDECL(int) DISInstrEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t uFilter,
629 PFNDISREADBYTES pfnReadBytes, void *pvUser,
630 PDISSTATE pDis, uint32_t *pcbInstr);
631DISDECL(int) DISInstrWithPrefetchedBytes(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
632 void const *pvPrefetched, size_t cbPretched,
633 PFNDISREADBYTES pfnReadBytes, void *pvUser,
634 PDISSTATE pDis, uint32_t *pcbInstr);
635
636DISDECL(int) DISGetParamSize(PCDISSTATE pDis, PCDISOPPARAM pParam);
637DISDECL(DISSELREG) DISDetectSegReg(PCDISSTATE pDis, PCDISOPPARAM pParam);
638DISDECL(uint8_t) DISQuerySegPrefixByte(PCDISSTATE pDis);
639
640
641
642/** @name Flags returned by DISQueryParamVal (DISQPVPARAMVAL::flags).
643 * @{
644 */
645#define DISQPV_FLAG_8 UINT8_C(0x01)
646#define DISQPV_FLAG_16 UINT8_C(0x02)
647#define DISQPV_FLAG_32 UINT8_C(0x04)
648#define DISQPV_FLAG_64 UINT8_C(0x08)
649#define DISQPV_FLAG_FARPTR16 UINT8_C(0x10)
650#define DISQPV_FLAG_FARPTR32 UINT8_C(0x20)
651/** @} */
652
653/** @name Types returned by DISQueryParamVal (DISQPVPARAMVAL::flags).
654 * @{ */
655#define DISQPV_TYPE_REGISTER UINT8_C(1)
656#define DISQPV_TYPE_ADDRESS UINT8_C(2)
657#define DISQPV_TYPE_IMMEDIATE UINT8_C(3)
658/** @} */
659
660typedef struct
661{
662 union
663 {
664 uint8_t val8;
665 uint16_t val16;
666 uint32_t val32;
667 uint64_t val64;
668
669 struct
670 {
671 uint16_t sel;
672 uint32_t offset;
673 } farptr;
674 } val;
675
676 uint8_t type;
677 uint8_t size;
678 uint8_t flags;
679} DISQPVPARAMVAL;
680/** Pointer to opcode parameter value. */
681typedef DISQPVPARAMVAL *PDISQPVPARAMVAL;
682
683/** Indicates which parameter DISQueryParamVal should operate on. */
684typedef enum DISQPVWHICH
685{
686 DISQPVWHICH_DST = 1,
687 DISQPVWHICH_SRC,
688 DISQPVWHAT_32_BIT_HACK = 0x7fffffff
689} DISQPVWHICH;
690DISDECL(int) DISQueryParamVal(PCPUMCTXCORE pCtx, PCDISSTATE pDis, PCDISOPPARAM pParam, PDISQPVPARAMVAL pParamVal, DISQPVWHICH parmtype);
691DISDECL(int) DISQueryParamRegPtr(PCPUMCTXCORE pCtx, PCDISSTATE pDis, PCDISOPPARAM pParam, void **ppReg, size_t *pcbSize);
692
693DISDECL(int) DISFetchReg8(PCCPUMCTXCORE pCtx, unsigned reg8, uint8_t *pVal);
694DISDECL(int) DISFetchReg16(PCCPUMCTXCORE pCtx, unsigned reg16, uint16_t *pVal);
695DISDECL(int) DISFetchReg32(PCCPUMCTXCORE pCtx, unsigned reg32, uint32_t *pVal);
696DISDECL(int) DISFetchReg64(PCCPUMCTXCORE pCtx, unsigned reg64, uint64_t *pVal);
697DISDECL(int) DISFetchRegSeg(PCCPUMCTXCORE pCtx, DISSELREG sel, RTSEL *pVal);
698DISDECL(int) DISFetchRegSegEx(PCPUMCTXCORE pCtx, DISSELREG sel, PCPUMSELREG *ppSelReg);
699DISDECL(int) DISWriteReg8(PCPUMCTXCORE pRegFrame, unsigned reg8, uint8_t val8);
700DISDECL(int) DISWriteReg16(PCPUMCTXCORE pRegFrame, unsigned reg32, uint16_t val16);
701DISDECL(int) DISWriteReg32(PCPUMCTXCORE pRegFrame, unsigned reg32, uint32_t val32);
702DISDECL(int) DISWriteReg64(PCPUMCTXCORE pRegFrame, unsigned reg64, uint64_t val64);
703DISDECL(int) DISWriteRegSeg(PCPUMCTXCORE pCtx, DISSELREG sel, RTSEL val);
704DISDECL(int) DISPtrReg8(PCPUMCTXCORE pCtx, unsigned reg8, uint8_t **ppReg);
705DISDECL(int) DISPtrReg16(PCPUMCTXCORE pCtx, unsigned reg16, uint16_t **ppReg);
706DISDECL(int) DISPtrReg32(PCPUMCTXCORE pCtx, unsigned reg32, uint32_t **ppReg);
707DISDECL(int) DISPtrReg64(PCPUMCTXCORE pCtx, unsigned reg64, uint64_t **ppReg);
708
709
710/**
711 * Try resolve an address into a symbol name.
712 *
713 * For use with DISFormatYasmEx(), DISFormatMasmEx() and DISFormatGasEx().
714 *
715 * @returns VBox status code.
716 * @retval VINF_SUCCESS on success, pszBuf contains the full symbol name.
717 * @retval VINF_BUFFER_OVERFLOW if pszBuf is too small the symbol name. The
718 * content of pszBuf is truncated and zero terminated.
719 * @retval VERR_SYMBOL_NOT_FOUND if no matching symbol was found for the address.
720 *
721 * @param pDis Pointer to the disassembler CPU state.
722 * @param u32Sel The selector value. Use DIS_FMT_SEL_IS_REG, DIS_FMT_SEL_GET_VALUE,
723 * DIS_FMT_SEL_GET_REG to access this.
724 * @param uAddress The segment address.
725 * @param pszBuf Where to store the symbol name
726 * @param cchBuf The size of the buffer.
727 * @param poff If not a perfect match, then this is where the offset from the return
728 * symbol to the specified address is returned.
729 * @param pvUser The user argument.
730 */
731typedef DECLCALLBACK(int) FNDISGETSYMBOL(PCDISSTATE pDis, uint32_t u32Sel, RTUINTPTR uAddress, char *pszBuf, size_t cchBuf, RTINTPTR *poff, void *pvUser);
732/** Pointer to a FNDISGETSYMBOL(). */
733typedef FNDISGETSYMBOL *PFNDISGETSYMBOL;
734
735/**
736 * Checks if the FNDISGETSYMBOL argument u32Sel is a register or not.
737 */
738#define DIS_FMT_SEL_IS_REG(u32Sel) ( !!((u32Sel) & RT_BIT(31)) )
739
740/**
741 * Extracts the selector value from the FNDISGETSYMBOL argument u32Sel.
742 * @returns Selector value.
743 */
744#define DIS_FMT_SEL_GET_VALUE(u32Sel) ( (RTSEL)(u32Sel) )
745
746/**
747 * Extracts the register number from the FNDISGETSYMBOL argument u32Sel.
748 * @returns USE_REG_CS, USE_REG_SS, USE_REG_DS, USE_REG_ES, USE_REG_FS or USE_REG_FS.
749 */
750#define DIS_FMT_SEL_GET_REG(u32Sel) ( ((u32Sel) >> 16) & 0xf )
751
752/** @internal */
753#define DIS_FMT_SEL_FROM_REG(uReg) ( ((uReg) << 16) | RT_BIT(31) | 0xffff )
754/** @internal */
755#define DIS_FMT_SEL_FROM_VALUE(Sel) ( (Sel) & 0xffff )
756
757
758/** @name Flags for use with DISFormatYasmEx(), DISFormatMasmEx() and DISFormatGasEx().
759 * @{
760 */
761/** Put the address to the right. */
762#define DIS_FMT_FLAGS_ADDR_RIGHT RT_BIT_32(0)
763/** Put the address to the left. */
764#define DIS_FMT_FLAGS_ADDR_LEFT RT_BIT_32(1)
765/** Put the address in comments.
766 * For some assemblers this implies placing it to the right. */
767#define DIS_FMT_FLAGS_ADDR_COMMENT RT_BIT_32(2)
768/** Put the instruction bytes to the right of the disassembly. */
769#define DIS_FMT_FLAGS_BYTES_RIGHT RT_BIT_32(3)
770/** Put the instruction bytes to the left of the disassembly. */
771#define DIS_FMT_FLAGS_BYTES_LEFT RT_BIT_32(4)
772/** Put the instruction bytes in comments.
773 * For some assemblers this implies placing the bytes to the right. */
774#define DIS_FMT_FLAGS_BYTES_COMMENT RT_BIT_32(5)
775/** Put the bytes in square brackets. */
776#define DIS_FMT_FLAGS_BYTES_BRACKETS RT_BIT_32(6)
777/** Put spaces between the bytes. */
778#define DIS_FMT_FLAGS_BYTES_SPACED RT_BIT_32(7)
779/** Display the relative +/- offset of branch instructions that uses relative addresses,
780 * and put the target address in parenthesis. */
781#define DIS_FMT_FLAGS_RELATIVE_BRANCH RT_BIT_32(8)
782/** Strict assembly. The assembly should, when ever possible, make the
783 * assembler reproduce the exact same binary. (Refers to the yasm
784 * strict keyword.) */
785#define DIS_FMT_FLAGS_STRICT RT_BIT_32(9)
786/** Checks if the given flags are a valid combination. */
787#define DIS_FMT_FLAGS_IS_VALID(fFlags) \
788 ( !((fFlags) & ~UINT32_C(0x000003ff)) \
789 && ((fFlags) & (DIS_FMT_FLAGS_ADDR_RIGHT | DIS_FMT_FLAGS_ADDR_LEFT)) != (DIS_FMT_FLAGS_ADDR_RIGHT | DIS_FMT_FLAGS_ADDR_LEFT) \
790 && ( !((fFlags) & DIS_FMT_FLAGS_ADDR_COMMENT) \
791 || (fFlags & (DIS_FMT_FLAGS_ADDR_RIGHT | DIS_FMT_FLAGS_ADDR_LEFT)) ) \
792 && ((fFlags) & (DIS_FMT_FLAGS_BYTES_RIGHT | DIS_FMT_FLAGS_BYTES_LEFT)) != (DIS_FMT_FLAGS_BYTES_RIGHT | DIS_FMT_FLAGS_BYTES_LEFT) \
793 && ( !((fFlags) & (DIS_FMT_FLAGS_BYTES_COMMENT | DIS_FMT_FLAGS_BYTES_BRACKETS)) \
794 || (fFlags & (DIS_FMT_FLAGS_BYTES_RIGHT | DIS_FMT_FLAGS_BYTES_LEFT)) ) \
795 )
796/** @} */
797
798DISDECL(size_t) DISFormatYasm( PCDISSTATE pDis, char *pszBuf, size_t cchBuf);
799DISDECL(size_t) DISFormatYasmEx(PCDISSTATE pDis, char *pszBuf, size_t cchBuf, uint32_t fFlags, PFNDISGETSYMBOL pfnGetSymbol, void *pvUser);
800DISDECL(size_t) DISFormatMasm( PCDISSTATE pDis, char *pszBuf, size_t cchBuf);
801DISDECL(size_t) DISFormatMasmEx(PCDISSTATE pDis, char *pszBuf, size_t cchBuf, uint32_t fFlags, PFNDISGETSYMBOL pfnGetSymbol, void *pvUser);
802DISDECL(size_t) DISFormatGas( PCDISSTATE pDis, char *pszBuf, size_t cchBuf);
803DISDECL(size_t) DISFormatGasEx( PCDISSTATE pDis, char *pszBuf, size_t cchBuf, uint32_t fFlags, PFNDISGETSYMBOL pfnGetSymbol, void *pvUser);
804
805/** @todo DISAnnotate(PCDISSTATE pDis, char *pszBuf, size_t cchBuf, register
806 * reader, memory reader); */
807
808DISDECL(bool) DISFormatYasmIsOddEncoding(PDISSTATE pDis);
809
810
811RT_C_DECLS_END
812
813#endif
814
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle
Contact – Privacy/Do Not Sell My Info – Terms of Use