1 /* Disassemble z8000 code.
2 Copyright (C) 1992-2023 Free Software Foundation, Inc.
3
4 This file is part of the GNU opcodes library.
5
6 This library is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 It is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14 License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this file; see the file COPYING. If not, write to the
18 Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #include "sysdep.h"
22 #include "disassemble.h"
23 #include "libiberty.h"
24
25 #define DEFINE_TABLE
26 #include "z8k-opc.h"
27
28 #include <setjmp.h>
29
30 typedef struct
31 {
32 /* These are all indexed by nibble number (i.e only every other entry
33 of bytes is used, and every 4th entry of words). */
34 unsigned char nibbles[24];
35 unsigned char bytes[24];
36 unsigned short words[24];
37
38 /* Nibble number of first word not yet fetched. */
39 unsigned int max_fetched;
40 bfd_vma insn_start;
41 OPCODES_SIGJMP_BUF bailout;
42
43 int tabl_index;
44 char instr_asmsrc[80];
45 unsigned long arg_reg[0x0f];
46 unsigned long immediate;
47 unsigned long displacement;
48 unsigned long address;
49 unsigned long cond_code;
50 unsigned long ctrl_code;
51 unsigned long flags;
52 unsigned long interrupts;
53 }
54 instr_data_s;
55
56 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
57 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
58 on error. */
59 #define FETCH_DATA(info, nibble) \
60 ((nibble) < ((instr_data_s *) (info->private_data))->max_fetched \
61 ? 1 : fetch_data ((info), (nibble)))
62
63 static int
64 fetch_data (struct disassemble_info *info, int nibble)
65 {
66 unsigned char mybuf[20];
67 int status;
68 instr_data_s *priv = (instr_data_s *) info->private_data;
69
70 if ((nibble % 4) != 0)
71 abort ();
72
73 status = (*info->read_memory_func) (priv->insn_start,
74 (bfd_byte *) mybuf,
75 nibble / 2,
76 info);
77 if (status != 0)
78 {
79 (*info->memory_error_func) (status, priv->insn_start, info);
80 OPCODES_SIGLONGJMP (priv->bailout, 1);
81 }
82
83 {
84 int i;
85 unsigned char *p = mybuf;
86
87 for (i = 0; i < nibble;)
88 {
89 priv->words[i] = (p[0] << 8) | p[1];
90
91 priv->bytes[i] = *p;
92 priv->nibbles[i++] = *p >> 4;
93 priv->nibbles[i++] = *p & 0xf;
94
95 ++p;
96 priv->bytes[i] = *p;
97 priv->nibbles[i++] = *p >> 4;
98 priv->nibbles[i++] = *p & 0xf;
99
100 ++p;
101 }
102 }
103 priv->max_fetched = nibble;
104 return 1;
105 }
106
107 static char *codes[16] =
108 {
109 "f",
110 "lt",
111 "le",
112 "ule",
113 "ov/pe",
114 "mi",
115 "eq",
116 "c/ult",
117 "t",
118 "ge",
119 "gt",
120 "ugt",
121 "nov/po",
122 "pl",
123 "ne",
124 "nc/uge"
125 };
126
127 static char *ctrl_names[8] =
128 {
129 "<invld>",
130 "flags",
131 "fcw",
132 "refresh",
133 "psapseg",
134 "psapoff",
135 "nspseg",
136 "nspoff"
137 };
138
139 static int seg_length;
140 int z8k_lookup_instr (unsigned char *, disassemble_info *);
141 static void output_instr (instr_data_s *, unsigned long, disassemble_info *);
142 static void unpack_instr (instr_data_s *, int, disassemble_info *);
143 static void unparse_instr (instr_data_s *, int);
144
145 static int
146 print_insn_z8k (bfd_vma addr, disassemble_info *info, int is_segmented)
147 {
148 instr_data_s instr_data;
149
150 info->private_data = &instr_data;
151 instr_data.max_fetched = 0;
152 instr_data.insn_start = addr;
153 if (OPCODES_SIGSETJMP (instr_data.bailout) != 0)
154 /* Error return. */
155 return -1;
156
157 info->bytes_per_chunk = 2;
158 info->bytes_per_line = 6;
159 info->display_endian = BFD_ENDIAN_BIG;
160
161 instr_data.tabl_index = z8k_lookup_instr (instr_data.nibbles, info);
162 if (instr_data.tabl_index >= 0)
163 {
164 unpack_instr (&instr_data, is_segmented, info);
165 unparse_instr (&instr_data, is_segmented);
166 output_instr (&instr_data, addr, info);
167 return z8k_table[instr_data.tabl_index].length + seg_length;
168 }
169 else
170 {
171 FETCH_DATA (info, 4);
172 (*info->fprintf_func) (info->stream, ".word %02x%02x",
173 instr_data.bytes[0], instr_data.bytes[2]);
174 return 2;
175 }
176 }
177
178 int
179 print_insn_z8001 (bfd_vma addr, disassemble_info *info)
180 {
181 return print_insn_z8k (addr, info, 1);
182 }
183
184 int
185 print_insn_z8002 (bfd_vma addr, disassemble_info *info)
186 {
187 return print_insn_z8k (addr, info, 0);
188 }
189
190 int
191 z8k_lookup_instr (unsigned char *nibbles, disassemble_info *info)
192 {
193 unsigned int nibl_index, tabl_index;
194 int nibl_matched;
195 int need_fetch = 0;
196 unsigned short instr_nibl;
197 unsigned short tabl_datum, datum_class, datum_value;
198
199 nibl_matched = 0;
200 tabl_index = 0;
201 FETCH_DATA (info, 4);
202 while (!nibl_matched && z8k_table[tabl_index].name)
203 {
204 nibl_matched = 1;
205 for (nibl_index = 0;
206 nibl_matched
207 && nibl_index < ARRAY_SIZE (z8k_table[0].byte_info)
208 && nibl_index < z8k_table[tabl_index].length * 2;
209 nibl_index++)
210 {
211 if ((nibl_index % 4) == 0)
212 {
213 /* Fetch data only if it isn't already there. */
214 if (nibl_index >= 4 || (nibl_index < 4 && need_fetch))
215 FETCH_DATA (info, nibl_index + 4); /* Fetch one word at a time. */
216 if (nibl_index < 4)
217 need_fetch = 0;
218 else
219 need_fetch = 1;
220 }
221 instr_nibl = nibbles[nibl_index];
222
223 tabl_datum = z8k_table[tabl_index].byte_info[nibl_index];
224 datum_class = tabl_datum & CLASS_MASK;
225 datum_value = ~CLASS_MASK & tabl_datum;
226
227 switch (datum_class)
228 {
229 case CLASS_BIT:
230 if (datum_value != instr_nibl)
231 nibl_matched = 0;
232 break;
233 case CLASS_IGNORE:
234 break;
235 case CLASS_00II:
236 if (!((~instr_nibl) & 0x4))
237 nibl_matched = 0;
238 break;
239 case CLASS_01II:
240 if (!(instr_nibl & 0x4))
241 nibl_matched = 0;
242 break;
243 case CLASS_0CCC:
244 if (!((~instr_nibl) & 0x8))
245 nibl_matched = 0;
246 break;
247 case CLASS_1CCC:
248 if (!(instr_nibl & 0x8))
249 nibl_matched = 0;
250 break;
251 case CLASS_0DISP7:
252 if (!((~instr_nibl) & 0x8))
253 nibl_matched = 0;
254 nibl_index += 1;
255 break;
256 case CLASS_1DISP7:
257 if (!(instr_nibl & 0x8))
258 nibl_matched = 0;
259 nibl_index += 1;
260 break;
261 case CLASS_REGN0:
262 if (instr_nibl == 0)
263 nibl_matched = 0;
264 break;
265 case CLASS_BIT_1OR2:
266 if ((instr_nibl | 0x2) != (datum_value | 0x2))
267 nibl_matched = 0;
268 break;
269 default:
270 break;
271 }
272 }
273
274 if (nibl_matched)
275 return tabl_index;
276
277 tabl_index++;
278 }
279 return -1;
280 }
281
282 static void
283 output_instr (instr_data_s *instr_data,
284 unsigned long addr ATTRIBUTE_UNUSED,
285 disassemble_info *info)
286 {
287 unsigned int num_bytes;
288 char out_str[100];
289
290 out_str[0] = 0;
291
292 num_bytes = (z8k_table[instr_data->tabl_index].length + seg_length) * 2;
293 FETCH_DATA (info, num_bytes);
294
295 strcat (out_str, instr_data->instr_asmsrc);
296
297 (*info->fprintf_func) (info->stream, "%s", out_str);
298 }
299
300 static void
301 unpack_instr (instr_data_s *instr_data, int is_segmented, disassemble_info *info)
302 {
303 unsigned int nibl_count, loop;
304 unsigned short instr_nibl, instr_byte, instr_word;
305 long instr_long;
306 unsigned int tabl_datum, datum_class;
307 unsigned short datum_value;
308
309 nibl_count = 0;
310 loop = 0;
311 seg_length = 0;
312
313 while (z8k_table[instr_data->tabl_index].byte_info[loop] != 0)
314 {
315 FETCH_DATA (info, nibl_count + 4 - (nibl_count % 4));
316 instr_nibl = instr_data->nibbles[nibl_count];
317 instr_byte = instr_data->bytes[nibl_count & ~1];
318 instr_word = instr_data->words[nibl_count & ~3];
319
320 tabl_datum = z8k_table[instr_data->tabl_index].byte_info[loop];
321 datum_class = tabl_datum & CLASS_MASK;
322 datum_value = tabl_datum & ~CLASS_MASK;
323
324 switch (datum_class)
325 {
326 case CLASS_DISP:
327 switch (datum_value)
328 {
329 case ARG_DISP16:
330 instr_data->displacement = instr_data->insn_start + 4
331 + (signed short) (instr_word & 0xffff);
332 nibl_count += 3;
333 break;
334 case ARG_DISP12:
335 if (instr_word & 0x800)
336 /* Negative 12 bit displacement. */
337 instr_data->displacement = instr_data->insn_start + 2
338 - (signed short) ((instr_word & 0xfff) | 0xf000) * 2;
339 else
340 instr_data->displacement = instr_data->insn_start + 2
341 - (instr_word & 0x0fff) * 2;
342
343 nibl_count += 2;
344 break;
345 default:
346 break;
347 }
348 break;
349 case CLASS_IMM:
350 switch (datum_value)
351 {
352 case ARG_IMM4:
353 instr_data->immediate = instr_nibl;
354 break;
355 case ARG_NIM4:
356 instr_data->immediate = (- instr_nibl) & 0xf;
357 break;
358 case ARG_NIM8:
359 instr_data->immediate = (- instr_byte) & 0xff;
360 nibl_count += 1;
361 break;
362 case ARG_IMM8:
363 instr_data->immediate = instr_byte;
364 nibl_count += 1;
365 break;
366 case ARG_IMM16:
367 instr_data->immediate = instr_word;
368 nibl_count += 3;
369 break;
370 case ARG_IMM32:
371 FETCH_DATA (info, nibl_count + 8);
372 instr_long = ((unsigned) instr_data->words[nibl_count] << 16
373 | instr_data->words[nibl_count + 4]);
374 instr_data->immediate = instr_long;
375 nibl_count += 7;
376 break;
377 case ARG_IMMN:
378 instr_data->immediate = instr_nibl - 1;
379 break;
380 case ARG_IMM4M1:
381 instr_data->immediate = instr_nibl + 1;
382 break;
383 case ARG_IMM_1:
384 instr_data->immediate = 1;
385 break;
386 case ARG_IMM_2:
387 instr_data->immediate = 2;
388 break;
389 case ARG_IMM2:
390 instr_data->immediate = instr_nibl & 0x3;
391 break;
392 default:
393 break;
394 }
395 break;
396 case CLASS_CC:
397 instr_data->cond_code = instr_nibl;
398 break;
399 case CLASS_ADDRESS:
400 if (is_segmented)
401 {
402 if (instr_nibl & 0x8)
403 {
404 FETCH_DATA (info, nibl_count + 8);
405 instr_long = ((unsigned) instr_data->words[nibl_count] << 16
406 | instr_data->words[nibl_count + 4]);
407 instr_data->address = ((instr_word & 0x7f00) << 16
408 | (instr_long & 0xffff));
409 nibl_count += 7;
410 seg_length = 2;
411 }
412 else
413 {
414 instr_data->address = ((instr_word & 0x7f00) << 16
415 | (instr_word & 0x00ff));
416 nibl_count += 3;
417 }
418 }
419 else
420 {
421 instr_data->address = instr_word;
422 nibl_count += 3;
423 }
424 break;
425 case CLASS_0CCC:
426 case CLASS_1CCC:
427 instr_data->ctrl_code = instr_nibl & 0x7;
428 break;
429 case CLASS_0DISP7:
430 instr_data->displacement =
431 instr_data->insn_start + 2 - (instr_byte & 0x7f) * 2;
432 nibl_count += 1;
433 break;
434 case CLASS_1DISP7:
435 instr_data->displacement =
436 instr_data->insn_start + 2 - (instr_byte & 0x7f) * 2;
437 nibl_count += 1;
438 break;
439 case CLASS_01II:
440 instr_data->interrupts = instr_nibl & 0x3;
441 break;
442 case CLASS_00II:
443 instr_data->interrupts = instr_nibl & 0x3;
444 break;
445 case CLASS_IGNORE:
446 case CLASS_BIT:
447 instr_data->ctrl_code = instr_nibl & 0x7;
448 break;
449 case CLASS_FLAGS:
450 instr_data->flags = instr_nibl;
451 break;
452 case CLASS_REG:
453 instr_data->arg_reg[datum_value] = instr_nibl;
454 break;
455 case CLASS_REGN0:
456 instr_data->arg_reg[datum_value] = instr_nibl;
457 break;
458 case CLASS_DISP8:
459 instr_data->displacement =
460 instr_data->insn_start + 2 + (signed char) instr_byte * 2;
461 nibl_count += 1;
462 break;
463 case CLASS_BIT_1OR2:
464 instr_data->immediate = ((instr_nibl >> 1) & 0x1) + 1;
465 nibl_count += 1;
466 break;
467 default:
468 abort ();
469 break;
470 }
471
472 loop += 1;
473 nibl_count += 1;
474 }
475 }
476
477 static void
478 print_intr(char *tmp_str, unsigned long interrupts)
479 {
480 int comma = 0;
481
482 *tmp_str = 0;
483 if (! (interrupts & 2))
484 {
485 strcat (tmp_str, "vi");
486 comma = 1;
487 }
488 if (! (interrupts & 1))
489 {
490 if (comma) strcat (tmp_str, ",");
491 strcat (tmp_str, "nvi");
492 }
493 }
494
495 static void
496 print_flags(char *tmp_str, unsigned long flags)
497 {
498 int comma = 0;
499
500 *tmp_str = 0;
501 if (flags & 8)
502 {
503 strcat (tmp_str, "c");
504 comma = 1;
505 }
506 if (flags & 4)
507 {
508 if (comma) strcat (tmp_str, ",");
509 strcat (tmp_str, "z");
510 comma = 1;
511 }
512 if (flags & 2)
513 {
514 if (comma) strcat (tmp_str, ",");
515 strcat (tmp_str, "s");
516 comma = 1;
517 }
518 if (flags & 1)
519 {
520 if (comma) strcat (tmp_str, ",");
521 strcat (tmp_str, "p");
522 }
523 }
524
525 static void
526 unparse_instr (instr_data_s *instr_data, int is_segmented)
527 {
528 unsigned short datum_value;
529 unsigned int tabl_datum, datum_class;
530 int loop, loop_limit;
531 char out_str[80], tmp_str[25];
532
533 sprintf (out_str, "%s\t", z8k_table[instr_data->tabl_index].name);
534
535 loop_limit = z8k_table[instr_data->tabl_index].noperands;
536 for (loop = 0; loop < loop_limit; loop++)
537 {
538 if (loop)
539 strcat (out_str, ",");
540
541 tabl_datum = z8k_table[instr_data->tabl_index].arg_info[loop];
542 datum_class = tabl_datum & CLASS_MASK;
543 datum_value = tabl_datum & ~CLASS_MASK;
544
545 switch (datum_class)
546 {
547 case CLASS_X:
548 sprintf (tmp_str, "0x%0lx(r%ld)", instr_data->address,
549 instr_data->arg_reg[datum_value]);
550 strcat (out_str, tmp_str);
551 break;
552 case CLASS_BA:
553 if (is_segmented)
554 sprintf (tmp_str, "rr%ld(#0x%lx)", instr_data->arg_reg[datum_value],
555 instr_data->immediate);
556 else
557 sprintf (tmp_str, "r%ld(#0x%lx)", instr_data->arg_reg[datum_value],
558 instr_data->immediate);
559 strcat (out_str, tmp_str);
560 break;
561 case CLASS_BX:
562 if (is_segmented)
563 sprintf (tmp_str, "rr%ld(r%ld)", instr_data->arg_reg[datum_value],
564 instr_data->arg_reg[ARG_RX]);
565 else
566 sprintf (tmp_str, "r%ld(r%ld)", instr_data->arg_reg[datum_value],
567 instr_data->arg_reg[ARG_RX]);
568 strcat (out_str, tmp_str);
569 break;
570 case CLASS_DISP:
571 sprintf (tmp_str, "0x%0lx", instr_data->displacement);
572 strcat (out_str, tmp_str);
573 break;
574 case CLASS_IMM:
575 if (datum_value == ARG_IMM2) /* True with EI/DI instructions only. */
576 {
577 print_intr (tmp_str, instr_data->interrupts);
578 strcat (out_str, tmp_str);
579 break;
580 }
581 sprintf (tmp_str, "#0x%0lx", instr_data->immediate);
582 strcat (out_str, tmp_str);
583 break;
584 case CLASS_CC:
585 sprintf (tmp_str, "%s", codes[instr_data->cond_code]);
586 strcat (out_str, tmp_str);
587 break;
588 case CLASS_CTRL:
589 sprintf (tmp_str, "%s", ctrl_names[instr_data->ctrl_code]);
590 strcat (out_str, tmp_str);
591 break;
592 case CLASS_DA:
593 case CLASS_ADDRESS:
594 sprintf (tmp_str, "0x%0lx", instr_data->address);
595 strcat (out_str, tmp_str);
596 break;
597 case CLASS_IR:
598 if (is_segmented)
599 sprintf (tmp_str, "@rr%ld", instr_data->arg_reg[datum_value]);
600 else
601 sprintf (tmp_str, "@r%ld", instr_data->arg_reg[datum_value]);
602 strcat (out_str, tmp_str);
603 break;
604 case CLASS_IRO:
605 sprintf (tmp_str, "@r%ld", instr_data->arg_reg[datum_value]);
606 strcat (out_str, tmp_str);
607 break;
608 case CLASS_FLAGS:
609 print_flags(tmp_str, instr_data->flags);
610 strcat (out_str, tmp_str);
611 break;
612 case CLASS_REG_BYTE:
613 if (instr_data->arg_reg[datum_value] >= 0x8)
614 sprintf (tmp_str, "rl%ld",
615 instr_data->arg_reg[datum_value] - 0x8);
616 else
617 sprintf (tmp_str, "rh%ld", instr_data->arg_reg[datum_value]);
618 strcat (out_str, tmp_str);
619 break;
620 case CLASS_REG_WORD:
621 sprintf (tmp_str, "r%ld", instr_data->arg_reg[datum_value]);
622 strcat (out_str, tmp_str);
623 break;
624 case CLASS_REG_QUAD:
625 sprintf (tmp_str, "rq%ld", instr_data->arg_reg[datum_value]);
626 strcat (out_str, tmp_str);
627 break;
628 case CLASS_REG_LONG:
629 sprintf (tmp_str, "rr%ld", instr_data->arg_reg[datum_value]);
630 strcat (out_str, tmp_str);
631 break;
632 case CLASS_PR:
633 if (is_segmented)
634 sprintf (tmp_str, "rr%ld", instr_data->arg_reg[datum_value]);
635 else
636 sprintf (tmp_str, "r%ld", instr_data->arg_reg[datum_value]);
637 strcat (out_str, tmp_str);
638 break;
639 default:
640 abort ();
641 break;
642 }
643 }
644
645 strcpy (instr_data->instr_asmsrc, out_str);
646 }