xref: /titanic_50/usr/src/lib/libdisasm/common/dis_i386.c (revision b0e753dd6a955fb2f10a0ce17d32bd33172e0400)
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  * Copyright 2012 Joshua M. Clulow <josh@sysmgr.org>
26  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
27  */
28 
29 #include <libdisasm.h>
30 
31 #include "dis_tables.h"
32 #include "libdisasm_impl.h"
33 
34 typedef struct dis_handle_i386 {
35 	int		dhx_mode;
36 	dis86_t		dhx_dis;
37 	uint64_t	dhx_end;
38 } dis_handle_i386_t;
39 
40 /*
41  * Returns true if we are near the end of a function.  This is a cheap hack at
42  * detecting NULL padding between functions.  If we're within a few bytes of the
43  * next function, or past the start, then return true.
44  */
45 static int
46 check_func(void *data)
47 {
48 	dis_handle_t *dhp = data;
49 	uint64_t start;
50 	size_t len;
51 
52 	if (dhp->dh_lookup(dhp->dh_data, dhp->dh_addr, NULL, 0, &start, &len)
53 	    != 0)
54 		return (0);
55 
56 	if (start < dhp->dh_addr)
57 		return (dhp->dh_addr > start + len - 0x10);
58 
59 	return (1);
60 }
61 
62 static int
63 get_byte(void *data)
64 {
65 	uchar_t byte;
66 	dis_handle_t *dhp = data;
67 
68 	if (dhp->dh_read(dhp->dh_data, dhp->dh_addr, &byte, sizeof (byte)) !=
69 	    sizeof (byte))
70 		return (-1);
71 
72 	dhp->dh_addr++;
73 
74 	return ((int)byte);
75 }
76 
77 static int
78 do_lookup(void *data, uint64_t addr, char *buf, size_t buflen)
79 {
80 	dis_handle_t *dhp = data;
81 
82 	return (dhp->dh_lookup(dhp->dh_data, addr, buf, buflen, NULL, NULL));
83 }
84 
85 static void
86 dis_i386_handle_detach(dis_handle_t *dhp)
87 {
88 	dis_free(dhp->dh_arch_private, sizeof (dis_handle_i386_t));
89 	dhp->dh_arch_private = NULL;
90 }
91 
92 static int
93 dis_i386_handle_attach(dis_handle_t *dhp)
94 {
95 	dis_handle_i386_t *dhx;
96 
97 	/*
98 	 * Validate architecture flags
99 	 */
100 	if (dhp->dh_flags & ~(DIS_X86_SIZE16 | DIS_X86_SIZE32 | DIS_X86_SIZE64 |
101 	    DIS_OCTAL | DIS_NOIMMSYM)) {
102 		(void) dis_seterrno(E_DIS_INVALFLAG);
103 		return (-1);
104 	}
105 
106 	/*
107 	 * Create and initialize the internal structure
108 	 */
109 	if ((dhx = dis_zalloc(sizeof (dis_handle_i386_t))) == NULL) {
110 		(void) dis_seterrno(E_DIS_NOMEM);
111 		return (-1);
112 	}
113 	dhp->dh_arch_private = dhx;
114 
115 	/*
116 	 * Initialize x86-specific architecture structure
117 	 */
118 	if (dhp->dh_flags & DIS_X86_SIZE16)
119 		dhx->dhx_mode = SIZE16;
120 	else if (dhp->dh_flags & DIS_X86_SIZE64)
121 		dhx->dhx_mode = SIZE64;
122 	else
123 		dhx->dhx_mode = SIZE32;
124 
125 	if (dhp->dh_flags & DIS_OCTAL)
126 		dhx->dhx_dis.d86_flags = DIS_F_OCTAL;
127 
128 	dhx->dhx_dis.d86_sprintf_func = dis_snprintf;
129 	dhx->dhx_dis.d86_get_byte = get_byte;
130 	dhx->dhx_dis.d86_sym_lookup = do_lookup;
131 	dhx->dhx_dis.d86_check_func = check_func;
132 
133 	dhx->dhx_dis.d86_data = dhp;
134 
135 	return (0);
136 }
137 
138 static int
139 dis_i386_disassemble(dis_handle_t *dhp, uint64_t addr, char *buf,
140     size_t buflen)
141 {
142 	dis_handle_i386_t *dhx = dhp->dh_arch_private;
143 	dhp->dh_addr = addr;
144 
145 	/* DIS_NOIMMSYM might not be set until now, so update */
146 	if (dhp->dh_flags & DIS_NOIMMSYM)
147 		dhx->dhx_dis.d86_flags |= DIS_F_NOIMMSYM;
148 	else
149 		dhx->dhx_dis.d86_flags &= ~DIS_F_NOIMMSYM;
150 
151 	if (dtrace_disx86(&dhx->dhx_dis, dhx->dhx_mode) != 0)
152 		return (-1);
153 
154 	if (buf != NULL)
155 		dtrace_disx86_str(&dhx->dhx_dis, dhx->dhx_mode, addr, buf,
156 		    buflen);
157 
158 	return (0);
159 }
160 
161 /* ARGSUSED */
162 static int
163 dis_i386_max_instrlen(dis_handle_t *dhp)
164 {
165 	return (15);
166 }
167 
168 /* ARGSUSED */
169 static int
170 dis_i386_min_instrlen(dis_handle_t *dhp)
171 {
172 	return (1);
173 }
174 
175 /*
176  * Return the previous instruction.  On x86, we have no choice except to
177  * disassemble everything from the start of the symbol, and stop when we have
178  * reached our instruction address.  If we're not in the middle of a known
179  * symbol, then we return the same address to indicate failure.
180  */
181 static uint64_t
182 dis_i386_previnstr(dis_handle_t *dhp, uint64_t pc, int n)
183 {
184 	uint64_t *hist, addr, start;
185 	int cur, nseen;
186 	uint64_t res = pc;
187 
188 	if (n <= 0)
189 		return (pc);
190 
191 	if (dhp->dh_lookup(dhp->dh_data, pc, NULL, 0, &start, NULL) != 0 ||
192 	    start == pc)
193 		return (res);
194 
195 	hist = dis_zalloc(sizeof (uint64_t) * n);
196 
197 	for (cur = 0, nseen = 0, addr = start; addr < pc; addr = dhp->dh_addr) {
198 		hist[cur] = addr;
199 		cur = (cur + 1) % n;
200 		nseen++;
201 
202 		/* if we cannot make forward progress, give up */
203 		if (dis_disassemble(dhp, addr, NULL, 0) != 0)
204 			goto done;
205 	}
206 
207 	if (addr != pc) {
208 		/*
209 		 * We scanned past %pc, but didn't find an instruction that
210 		 * started at %pc.  This means that either the caller specified
211 		 * an invalid address, or we ran into something other than code
212 		 * during our scan.  Virtually any combination of bytes can be
213 		 * construed as a valid Intel instruction, so any non-code bytes
214 		 * we encounter will have thrown off the scan.
215 		 */
216 		goto done;
217 	}
218 
219 	res = hist[(cur + n - MIN(n, nseen)) % n];
220 
221 done:
222 	dis_free(hist, sizeof (uint64_t) * n);
223 	return (res);
224 }
225 
226 static int
227 dis_i386_supports_flags(int flags)
228 {
229 	int archflags = flags & DIS_ARCH_MASK;
230 
231 	if (archflags == DIS_X86_SIZE16 || archflags == DIS_X86_SIZE32 ||
232 	    archflags == DIS_X86_SIZE64)
233 		return (1);
234 
235 	return (0);
236 }
237 
238 static int
239 dis_i386_instrlen(dis_handle_t *dhp, uint64_t pc)
240 {
241 	if (dis_disassemble(dhp, pc, NULL, 0) != 0)
242 		return (-1);
243 
244 	return (dhp->dh_addr - pc);
245 }
246 
247 dis_arch_t dis_arch_i386 = {
248 	dis_i386_supports_flags,
249 	dis_i386_handle_attach,
250 	dis_i386_handle_detach,
251 	dis_i386_disassemble,
252 	dis_i386_previnstr,
253 	dis_i386_min_instrlen,
254 	dis_i386_max_instrlen,
255 	dis_i386_instrlen,
256 };
257