1 /* Disassemble z8000 code.
2 Copyright 1992, 1993, 1995, 1998 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program 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 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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];
38 /* Nibble number of first word not yet fetched. */
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
;
52 unsigned long interrupts
;
56 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
57 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
59 #define FETCH_DATA(info, nibble) \
60 ((nibble) < ((instr_data_s *)(info->private_data))->max_fetched \
61 ? 1 : fetch_data ((info), (nibble)))
64 fetch_data (info
, nibble
)
65 struct disassemble_info
*info
;
68 unsigned char mybuf
[20];
70 instr_data_s
*priv
= (instr_data_s
*)info
->private_data
;
72 if ((nibble
% 4) != 0)
75 status
= (*info
->read_memory_func
) (priv
->insn_start
,
81 (*info
->memory_error_func
) (status
, priv
->insn_start
, info
);
82 longjmp (priv
->bailout
, 1);
87 unsigned char *p
= mybuf
;
89 for (i
= 0; i
< nibble
;)
91 priv
->words
[i
] = (p
[0] << 8) | p
[1];
94 priv
->nibbles
[i
++] = *p
>> 4;
95 priv
->nibbles
[i
++] = *p
&0xf;
99 priv
->nibbles
[i
++] = *p
>> 4;
100 priv
->nibbles
[i
++] = *p
& 0xf;
105 priv
->max_fetched
= nibble
;
109 static char *codes
[16] =
129 int z8k_lookup_instr
PARAMS ((unsigned char*, disassemble_info
*));
130 static void output_instr
131 PARAMS ((instr_data_s
*, unsigned long, disassemble_info
*));
132 static void unpack_instr
PARAMS ((instr_data_s
*, int, disassemble_info
*));
133 static void unparse_instr
PARAMS ((instr_data_s
*));
136 print_insn_z8k (addr
, info
, is_segmented
)
138 disassemble_info
*info
;
141 instr_data_s instr_data
;
143 info
->private_data
= (PTR
) &instr_data
;
144 instr_data
.max_fetched
= 0;
145 instr_data
.insn_start
= addr
;
146 if (setjmp (instr_data
.bailout
) != 0)
150 instr_data
.tabl_index
= z8k_lookup_instr (instr_data
.nibbles
, info
);
151 if (instr_data
.tabl_index
> 0)
153 unpack_instr (&instr_data
, is_segmented
, info
);
154 unparse_instr (&instr_data
);
155 output_instr (&instr_data
, addr
, info
);
156 return z8k_table
[instr_data
.tabl_index
].length
;
160 FETCH_DATA (info
, 4);
161 (*info
->fprintf_func
) (info
->stream
, ".word %02x%02x",
162 instr_data
.bytes
[0], instr_data
.bytes
[2]);
168 print_insn_z8001 (addr
, info
)
170 disassemble_info
*info
;
172 return print_insn_z8k (addr
, info
, 1);
176 print_insn_z8002 (addr
, info
)
178 disassemble_info
*info
;
180 return print_insn_z8k (addr
, info
, 0);
184 z8k_lookup_instr (nibbles
, info
)
185 unsigned char *nibbles
;
186 disassemble_info
*info
;
189 int nibl_index
, tabl_index
;
191 unsigned short instr_nibl
;
192 unsigned short tabl_datum
, datum_class
, datum_value
;
196 while (!nibl_matched
&& z8k_table
[tabl_index
].name
)
199 for (nibl_index
= 0; nibl_index
< z8k_table
[tabl_index
].length
* 2 && nibl_matched
; nibl_index
++)
201 if ((nibl_index
% 4) == 0)
202 /* Fetch one word at a time. */
203 FETCH_DATA (info
, nibl_index
+ 4);
204 instr_nibl
= nibbles
[nibl_index
];
206 tabl_datum
= z8k_table
[tabl_index
].byte_info
[nibl_index
];
207 datum_class
= tabl_datum
& CLASS_MASK
;
208 datum_value
= ~CLASS_MASK
& tabl_datum
;
213 if (datum_value
!= instr_nibl
)
217 if (!((~instr_nibl
) & 0x4))
221 if (!(instr_nibl
& 0x4))
225 if (!((~instr_nibl
) & 0x8))
229 if (!(instr_nibl
& 0x8))
233 if (!((~instr_nibl
) & 0x8))
238 if (!(instr_nibl
& 0x8))
247 if ((instr_nibl
| 0x2) != (datum_value
| 0x2))
266 output_instr (instr_data
, addr
, info
)
267 instr_data_s
*instr_data
;
269 disassemble_info
*info
;
271 int loop
, loop_limit
;
275 strcpy (out_str
, "\t");
277 loop_limit
= z8k_table
[instr_data
->tabl_index
].length
* 2;
278 FETCH_DATA (info
, loop_limit
);
279 for (loop
= 0; loop
< loop_limit
; loop
++)
281 sprintf (tmp_str
, "%x", instr_data
->nibbles
[loop
]);
282 strcat (out_str
, tmp_str
);
287 strcat (out_str
, " ");
290 strcat (out_str
, instr_data
->instr_asmsrc
);
292 (*info
->fprintf_func
) (info
->stream
, "%s", out_str
);
296 unpack_instr (instr_data
, is_segmented
, info
)
297 instr_data_s
*instr_data
;
299 disassemble_info
*info
;
301 int nibl_count
, loop
;
302 unsigned short instr_nibl
, instr_byte
, instr_word
;
304 unsigned short tabl_datum
, datum_class
, datum_value
;
308 while (z8k_table
[instr_data
->tabl_index
].byte_info
[loop
] != 0)
310 FETCH_DATA (info
, nibl_count
+ 4 - (nibl_count
% 4));
311 instr_nibl
= instr_data
->nibbles
[nibl_count
];
312 instr_byte
= instr_data
->bytes
[nibl_count
];
313 instr_word
= instr_data
->words
[nibl_count
];
315 tabl_datum
= z8k_table
[instr_data
->tabl_index
].byte_info
[loop
];
316 datum_class
= tabl_datum
& CLASS_MASK
;
317 datum_value
= tabl_datum
& ~CLASS_MASK
;
322 instr_data
->address
= instr_nibl
;
325 instr_data
->displacement
= instr_nibl
;
328 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
334 instr_data
->displacement
= instr_word
;
338 instr_data
->displacement
= instr_word
& 0x0fff;
349 instr_data
->immediate
= instr_nibl
;
352 instr_data
->immediate
= (-instr_byte
);
356 instr_data
->immediate
= instr_byte
;
360 instr_data
->immediate
= instr_word
;
364 FETCH_DATA (info
, nibl_count
+ 8);
365 instr_long
= (instr_data
->words
[nibl_count
] << 16)
366 | (instr_data
->words
[nibl_count
+ 4]);
367 instr_data
->immediate
= instr_long
;
371 instr_data
->immediate
= instr_nibl
- 1;
374 instr_data
->immediate
= instr_nibl
+ 1;
377 instr_data
->immediate
= 1;
380 instr_data
->immediate
= 2;
383 instr_data
->immediate
= instr_nibl
& 0x3;
390 instr_data
->cond_code
= instr_nibl
;
393 instr_data
->ctrl_code
= instr_nibl
;
399 if (instr_nibl
& 0x8)
401 FETCH_DATA (info
, nibl_count
+ 8);
402 instr_long
= (instr_data
->words
[nibl_count
] << 16)
403 | (instr_data
->words
[nibl_count
+ 4]);
404 instr_data
->address
= ((instr_word
& 0x7f00) << 8) +
405 (instr_long
& 0xffff);
410 instr_data
->address
= ((instr_word
& 0x7f00) << 8) +
411 (instr_word
& 0x00ff);
417 instr_data
->address
= instr_word
;
422 instr_data
->cond_code
= instr_nibl
& 0x7;
425 instr_data
->cond_code
= instr_nibl
& 0x7;
428 instr_data
->displacement
= instr_byte
& 0x7f;
432 instr_data
->displacement
= instr_byte
& 0x7f;
436 instr_data
->interrupts
= instr_nibl
& 0x3;
439 instr_data
->interrupts
= instr_nibl
& 0x3;
445 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
448 instr_data
->flags
= instr_nibl
;
451 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
454 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
457 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
460 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
463 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
466 instr_data
->arg_reg
[datum_value
] = instr_nibl
;
478 unparse_instr (instr_data
)
479 instr_data_s
*instr_data
;
481 unsigned short tabl_datum
, datum_class
, datum_value
;
482 int loop
, loop_limit
;
483 char out_str
[80], tmp_str
[25];
485 sprintf (out_str
, "\t%s\t", z8k_table
[instr_data
->tabl_index
].name
);
487 loop_limit
= z8k_table
[instr_data
->tabl_index
].noperands
;
488 for (loop
= 0; loop
< loop_limit
; loop
++)
491 strcat (out_str
, ",");
493 tabl_datum
= z8k_table
[instr_data
->tabl_index
].arg_info
[loop
];
494 datum_class
= tabl_datum
& CLASS_MASK
;
495 datum_value
= tabl_datum
& ~CLASS_MASK
;
500 sprintf (tmp_str
, "0x%0lx(R%ld)", instr_data
->address
,
501 instr_data
->arg_reg
[datum_value
]);
502 strcat (out_str
, tmp_str
);
505 sprintf (tmp_str
, "r%ld(#%lx)", instr_data
->arg_reg
[datum_value
],
506 instr_data
->immediate
);
507 strcat (out_str
, tmp_str
);
510 sprintf (tmp_str
, "r%ld(R%ld)", instr_data
->arg_reg
[datum_value
],
511 instr_data
->arg_reg
[ARG_RX
]);
512 strcat (out_str
, tmp_str
);
515 sprintf (tmp_str
, "#0x%0lx", instr_data
->displacement
);
516 strcat (out_str
, tmp_str
);
519 sprintf (tmp_str
, "#0x%0lx", instr_data
->immediate
);
520 strcat (out_str
, tmp_str
);
523 sprintf (tmp_str
, "%s", codes
[instr_data
->cond_code
]);
524 strcat (out_str
, tmp_str
);
527 sprintf (tmp_str
, "0x%0lx", instr_data
->ctrl_code
);
528 strcat (out_str
, tmp_str
);
532 sprintf (tmp_str
, "#0x%0lx", instr_data
->address
);
533 strcat (out_str
, tmp_str
);
536 sprintf (tmp_str
, "@R%ld", instr_data
->arg_reg
[datum_value
]);
537 strcat (out_str
, tmp_str
);
540 sprintf (tmp_str
, "0x%0lx", instr_data
->flags
);
541 strcat (out_str
, tmp_str
);
544 if (instr_data
->arg_reg
[datum_value
] >= 0x8)
546 sprintf (tmp_str
, "rl%ld",
547 instr_data
->arg_reg
[datum_value
] - 0x8);
551 sprintf (tmp_str
, "rh%ld", instr_data
->arg_reg
[datum_value
]);
553 strcat (out_str
, tmp_str
);
556 sprintf (tmp_str
, "r%ld", instr_data
->arg_reg
[datum_value
]);
557 strcat (out_str
, tmp_str
);
560 sprintf (tmp_str
, "rq%ld", instr_data
->arg_reg
[datum_value
]);
561 strcat (out_str
, tmp_str
);
564 sprintf (tmp_str
, "rr%ld", instr_data
->arg_reg
[datum_value
]);
565 strcat (out_str
, tmp_str
);
572 strcpy (instr_data
->instr_asmsrc
, out_str
);
This page took 0.042023 seconds and 4 git commands to generate.