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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22
23 /*
24 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 /*
29 * Copyright (c) 2013 by Delphix. All rights reserved.
30 * Copyright (c) 2013 Joyent, Inc. All rights reserved.
31 */
32
33 #include <strings.h>
34 #include <stdio.h>
35
36 #include <dt_impl.h>
37 #include <dt_ident.h>
38
39 /*ARGSUSED*/
40 static void
41 dt_dis_log(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
42 {
43 (void) fprintf(fp, "%-4s %%r%u, %%r%u, %%r%u", name,
44 DIF_INSTR_R1(in), DIF_INSTR_R2(in), DIF_INSTR_RD(in));
45 }
46
47 /*ARGSUSED*/
48 static void
49 dt_dis_branch(const dtrace_difo_t *dp, const char *name,
50 dif_instr_t in, FILE *fp)
51 {
52 (void) fprintf(fp, "%-4s %u", name, DIF_INSTR_LABEL(in));
53 }
54
55 /*ARGSUSED*/
56 static void
57 dt_dis_load(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
58 {
59 (void) fprintf(fp, "%-4s [%%r%u], %%r%u", name,
60 DIF_INSTR_R1(in), DIF_INSTR_RD(in));
61 }
62
63 /*ARGSUSED*/
64 static void
65 dt_dis_store(const dtrace_difo_t *dp, const char *name,
66 dif_instr_t in, FILE *fp)
67 {
68 (void) fprintf(fp, "%-4s %%r%u, [%%r%u]", name,
69 DIF_INSTR_R1(in), DIF_INSTR_RD(in));
70 }
71
72 /*ARGSUSED*/
73 static void
74 dt_dis_str(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
75 {
76 (void) fprintf(fp, "%s", name);
77 }
78
79 /*ARGSUSED*/
80 static void
81 dt_dis_r1rd(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
82 {
83 (void) fprintf(fp, "%-4s %%r%u, %%r%u", name,
84 DIF_INSTR_R1(in), DIF_INSTR_RD(in));
85 }
86
87 /*ARGSUSED*/
88 static void
89 dt_dis_cmp(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
90 {
91 (void) fprintf(fp, "%-4s %%r%u, %%r%u", name,
92 DIF_INSTR_R1(in), DIF_INSTR_R2(in));
93 }
94
95 /*ARGSUSED*/
96 static void
97 dt_dis_tst(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
98 {
99 (void) fprintf(fp, "%-4s %%r%u", name, DIF_INSTR_R1(in));
100 }
101
102 static const char *
103 dt_dis_varname(const dtrace_difo_t *dp, uint_t id, uint_t scope)
104 {
105 const dtrace_difv_t *dvp = dp->dtdo_vartab;
106 uint_t i;
107
108 for (i = 0; i < dp->dtdo_varlen; i++, dvp++) {
109 if (dvp->dtdv_id == id && dvp->dtdv_scope == scope) {
110 if (dvp->dtdv_name < dp->dtdo_strlen)
111 return (dp->dtdo_strtab + dvp->dtdv_name);
112 break;
113 }
114 }
115
116 return (NULL);
117 }
118
119 static uint_t
120 dt_dis_scope(const char *name)
121 {
122 switch (name[2]) {
123 case 'l': return (DIFV_SCOPE_LOCAL);
124 case 't': return (DIFV_SCOPE_THREAD);
125 case 'g': return (DIFV_SCOPE_GLOBAL);
126 default: return (-1u);
127 }
128 }
129
130 static void
131 dt_dis_lda(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
132 {
133 uint_t var = DIF_INSTR_R1(in);
134 const char *vname;
135
136 (void) fprintf(fp, "%-4s DT_VAR(%u), %%r%u, %%r%u", name,
137 var, DIF_INSTR_R2(in), DIF_INSTR_RD(in));
138
139 if ((vname = dt_dis_varname(dp, var, dt_dis_scope(name))) != NULL)
140 (void) fprintf(fp, "\t\t! DT_VAR(%u) = \"%s\"", var, vname);
141 }
142
143 static void
144 dt_dis_ldv(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
145 {
146 uint_t var = DIF_INSTR_VAR(in);
147 const char *vname;
148
149 (void) fprintf(fp, "%-4s DT_VAR(%u), %%r%u",
150 name, var, DIF_INSTR_RD(in));
151
152 if ((vname = dt_dis_varname(dp, var, dt_dis_scope(name))) != NULL)
153 (void) fprintf(fp, "\t\t! DT_VAR(%u) = \"%s\"", var, vname);
154 }
155
156 static void
157 dt_dis_stv(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
158 {
159 uint_t var = DIF_INSTR_VAR(in);
160 const char *vname;
161
162 (void) fprintf(fp, "%-4s %%r%u, DT_VAR(%u)",
163 name, DIF_INSTR_RS(in), var);
164
165 if ((vname = dt_dis_varname(dp, var, dt_dis_scope(name))) != NULL)
166 (void) fprintf(fp, "\t\t! DT_VAR(%u) = \"%s\"", var, vname);
167 }
168
169 static void
170 dt_dis_setx(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
171 {
172 uint_t intptr = DIF_INSTR_INTEGER(in);
173
174 (void) fprintf(fp, "%-4s DT_INTEGER[%u], %%r%u", name,
175 intptr, DIF_INSTR_RD(in));
176
177 if (intptr < dp->dtdo_intlen) {
178 (void) fprintf(fp, "\t\t! 0x%llx",
179 (u_longlong_t)dp->dtdo_inttab[intptr]);
180 }
181 }
182
183 static void
184 dt_dis_sets(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
185 {
186 uint_t strptr = DIF_INSTR_STRING(in);
187
188 (void) fprintf(fp, "%-4s DT_STRING[%u], %%r%u", name,
189 strptr, DIF_INSTR_RD(in));
190
191 if (strptr < dp->dtdo_strlen)
192 (void) fprintf(fp, "\t\t! \"%s\"", dp->dtdo_strtab + strptr);
193 }
194
195 /*ARGSUSED*/
196 static void
197 dt_dis_ret(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
198 {
199 (void) fprintf(fp, "%-4s %%r%u", name, DIF_INSTR_RD(in));
200 }
201
202 /*ARGSUSED*/
203 static void
204 dt_dis_call(const dtrace_difo_t *dp, const char *name, dif_instr_t in, FILE *fp)
205 {
206 uint_t subr = DIF_INSTR_SUBR(in);
207
208 (void) fprintf(fp, "%-4s DIF_SUBR(%u), %%r%u\t\t! %s",
209 name, subr, DIF_INSTR_RD(in), dtrace_subrstr(NULL, subr));
210 }
211
212 /*ARGSUSED*/
213 static void
214 dt_dis_pushts(const dtrace_difo_t *dp,
215 const char *name, dif_instr_t in, FILE *fp)
216 {
217 static const char *const tnames[] = { "D type", "string" };
218 uint_t type = DIF_INSTR_TYPE(in);
219 const char *pad;
220
221 if (DIF_INSTR_OP(in) == DIF_OP_PUSHTV) {
222 (void) fprintf(fp, "%-4s DT_TYPE(%u), %%r%u",
223 name, type, DIF_INSTR_RS(in));
224 pad = "\t\t";
225 } else {
226 (void) fprintf(fp, "%-4s DT_TYPE(%u), %%r%u, %%r%u",
227 name, type, DIF_INSTR_R2(in), DIF_INSTR_RS(in));
228 pad = "\t";
229 }
230
231 if (type < sizeof (tnames) / sizeof (tnames[0])) {
232 (void) fprintf(fp, "%s! DT_TYPE(%u) = %s", pad,
233 type, tnames[type]);
234 }
235 }
236
237 static void
238 dt_dis_xlate(const dtrace_difo_t *dp,
239 const char *name, dif_instr_t in, FILE *fp)
240 {
241 uint_t xlr = DIF_INSTR_XLREF(in);
242
243 (void) fprintf(fp, "%-4s DT_XLREF[%u], %%r%u",
244 name, xlr, DIF_INSTR_RD(in));
245
246 if (xlr < dp->dtdo_xlmlen) {
247 (void) fprintf(fp, "\t\t! DT_XLREF[%u] = %u.%s", xlr,
248 (uint_t)dp->dtdo_xlmtab[xlr]->dn_membexpr->dn_xlator->dx_id,
249 dp->dtdo_xlmtab[xlr]->dn_membname);
250 }
251 }
252
253 static char *
254 dt_dis_typestr(const dtrace_diftype_t *t, char *buf, size_t len)
255 {
256 char kind[16], ckind[16];
257
258 switch (t->dtdt_kind) {
259 case DIF_TYPE_CTF:
260 (void) strcpy(kind, "D type");
261 break;
262 case DIF_TYPE_STRING:
263 (void) strcpy(kind, "string");
264 break;
265 default:
266 (void) snprintf(kind, sizeof (kind), "0x%x", t->dtdt_kind);
267 }
268
269 switch (t->dtdt_ckind) {
270 case CTF_K_UNKNOWN:
271 (void) strcpy(ckind, "unknown");
272 break;
273 case CTF_K_INTEGER:
274 (void) strcpy(ckind, "integer");
275 break;
276 case CTF_K_FLOAT:
277 (void) strcpy(ckind, "float");
278 break;
279 case CTF_K_POINTER:
280 (void) strcpy(ckind, "pointer");
281 break;
282 case CTF_K_ARRAY:
283 (void) strcpy(ckind, "array");
284 break;
285 case CTF_K_FUNCTION:
286 (void) strcpy(ckind, "function");
287 break;
288 case CTF_K_STRUCT:
289 (void) strcpy(ckind, "struct");
290 break;
291 case CTF_K_UNION:
292 (void) strcpy(ckind, "union");
293 break;
294 case CTF_K_ENUM:
295 (void) strcpy(ckind, "enum");
296 break;
297 case CTF_K_FORWARD:
298 (void) strcpy(ckind, "forward");
299 break;
300 case CTF_K_TYPEDEF:
301 (void) strcpy(ckind, "typedef");
302 break;
303 case CTF_K_VOLATILE:
304 (void) strcpy(ckind, "volatile");
305 break;
306 case CTF_K_CONST:
307 (void) strcpy(ckind, "const");
308 break;
309 case CTF_K_RESTRICT:
310 (void) strcpy(ckind, "restrict");
311 break;
312 default:
313 (void) snprintf(ckind, sizeof (ckind), "0x%x", t->dtdt_ckind);
314 }
315
316 if (t->dtdt_flags & (DIF_TF_BYREF | DIF_TF_BYUREF)) {
317 (void) snprintf(buf, len, "%s (%s) by %sref (size %lu)",
318 kind, ckind, (t->dtdt_flags & DIF_TF_BYUREF) ? "user " : "",
319 (ulong_t)t->dtdt_size);
320 } else {
321 (void) snprintf(buf, len, "%s (%s) (size %lu)",
322 kind, ckind, (ulong_t)t->dtdt_size);
323 }
324
325 return (buf);
326 }
327
328 static void
329 dt_dis_rtab(const char *rtag, const dtrace_difo_t *dp, FILE *fp,
330 const dof_relodesc_t *rp, uint32_t len)
331 {
332 (void) fprintf(fp, "\n%-4s %-8s %-8s %s\n",
333 rtag, "OFFSET", "DATA", "NAME");
334
335 for (; len != 0; len--, rp++) {
336 (void) fprintf(fp, "%-4u %-8llu %-8llu %s\n",
337 rp->dofr_type, (u_longlong_t)rp->dofr_offset,
338 (u_longlong_t)rp->dofr_data,
339 &dp->dtdo_strtab[rp->dofr_name]);
340 }
341 }
342
343 void
344 dt_dis(const dtrace_difo_t *dp, FILE *fp)
345 {
346 static const struct opent {
347 const char *op_name;
348 void (*op_func)(const dtrace_difo_t *, const char *,
349 dif_instr_t, FILE *);
350 } optab[] = {
351 { "(illegal opcode)", dt_dis_str },
352 { "or", dt_dis_log }, /* DIF_OP_OR */
353 { "xor", dt_dis_log }, /* DIF_OP_XOR */
354 { "and", dt_dis_log }, /* DIF_OP_AND */
355 { "sll", dt_dis_log }, /* DIF_OP_SLL */
356 { "srl", dt_dis_log }, /* DIF_OP_SRL */
357 { "sub", dt_dis_log }, /* DIF_OP_SUB */
358 { "add", dt_dis_log }, /* DIF_OP_ADD */
359 { "mul", dt_dis_log }, /* DIF_OP_MUL */
360 { "sdiv", dt_dis_log }, /* DIF_OP_SDIV */
361 { "udiv", dt_dis_log }, /* DIF_OP_UDIV */
362 { "srem", dt_dis_log }, /* DIF_OP_SREM */
363 { "urem", dt_dis_log }, /* DIF_OP_UREM */
364 { "not", dt_dis_r1rd }, /* DIF_OP_NOT */
365 { "mov", dt_dis_r1rd }, /* DIF_OP_MOV */
366 { "cmp", dt_dis_cmp }, /* DIF_OP_CMP */
367 { "tst", dt_dis_tst }, /* DIF_OP_TST */
368 { "ba", dt_dis_branch }, /* DIF_OP_BA */
369 { "be", dt_dis_branch }, /* DIF_OP_BE */
370 { "bne", dt_dis_branch }, /* DIF_OP_BNE */
371 { "bg", dt_dis_branch }, /* DIF_OP_BG */
372 { "bgu", dt_dis_branch }, /* DIF_OP_BGU */
373 { "bge", dt_dis_branch }, /* DIF_OP_BGE */
374 { "bgeu", dt_dis_branch }, /* DIF_OP_BGEU */
375 { "bl", dt_dis_branch }, /* DIF_OP_BL */
376 { "blu", dt_dis_branch }, /* DIF_OP_BLU */
377 { "ble", dt_dis_branch }, /* DIF_OP_BLE */
378 { "bleu", dt_dis_branch }, /* DIF_OP_BLEU */
379 { "ldsb", dt_dis_load }, /* DIF_OP_LDSB */
380 { "ldsh", dt_dis_load }, /* DIF_OP_LDSH */
381 { "ldsw", dt_dis_load }, /* DIF_OP_LDSW */
382 { "ldub", dt_dis_load }, /* DIF_OP_LDUB */
383 { "lduh", dt_dis_load }, /* DIF_OP_LDUH */
384 { "lduw", dt_dis_load }, /* DIF_OP_LDUW */
385 { "ldx", dt_dis_load }, /* DIF_OP_LDX */
386 { "ret", dt_dis_ret }, /* DIF_OP_RET */
387 { "nop", dt_dis_str }, /* DIF_OP_NOP */
388 { "setx", dt_dis_setx }, /* DIF_OP_SETX */
389 { "sets", dt_dis_sets }, /* DIF_OP_SETS */
390 { "scmp", dt_dis_cmp }, /* DIF_OP_SCMP */
391 { "ldga", dt_dis_lda }, /* DIF_OP_LDGA */
392 { "ldgs", dt_dis_ldv }, /* DIF_OP_LDGS */
393 { "stgs", dt_dis_stv }, /* DIF_OP_STGS */
394 { "ldta", dt_dis_lda }, /* DIF_OP_LDTA */
395 { "ldts", dt_dis_ldv }, /* DIF_OP_LDTS */
396 { "stts", dt_dis_stv }, /* DIF_OP_STTS */
397 { "sra", dt_dis_log }, /* DIF_OP_SRA */
398 { "call", dt_dis_call }, /* DIF_OP_CALL */
399 { "pushtr", dt_dis_pushts }, /* DIF_OP_PUSHTR */
400 { "pushtv", dt_dis_pushts }, /* DIF_OP_PUSHTV */
401 { "popts", dt_dis_str }, /* DIF_OP_POPTS */
402 { "flushts", dt_dis_str }, /* DIF_OP_FLUSHTS */
403 { "ldgaa", dt_dis_ldv }, /* DIF_OP_LDGAA */
404 { "ldtaa", dt_dis_ldv }, /* DIF_OP_LDTAA */
405 { "stgaa", dt_dis_stv }, /* DIF_OP_STGAA */
406 { "sttaa", dt_dis_stv }, /* DIF_OP_STTAA */
407 { "ldls", dt_dis_ldv }, /* DIF_OP_LDLS */
408 { "stls", dt_dis_stv }, /* DIF_OP_STLS */
409 { "allocs", dt_dis_r1rd }, /* DIF_OP_ALLOCS */
410 { "copys", dt_dis_log }, /* DIF_OP_COPYS */
411 { "stb", dt_dis_store }, /* DIF_OP_STB */
412 { "sth", dt_dis_store }, /* DIF_OP_STH */
413 { "stw", dt_dis_store }, /* DIF_OP_STW */
414 { "stx", dt_dis_store }, /* DIF_OP_STX */
415 { "uldsb", dt_dis_load }, /* DIF_OP_ULDSB */
416 { "uldsh", dt_dis_load }, /* DIF_OP_ULDSH */
417 { "uldsw", dt_dis_load }, /* DIF_OP_ULDSW */
418 { "uldub", dt_dis_load }, /* DIF_OP_ULDUB */
419 { "ulduh", dt_dis_load }, /* DIF_OP_ULDUH */
420 { "ulduw", dt_dis_load }, /* DIF_OP_ULDUW */
421 { "uldx", dt_dis_load }, /* DIF_OP_ULDX */
422 { "rldsb", dt_dis_load }, /* DIF_OP_RLDSB */
423 { "rldsh", dt_dis_load }, /* DIF_OP_RLDSH */
424 { "rldsw", dt_dis_load }, /* DIF_OP_RLDSW */
425 { "rldub", dt_dis_load }, /* DIF_OP_RLDUB */
426 { "rlduh", dt_dis_load }, /* DIF_OP_RLDUH */
427 { "rlduw", dt_dis_load }, /* DIF_OP_RLDUW */
428 { "rldx", dt_dis_load }, /* DIF_OP_RLDX */
429 { "xlate", dt_dis_xlate }, /* DIF_OP_XLATE */
430 { "xlarg", dt_dis_xlate }, /* DIF_OP_XLARG */
431 };
432
433 const struct opent *op;
434 ulong_t i = 0;
435 char type[DT_TYPE_NAMELEN];
436
437 (void) fprintf(fp, "\nDIFO 0x%p returns %s\n", (void *)dp,
438 dt_dis_typestr(&dp->dtdo_rtype, type, sizeof (type)));
439
440 (void) fprintf(fp, "%-3s %-8s %s\n",
441 "OFF", "OPCODE", "INSTRUCTION");
442
443 for (i = 0; i < dp->dtdo_len; i++) {
444 dif_instr_t instr = dp->dtdo_buf[i];
445 dif_instr_t opcode = DIF_INSTR_OP(instr);
446
447 if (opcode >= sizeof (optab) / sizeof (optab[0]))
448 opcode = 0; /* force invalid opcode message */
449
450 op = &optab[opcode];
451 (void) fprintf(fp, "%02lu: %08x ", i, instr);
452 op->op_func(dp, op->op_name, instr, fp);
453 (void) fprintf(fp, "\n");
454 }
455
456 if (dp->dtdo_varlen != 0) {
457 (void) fprintf(fp, "\n%-16s %-4s %-3s %-3s %-4s %s\n",
458 "NAME", "ID", "KND", "SCP", "FLAG", "TYPE");
459 }
460
461 for (i = 0; i < dp->dtdo_varlen; i++) {
462 dtrace_difv_t *v = &dp->dtdo_vartab[i];
463 char kind[4], scope[4], flags[16] = { 0 };
464
465 switch (v->dtdv_kind) {
466 case DIFV_KIND_ARRAY:
467 (void) strcpy(kind, "arr");
468 break;
469 case DIFV_KIND_SCALAR:
470 (void) strcpy(kind, "scl");
471 break;
472 default:
473 (void) snprintf(kind, sizeof (kind),
474 "%u", v->dtdv_kind);
475 }
476
477 switch (v->dtdv_scope) {
478 case DIFV_SCOPE_GLOBAL:
479 (void) strcpy(scope, "glb");
480 break;
481 case DIFV_SCOPE_THREAD:
482 (void) strcpy(scope, "tls");
483 break;
484 case DIFV_SCOPE_LOCAL:
485 (void) strcpy(scope, "loc");
486 break;
487 default:
488 (void) snprintf(scope, sizeof (scope),
489 "%u", v->dtdv_scope);
490 }
491
492 if (v->dtdv_flags & ~(DIFV_F_REF | DIFV_F_MOD)) {
493 (void) snprintf(flags, sizeof (flags), "/0x%x",
494 v->dtdv_flags & ~(DIFV_F_REF | DIFV_F_MOD));
495 }
496
497 if (v->dtdv_flags & DIFV_F_REF)
498 (void) strcat(flags, "/r");
499 if (v->dtdv_flags & DIFV_F_MOD)
500 (void) strcat(flags, "/w");
501
502 (void) fprintf(fp, "%-16s %-4x %-3s %-3s %-4s %s\n",
503 &dp->dtdo_strtab[v->dtdv_name],
504 v->dtdv_id, kind, scope, flags + 1,
505 dt_dis_typestr(&v->dtdv_type, type, sizeof (type)));
506 }
507
508 if (dp->dtdo_xlmlen != 0) {
509 (void) fprintf(fp, "\n%-4s %-3s %-12s %s\n",
510 "XLID", "ARG", "MEMBER", "TYPE");
511 }
512
513 for (i = 0; i < dp->dtdo_xlmlen; i++) {
514 dt_node_t *dnp = dp->dtdo_xlmtab[i];
515 dt_xlator_t *dxp = dnp->dn_membexpr->dn_xlator;
516 (void) fprintf(fp, "%-4u %-3d %-12s %s\n",
517 (uint_t)dxp->dx_id, dxp->dx_arg, dnp->dn_membname,
518 dt_node_type_name(dnp, type, sizeof (type)));
519 }
520
521 if (dp->dtdo_krelen != 0)
522 dt_dis_rtab("KREL", dp, fp, dp->dtdo_kreltab, dp->dtdo_krelen);
523
524 if (dp->dtdo_urelen != 0)
525 dt_dis_rtab("UREL", dp, fp, dp->dtdo_ureltab, dp->dtdo_urelen);
526 }