1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
24 * Use is subject to license terms.
25 */
26
27/*
28 * Copyright 2007 Jason King.  All rights reserved.
29 * Use is subject to license terms.
30 * Copyright 2012 Joshua M. Clulow <josh@sysmgr.org>
31 */
32
33/*
34 * The sparc disassembler is mostly straightforward, each instruction is
35 * represented by an inst_t structure.  The inst_t definitions are organized
36 * into tables.  The tables are correspond to the opcode maps documented in the
37 * various sparc architecture manuals.  Each table defines the bit range of the
38 * instruction whose value act as an index into the array of instructions.  A
39 * table can also refer to another table if needed.  Each table also contains
40 * a function pointer of type format_fcn that knows how to output the
41 * instructions in the table, as well as handle any synthetic instructions
42 *
43 * Unfortunately, the changes from sparcv8 -> sparcv9 not only include new
44 * instructions, they sometimes renamed or just reused the same instruction to
45 * do different operations (i.e. the sparcv8 coprocessor instructions).  To
46 * accommodate this, each table can define an overlay table.  The overlay table
47 * is a list of (table index, architecture, new instruction definition) values.
48 *
49 *
50 * Traversal starts with the first table,
51 *   get index value from the instruction
52 *   if an relevant overlay entry exists for this index,
53 *        grab the overlay definition
54 *   else
55 *        grab the definition from the array (corresponding to the index value)
56 *
57 * If the entry is an instruction,
58 *     call print function of instruction.
59 * If the entry is a pointer to another table
60 *     traverse the table
61 * If not valid,
62 *     return an error
63 *
64 *
65 * To keep dis happy, for sparc, instead of actually returning an error, if
66 * the instruction cannot be disassembled, we instead merely place the value
67 * of the instruction into the output buffer.
68 *
69 * Adding new instructions:
70 *
71 * With the above information, it hopefully makes it clear how to add support
72 * for decoding new instructions.  Presumably, with new instructions will come
73 * a new dissassembly mode (I.e. DIS_SPARC_V8, DIS_SPARC_V9, etc.).
74 *
75 * If the dissassembled format does not correspond to one of the existing
76 * formats, a new formatter will have to be written.  The 'flags' value of
77 * inst_t is intended to instruct the corresponding formatter about how to
78 * output the instruction.
79 *
80 * If the corresponding entry in the correct table is currently unoccupied,
81 * simply replace the INVALID entry with the correct definition.  The INST and
82 * TABLE macros are suggested to be used for this.  If there is already an
83 * instruction defined, then the entry must be placed in an overlay table.  If
84 * no overlay table exists for the instruction table, one will need to be
85 * created.
86 */
87
88#include <libdisasm.h>
89#include <stdlib.h>
90#include <stdio.h>
91#include <sys/types.h>
92#include <sys/byteorder.h>
93#include <string.h>
94
95#include "libdisasm_impl.h"
96#include "dis_sparc.h"
97
98static const inst_t *dis_get_overlay(dis_handle_t *, const table_t *,
99    uint32_t);
100static uint32_t dis_get_bits(uint32_t, int, int);
101
102#if !defined(DIS_STANDALONE)
103static void do_binary(uint32_t);
104#endif /* DIS_STANDALONE */
105
106static void
107dis_sparc_handle_detach(dis_handle_t *dhp)
108{
109	dis_free(dhp->dh_arch_private, sizeof (dis_handle_sparc_t));
110	dhp->dh_arch_private = NULL;
111}
112
113static int
114dis_sparc_handle_attach(dis_handle_t *dhp)
115{
116	dis_handle_sparc_t *dhx;
117
118#if !defined(DIS_STANDALONE)
119	char *opt = NULL;
120	char *opt2, *save, *end;
121#endif
122
123	/* Validate architecture flags */
124	if ((dhp->dh_flags & (DIS_SPARC_V8|DIS_SPARC_V9|DIS_SPARC_V9_SGI))
125	    == 0) {
126		(void) dis_seterrno(E_DIS_INVALFLAG);
127		return (-1);
128	}
129
130	if ((dhx = dis_zalloc(sizeof (dis_handle_sparc_t))) == NULL) {
131		(void) dis_seterrno(E_DIS_NOMEM);
132		return (0);
133	}
134	dhx->dhx_debug = DIS_DEBUG_COMPAT;
135	dhp->dh_arch_private = dhx;
136
137#if !defined(DIS_STANDALONE)
138
139	opt = getenv("_LIBDISASM_DEBUG");
140	if (opt == NULL)
141		return (0);
142
143	opt2 = strdup(opt);
144	if (opt2 == NULL) {
145		dis_handle_destroy(dhp);
146		dis_free(dhx, sizeof (dis_handle_sparc_t));
147		(void) dis_seterrno(E_DIS_NOMEM);
148		return (-1);
149	}
150	save = opt2;
151
152	while (opt2 != NULL) {
153		end = strchr(opt2, ',');
154
155		if (end != 0)
156			*end++ = '\0';
157
158		if (strcasecmp("synth-all", opt2) == 0)
159			dhx->dhx_debug |= DIS_DEBUG_SYN_ALL;
160
161		if (strcasecmp("compat", opt2) == 0)
162			dhx->dhx_debug |= DIS_DEBUG_COMPAT;
163
164		if (strcasecmp("synth-none", opt2) == 0)
165			dhx->dhx_debug &= ~(DIS_DEBUG_SYN_ALL|DIS_DEBUG_COMPAT);
166
167		if (strcasecmp("binary", opt2) == 0)
168			dhx->dhx_debug |= DIS_DEBUG_PRTBIN;
169
170		if (strcasecmp("format", opt2) == 0)
171			dhx->dhx_debug |= DIS_DEBUG_PRTFMT;
172
173		if (strcasecmp("all", opt2) == 0)
174			dhx->dhx_debug = DIS_DEBUG_ALL;
175
176		if (strcasecmp("none", opt2) == 0)
177			dhx->dhx_debug = DIS_DEBUG_NONE;
178
179		opt2 = end;
180	}
181	free(save);
182#endif /* DIS_STANDALONE */
183	return (0);
184}
185
186/* ARGSUSED */
187static int
188dis_sparc_max_instrlen(dis_handle_t *dhp)
189{
190	return (4);
191}
192
193/* ARGSUSED */
194static int
195dis_sparc_min_instrlen(dis_handle_t *dhp)
196{
197	return (4);
198}
199
200/* ARGSUSED */
201static uint64_t
202dis_sparc_previnstr(dis_handle_t *dhp, uint64_t pc, int n)
203{
204	if (n <= 0)
205		return (pc);
206
207	if (pc < n)
208		return (pc);
209
210	return (pc - n*4);
211}
212
213/* ARGSUSED */
214static int
215dis_sparc_instrlen(dis_handle_t *dhp, uint64_t pc)
216{
217	return (4);
218}
219
220static int
221dis_sparc_disassemble(dis_handle_t *dhp, uint64_t addr, char *buf,
222    size_t buflen)
223{
224	dis_handle_sparc_t *dhx = dhp->dh_arch_private;
225	const table_t *tp = &initial_table;
226	const inst_t *inp = NULL;
227
228	uint32_t instr;
229	uint32_t idx = 0;
230
231	if (dhp->dh_read(dhp->dh_data, addr, &instr, sizeof (instr)) !=
232	    sizeof (instr))
233		return (-1);
234
235	dhx->dhx_buf    = buf;
236	dhx->dhx_buflen = buflen;
237	dhp->dh_addr    = addr;
238
239	buf[0] = '\0';
240
241	/* this allows sparc code to be tested on x86 */
242#if !defined(DIS_STANDALONE)
243	instr = BE_32(instr);
244#endif /* DIS_STANDALONE */
245
246#if !defined(DIS_STANDALONE)
247	if ((dhx->dhx_debug & DIS_DEBUG_PRTBIN) != 0)
248		do_binary(instr);
249#endif /* DIS_STANDALONE */
250
251	/* CONSTCOND */
252	while (1) {
253		idx = dis_get_bits(instr, tp->tbl_field, tp->tbl_len);
254		inp = &tp->tbl_inp[idx];
255
256		inp = dis_get_overlay(dhp, tp, idx);
257
258		if ((inp->in_type == INST_NONE) ||
259		    ((inp->in_arch & dhp->dh_flags) == 0))
260			goto error;
261
262		if (inp->in_type == INST_TBL) {
263			tp = inp->in_data.in_tbl;
264			continue;
265		}
266
267		break;
268	}
269
270	if (tp->tbl_fmt(dhp, instr, inp, idx) == 0)
271		return (0);
272
273error:
274
275	(void) dis_snprintf(buf, buflen,
276	    ((dhp->dh_flags & DIS_OCTAL) != 0) ? "0%011lo" : "0x%08lx",
277	    instr);
278
279	return (0);
280}
281
282static uint32_t
283dis_get_bits(uint32_t instr, int offset, int length)
284{
285	uint32_t mask, val;
286	int i;
287
288	for (i = 0, mask = 0; i < length; ++i)
289		mask |= (1UL << i);
290
291	mask = mask << (offset - length + 1);
292
293	val = instr & mask;
294
295	val = val >> (offset - length + 1);
296
297	return (val);
298}
299
300static const inst_t *
301dis_get_overlay(dis_handle_t *dhp, const table_t *tp, uint32_t idx)
302{
303	const inst_t *ip = &tp->tbl_inp[idx];
304	int i;
305
306	if (tp->tbl_ovp == NULL)
307		return (ip);
308
309	for (i = 0; tp->tbl_ovp[i].ov_idx != -1; ++i) {
310		if (tp->tbl_ovp[i].ov_idx != idx)
311			continue;
312
313		if ((tp->tbl_ovp[i].ov_inst.in_arch & dhp->dh_flags) == 0)
314			continue;
315
316		ip = &tp->tbl_ovp[i].ov_inst;
317		break;
318	}
319
320	return (ip);
321}
322
323#if !defined(DIS_STANDALONE)
324static void
325do_binary(uint32_t instr)
326{
327	(void) fprintf(stderr, "DISASM: ");
328	prt_binary(instr, 32);
329	(void) fprintf(stderr, "\n");
330}
331#endif /* DIS_STANDALONE */
332
333static int
334dis_sparc_supports_flags(int flags)
335{
336	int archflags = flags & DIS_ARCH_MASK;
337
338	if (archflags == DIS_SPARC_V8 ||
339	    (archflags & (DIS_SPARC_V9 | DIS_SPARC_V8)) == DIS_SPARC_V9)
340		return (1);
341
342	return (0);
343}
344
345const dis_arch_t dis_arch_sparc = {
346	.da_supports_flags	= dis_sparc_supports_flags,
347	.da_handle_attach	= dis_sparc_handle_attach,
348	.da_handle_detach	= dis_sparc_handle_detach,
349	.da_disassemble		= dis_sparc_disassemble,
350	.da_previnstr		= dis_sparc_previnstr,
351	.da_min_instrlen	= dis_sparc_min_instrlen,
352	.da_max_instrlen	= dis_sparc_max_instrlen,
353	.da_instrlen		= dis_sparc_instrlen
354};
355