]>
Commit | Line | Data |
---|---|---|
7b61b094 MA |
1 | /* Disassemble MN10200 instructions. |
2 | Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc. | |
3 | ||
4 | This program is free software; you can redistribute it and/or modify | |
5 | it under the terms of the GNU General Public License as published by | |
6 | the Free Software Foundation; either version 2 of the License, or | |
7 | (at your option) any later version. | |
8 | ||
9 | This program is distributed in the hope that it will be useful, | |
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | GNU General Public License for more details. | |
13 | ||
14 | You should have received a copy of the GNU General Public License | |
15 | along with this program; if not, write to the Free Software | |
16 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
17 | ||
18 | ||
19 | #include <stdio.h> | |
20 | ||
21 | #include "ansidecl.h" | |
22 | #include "opcode/mn10200.h" | |
23 | #include "dis-asm.h" | |
24 | #include "opintl.h" | |
25 | ||
26 | static void disassemble PARAMS ((bfd_vma, struct disassemble_info *, | |
27 | unsigned long insn, unsigned long, | |
28 | unsigned int)); | |
29 | ||
30 | int | |
31 | print_insn_mn10200 (memaddr, info) | |
32 | bfd_vma memaddr; | |
33 | struct disassemble_info *info; | |
34 | { | |
35 | int status; | |
36 | bfd_byte buffer[4]; | |
37 | unsigned long insn; | |
38 | unsigned long extension = 0; | |
39 | unsigned int consume; | |
40 | ||
41 | /* First figure out how big the opcode is. */ | |
42 | status = (*info->read_memory_func) (memaddr, buffer, 1, info); | |
43 | if (status != 0) | |
44 | { | |
45 | (*info->memory_error_func) (status, memaddr, info); | |
46 | return -1; | |
47 | } | |
48 | insn = *(unsigned char *) buffer; | |
49 | ||
50 | /* These are one byte insns. */ | |
51 | if ((insn & 0xf0) == 0x00 | |
52 | || (insn & 0xf0) == 0x10 | |
53 | || (insn & 0xf0) == 0x20 | |
54 | || (insn & 0xf0) == 0x30 | |
55 | || ((insn & 0xf0) == 0x80 | |
56 | && (insn & 0x0c) >> 2 != (insn & 0x03)) | |
57 | || (insn & 0xf0) == 0x90 | |
58 | || (insn & 0xf0) == 0xa0 | |
59 | || (insn & 0xf0) == 0xb0 | |
60 | || (insn & 0xff) == 0xeb | |
61 | || (insn & 0xff) == 0xf6 | |
62 | || (insn & 0xff) == 0xfe | |
63 | || (insn & 0xff) == 0xff) | |
64 | { | |
65 | extension = 0; | |
66 | consume = 1; | |
67 | } | |
68 | ||
69 | /* These are two byte insns. */ | |
70 | else if ((insn & 0xf0) == 0x40 | |
71 | || (insn & 0xf0) == 0x50 | |
72 | || (insn & 0xf0) == 0x60 | |
73 | || (insn & 0xf0) == 0x70 | |
74 | || (insn & 0xf0) == 0x80 | |
75 | || (insn & 0xfc) == 0xd0 | |
76 | || (insn & 0xfc) == 0xd4 | |
77 | || (insn & 0xfc) == 0xd8 | |
78 | || (insn & 0xfc) == 0xe0 | |
79 | || (insn & 0xfc) == 0xe4 | |
80 | || (insn & 0xff) == 0xe8 | |
81 | || (insn & 0xff) == 0xe9 | |
82 | || (insn & 0xff) == 0xea | |
83 | || (insn & 0xff) == 0xf0 | |
84 | || (insn & 0xff) == 0xf1 | |
85 | || (insn & 0xff) == 0xf2 | |
86 | || (insn & 0xff) == 0xf3) | |
87 | { | |
88 | status = (*info->read_memory_func) (memaddr, buffer, 2, info); | |
89 | if (status != 0) | |
90 | { | |
91 | (*info->memory_error_func) (status, memaddr, info); | |
92 | return -1; | |
93 | } | |
94 | insn = bfd_getb16 (buffer); | |
95 | consume = 2; | |
96 | } | |
97 | ||
98 | /* These are three byte insns with a 16bit operand in little | |
99 | endian form. */ | |
100 | else if ((insn & 0xf0) == 0xc0 | |
101 | || (insn & 0xfc) == 0xdc | |
102 | || (insn & 0xfc) == 0xec | |
103 | || (insn & 0xff) == 0xf8 | |
104 | || (insn & 0xff) == 0xf9 | |
105 | || (insn & 0xff) == 0xfa | |
106 | || (insn & 0xff) == 0xfb | |
107 | || (insn & 0xff) == 0xfc | |
108 | || (insn & 0xff) == 0xfd) | |
109 | { | |
110 | status = (*info->read_memory_func) (memaddr + 1, buffer, 2, info); | |
111 | if (status != 0) | |
112 | { | |
113 | (*info->memory_error_func) (status, memaddr, info); | |
114 | return -1; | |
115 | } | |
116 | insn <<= 16; | |
117 | insn |= bfd_getl16 (buffer); | |
118 | extension = 0; | |
119 | consume = 3; | |
120 | } | |
121 | /* These are three byte insns too, but we don't have to mess with | |
122 | endianness stuff. */ | |
123 | else if ((insn & 0xff) == 0xf5) | |
124 | { | |
125 | status = (*info->read_memory_func) (memaddr + 1, buffer, 2, info); | |
126 | if (status != 0) | |
127 | { | |
128 | (*info->memory_error_func) (status, memaddr, info); | |
129 | return -1; | |
130 | } | |
131 | insn <<= 16; | |
132 | insn |= bfd_getb16 (buffer); | |
133 | extension = 0; | |
134 | consume = 3; | |
135 | } | |
136 | ||
137 | /* These are four byte insns. */ | |
138 | else if ((insn & 0xff) == 0xf7) | |
139 | { | |
140 | status = (*info->read_memory_func) (memaddr, buffer, 2, info); | |
141 | if (status != 0) | |
142 | { | |
143 | (*info->memory_error_func) (status, memaddr, info); | |
144 | return -1; | |
145 | } | |
146 | insn = bfd_getb16 (buffer); | |
147 | insn <<= 16; | |
148 | status = (*info->read_memory_func) (memaddr + 2, buffer, 2, info); | |
149 | if (status != 0) | |
150 | { | |
151 | (*info->memory_error_func) (status, memaddr, info); | |
152 | return -1; | |
153 | } | |
154 | insn |= bfd_getl16 (buffer); | |
155 | extension = 0; | |
156 | consume = 4; | |
157 | } | |
158 | ||
159 | /* These are five byte insns. */ | |
160 | else if ((insn & 0xff) == 0xf4) | |
161 | { | |
162 | status = (*info->read_memory_func) (memaddr, buffer, 2, info); | |
163 | if (status != 0) | |
164 | { | |
165 | (*info->memory_error_func) (status, memaddr, info); | |
166 | return -1; | |
167 | } | |
168 | insn = bfd_getb16 (buffer); | |
169 | insn <<= 16; | |
170 | ||
171 | status = (*info->read_memory_func) (memaddr + 4, buffer, 1, info); | |
172 | if (status != 0) | |
173 | { | |
174 | (*info->memory_error_func) (status, memaddr, info); | |
175 | return -1; | |
176 | } | |
177 | insn |= *(unsigned char *)buffer << 8; | |
178 | ||
179 | status = (*info->read_memory_func) (memaddr + 3, buffer, 1, info); | |
180 | if (status != 0) | |
181 | { | |
182 | (*info->memory_error_func) (status, memaddr, info); | |
183 | return -1; | |
184 | } | |
185 | insn |= *(unsigned char *)buffer; | |
186 | ||
187 | status = (*info->read_memory_func) (memaddr + 2, buffer, 1, info); | |
188 | if (status != 0) | |
189 | { | |
190 | (*info->memory_error_func) (status, memaddr, info); | |
191 | return -1; | |
192 | } | |
193 | extension = *(unsigned char *)buffer; | |
194 | consume = 5; | |
195 | } | |
196 | else | |
197 | { | |
198 | (*info->fprintf_func) (info->stream, _("unknown\t0x%02x"), insn); | |
199 | return 1; | |
200 | } | |
201 | ||
202 | disassemble (memaddr, info, insn, extension, consume); | |
203 | ||
204 | return consume; | |
205 | } | |
206 | ||
207 | static void | |
208 | disassemble (memaddr, info, insn, extension, size) | |
209 | bfd_vma memaddr; | |
210 | struct disassemble_info *info; | |
211 | unsigned long insn; | |
212 | unsigned long extension; | |
213 | unsigned int size; | |
214 | { | |
215 | struct mn10200_opcode *op = (struct mn10200_opcode *)mn10200_opcodes; | |
216 | const struct mn10200_operand *operand; | |
217 | int match = 0; | |
218 | ||
219 | /* Find the opcode. */ | |
220 | while (op->name) | |
221 | { | |
222 | int mysize, extra_shift; | |
223 | ||
224 | if (op->format == FMT_1) | |
225 | mysize = 1; | |
226 | else if (op->format == FMT_2 | |
227 | || op->format == FMT_4) | |
228 | mysize = 2; | |
229 | else if (op->format == FMT_3 | |
230 | || op->format == FMT_5) | |
231 | mysize = 3; | |
232 | else if (op->format == FMT_6) | |
233 | mysize = 4; | |
234 | else if (op->format == FMT_7) | |
235 | mysize = 5; | |
236 | else | |
237 | abort (); | |
238 | ||
239 | if (op->format == FMT_2 || op->format == FMT_5) | |
240 | extra_shift = 8; | |
241 | else if (op->format == FMT_3 | |
242 | || op->format == FMT_6 | |
243 | || op->format == FMT_7) | |
244 | extra_shift = 16; | |
245 | else | |
246 | extra_shift = 0; | |
247 | ||
248 | if ((op->mask & insn) == op->opcode | |
249 | && size == (unsigned int) mysize) | |
250 | { | |
251 | const unsigned char *opindex_ptr; | |
252 | unsigned int nocomma; | |
253 | int paren = 0; | |
254 | ||
255 | match = 1; | |
256 | (*info->fprintf_func) (info->stream, "%s\t", op->name); | |
257 | ||
258 | /* Now print the operands. */ | |
259 | for (opindex_ptr = op->operands, nocomma = 1; | |
260 | *opindex_ptr != 0; | |
261 | opindex_ptr++) | |
262 | { | |
263 | unsigned long value; | |
264 | ||
265 | operand = &mn10200_operands[*opindex_ptr]; | |
266 | ||
267 | if ((operand->flags & MN10200_OPERAND_EXTENDED) != 0) | |
268 | { | |
269 | value = (insn & 0xffff) << 8; | |
270 | value |= extension; | |
271 | } | |
272 | else | |
273 | { | |
274 | value = ((insn >> (operand->shift)) | |
275 | & ((1 << operand->bits) - 1)); | |
276 | } | |
277 | ||
278 | if ((operand->flags & MN10200_OPERAND_SIGNED) != 0) | |
279 | value = ((long)(value << (32 - operand->bits)) | |
280 | >> (32 - operand->bits)); | |
281 | ||
282 | if (!nocomma | |
283 | && (!paren | |
284 | || ((operand->flags & MN10200_OPERAND_PAREN) == 0))) | |
285 | (*info->fprintf_func) (info->stream, ","); | |
286 | ||
287 | nocomma = 0; | |
288 | ||
289 | if ((operand->flags & MN10200_OPERAND_DREG) != 0) | |
290 | { | |
291 | value = ((insn >> (operand->shift + extra_shift)) | |
292 | & ((1 << operand->bits) - 1)); | |
293 | (*info->fprintf_func) (info->stream, "d%d", value); | |
294 | } | |
295 | ||
296 | else if ((operand->flags & MN10200_OPERAND_AREG) != 0) | |
297 | { | |
298 | value = ((insn >> (operand->shift + extra_shift)) | |
299 | & ((1 << operand->bits) - 1)); | |
300 | (*info->fprintf_func) (info->stream, "a%d", value); | |
301 | } | |
302 | ||
303 | else if ((operand->flags & MN10200_OPERAND_PSW) != 0) | |
304 | (*info->fprintf_func) (info->stream, "psw"); | |
305 | ||
306 | else if ((operand->flags & MN10200_OPERAND_MDR) != 0) | |
307 | (*info->fprintf_func) (info->stream, "mdr"); | |
308 | ||
309 | else if ((operand->flags & MN10200_OPERAND_PAREN) != 0) | |
310 | { | |
311 | if (paren) | |
312 | (*info->fprintf_func) (info->stream, ")"); | |
313 | else | |
314 | { | |
315 | (*info->fprintf_func) (info->stream, "("); | |
316 | nocomma = 1; | |
317 | } | |
318 | paren = !paren; | |
319 | } | |
320 | ||
321 | else if ((operand->flags & MN10200_OPERAND_PCREL) != 0) | |
322 | (*info->print_address_func) ((value + memaddr + mysize) & 0xffffff, info); | |
323 | ||
324 | else if ((operand->flags & MN10200_OPERAND_MEMADDR) != 0) | |
325 | (*info->print_address_func) (value, info); | |
326 | ||
327 | else | |
328 | (*info->fprintf_func) (info->stream, "%d", value); | |
329 | } | |
330 | /* All done. */ | |
331 | break; | |
332 | } | |
333 | op++; | |
334 | } | |
335 | ||
336 | if (!match) | |
337 | { | |
338 | (*info->fprintf_func) (info->stream, _("unknown\t0x%04x"), insn); | |
339 | } | |
340 | } |