xref: /titanic_51/usr/src/lib/libdisasm/common/dis_sparc.c (revision 9ef283481583d677cd2cf5449ef49b90eacc97d4)
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 
98 static const inst_t *dis_get_overlay(dis_handle_t *, const table_t *,
99     uint32_t);
100 static uint32_t dis_get_bits(uint32_t, int, int);
101 
102 #if !defined(DIS_STANDALONE)
103 static void do_binary(uint32_t);
104 #endif /* DIS_STANDALONE */
105 
106 static void
107 dis_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 
113 static int
114 dis_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 (NULL);
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 */
187 static int
188 dis_sparc_max_instrlen(dis_handle_t *dhp)
189 {
190 	return (4);
191 }
192 
193 /* ARGSUSED */
194 static int
195 dis_sparc_min_instrlen(dis_handle_t *dhp)
196 {
197 	return (4);
198 }
199 
200 /*
201  * The dis_i386.c comment for this says it returns the previous instruction,
202  * however, I'm fairly sure it's actually returning the _address_ of the
203  * nth previous instruction.
204  */
205 /* ARGSUSED */
206 static uint64_t
207 dis_sparc_previnstr(dis_handle_t *dhp, uint64_t pc, int n)
208 {
209 	if (n <= 0)
210 		return (pc);
211 
212 	if (pc < n)
213 		return (pc);
214 
215 	return (pc - n*4);
216 }
217 
218 /* ARGSUSED */
219 static int
220 dis_sparc_instrlen(dis_handle_t *dhp, uint64_t pc)
221 {
222 	return (4);
223 }
224 
225 static int
226 dis_sparc_disassemble(dis_handle_t *dhp, uint64_t addr, char *buf,
227     size_t buflen)
228 {
229 	dis_handle_sparc_t *dhx = dhp->dh_arch_private;
230 	const table_t *tp = &initial_table;
231 	const inst_t *inp = NULL;
232 
233 	uint32_t instr;
234 	uint32_t idx = 0;
235 
236 	if (dhp->dh_read(dhp->dh_data, addr, &instr, sizeof (instr)) !=
237 	    sizeof (instr))
238 		return (-1);
239 
240 	dhx->dhx_buf    = buf;
241 	dhx->dhx_buflen = buflen;
242 	dhp->dh_addr    = addr;
243 
244 	buf[0] = '\0';
245 
246 	/* this allows sparc code to be tested on x86 */
247 #if !defined(DIS_STANDALONE)
248 	instr = BE_32(instr);
249 #endif /* DIS_STANDALONE */
250 
251 #if !defined(DIS_STANDALONE)
252 	if ((dhx->dhx_debug & DIS_DEBUG_PRTBIN) != 0)
253 		do_binary(instr);
254 #endif /* DIS_STANDALONE */
255 
256 	/* CONSTCOND */
257 	while (1) {
258 		idx = dis_get_bits(instr, tp->tbl_field, tp->tbl_len);
259 		inp = &tp->tbl_inp[idx];
260 
261 		inp = dis_get_overlay(dhp, tp, idx);
262 
263 		if ((inp->in_type == INST_NONE) ||
264 		    ((inp->in_arch & dhp->dh_flags) == 0))
265 			goto error;
266 
267 		if (inp->in_type == INST_TBL) {
268 			tp = inp->in_data.in_tbl;
269 			continue;
270 		}
271 
272 		break;
273 	}
274 
275 	if (tp->tbl_fmt(dhp, instr, inp, idx) == 0)
276 		return (0);
277 
278 error:
279 
280 	(void) dis_snprintf(buf, buflen,
281 	    ((dhp->dh_flags & DIS_OCTAL) != 0) ? "0%011lo" : "0x%08lx",
282 	    instr);
283 
284 	return (0);
285 }
286 
287 static uint32_t
288 dis_get_bits(uint32_t instr, int offset, int length)
289 {
290 	uint32_t mask, val;
291 	int i;
292 
293 	for (i = 0, mask = 0; i < length; ++i)
294 		mask |= (1UL << i);
295 
296 	mask = mask << (offset - length + 1);
297 
298 	val = instr & mask;
299 
300 	val = val >> (offset - length + 1);
301 
302 	return (val);
303 }
304 
305 static const inst_t *
306 dis_get_overlay(dis_handle_t *dhp, const table_t *tp, uint32_t idx)
307 {
308 	const inst_t *ip = &tp->tbl_inp[idx];
309 	int i;
310 
311 	if (tp->tbl_ovp == NULL)
312 		return (ip);
313 
314 	for (i = 0; tp->tbl_ovp[i].ov_idx != -1; ++i) {
315 		if (tp->tbl_ovp[i].ov_idx != idx)
316 			continue;
317 
318 		if ((tp->tbl_ovp[i].ov_inst.in_arch & dhp->dh_flags) == 0)
319 			continue;
320 
321 		ip = &tp->tbl_ovp[i].ov_inst;
322 		break;
323 	}
324 
325 	return (ip);
326 }
327 
328 #if !defined(DIS_STANDALONE)
329 static void
330 do_binary(uint32_t instr)
331 {
332 	(void) fprintf(stderr, "DISASM: ");
333 	prt_binary(instr, 32);
334 	(void) fprintf(stderr, "\n");
335 }
336 #endif /* DIS_STANDALONE */
337 
338 static int
339 dis_sparc_supports_flags(int flags)
340 {
341 	int archflags = flags & DIS_ARCH_MASK;
342 
343 	if (archflags == DIS_SPARC_V8 ||
344 	    (archflags & (DIS_SPARC_V9 | DIS_SPARC_V8)) == DIS_SPARC_V9)
345 		return (1);
346 
347 	return (0);
348 }
349 
350 const dis_arch_t dis_arch_sparc = {
351 	dis_sparc_supports_flags,
352 	dis_sparc_handle_attach,
353 	dis_sparc_handle_detach,
354 	dis_sparc_disassemble,
355 	dis_sparc_previnstr,
356 	dis_sparc_min_instrlen,
357 	dis_sparc_max_instrlen,
358 	dis_sparc_instrlen
359 };
360