Disasm.cpp@ 26509

Last change on this file since 26509 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	*/
59	DISDECL(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	*/
93	DISDECL(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	*/
114	DISDECL(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	//*****************************************************************************
307	char 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	//*****************************************************************************
327	void 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.

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

Download in other formats: