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.
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.
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]
23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
28 * Copyright 2007 Jason King. All rights reserved.
29 * Use is subject to license terms.
33 * The sparc disassembler is mostly straightforward, each instruction is
34 * represented by an inst_t structure. The inst_t definitions are organized
35 * into tables. The tables are correspond to the opcode maps documented in the
36 * various sparc architecture manuals. Each table defines the bit range of the
37 * instruction whose value act as an index into the array of instructions. A
38 * table can also refer to another table if needed. Each table also contains
39 * a function pointer of type format_fcn that knows how to output the
40 * instructions in the table, as well as handle any synthetic instructions
42 * Unfortunately, the changes from sparcv8 -> sparcv9 not only include new
43 * instructions, they sometimes renamed or just reused the same instruction to
44 * do different operations (i.e. the sparcv8 coprocessor instructions). To
45 * accommodate this, each table can define an overlay table. The overlay table
46 * is a list of (table index, architecture, new instruction definition) values.
49 * Traversal starts with the first table,
50 * get index value from the instruction
51 * if an relevant overlay entry exists for this index,
52 * grab the overlay definition
54 * grab the definition from the array (corresponding to the index value)
56 * If the entry is an instruction,
57 * call print function of instruction.
58 * If the entry is a pointer to another table
64 * To keep dis happy, for sparc, instead of actually returning an error, if
65 * the instruction cannot be disassembled, we instead merely place the value
66 * of the instruction into the output buffer.
68 * Adding new instructions:
70 * With the above information, it hopefully makes it clear how to add support
71 * for decoding new instructions. Presumably, with new instructions will come
72 * a new dissassembly mode (I.e. DIS_SPARC_V8, DIS_SPARC_V9, etc.).
74 * If the dissassembled format does not correspond to one of the existing
75 * formats, a new formatter will have to be written. The 'flags' value of
76 * inst_t is intended to instruct the corresponding formatter about how to
77 * output the instruction.
79 * If the corresponding entry in the correct table is currently unoccupied,
80 * simply replace the INVALID entry with the correct definition. The INST and
81 * TABLE macros are suggested to be used for this. If there is already an
82 * instruction defined, then the entry must be placed in an overlay table. If
83 * no overlay table exists for the instruction table, one will need to be
87 #include <libdisasm.h>
90 #include <sys/types.h>
91 #include <sys/byteorder.h>
94 #include "libdisasm_impl.h"
95 #include "dis_sparc.h"
97 static const inst_t
*dis_get_overlay(dis_handle_t
*, const table_t
*,
99 static uint32_t dis_get_bits(uint32_t, int, int);
101 #if !defined(DIS_STANDALONE)
102 static void do_binary(uint32_t);
103 #endif /* DIS_STANDALONE */
106 dis_handle_create(int flags
, void *data
, dis_lookup_f lookup_func
,
107 dis_read_f read_func
)
110 #if !defined(DIS_STANDALONE)
112 char *opt2
, *save
, *end
;
116 if ((flags
& (DIS_SPARC_V8
|DIS_SPARC_V9
|DIS_SPARC_V9_SGI
)) == 0) {
117 (void) dis_seterrno(E_DIS_INVALFLAG
);
121 if ((dhp
= dis_zalloc(sizeof (struct dis_handle
))) == NULL
) {
122 (void) dis_seterrno(E_DIS_NOMEM
);
126 dhp
->dh_lookup
= lookup_func
;
127 dhp
->dh_read
= read_func
;
128 dhp
->dh_flags
= flags
;
130 dhp
->dh_debug
= DIS_DEBUG_COMPAT
;
132 #if !defined(DIS_STANDALONE)
134 opt
= getenv("_LIBDISASM_DEBUG");
140 dis_handle_destroy(dhp
);
141 (void) dis_seterrno(E_DIS_NOMEM
);
146 while (opt2
!= NULL
) {
147 end
= strchr(opt2
, ',');
152 if (strcasecmp("synth-all", opt2
) == 0)
153 dhp
->dh_debug
|= DIS_DEBUG_SYN_ALL
;
155 if (strcasecmp("compat", opt2
) == 0)
156 dhp
->dh_debug
|= DIS_DEBUG_COMPAT
;
158 if (strcasecmp("synth-none", opt2
) == 0)
159 dhp
->dh_debug
&= ~(DIS_DEBUG_SYN_ALL
|DIS_DEBUG_COMPAT
);
161 if (strcasecmp("binary", opt2
) == 0)
162 dhp
->dh_debug
|= DIS_DEBUG_PRTBIN
;
164 if (strcasecmp("format", opt2
) == 0)
165 dhp
->dh_debug
|= DIS_DEBUG_PRTFMT
;
167 if (strcasecmp("all", opt2
) == 0)
168 dhp
->dh_debug
= DIS_DEBUG_ALL
;
170 if (strcasecmp("none", opt2
) == 0)
171 dhp
->dh_debug
= DIS_DEBUG_NONE
;
176 #endif /* DIS_STANDALONE */
181 dis_handle_destroy(dis_handle_t
*dhp
)
183 dis_free(dhp
, sizeof (dis_handle_t
));
187 dis_set_data(dis_handle_t
*dhp
, void *data
)
193 dis_flags_set(dis_handle_t
*dhp
, int f
)
199 dis_flags_clear(dis_handle_t
*dhp
, int f
)
206 dis_max_instrlen(dis_handle_t
*dhp
)
212 * The dis_i386.c comment for this says it returns the previous instruction,
213 * however, I'm fairly sure it's actually returning the _address_ of the
214 * nth previous instruction.
218 dis_previnstr(dis_handle_t
*dhp
, uint64_t pc
, int n
)
231 dis_instrlen(dis_handle_t
*dhp
, uint64_t pc
)
237 dis_disassemble(dis_handle_t
*dhp
, uint64_t addr
, char *buf
, size_t buflen
)
239 const table_t
*tp
= &initial_table
;
240 const inst_t
*inp
= NULL
;
245 if (dhp
->dh_read(dhp
->dh_data
, addr
, &instr
, sizeof (instr
)) !=
250 dhp
->dh_buflen
= buflen
;
255 /* this allows sparc code to be tested on x86 */
256 instr
= BE_32(instr
);
258 #if !defined(DIS_STANDALONE)
259 if ((dhp
->dh_debug
& DIS_DEBUG_PRTBIN
) != 0)
261 #endif /* DIS_STANDALONE */
265 idx
= dis_get_bits(instr
, tp
->tbl_field
, tp
->tbl_len
);
266 inp
= &tp
->tbl_inp
[idx
];
268 inp
= dis_get_overlay(dhp
, tp
, idx
);
270 if ((inp
->in_type
== INST_NONE
) ||
271 ((inp
->in_arch
& dhp
->dh_flags
) == 0))
274 if (inp
->in_type
== INST_TBL
) {
275 tp
= inp
->in_data
.in_tbl
;
282 if (tp
->tbl_fmt(dhp
, instr
, inp
, idx
) == 0)
287 (void) snprintf(buf
, buflen
,
288 ((dhp
->dh_flags
& DIS_OCTAL
) != 0) ? "0%011lo" : "0x%08lx",
295 dis_get_bits(uint32_t instr
, int offset
, int length
)
300 for (i
= 0, mask
= 0; i
< length
; ++i
)
303 mask
= mask
<< (offset
- length
+ 1);
307 val
= val
>> (offset
- length
+ 1);
312 static const inst_t
*
313 dis_get_overlay(dis_handle_t
*dhp
, const table_t
*tp
, uint32_t idx
)
315 const inst_t
*ip
= &tp
->tbl_inp
[idx
];
318 if (tp
->tbl_ovp
== NULL
)
321 for (i
= 0; tp
->tbl_ovp
[i
].ov_idx
!= -1; ++i
) {
322 if (tp
->tbl_ovp
[i
].ov_idx
!= idx
)
325 if ((tp
->tbl_ovp
[i
].ov_inst
.in_arch
& dhp
->dh_flags
) == 0)
328 ip
= &tp
->tbl_ovp
[i
].ov_inst
;
335 #if !defined(DIS_STANDALONE)
337 do_binary(uint32_t instr
)
339 (void) fprintf(stderr
, "DISASM: ");
340 prt_binary(instr
, 32);
341 (void) fprintf(stderr
, "\n");
343 #endif /* DIS_STANDALONE */