VirtualBox

source: vbox/trunk/src/VBox/Disassembler/Disasm.cpp@ 25414

Last change on this file since 25414 was 20961, checked in by vboxsync, 15 years ago

fixed typo, it means occurred, not occured
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 15.9 KB
Line 
1/** @file
2 *
3 * VBox disassembler:
4 * Main
5 */
6
7/*
8 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 *
18 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
19 * Clara, CA 95054 USA or visit http://www.sun.com if you need
20 * additional information or have any questions.
21 */
22
23
24/*******************************************************************************
25* Header Files *
26*******************************************************************************/
27#ifdef USING_VISUAL_STUDIO
28# include <stdafx.h>
29#endif
30#include <VBox/dis.h>
31#include <VBox/disopcode.h>
32#include <VBox/err.h>
33#include <iprt/assert.h>
34#include <iprt/string.h>
35#include "DisasmInternal.h"
36#include "DisasmTables.h"
37
38
39/**
40 * Disassembles a code block.
41 *
42 * @returns VBox error code
43 * @param pCpu Pointer to cpu structure which have DISCPUSTATE::mode
44 * set correctly.
45 * @param pvCodeBlock Pointer to the strunction to disassemble.
46 * @param cbMax Maximum number of bytes to disassemble.
47 * @param pcbSize Where to store the size of the instruction.
48 * NULL is allowed.
49 *
50 *
51 * @todo Define output callback.
52 * @todo Using signed integers as sizes is a bit odd. There are still
53 * some GCC warnings about mixing signed and unsigend integers.
54 * @todo Need to extend this interface to include a code address so we
55 * can dissassemble GC code. Perhaps a new function is better...
56 * @remark cbMax isn't respected as a boundry. DISInstr() will read beyond cbMax.
57 * This means *pcbSize >= cbMax sometimes.
58 */
59DISDECL(int) DISBlock(PDISCPUSTATE pCpu, RTUINTPTR pvCodeBlock, unsigned cbMax, unsigned *pSize)
60{
61 unsigned i = 0;
62 char szOutput[256];
63
64 while (i < cbMax)
65 {
66 unsigned cbInstr;
67 int rc = DISInstr(pCpu, pvCodeBlock + i, 0, &cbInstr, szOutput);
68 if (RT_FAILURE(rc))
69 return rc;
70
71 i += cbInstr;
72 }
73
74 if (pSize)
75 *pSize = i;
76 return true;
77}
78
79/**
80 * Disassembles one instruction
81 *
82 * @returns VBox error code
83 * @param pCpu Pointer to cpu structure which have DISCPUSTATE::mode
84 * set correctly.
85 * @param pu8Instruction Pointer to the strunction to disassemble.
86 * @param u32EipOffset Offset to add to instruction address to get the real virtual address
87 * @param pcbSize Where to store the size of the instruction.
88 * NULL is allowed.
89 * @param pszOutput Storage for disassembled instruction
90 *
91 * @todo Define output callback.
92 */
93DISDECL(int) DISInstr(PDISCPUSTATE pCpu, RTUINTPTR pu8Instruction, unsigned u32EipOffset, unsigned *pcbSize,
94 char *pszOutput)
95{
96 return DISInstrEx(pCpu, pu8Instruction, u32EipOffset, pcbSize, pszOutput, OPTYPE_ALL);
97}
98
99/**
100 * Disassembles one instruction; only fully disassembly an instruction if it matches the filter criteria
101 *
102 * @returns VBox error code
103 * @param pCpu Pointer to cpu structure which have DISCPUSTATE::mode
104 * set correctly.
105 * @param pu8Instruction Pointer to the strunction to disassemble.
106 * @param u32EipOffset Offset to add to instruction address to get the real virtual address
107 * @param pcbSize Where to store the size of the instruction.
108 * NULL is allowed.
109 * @param pszOutput Storage for disassembled instruction
110 * @param uFilter Instruction type filter
111 *
112 * @todo Define output callback.
113 */
114DISDECL(int) DISInstrEx(PDISCPUSTATE pCpu, RTUINTPTR pu8Instruction, unsigned u32EipOffset, unsigned *pcbSize,
115 char *pszOutput, unsigned uFilter)
116{
117 unsigned i = 0, prefixbytes;
118 unsigned idx, inc;
119 const OPCODE *paOneByteMap;
120#ifdef __L4ENV__
121 jmp_buf jumpbuffer;
122#endif
123
124 //reset instruction settings
125 pCpu->prefix = PREFIX_NONE;
126 pCpu->enmPrefixSeg = DIS_SELREG_DS;
127 pCpu->ModRM.u = 0;
128 pCpu->SIB.u = 0;
129 pCpu->lastprefix = 0;
130 pCpu->param1.parval = 0;
131 pCpu->param2.parval = 0;
132 pCpu->param3.parval = 0;
133 pCpu->param1.szParam[0] = 0;
134 pCpu->param2.szParam[0] = 0;
135 pCpu->param3.szParam[0] = 0;
136 pCpu->param1.size = 0;
137 pCpu->param2.size = 0;
138 pCpu->param3.size = 0;
139 pCpu->param1.flags = 0;
140 pCpu->param2.flags = 0;
141 pCpu->param3.flags = 0;
142 pCpu->uFilter = uFilter;
143 pCpu->pfnDisasmFnTable = pfnFullDisasm;
144
145 if (pszOutput)
146 *pszOutput = '\0';
147
148 if (pCpu->mode == CPUMODE_64BIT)
149 {
150 paOneByteMap = g_aOneByteMapX64;
151 pCpu->addrmode = CPUMODE_64BIT;
152 pCpu->opmode = CPUMODE_32BIT;
153 }
154 else
155 {
156 paOneByteMap = g_aOneByteMapX86;
157 pCpu->addrmode = pCpu->mode;
158 pCpu->opmode = pCpu->mode;
159 }
160
161 prefixbytes = 0;
162#ifndef __L4ENV__ /* Unfortunately, we have no exception handling in l4env */
163 try
164#else
165 pCpu->pJumpBuffer = &jumpbuffer;
166 if (setjmp(jumpbuffer) == 0)
167#endif
168 {
169 while(1)
170 {
171 uint8_t codebyte = DISReadByte(pCpu, pu8Instruction+i);
172 uint8_t opcode = paOneByteMap[codebyte].opcode;
173
174 /* Hardcoded assumption about OP_* values!! */
175 if (opcode <= OP_LAST_PREFIX)
176 {
177 /* The REX prefix must precede the opcode byte(s). Any other placement is ignored. */
178 if (opcode != OP_REX)
179 {
180 pCpu->lastprefix = opcode;
181 pCpu->prefix &= ~PREFIX_REX;
182 }
183
184 switch(opcode)
185 {
186 case OP_INVALID:
187#if 0 //defined (DEBUG_Sander)
188 AssertMsgFailed(("Invalid opcode!!\n"));
189#endif
190 return VERR_DIS_INVALID_OPCODE;
191
192 // segment override prefix byte
193 case OP_SEG:
194 pCpu->enmPrefixSeg = (DIS_SELREG)(paOneByteMap[codebyte].param1 - OP_PARM_REG_SEG_START);
195 /* Segment prefixes for CS, DS, ES and SS are ignored in long mode. */
196 if ( pCpu->mode != CPUMODE_64BIT
197 || pCpu->enmPrefixSeg >= DIS_SELREG_FS)
198 {
199 pCpu->prefix |= PREFIX_SEG;
200 }
201 i += sizeof(uint8_t);
202 prefixbytes++;
203 continue; //fetch the next byte
204
205 // lock prefix byte
206 case OP_LOCK:
207 pCpu->prefix |= PREFIX_LOCK;
208 i += sizeof(uint8_t);
209 prefixbytes++;
210 continue; //fetch the next byte
211
212 // address size override prefix byte
213 case OP_ADDRSIZE:
214 pCpu->prefix |= PREFIX_ADDRSIZE;
215 if (pCpu->mode == CPUMODE_16BIT)
216 pCpu->addrmode = CPUMODE_32BIT;
217 else
218 if (pCpu->mode == CPUMODE_32BIT)
219 pCpu->addrmode = CPUMODE_16BIT;
220 else
221 pCpu->addrmode = CPUMODE_32BIT; /* 64 bits */
222
223 i += sizeof(uint8_t);
224 prefixbytes++;
225 continue; //fetch the next byte
226
227 // operand size override prefix byte
228 case OP_OPSIZE:
229 pCpu->prefix |= PREFIX_OPSIZE;
230 if (pCpu->mode == CPUMODE_16BIT)
231 pCpu->opmode = CPUMODE_32BIT;
232 else
233 pCpu->opmode = CPUMODE_16BIT; /* for 32 and 64 bits mode (there is no 32 bits operand size override prefix) */
234
235 i += sizeof(uint8_t);
236 prefixbytes++;
237 continue; //fetch the next byte
238
239 // rep and repne are not really prefixes, but we'll treat them as such
240 case OP_REPE:
241 pCpu->prefix |= PREFIX_REP;
242 i += sizeof(uint8_t);
243 prefixbytes += sizeof(uint8_t);
244 continue; //fetch the next byte
245
246 case OP_REPNE:
247 pCpu->prefix |= PREFIX_REPNE;
248 i += sizeof(uint8_t);
249 prefixbytes += sizeof(uint8_t);
250 continue; //fetch the next byte
251
252 case OP_REX:
253 Assert(pCpu->mode == CPUMODE_64BIT);
254 /* REX prefix byte */
255 pCpu->prefix |= PREFIX_REX;
256 pCpu->prefix_rex = PREFIX_REX_OP_2_FLAGS(paOneByteMap[codebyte].param1);
257 i += sizeof(uint8_t);
258 prefixbytes += sizeof(uint8_t);
259
260 if (pCpu->prefix_rex & PREFIX_REX_FLAGS_W)
261 pCpu->opmode = CPUMODE_64BIT; /* overrides size prefix byte */
262 continue; //fetch the next byte
263 }
264 }
265
266 idx = i;
267 i += sizeof(uint8_t); //first opcode byte
268
269 pCpu->opcode = codebyte;
270 /* Prefix byte(s) is/are part of the instruction. */
271 pCpu->opaddr = pu8Instruction + idx + u32EipOffset - prefixbytes;
272
273 inc = ParseInstruction(pu8Instruction + i, &paOneByteMap[pCpu->opcode], pCpu);
274
275 pCpu->opsize = prefixbytes + inc + sizeof(uint8_t);
276
277 if(pszOutput) {
278 disasmSprintf(pszOutput, pu8Instruction+i-1-prefixbytes, pCpu, &pCpu->param1, &pCpu->param2, &pCpu->param3);
279 }
280
281 i += inc;
282 prefixbytes = 0;
283 break;
284 }
285 }
286#ifndef __L4ENV__
287 catch(...)
288#else
289 else /* setjmp has returned a non-zero value: an exception occurred */
290#endif
291 {
292 if (pcbSize)
293 *pcbSize = 0;
294 return VERR_DIS_GEN_FAILURE;
295 }
296
297 if (pcbSize)
298 *pcbSize = i;
299
300 if (pCpu->prefix & PREFIX_LOCK)
301 disValidateLockSequence(pCpu);
302
303 return VINF_SUCCESS;
304}
305//*****************************************************************************
306//*****************************************************************************
307char *DbgBytesToString(PDISCPUSTATE pCpu, RTUINTPTR pBytes, int size, char *pszOutput)
308{
309 char *psz = strchr(pszOutput, '\0');
310 size_t len;
311 int i;
312
313 for(len = psz - pszOutput; len < 40; len++)
314 *psz++ = ' ';
315 *psz++ = ' ';
316 *psz++ = '[';
317
318 for(i = 0; (int)i < size; i++)
319 psz += RTStrPrintf(psz, 64, "%02X ", DISReadByte(pCpu, pBytes+i));
320
321 psz[-1] = ']'; // replaces space
322
323 return pszOutput;
324}
325//*****************************************************************************
326//*****************************************************************************
327void disasmSprintf(char *pszOutput, RTUINTPTR pu8Instruction, PDISCPUSTATE pCpu, OP_PARAMETER *pParam1, OP_PARAMETER *pParam2, OP_PARAMETER *pParam3)
328{
329 const char *lpszFormat = pCpu->pszOpcode;
330 int param = 1;
331
332 RTStrPrintf(pszOutput, 64, "%08X: ", (unsigned)pCpu->opaddr);
333 if(pCpu->prefix & PREFIX_LOCK)
334 {
335 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, "lock ");
336 }
337 if(pCpu->prefix & PREFIX_REP)
338 {
339 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, "rep(e) ");
340 }
341 else
342 if(pCpu->prefix & PREFIX_REPNE)
343 {
344 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, "repne ");
345 }
346
347 if(!strcmp("Invalid Opcode", lpszFormat))
348 {
349 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, "Invalid Opcode [%02X][%02X]", DISReadByte(pCpu, pu8Instruction), DISReadByte(pCpu, pu8Instruction+1) );
350 }
351 else
352 while(*lpszFormat)
353 {
354 switch(*lpszFormat)
355 {
356 case '%':
357 switch(*(lpszFormat+1))
358 {
359 case 'J': //Relative jump offset
360 {
361 int32_t disp;
362
363 AssertMsg(param == 1, ("Invalid branch parameter nr"));
364 if(pParam1->flags & USE_IMMEDIATE8_REL)
365 {
366 disp = (int32_t)(char)pParam1->parval;
367 }
368 else
369 if(pParam1->flags & USE_IMMEDIATE16_REL)
370 {
371 disp = (int32_t)(uint16_t)pParam1->parval;
372 }
373 else
374 if(pParam1->flags & USE_IMMEDIATE32_REL)
375 {
376 disp = (int32_t)pParam1->parval;
377 }
378 else
379 if(pParam1->flags & USE_IMMEDIATE64_REL)
380 {
381 /* @todo: is this correct? */
382 disp = (int32_t)pParam1->parval;
383 }
384 else
385 {
386 AssertMsgFailed(("Oops!\n"));
387 return;
388 }
389 uint32_t addr = (uint32_t)(pCpu->opaddr + pCpu->opsize) + disp;
390 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, "[%08X]", addr);
391 }
392
393 //no break;
394
395 case 'A': //direct address
396 case 'C': //control register
397 case 'D': //debug register
398 case 'E': //ModRM specifies parameter
399 case 'F': //Eflags register
400 case 'G': //ModRM selects general register
401 case 'I': //Immediate data
402 case 'M': //ModRM may only refer to memory
403 case 'O': //No ModRM byte
404 case 'P': //ModRM byte selects MMX register
405 case 'Q': //ModRM byte selects MMX register or memory address
406 case 'R': //ModRM byte may only refer to a general register
407 case 'S': //ModRM byte selects a segment register
408 case 'T': //ModRM byte selects a test register
409 case 'V': //ModRM byte selects an XMM/SSE register
410 case 'W': //ModRM byte selects an XMM/SSE register or a memory address
411 case 'X': //DS:SI
412 case 'Y': //ES:DI
413 switch(param)
414 {
415 case 1:
416 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, pParam1->szParam);
417 break;
418 case 2:
419 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, pParam2->szParam);
420 break;
421 case 3:
422 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, pParam3->szParam);
423 break;
424 }
425 break;
426
427 case 'e': //register based on operand size (e.g. %eAX)
428 if(pCpu->opmode == CPUMODE_32BIT)
429 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, "E");
430 if(pCpu->opmode == CPUMODE_64BIT)
431 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, "R");
432
433 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, "%c%c", lpszFormat[2], lpszFormat[3]);
434 break;
435
436 default:
437 AssertMsgFailed(("Oops!\n"));
438 break;
439 }
440
441 //Go to the next parameter in the format string
442 while(*lpszFormat && *lpszFormat != ',') lpszFormat++;
443 if(*lpszFormat == ',') lpszFormat--;
444
445 break;
446
447 case ',':
448 param++;
449 //no break
450
451 default:
452 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, "%c", *lpszFormat);
453 break;
454 }
455
456 if(*lpszFormat) lpszFormat++;
457 }
458 DbgBytesToString(pCpu, pu8Instruction, pCpu->opsize, pszOutput);
459 RTStrPrintf(&pszOutput[strlen(pszOutput)], 64, "\n");
460}
461//*****************************************************************************
462//*****************************************************************************
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use