1 /* $NetBSD: db_disasm.c,v 1.24 2021/07/24 21:31:36 andvar Exp $ */
2 /*
3 * Copyright (c) 1996 Ludd, University of Lule}, Sweden.
4 * All rights reserved.
5 *
6 * This code is derived from software contributed to Ludd by
7 * Bertram Barth.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #include <sys/cdefs.h>
31 __KERNEL_RCSID(0, "$NetBSD: db_disasm.c,v 1.24 2021/07/24 21:31:36 andvar Exp $");
32
33 #include <sys/param.h>
34 #include <sys/proc.h>
35 #include <sys/reboot.h>
36 #include <sys/systm.h>
37
38 #include <machine/db_machdep.h>
39 #include <ddb/db_sym.h>
40 #include <ddb/db_variables.h>
41 #include <ddb/db_interface.h>
42 #include <ddb/db_output.h>
43
44 #include <vax/vax/db_disasm.h>
45
46 #ifdef VMS_MODE
47 #define DEFERRED '@'
48 #define LITERAL '#'
49 #else
50 #define DEFERRED '*'
51 #define LITERAL '$'
52 #endif
53 /*
54 * disassembling vax instructions works as follows:
55 *
56 * 1. get first byte as opcode (check for two-byte opcodes!)
57 * 2. lookup in op-table for mnemonic and operand-list
58 * 2.a store the mnemonic
59 * 3. for each operand in list: get the size/type
60 * 3.a evaluate addressing mode for this operand
61 * 3.b store each operand(s)
62 * 4. db_printf the opcode and the (value of the) operands
63 * 5. return the start of the next instruction
64 *
65 * - if jump/branch calculate (and display) the target-address
66 */
67
68 /*
69 #define BROKEN_DB_REGS
70 */
71 #ifdef BROKEN_DB_REGS
72 const struct { /* Due to order and contents of db_regs[], we can't */
73 const char *name; /* use this array to extract register-names. */
74 void *valuep; /* eg. "psl" vs "pc", "pc" vs "sp" */
75 } my_db_regs[16] = {
76 { "r0", NULL },
77 { "r1", NULL },
78 { "r2", NULL },
79 { "r3", NULL },
80 { "r4", NULL },
81 { "r5", NULL },
82 { "r6", NULL },
83 { "r7", NULL },
84 { "r8", NULL },
85 { "r9", NULL },
86 { "r10", NULL },
87 { "r11", NULL },
88 { "ap", NULL }, /* aka "r12" */
89 { "fp", NULL }, /* aka "r13" */
90 { "sp", NULL }, /* aka "r14" */
91 { "pc", NULL }, /* aka "r15" */
92 };
93 #else
94 #define my_db_regs db_regs
95 #endif
96
97 typedef struct {
98 char dasm[256]; /* disassebled instruction as text */
99 char *curp; /* pointer into result */
100 char *ppc; /* pseudo PC */
101 int opc; /* op-code */
102 const char *argp; /* pointer into argument-list */
103 int itype; /* instruction-type, eg. branch, call, unspec */
104 int atype; /* argument-type, eg. byte, long, address */
105 int off; /* offset specified by last argument */
106 int addr; /* address specified by last argument */
107 } inst_buffer;
108
109 #define ITYPE_INVALID -1
110 #define ITYPE_UNSPEC 0
111 #define ITYPE_BRANCH 1
112 #define ITYPE_CALL 2
113
114 static inline int get_byte(inst_buffer * ib);
115 static inline int get_word(inst_buffer * ib);
116 static inline int get_long(inst_buffer * ib);
117
118 static int get_opcode(inst_buffer * ib);
119 static int get_operands(inst_buffer * ib);
120 static int get_operand(inst_buffer * ib, int size);
121
122 static inline void add_char(inst_buffer * ib, char c);
123 static inline void add_str(inst_buffer * ib, const char *s);
124 static void add_int(inst_buffer * ib, int i);
125 static void add_xint(inst_buffer * ib, int i);
126 static void add_sym(inst_buffer * ib, int i);
127 static void add_off(inst_buffer * ib, int i);
128
129 #define err_print printf
130
131 /*
132 * Disassemble instruction at 'loc'. 'altfmt' specifies an
133 * (optional) alternate format (altfmt for vax: don't assume
134 * that each external label is a procedure entry mask).
135 * Return address of start of next instruction.
136 * Since this function is used by 'examine' and by 'step'
137 * "next instruction" does NOT mean the next instruction to
138 * be executed but the 'linear' next instruction.
139 */
140 db_addr_t
db_disasm(db_addr_t loc,bool altfmt)141 db_disasm(db_addr_t loc, bool altfmt)
142 {
143 db_expr_t diff;
144 db_sym_t sym;
145 const char *symname;
146
147 inst_buffer ib;
148
149 memset(&ib, 0, sizeof(ib));
150 ib.ppc = (void *) loc;
151 ib.curp = ib.dasm;
152
153 if (!altfmt) { /* ignore potential entry masks in altfmt */
154 diff = INT_MAX;
155 symname = NULL;
156 sym = db_search_symbol(loc, DB_STGY_PROC, &diff);
157 db_symbol_values(sym, &symname, 0);
158
159 if (symname && !diff) { /* symbol at loc */
160 db_printf("function \"%s()\", entry-mask 0x%x\n\t\t",
161 symname, (unsigned short) get_word(&ib));
162 ib.ppc += 2;
163 }
164 }
165 get_opcode(&ib);
166 get_operands(&ib);
167 db_printf("%s\n", ib.dasm);
168
169 return ((u_int) ib.ppc);
170 }
171
172 int
get_opcode(inst_buffer * ib)173 get_opcode(inst_buffer *ib)
174 {
175 ib->opc = get_byte(ib);
176 if (ib->opc >> 2 == 0x3F) { /* two byte op-code */
177 ib->opc = ib->opc << 8;
178 ib->opc += get_byte(ib);
179 }
180 switch (ib->opc) {
181 case 0xFA: /* CALLG */
182 case 0xFB: /* CALLS */
183 case 0xFC: /* XFC */
184 ib->itype = ITYPE_CALL;
185 break;
186 case 0x16: /* JSB */
187 case 0x17: /* JMP */
188 ib->itype = ITYPE_BRANCH;
189 break;
190 default:
191 ib->itype = ITYPE_UNSPEC;
192 }
193 if (ib->opc < 0 || ib->opc > 0xFF) {
194 add_str(ib, "invalid or two-byte opcode ");
195 add_xint(ib, ib->opc);
196 ib->itype = ITYPE_INVALID;
197 } else {
198 add_str(ib, vax_inst[ib->opc].mnemonic);
199 add_char(ib, '\t');
200 }
201 return (ib->opc);
202 }
203
204 int
get_operands(inst_buffer * ib)205 get_operands(inst_buffer *ib)
206 {
207 int aa = 0; /* absolute address mode ? */
208 int size;
209
210 if (ib->opc < 0 || ib->opc > 0xFF) {
211 /* invalid or two-byte opcode */
212 ib->argp = NULL;
213 return (-1);
214 }
215 ib->argp = vax_inst[ib->opc].argdesc;
216 if (ib->argp == NULL)
217 return 0;
218
219 while (*ib->argp) {
220 switch (*ib->argp) {
221
222 case 'b': /* branch displacement */
223 switch (*(++ib->argp)) {
224 case 'b':
225 ib->off = (signed char) get_byte(ib);
226 break;
227 case 'w':
228 ib->off = (short) get_word(ib);
229 break;
230 case 'l':
231 ib->off = get_long(ib);
232 break;
233 default:
234 err_print("XXX error\n");
235 }
236 /* add_int(ib, ib->off); */
237 ib->addr = (u_int) ib->ppc + ib->off;
238 add_off(ib, ib->addr);
239 break;
240
241 case 'a': /* absolute addressing mode */
242 aa = 1; /* do not break here ! */
243
244 default:
245 switch (*(++ib->argp)) {
246 case 'b': /* Byte */
247 size = SIZE_BYTE;
248 break;
249 case 'w': /* Word */
250 size = SIZE_WORD;
251 break;
252 case 'l': /* Long-Word */
253 case 'f': /* F_Floating */
254 size = SIZE_LONG;
255 break;
256 case 'q': /* Quad-Word */
257 case 'd': /* D_Floating */
258 case 'g': /* G_Floating */
259 size = SIZE_QWORD;
260 break;
261 case 'o': /* Octa-Word */
262 case 'h': /* H_Floating */
263 size = SIZE_OWORD;
264 break;
265 default:
266 err_print("invalid op-type %X (%c) found.\n",
267 *ib->argp, *ib->argp);
268 size = 0;
269 }
270 if (aa) {
271 /* get the address */
272 ib->addr = get_operand(ib, size);
273 add_sym(ib, ib->addr);
274 } else {
275 /* get the operand */
276 ib->addr = get_operand(ib, size);
277 add_off(ib, ib->addr);
278 }
279 }
280
281 if (!*ib->argp || !*++ib->argp)
282 break;
283 if (*ib->argp++ == ',') {
284 add_char(ib, ',');
285 add_char(ib, ' ');
286 } else {
287 err_print("XXX error\n");
288 add_char(ib, '\0');
289 return (-1);
290 }
291 }
292
293 add_char(ib, '\0');
294 return (0);
295 }
296
297 int
get_operand(inst_buffer * ib,int size)298 get_operand(inst_buffer *ib, int size)
299 {
300 int c = get_byte(ib);
301 int mode = c >> 4;
302 int reg = c & 0x0F;
303 int lit = c & 0x3F;
304 int tmp = 0;
305 char buf[16];
306
307 switch (mode) {
308 case 0: /* literal */
309 case 1: /* literal */
310 case 2: /* literal */
311 case 3: /* literal */
312 add_char(ib, LITERAL);
313 add_int(ib, lit);
314 tmp = lit;
315 break;
316
317 case 4: /* indexed */
318 snprintf(buf, sizeof(buf), "[%s]", my_db_regs[reg].name);
319 get_operand(ib, 0);
320 add_str(ib, buf);
321 break;
322
323 case 5: /* register */
324 add_str(ib, my_db_regs[reg].name);
325 break;
326
327 case 6: /* register deferred */
328 add_char(ib, '(');
329 add_str(ib, my_db_regs[reg].name);
330 add_char(ib, ')');
331 break;
332
333 case 7: /* autodecrement */
334 add_char(ib, '-');
335 add_char(ib, '(');
336 add_str(ib, my_db_regs[reg].name);
337 add_char(ib, ')');
338 if (reg == 0x0F) { /* pc is not allowed in this mode */
339 err_print("autodecrement not allowd for PC.\n");
340 }
341 break;
342
343 case 9: /* autoincrement deferred */
344 add_char(ib, DEFERRED);
345 if (reg == 0x0F) { /* pc: immediate deferred */
346 /*
347 * addresses are always longwords!
348 */
349 tmp = get_long(ib);
350 add_off(ib, tmp);
351 break;
352 }
353 /* fall through */
354 case 8: /* autoincrement */
355 if (reg == 0x0F) { /* pc: immediate ==> special syntax */
356 switch (size) {
357 case SIZE_BYTE:
358 tmp = (signed char) get_byte(ib);
359 break;
360 case SIZE_WORD:
361 tmp = (signed short) get_word(ib);
362 break;
363 case SIZE_LONG:
364 tmp = get_long(ib);
365 break;
366 default:
367 err_print("illegal op-type %d\n", size);
368 tmp = -1;
369 }
370 if (mode == 8)
371 add_char(ib, LITERAL);
372 add_int(ib, tmp);
373 break;
374 }
375 add_char(ib, '(');
376 add_str(ib, my_db_regs[reg].name);
377 add_char(ib, ')');
378 add_char(ib, '+');
379 break;
380
381 case 11: /* byte displacement deferred/ relative deferred */
382 add_char(ib, DEFERRED);
383 case 10: /* byte displacement / relative mode */
384 tmp = (signed char) get_byte(ib);
385 if (reg == 0x0F) {
386 add_off(ib, (u_int) ib->ppc + tmp);
387 break;
388 }
389 /* add_str (ib, "b^"); */
390 add_int(ib, tmp);
391 add_char(ib, '(');
392 add_str(ib, my_db_regs[reg].name);
393 add_char(ib, ')');
394 break;
395
396 case 13: /* word displacement deferred */
397 add_char(ib, DEFERRED);
398 case 12: /* word displacement */
399 tmp = (signed short) get_word(ib);
400 if (reg == 0x0F) {
401 add_off(ib, (u_int) ib->ppc + tmp);
402 break;
403 }
404 /* add_str (ib, "w^"); */
405 add_int(ib, tmp);
406 add_char(ib, '(');
407 add_str(ib, my_db_regs[reg].name);
408 add_char(ib, ')');
409 break;
410
411 case 15: /* long displacement referred */
412 add_char(ib, DEFERRED);
413 case 14: /* long displacement */
414 tmp = get_long(ib);
415 if (reg == 0x0F) {
416 add_off(ib, (u_int) ib->ppc + tmp);
417 break;
418 }
419 /* add_str (ib, "l^"); */
420 add_int(ib, tmp);
421 add_char(ib, '(');
422 add_str(ib, my_db_regs[reg].name);
423 add_char(ib, ')');
424 break;
425
426 default:
427 err_print("can\'t evaluate operand (%02X).\n", lit);
428 break;
429 }
430
431 return (0);
432 }
433
434 int
get_byte(inst_buffer * ib)435 get_byte(inst_buffer *ib)
436 {
437 return ((unsigned char) *(ib->ppc++));
438 }
439
440 int
get_word(inst_buffer * ib)441 get_word(inst_buffer *ib)
442 {
443 int tmp = *(uint16_t *)ib->ppc;
444 ib->ppc += 2;
445 return tmp;
446 }
447
448 int
get_long(inst_buffer * ib)449 get_long(inst_buffer *ib)
450 {
451 int tmp = *(int *)ib->ppc;
452 ib->ppc += 4;
453 return (tmp);
454 }
455
456 void
add_char(inst_buffer * ib,char c)457 add_char(inst_buffer *ib, char c)
458 {
459 *ib->curp++ = c;
460 }
461
462 void
add_str(inst_buffer * ib,const char * s)463 add_str(inst_buffer *ib, const char *s)
464 {
465 while ((*ib->curp++ = *s++));
466 --ib->curp;
467 }
468
469 void
add_int(inst_buffer * ib,int i)470 add_int(inst_buffer *ib, int i)
471 {
472 char buf[32];
473 if (i < 100 && i > -100)
474 snprintf(buf, sizeof(buf), "%d", i);
475 else
476 snprintf(buf, sizeof(buf), "0x%x", i);
477 add_str(ib, buf);
478 }
479
480 void
add_xint(inst_buffer * ib,int val)481 add_xint(inst_buffer *ib, int val)
482 {
483 char buf[32];
484 snprintf(buf, sizeof(buf), "0x%x", val);
485 add_str(ib, buf);
486 }
487
488 void
add_sym(inst_buffer * ib,int loc)489 add_sym(inst_buffer *ib, int loc)
490 {
491 db_expr_t diff;
492 db_sym_t sym;
493 const char *symname;
494
495 if (!loc)
496 return;
497
498 diff = INT_MAX;
499 symname = NULL;
500 sym = db_search_symbol(loc, DB_STGY_ANY, &diff);
501 db_symbol_values(sym, &symname, 0);
502
503 if (symname && !diff) {
504 /* add_char(ib, '<'); */
505 add_str(ib, symname);
506 /* add_char(ib, '>'); */
507 } else
508 add_xint(ib, loc);
509 }
510
511 void
add_off(inst_buffer * ib,int loc)512 add_off(inst_buffer *ib, int loc)
513 {
514 db_expr_t diff;
515 db_sym_t sym;
516 const char *symname;
517
518 if (!loc)
519 return;
520
521 diff = INT_MAX;
522 symname = NULL;
523 sym = db_search_symbol(loc, DB_STGY_ANY, &diff);
524 db_symbol_values(sym, &symname, 0);
525
526 if (symname) {
527 /* add_char(ib, '<'); */
528 add_str(ib, symname);
529 if (diff) {
530 add_char(ib, '+');
531 add_xint(ib, diff);
532 }
533 /* add_char(ib, '>'); */
534 } else
535 add_xint(ib, loc);
536 }
537