DisasmFormatArmV8.cpp@ 99678

Last change on this file since 99678 was 99321, checked in by vboxsync, 20 months ago
Disassember: Continue work on the ARMv8 disassember, defining the instruction table layout and intermediate structures for decoding, bugref:10394 [scm fix]
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 18.8 KB

Line
1	/* $Id: DisasmFormatArmV8.cpp 99321 2023-04-06 19:36:23Z vboxsync $ */
2	/** @file
3	* VBox Disassembler - Yasm(/Nasm) Style Formatter.
4	*/
5
6	/*
7	* Copyright (C) 2008-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <VBox/dis.h>
33	#include "DisasmInternal.h"
34	#include <iprt/assert.h>
35	#include <iprt/ctype.h>
36	#include <iprt/errcore.h>
37	#include <iprt/string.h>
38
39
40	/*********************************************************************************************************************************
41	* Global Variables *
42	*********************************************************************************************************************************/
43	static const char g_szSpaces[] =
44	" ";
45	static const char g_aszArmV8RegGen32[32][4] =
46	{
47	"w0\0", "w1\0", "w2\0", "w3\0", "w4\0", "w5\0", "w6\0", "w7\0", "w8\0", "w9\0", "w10", "w11", "w12", "w13", "w14", "w15",
48	"w16", "w17", "w18", "w19", "w20", "w21", "w22", "w23", "w24", "w25", "w26", "w27", "w28", "w29", "w30", "zr"
49	};
50	static const char g_aszArmV8RegGen64[32][4] =
51	{
52	"x0\0", "x1\0", "x2\0", "x3\0", "x4\0", "x5\0", "x6\0", "x7\0", "x8\0", "x9\0", "x10", "x11", "x12", "x13", "x14", "x15",
53	"x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23", "x24", "x25", "x26", "x27", "x28", "x29", "x30", "zr"
54	};
55
56
57	/**
58	* Gets the base register name for the given parameter.
59	*
60	* @returns Pointer to the register name.
61	* @param pDis The disassembler state.
62	* @param pParam The parameter.
63	* @param pcchReg Where to store the length of the name.
64	*/
65	static const char disasmFormatArmV8Reg(PCDISSTATE pDis, PCDISOPPARAM pParam, size_t pcchReg)
66	{
67	RT_NOREF_PV(pDis);
68
69	switch (pParam->fUse & ( DISUSE_REG_GEN8 \| DISUSE_REG_GEN16 \| DISUSE_REG_GEN32 \| DISUSE_REG_GEN64
70	\| DISUSE_REG_FP \| DISUSE_REG_MMX \| DISUSE_REG_XMM \| DISUSE_REG_YMM
71	\| DISUSE_REG_CR \| DISUSE_REG_DBG \| DISUSE_REG_SEG \| DISUSE_REG_TEST))
72
73	{
74	case DISUSE_REG_GEN32:
75	{
76	Assert(pParam->arch.armv8.Reg.idxGenReg < RT_ELEMENTS(g_aszArmV8RegGen32));
77	const char *psz = g_aszArmV8RegGen32[pParam->arch.armv8.Reg.idxGenReg];
78	*pcchReg = 2 + !!psz[2];
79	return psz;
80	}
81
82	case DISUSE_REG_GEN64:
83	{
84	Assert(pParam->arch.armv8.Reg.idxGenReg < RT_ELEMENTS(g_aszArmV8RegGen64));
85	const char *psz = g_aszArmV8RegGen64[pParam->arch.armv8.Reg.idxGenReg];
86	*pcchReg = 2 + !!psz[2];
87	return psz;
88	return psz;
89	}
90
91	default:
92	AssertMsgFailed(("%#x\n", pParam->fUse));
93	*pcchReg = 3;
94	return "r??";
95	}
96	}
97
98
99	/**
100	* Formats the current instruction in Yasm (/ Nasm) style.
101	*
102	*
103	* @returns The number of output characters. If this is >= cchBuf, then the content
104	* of pszBuf will be truncated.
105	* @param pDis Pointer to the disassembler state.
106	* @param pszBuf The output buffer.
107	* @param cchBuf The size of the output buffer.
108	* @param fFlags Format flags, see DIS_FORMAT_FLAGS_*.
109	* @param pfnGetSymbol Get symbol name for a jmp or call target address. Optional.
110	* @param pvUser User argument for pfnGetSymbol.
111	*/
112	DISDECL(size_t) DISFormatArmV8Ex(PCDISSTATE pDis, char *pszBuf, size_t cchBuf, uint32_t fFlags,
113	PFNDISGETSYMBOL pfnGetSymbol, void *pvUser)
114	{
115	/** @todo monitor and mwait aren't formatted correctly in 64-bit mode. */
116	/*
117	* Input validation and massaging.
118	*/
119	AssertPtr(pDis);
120	AssertPtrNull(pszBuf);
121	Assert(pszBuf \|\| !cchBuf);
122	AssertPtrNull(pfnGetSymbol);
123	AssertMsg(DIS_FMT_FLAGS_IS_VALID(fFlags), ("%#x\n", fFlags));
124	if (fFlags & DIS_FMT_FLAGS_ADDR_COMMENT)
125	fFlags = (fFlags & ~DIS_FMT_FLAGS_ADDR_LEFT) \| DIS_FMT_FLAGS_ADDR_RIGHT;
126	if (fFlags & DIS_FMT_FLAGS_BYTES_COMMENT)
127	fFlags = (fFlags & ~DIS_FMT_FLAGS_BYTES_LEFT) \| DIS_FMT_FLAGS_BYTES_RIGHT;
128
129	PCDISOPCODE const pOp = pDis->pCurInstr;
130
131	/*
132	* Output macros
133	*/
134	char *pszDst = pszBuf;
135	size_t cchDst = cchBuf;
136	size_t cchOutput = 0;
137	#define PUT_C(ch) \
138	do { \
139	cchOutput++; \
140	if (cchDst > 1) \
141	{ \
142	cchDst--; \
143	*pszDst++ = (ch); \
144	} \
145	} while (0)
146	#define PUT_STR(pszSrc, cchSrc) \
147	do { \
148	cchOutput += (cchSrc); \
149	if (cchDst > (cchSrc)) \
150	{ \
151	memcpy(pszDst, (pszSrc), (cchSrc)); \
152	pszDst += (cchSrc); \
153	cchDst -= (cchSrc); \
154	} \
155	else if (cchDst > 1) \
156	{ \
157	memcpy(pszDst, (pszSrc), cchDst - 1); \
158	pszDst += cchDst - 1; \
159	cchDst = 1; \
160	} \
161	} while (0)
162	#define PUT_SZ(sz) \
163	PUT_STR((sz), sizeof(sz) - 1)
164	#define PUT_SZ_STRICT(szStrict, szRelaxed) \
165	do { if (fFlags & DIS_FMT_FLAGS_STRICT) PUT_SZ(szStrict); else PUT_SZ(szRelaxed); } while (0)
166	#define PUT_PSZ(psz) \
167	do { const size_t cchTmp = strlen(psz); PUT_STR((psz), cchTmp); } while (0)
168	#define PUT_NUM(cch, fmt, num) \
169	do { \
170	cchOutput += (cch); \
171	if (cchDst > 1) \
172	{ \
173	const size_t cchTmp = RTStrPrintf(pszDst, cchDst, fmt, (num)); \
174	pszDst += cchTmp; \
175	cchDst -= cchTmp; \
176	Assert(cchTmp == (cch) \|\| cchDst == 1); \
177	} \
178	} while (0)
179	/** @todo add two flags for choosing between %X / %x and h / 0x. */
180	#define PUT_NUM_8(num) PUT_NUM(4, "0x%02x", (uint8_t)(num))
181	#define PUT_NUM_16(num) PUT_NUM(6, "0x%04x", (uint16_t)(num))
182	#define PUT_NUM_32(num) PUT_NUM(10, "0x%08x", (uint32_t)(num))
183	#define PUT_NUM_64(num) PUT_NUM(18, "0x%016RX64", (uint64_t)(num))
184
185	#define PUT_NUM_SIGN(cch, fmt, num, stype, utype) \
186	do { \
187	if ((stype)(num) >= 0) \
188	{ \
189	PUT_C('+'); \
190	PUT_NUM(cch, fmt, (utype)(num)); \
191	} \
192	else \
193	{ \
194	PUT_C('-'); \
195	PUT_NUM(cch, fmt, (utype)-(stype)(num)); \
196	} \
197	} while (0)
198	#define PUT_NUM_S8(num) PUT_NUM_SIGN(4, "0x%02x", num, int8_t, uint8_t)
199	#define PUT_NUM_S16(num) PUT_NUM_SIGN(6, "0x%04x", num, int16_t, uint16_t)
200	#define PUT_NUM_S32(num) PUT_NUM_SIGN(10, "0x%08x", num, int32_t, uint32_t)
201	#define PUT_NUM_S64(num) PUT_NUM_SIGN(18, "0x%016RX64", num, int64_t, uint64_t)
202
203	#define PUT_SYMBOL_TWO(a_rcSym, a_szStart, a_chEnd) \
204	do { \
205	if (RT_SUCCESS(a_rcSym)) \
206	{ \
207	PUT_SZ(a_szStart); \
208	PUT_PSZ(szSymbol); \
209	if (off != 0) \
210	{ \
211	if ((int8_t)off == off) \
212	PUT_NUM_S8(off); \
213	else if ((int16_t)off == off) \
214	PUT_NUM_S16(off); \
215	else if ((int32_t)off == off) \
216	PUT_NUM_S32(off); \
217	else \
218	PUT_NUM_S64(off); \
219	} \
220	PUT_C(a_chEnd); \
221	} \
222	} while (0)
223
224	#define PUT_SYMBOL(a_uSeg, a_uAddr, a_szStart, a_chEnd) \
225	do { \
226	if (pfnGetSymbol) \
227	{ \
228	int rcSym = pfnGetSymbol(pDis, a_uSeg, a_uAddr, szSymbol, sizeof(szSymbol), &off, pvUser); \
229	PUT_SYMBOL_TWO(rcSym, a_szStart, a_chEnd); \
230	} \
231	} while (0)
232
233
234	/*
235	* The address?
236	*/
237	if (fFlags & DIS_FMT_FLAGS_ADDR_LEFT)
238	{
239	#if HC_ARCH_BITS == 64 \|\| GC_ARCH_BITS == 64
240	if (pDis->uInstrAddr >= _4G)
241	PUT_NUM(9, "%08x`", (uint32_t)(pDis->uInstrAddr >> 32));
242	#endif
243	PUT_NUM(8, "%08x", (uint32_t)pDis->uInstrAddr);
244	PUT_C(' ');
245	}
246
247	/*
248	* The opcode bytes?
249	*/
250	if (fFlags & DIS_FMT_FLAGS_BYTES_LEFT)
251	{
252	size_t cchTmp = disFormatBytes(pDis, pszDst, cchDst, fFlags);
253	cchOutput += cchTmp;
254	if (cchDst > 1)
255	{
256	if (cchTmp <= cchDst)
257	{
258	cchDst -= cchTmp;
259	pszDst += cchTmp;
260	}
261	else
262	{
263	pszDst += cchDst - 1;
264	cchDst = 1;
265	}
266	}
267
268	/* Some padding to align the instruction. */
269	size_t cchPadding = (7 * (2 + !!(fFlags & DIS_FMT_FLAGS_BYTES_SPACED)))
270	+ !!(fFlags & DIS_FMT_FLAGS_BYTES_BRACKETS) * 2
271	+ 2;
272	cchPadding = cchTmp + 1 >= cchPadding ? 1 : cchPadding - cchTmp;
273	PUT_STR(g_szSpaces, cchPadding);
274	}
275
276
277	/*
278	* Filter out invalid opcodes first as they need special
279	* treatment. UDF is an exception and should be handled normally.
280	*/
281	size_t const offInstruction = cchOutput;
282	if (pOp->uOpcode == OP_INVALID)
283	PUT_SZ("Illegal opcode");
284	else
285	{
286	/*
287	* Formatting context and associated macros.
288	*/
289	PCDISOPPARAM pParam = &pDis->Param1;
290	int iParam = 1;
291
292	const char *pszFmt = pOp->pszOpcode;
293
294	/*
295	* The formatting loop.
296	*/
297	RTINTPTR off;
298	char szSymbol[128];
299	char ch;
300	while ((ch = *pszFmt++) != '\0')
301	{
302	if (ch == '%')
303	{
304	ch = *pszFmt++;
305	switch (ch)
306	{
307	case 'I': /* Immediate data. */
308	PUT_C('#');
309	switch (pParam->fUse & ( DISUSE_IMMEDIATE8 \| DISUSE_IMMEDIATE16 \| DISUSE_IMMEDIATE32 \| DISUSE_IMMEDIATE64
310	\| DISUSE_IMMEDIATE16_SX8 \| DISUSE_IMMEDIATE32_SX8 \| DISUSE_IMMEDIATE64_SX8))
311	{
312	case DISUSE_IMMEDIATE8:
313	PUT_NUM_8(pParam->uValue);
314	break;
315	case DISUSE_IMMEDIATE16:
316	PUT_NUM_16(pParam->uValue);
317	break;
318	case DISUSE_IMMEDIATE16_SX8:
319	PUT_NUM_16(pParam->uValue);
320	break;
321	case DISUSE_IMMEDIATE32:
322	PUT_NUM_32(pParam->uValue);
323	/** @todo Symbols */
324	break;
325	case DISUSE_IMMEDIATE32_SX8:
326	PUT_NUM_32(pParam->uValue);
327	break;
328	case DISUSE_IMMEDIATE64_SX8:
329	PUT_NUM_64(pParam->uValue);
330	break;
331	case DISUSE_IMMEDIATE64:
332	PUT_NUM_64(pParam->uValue);
333	/** @todo Symbols */
334	break;
335	default:
336	AssertFailed();
337	break;
338	}
339	break;
340
341	case 'X': /* Register. */
342	{
343	pszFmt += RT_C_IS_ALPHA(pszFmt[0]) ? RT_C_IS_ALPHA(pszFmt[1]) ? 2 : 1 : 0;
344	Assert(!(pParam->fUse & (DISUSE_DISPLACEMENT8 \| DISUSE_DISPLACEMENT16 \| DISUSE_DISPLACEMENT32 \| DISUSE_DISPLACEMENT64 \| DISUSE_RIPDISPLACEMENT32)));
345
346	size_t cchReg;
347	const char *pszReg = disasmFormatArmV8Reg(pDis, pParam, &cchReg);
348	PUT_STR(pszReg, cchReg);
349	break;
350	}
351
352	case 'J': /* Relative jump offset (ParseImmBRel + ParseImmVRel). */
353	{
354	int32_t offDisplacement;
355
356	PUT_C('#');
357	if (pParam->fUse & DISUSE_IMMEDIATE8_REL)
358	{
359	offDisplacement = (int8_t)pParam->uValue;
360	if (fFlags & DIS_FMT_FLAGS_RELATIVE_BRANCH)
361	PUT_NUM_S8(offDisplacement);
362	}
363	else if (pParam->fUse & DISUSE_IMMEDIATE16_REL)
364	{
365	offDisplacement = (int16_t)pParam->uValue;
366	if (fFlags & DIS_FMT_FLAGS_RELATIVE_BRANCH)
367	PUT_NUM_S16(offDisplacement);
368	}
369	else
370	{
371	offDisplacement = (int32_t)pParam->uValue;
372	if (fFlags & DIS_FMT_FLAGS_RELATIVE_BRANCH)
373	PUT_NUM_S32(offDisplacement);
374	}
375	if (fFlags & DIS_FMT_FLAGS_RELATIVE_BRANCH)
376	PUT_SZ(" (");
377
378	RTUINTPTR uTrgAddr = pDis->uInstrAddr + pDis->cbInstr + offDisplacement;
379	if ( pDis->uCpuMode == DISCPUMODE_ARMV8_A32
380	\|\| pDis->uCpuMode == DISCPUMODE_ARMV8_T32)
381	PUT_NUM_32(uTrgAddr);
382	else if (pDis->uCpuMode == DISCPUMODE_ARMV8_A64)
383	PUT_NUM_64(uTrgAddr);
384	else
385	AssertReleaseFailed();
386
387	if (fFlags & DIS_FMT_FLAGS_RELATIVE_BRANCH)
388	{
389	PUT_SYMBOL(DIS_FMT_SEL_FROM_REG(DISSELREG_CS), uTrgAddr, " = ", ' ');
390	PUT_C(')');
391	}
392	else
393	PUT_SYMBOL(DIS_FMT_SEL_FROM_REG(DISSELREG_CS), uTrgAddr, " (", ')');
394	break;
395	}
396
397	case 'C': /* Conditional */
398	{
399	/** @todo */
400	/* Skip any whitespace coming after (as this is not really part of the parameters). */
401	while (*pszFmt == ' ')
402	pszFmt++;
403
404	switch (++iParam)
405	{
406	case 2: pParam = &pDis->Param2; break;
407	case 3: pParam = &pDis->Param3; break;
408	case 4: pParam = &pDis->Param4; break;
409	default: pParam = NULL; break;
410	}
411	break;
412	}
413
414	default:
415	AssertMsgFailed(("%c%s!\n", ch, pszFmt));
416	break;
417	}
418	AssertMsg(pszFmt == ',' \|\| pszFmt == '\0' \|\| *pszFmt == '%', ("%c%s\n", ch, pszFmt));
419	}
420	else
421	{
422	PUT_C(ch);
423	if (ch == ',')
424	{
425	Assert(*pszFmt != ' ');
426	PUT_C(' ');
427	switch (++iParam)
428	{
429	case 2: pParam = &pDis->Param2; break;
430	case 3: pParam = &pDis->Param3; break;
431	case 4: pParam = &pDis->Param4; break;
432	default: pParam = NULL; break;
433	}
434	}
435	}
436	} /* while more to format */
437	}
438
439	/*
440	* Any additional output to the right of the instruction?
441	*/
442	if (fFlags & (DIS_FMT_FLAGS_BYTES_RIGHT \| DIS_FMT_FLAGS_ADDR_RIGHT))
443	{
444	/* some up front padding. */
445	size_t cchPadding = cchOutput - offInstruction;
446	cchPadding = cchPadding + 1 >= 42 ? 1 : 42 - cchPadding;
447	PUT_STR(g_szSpaces, cchPadding);
448
449	/* comment? */
450	if (fFlags & (DIS_FMT_FLAGS_BYTES_RIGHT \| DIS_FMT_FLAGS_ADDR_RIGHT))
451	PUT_SZ(";");
452
453	/*
454	* The address?
455	*/
456	if (fFlags & DIS_FMT_FLAGS_ADDR_RIGHT)
457	{
458	PUT_C(' ');
459	#if HC_ARCH_BITS == 64 \|\| GC_ARCH_BITS == 64
460	if (pDis->uInstrAddr >= _4G)
461	PUT_NUM(9, "%08x`", (uint32_t)(pDis->uInstrAddr >> 32));
462	#endif
463	PUT_NUM(8, "%08x", (uint32_t)pDis->uInstrAddr);
464	}
465
466	/*
467	* Opcode bytes?
468	*/
469	if (fFlags & DIS_FMT_FLAGS_BYTES_RIGHT)
470	{
471	PUT_C(' ');
472	size_t cchTmp = disFormatBytes(pDis, pszDst, cchDst, fFlags);
473	cchOutput += cchTmp;
474	if (cchTmp >= cchDst)
475	cchTmp = cchDst - (cchDst != 0);
476	cchDst -= cchTmp;
477	pszDst += cchTmp;
478	}
479	}
480
481	/*
482	* Terminate it - on overflow we'll have reserved one byte for this.
483	*/
484	if (cchDst > 0)
485	*pszDst = '\0';
486	else
487	Assert(!cchBuf);
488
489	/* clean up macros */
490	#undef PUT_PSZ
491	#undef PUT_SZ
492	#undef PUT_STR
493	#undef PUT_C
494	return cchOutput;
495	}
496
497
498	/**
499	* Formats the current instruction in Yasm (/ Nasm) style.
500	*
501	* This is a simplified version of DISFormatYasmEx() provided for your convenience.
502	*
503	*
504	* @returns The number of output characters. If this is >= cchBuf, then the content
505	* of pszBuf will be truncated.
506	* @param pDis Pointer to the disassembler state.
507	* @param pszBuf The output buffer.
508	* @param cchBuf The size of the output buffer.
509	*/
510	DISDECL(size_t) DISFormatArmV8(PCDISSTATE pDis, char *pszBuf, size_t cchBuf)
511	{
512	return DISFormatArmV8Ex(pDis, pszBuf, cchBuf, 0 /* fFlags /, NULL / pfnGetSymbol /, NULL / pvUser */);
513	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Disassembler/DisasmFormatArmV8.cpp@ 99678

Download in other formats: