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