Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* Disassemble MN10300 instructions. |
df7b86aa | 2 | Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2005, 2007, 2012 |
aef6203b | 3 | Free Software Foundation, Inc. |
252b5132 | 4 | |
9b201bb5 NC |
5 | This file is part of the GNU opcodes library. |
6 | ||
7 | This library is free software; you can redistribute it and/or modify | |
47b0e7ad | 8 | it under the terms of the GNU General Public License as published by |
9b201bb5 NC |
9 | the Free Software Foundation; either version 3, or (at your option) |
10 | any later version. | |
252b5132 | 11 | |
9b201bb5 NC |
12 | It is distributed in the hope that it will be useful, but WITHOUT |
13 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | |
14 | or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public | |
15 | License for more details. | |
252b5132 | 16 | |
47b0e7ad NC |
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., 51 Franklin Street - Fifth Floor, Boston, | |
20 | MA 02110-1301, USA. */ | |
252b5132 | 21 | |
0d8dfecf | 22 | #include "sysdep.h" |
df7b86aa | 23 | #include <stdio.h> |
33822a8e | 24 | #include "opcode/mn10300.h" |
252b5132 RH |
25 | #include "dis-asm.h" |
26 | #include "opintl.h" | |
27 | ||
40fa0207 | 28 | #define HAVE_AM33_2 (info->mach == AM33_2) |
47b0e7ad NC |
29 | #define HAVE_AM33 (info->mach == AM33 || HAVE_AM33_2) |
30 | #define HAVE_AM30 (info->mach == AM30) | |
252b5132 RH |
31 | |
32 | static void | |
47b0e7ad NC |
33 | disassemble (bfd_vma memaddr, |
34 | struct disassemble_info *info, | |
35 | unsigned long insn, | |
36 | unsigned int size) | |
252b5132 | 37 | { |
47b0e7ad | 38 | struct mn10300_opcode *op = (struct mn10300_opcode *) mn10300_opcodes; |
252b5132 RH |
39 | const struct mn10300_operand *operand; |
40 | bfd_byte buffer[4]; | |
41 | unsigned long extension = 0; | |
42 | int status, match = 0; | |
43 | ||
44 | /* Find the opcode. */ | |
45 | while (op->name) | |
46 | { | |
47 | int mysize, extra_shift; | |
48 | ||
49 | if (op->format == FMT_S0) | |
50 | mysize = 1; | |
51 | else if (op->format == FMT_S1 | |
52 | || op->format == FMT_D0) | |
53 | mysize = 2; | |
54 | else if (op->format == FMT_S2 | |
55 | || op->format == FMT_D1) | |
56 | mysize = 3; | |
57 | else if (op->format == FMT_S4) | |
58 | mysize = 5; | |
59 | else if (op->format == FMT_D2) | |
60 | mysize = 4; | |
40fa0207 AO |
61 | else if (op->format == FMT_D3) |
62 | mysize = 5; | |
252b5132 RH |
63 | else if (op->format == FMT_D4) |
64 | mysize = 6; | |
a9af5e04 JL |
65 | else if (op->format == FMT_D6) |
66 | mysize = 3; | |
67 | else if (op->format == FMT_D7 || op->format == FMT_D10) | |
68 | mysize = 4; | |
69 | else if (op->format == FMT_D8) | |
70 | mysize = 6; | |
71 | else if (op->format == FMT_D9) | |
72 | mysize = 7; | |
252b5132 RH |
73 | else |
74 | mysize = 7; | |
33822a8e | 75 | |
252b5132 RH |
76 | if ((op->mask & insn) == op->opcode |
77 | && size == (unsigned int) mysize | |
78 | && (op->machine == 0 | |
40fa0207 | 79 | || (op->machine == AM33_2 && HAVE_AM33_2) |
4d85706b AO |
80 | || (op->machine == AM33 && HAVE_AM33) |
81 | || (op->machine == AM30 && HAVE_AM30))) | |
252b5132 RH |
82 | { |
83 | const unsigned char *opindex_ptr; | |
84 | unsigned int nocomma; | |
85 | int paren = 0; | |
33822a8e | 86 | |
252b5132 RH |
87 | if (op->format == FMT_D1 || op->format == FMT_S1) |
88 | extra_shift = 8; | |
89 | else if (op->format == FMT_D2 || op->format == FMT_D4 | |
90 | || op->format == FMT_S2 || op->format == FMT_S4 | |
91 | || op->format == FMT_S6 || op->format == FMT_D5) | |
92 | extra_shift = 16; | |
a9af5e04 JL |
93 | else if (op->format == FMT_D7 |
94 | || op->format == FMT_D8 | |
95 | || op->format == FMT_D9) | |
96 | extra_shift = 8; | |
252b5132 RH |
97 | else |
98 | extra_shift = 0; | |
99 | ||
100 | if (size == 1 || size == 2) | |
47b0e7ad NC |
101 | extension = 0; |
102 | ||
252b5132 RH |
103 | else if (size == 3 |
104 | && (op->format == FMT_D1 | |
105 | || op->opcode == 0xdf0000 | |
106 | || op->opcode == 0xde0000)) | |
47b0e7ad NC |
107 | extension = 0; |
108 | ||
a9af5e04 JL |
109 | else if (size == 3 |
110 | && op->format == FMT_D6) | |
47b0e7ad NC |
111 | extension = 0; |
112 | ||
252b5132 RH |
113 | else if (size == 3) |
114 | { | |
115 | insn &= 0xff0000; | |
116 | status = (*info->read_memory_func) (memaddr + 1, buffer, 2, info); | |
117 | if (status != 0) | |
118 | { | |
119 | (*info->memory_error_func) (status, memaddr, info); | |
120 | return; | |
121 | } | |
122 | ||
123 | insn |= bfd_getl16 (buffer); | |
124 | extension = 0; | |
125 | } | |
126 | else if (size == 4 | |
127 | && (op->opcode == 0xfaf80000 | |
128 | || op->opcode == 0xfaf00000 | |
129 | || op->opcode == 0xfaf40000)) | |
47b0e7ad NC |
130 | extension = 0; |
131 | ||
a9af5e04 JL |
132 | else if (size == 4 |
133 | && (op->format == FMT_D7 | |
134 | || op->format == FMT_D10)) | |
47b0e7ad NC |
135 | extension = 0; |
136 | ||
252b5132 RH |
137 | else if (size == 4) |
138 | { | |
139 | insn &= 0xffff0000; | |
140 | status = (*info->read_memory_func) (memaddr + 2, buffer, 2, info); | |
141 | if (status != 0) | |
142 | { | |
143 | (*info->memory_error_func) (status, memaddr, info); | |
144 | return; | |
145 | } | |
146 | ||
147 | insn |= bfd_getl16 (buffer); | |
148 | extension = 0; | |
149 | } | |
150 | else if (size == 5 && op->opcode == 0xdc000000) | |
151 | { | |
152 | unsigned long temp = 0; | |
47b0e7ad | 153 | |
252b5132 RH |
154 | status = (*info->read_memory_func) (memaddr + 1, buffer, 4, info); |
155 | if (status != 0) | |
156 | { | |
157 | (*info->memory_error_func) (status, memaddr, info); | |
158 | return; | |
159 | } | |
160 | temp |= bfd_getl32 (buffer); | |
161 | ||
162 | insn &= 0xff000000; | |
163 | insn |= (temp & 0xffffff00) >> 8; | |
164 | extension = temp & 0xff; | |
165 | } | |
40fa0207 AO |
166 | else if (size == 5 && op->format == FMT_D3) |
167 | { | |
168 | status = (*info->read_memory_func) (memaddr + 2, buffer, 2, info); | |
169 | if (status != 0) | |
170 | { | |
171 | (*info->memory_error_func) (status, memaddr, info); | |
172 | return; | |
173 | } | |
174 | insn &= 0xffff0000; | |
175 | insn |= bfd_getl16 (buffer); | |
176 | ||
177 | status = (*info->read_memory_func) (memaddr + 4, buffer, 1, info); | |
178 | if (status != 0) | |
179 | { | |
180 | (*info->memory_error_func) (status, memaddr, info); | |
181 | return; | |
182 | } | |
183 | extension = *(unsigned char *) buffer; | |
184 | } | |
252b5132 RH |
185 | else if (size == 5) |
186 | { | |
187 | unsigned long temp = 0; | |
47b0e7ad | 188 | |
252b5132 RH |
189 | status = (*info->read_memory_func) (memaddr + 1, buffer, 2, info); |
190 | if (status != 0) | |
191 | { | |
192 | (*info->memory_error_func) (status, memaddr, info); | |
193 | return; | |
194 | } | |
195 | temp |= bfd_getl16 (buffer); | |
196 | ||
197 | insn &= 0xff0000ff; | |
198 | insn |= temp << 8; | |
199 | ||
200 | status = (*info->read_memory_func) (memaddr + 4, buffer, 1, info); | |
201 | if (status != 0) | |
202 | { | |
203 | (*info->memory_error_func) (status, memaddr, info); | |
204 | return; | |
205 | } | |
33822a8e | 206 | extension = *(unsigned char *) buffer; |
252b5132 | 207 | } |
a9af5e04 JL |
208 | else if (size == 6 && op->format == FMT_D8) |
209 | { | |
210 | insn &= 0xffffff00; | |
211 | status = (*info->read_memory_func) (memaddr + 5, buffer, 1, info); | |
212 | if (status != 0) | |
213 | { | |
214 | (*info->memory_error_func) (status, memaddr, info); | |
215 | return; | |
216 | } | |
33822a8e | 217 | insn |= *(unsigned char *) buffer; |
a9af5e04 JL |
218 | |
219 | status = (*info->read_memory_func) (memaddr + 3, buffer, 2, info); | |
220 | if (status != 0) | |
221 | { | |
222 | (*info->memory_error_func) (status, memaddr, info); | |
223 | return; | |
224 | } | |
225 | extension = bfd_getl16 (buffer); | |
226 | } | |
252b5132 RH |
227 | else if (size == 6) |
228 | { | |
229 | unsigned long temp = 0; | |
47b0e7ad | 230 | |
252b5132 RH |
231 | status = (*info->read_memory_func) (memaddr + 2, buffer, 4, info); |
232 | if (status != 0) | |
233 | { | |
234 | (*info->memory_error_func) (status, memaddr, info); | |
235 | return; | |
236 | } | |
237 | temp |= bfd_getl32 (buffer); | |
238 | ||
239 | insn &= 0xffff0000; | |
240 | insn |= (temp >> 16) & 0xffff; | |
241 | extension = temp & 0xffff; | |
242 | } | |
a9af5e04 JL |
243 | else if (size == 7 && op->format == FMT_D9) |
244 | { | |
245 | insn &= 0xffffff00; | |
246 | status = (*info->read_memory_func) (memaddr + 3, buffer, 4, info); | |
247 | if (status != 0) | |
248 | { | |
249 | (*info->memory_error_func) (status, memaddr, info); | |
250 | return; | |
251 | } | |
252 | extension = bfd_getl32 (buffer); | |
253 | insn |= (extension & 0xff000000) >> 24; | |
254 | extension &= 0xffffff; | |
255 | } | |
252b5132 RH |
256 | else if (size == 7 && op->opcode == 0xdd000000) |
257 | { | |
258 | unsigned long temp = 0; | |
47b0e7ad | 259 | |
252b5132 RH |
260 | status = (*info->read_memory_func) (memaddr + 1, buffer, 4, info); |
261 | if (status != 0) | |
262 | { | |
263 | (*info->memory_error_func) (status, memaddr, info); | |
264 | return; | |
265 | } | |
266 | temp |= bfd_getl32 (buffer); | |
267 | ||
268 | insn &= 0xff000000; | |
269 | insn |= (temp >> 8) & 0xffffff; | |
270 | extension = (temp & 0xff) << 16; | |
33822a8e | 271 | |
252b5132 RH |
272 | status = (*info->read_memory_func) (memaddr + 5, buffer, 2, info); |
273 | if (status != 0) | |
274 | { | |
275 | (*info->memory_error_func) (status, memaddr, info); | |
276 | return; | |
277 | } | |
278 | extension |= bfd_getb16 (buffer); | |
279 | } | |
280 | else if (size == 7) | |
281 | { | |
282 | unsigned long temp = 0; | |
47b0e7ad | 283 | |
252b5132 RH |
284 | status = (*info->read_memory_func) (memaddr + 2, buffer, 4, info); |
285 | if (status != 0) | |
286 | { | |
287 | (*info->memory_error_func) (status, memaddr, info); | |
288 | return; | |
289 | } | |
290 | temp |= bfd_getl32 (buffer); | |
291 | ||
292 | insn &= 0xffff0000; | |
293 | insn |= (temp >> 16) & 0xffff; | |
294 | extension = (temp & 0xffff) << 8; | |
33822a8e | 295 | |
252b5132 RH |
296 | status = (*info->read_memory_func) (memaddr + 6, buffer, 1, info); |
297 | if (status != 0) | |
298 | { | |
299 | (*info->memory_error_func) (status, memaddr, info); | |
300 | return; | |
301 | } | |
33822a8e | 302 | extension |= *(unsigned char *) buffer; |
252b5132 RH |
303 | } |
304 | ||
305 | match = 1; | |
306 | (*info->fprintf_func) (info->stream, "%s\t", op->name); | |
307 | ||
308 | /* Now print the operands. */ | |
309 | for (opindex_ptr = op->operands, nocomma = 1; | |
310 | *opindex_ptr != 0; | |
311 | opindex_ptr++) | |
312 | { | |
313 | unsigned long value; | |
314 | ||
315 | operand = &mn10300_operands[*opindex_ptr]; | |
316 | ||
a9af5e04 JL |
317 | /* If this operand is a PLUS (autoincrement), then do not emit |
318 | a comma before emitting the plus. */ | |
319 | if ((operand->flags & MN10300_OPERAND_PLUS) != 0) | |
320 | nocomma = 1; | |
252b5132 RH |
321 | |
322 | if ((operand->flags & MN10300_OPERAND_SPLIT) != 0) | |
323 | { | |
324 | unsigned long temp; | |
47b0e7ad | 325 | |
252b5132 RH |
326 | value = insn & ((1 << operand->bits) - 1); |
327 | value <<= (32 - operand->bits); | |
328 | temp = extension >> operand->shift; | |
329 | temp &= ((1 << (32 - operand->bits)) - 1); | |
330 | value |= temp; | |
33822a8e KH |
331 | value = ((value ^ (((unsigned long) 1) << 31)) |
332 | - (((unsigned long) 1) << 31)); | |
252b5132 | 333 | } |
a9af5e04 JL |
334 | else if ((operand->flags & MN10300_OPERAND_24BIT) != 0) |
335 | { | |
336 | unsigned long temp; | |
47b0e7ad | 337 | |
a9af5e04 JL |
338 | value = insn & ((1 << operand->bits) - 1); |
339 | value <<= (24 - operand->bits); | |
340 | temp = extension >> operand->shift; | |
341 | temp &= ((1 << (24 - operand->bits)) - 1); | |
342 | value |= temp; | |
343 | if ((operand->flags & MN10300_OPERAND_SIGNED) != 0) | |
d6062282 | 344 | value = ((value & 0xffffff) ^ 0x800000) - 0x800000; |
a9af5e04 | 345 | } |
40fa0207 AO |
346 | else if ((operand->flags & (MN10300_OPERAND_FSREG |
347 | | MN10300_OPERAND_FDREG))) | |
348 | { | |
349 | /* See m10300-opc.c just before #define FSM0 for an | |
350 | explanation of these variables. Note that | |
351 | FMT-implied shifts are not taken into account for | |
352 | FP registers. */ | |
353 | unsigned long mask_low, mask_high; | |
354 | int shl_low, shr_high, shl_high; | |
355 | ||
356 | switch (operand->bits) | |
357 | { | |
358 | case 5: | |
359 | /* Handle regular FP registers. */ | |
360 | if (operand->shift >= 0) | |
361 | { | |
362 | /* This is an `m' register. */ | |
363 | shl_low = operand->shift; | |
364 | shl_high = 8 + (8 & shl_low) + (shl_low & 4) / 4; | |
365 | } | |
366 | else | |
367 | { | |
368 | /* This is an `n' register. */ | |
369 | shl_low = -operand->shift; | |
370 | shl_high = shl_low / 4; | |
371 | } | |
372 | mask_low = 0x0f; | |
373 | mask_high = 0x10; | |
374 | shr_high = 4; | |
375 | break; | |
376 | ||
377 | case 3: | |
378 | /* Handle accumulators. */ | |
379 | shl_low = -operand->shift; | |
380 | shl_high = 0; | |
381 | mask_low = 0x03; | |
382 | mask_high = 0x04; | |
383 | shr_high = 2; | |
384 | break; | |
385 | ||
386 | default: | |
387 | abort (); | |
388 | } | |
389 | value = ((((insn >> shl_high) << shr_high) & mask_high) | |
390 | | ((insn >> shl_low) & mask_low)); | |
391 | } | |
252b5132 | 392 | else if ((operand->flags & MN10300_OPERAND_EXTENDED) != 0) |
47b0e7ad NC |
393 | value = ((extension >> (operand->shift)) |
394 | & ((1 << operand->bits) - 1)); | |
395 | ||
252b5132 | 396 | else |
47b0e7ad NC |
397 | value = ((insn >> (operand->shift)) |
398 | & ((1 << operand->bits) - 1)); | |
252b5132 RH |
399 | |
400 | if ((operand->flags & MN10300_OPERAND_SIGNED) != 0 | |
d6062282 AO |
401 | /* These are properly extended by the code above. */ |
402 | && ((operand->flags & MN10300_OPERAND_24BIT) == 0)) | |
33822a8e KH |
403 | value = ((value ^ (((unsigned long) 1) << (operand->bits - 1))) |
404 | - (((unsigned long) 1) << (operand->bits - 1))); | |
252b5132 RH |
405 | |
406 | if (!nocomma | |
407 | && (!paren | |
408 | || ((operand->flags & MN10300_OPERAND_PAREN) == 0))) | |
409 | (*info->fprintf_func) (info->stream, ","); | |
410 | ||
411 | nocomma = 0; | |
33822a8e | 412 | |
252b5132 RH |
413 | if ((operand->flags & MN10300_OPERAND_DREG) != 0) |
414 | { | |
415 | value = ((insn >> (operand->shift + extra_shift)) | |
416 | & ((1 << operand->bits) - 1)); | |
33822a8e | 417 | (*info->fprintf_func) (info->stream, "d%d", (int) value); |
252b5132 RH |
418 | } |
419 | ||
420 | else if ((operand->flags & MN10300_OPERAND_AREG) != 0) | |
421 | { | |
422 | value = ((insn >> (operand->shift + extra_shift)) | |
423 | & ((1 << operand->bits) - 1)); | |
33822a8e | 424 | (*info->fprintf_func) (info->stream, "a%d", (int) value); |
252b5132 RH |
425 | } |
426 | ||
427 | else if ((operand->flags & MN10300_OPERAND_SP) != 0) | |
428 | (*info->fprintf_func) (info->stream, "sp"); | |
429 | ||
430 | else if ((operand->flags & MN10300_OPERAND_PSW) != 0) | |
431 | (*info->fprintf_func) (info->stream, "psw"); | |
432 | ||
433 | else if ((operand->flags & MN10300_OPERAND_MDR) != 0) | |
434 | (*info->fprintf_func) (info->stream, "mdr"); | |
435 | ||
a9af5e04 JL |
436 | else if ((operand->flags & MN10300_OPERAND_RREG) != 0) |
437 | { | |
438 | value = ((insn >> (operand->shift + extra_shift)) | |
439 | & ((1 << operand->bits) - 1)); | |
440 | if (value < 8) | |
33822a8e | 441 | (*info->fprintf_func) (info->stream, "r%d", (int) value); |
a9af5e04 | 442 | else if (value < 12) |
33822a8e | 443 | (*info->fprintf_func) (info->stream, "a%d", (int) value - 8); |
a9af5e04 | 444 | else |
33822a8e | 445 | (*info->fprintf_func) (info->stream, "d%d", (int) value - 12); |
a9af5e04 JL |
446 | } |
447 | ||
448 | else if ((operand->flags & MN10300_OPERAND_XRREG) != 0) | |
449 | { | |
450 | value = ((insn >> (operand->shift + extra_shift)) | |
451 | & ((1 << operand->bits) - 1)); | |
452 | if (value == 0) | |
0fd3a477 | 453 | (*info->fprintf_func) (info->stream, "sp"); |
a9af5e04 | 454 | else |
33822a8e | 455 | (*info->fprintf_func) (info->stream, "xr%d", (int) value); |
a9af5e04 JL |
456 | } |
457 | ||
40fa0207 AO |
458 | else if ((operand->flags & MN10300_OPERAND_FSREG) != 0) |
459 | (*info->fprintf_func) (info->stream, "fs%d", (int) value); | |
460 | ||
461 | else if ((operand->flags & MN10300_OPERAND_FDREG) != 0) | |
462 | (*info->fprintf_func) (info->stream, "fd%d", (int) value); | |
463 | ||
464 | else if ((operand->flags & MN10300_OPERAND_FPCR) != 0) | |
465 | (*info->fprintf_func) (info->stream, "fpcr"); | |
466 | ||
a9af5e04 JL |
467 | else if ((operand->flags & MN10300_OPERAND_USP) != 0) |
468 | (*info->fprintf_func) (info->stream, "usp"); | |
469 | ||
470 | else if ((operand->flags & MN10300_OPERAND_SSP) != 0) | |
471 | (*info->fprintf_func) (info->stream, "ssp"); | |
472 | ||
473 | else if ((operand->flags & MN10300_OPERAND_MSP) != 0) | |
474 | (*info->fprintf_func) (info->stream, "msp"); | |
475 | ||
476 | else if ((operand->flags & MN10300_OPERAND_PC) != 0) | |
477 | (*info->fprintf_func) (info->stream, "pc"); | |
478 | ||
479 | else if ((operand->flags & MN10300_OPERAND_EPSW) != 0) | |
480 | (*info->fprintf_func) (info->stream, "epsw"); | |
481 | ||
482 | else if ((operand->flags & MN10300_OPERAND_PLUS) != 0) | |
483 | (*info->fprintf_func) (info->stream, "+"); | |
252b5132 RH |
484 | |
485 | else if ((operand->flags & MN10300_OPERAND_PAREN) != 0) | |
486 | { | |
487 | if (paren) | |
488 | (*info->fprintf_func) (info->stream, ")"); | |
489 | else | |
490 | { | |
491 | (*info->fprintf_func) (info->stream, "("); | |
492 | nocomma = 1; | |
493 | } | |
494 | paren = !paren; | |
495 | } | |
496 | ||
497 | else if ((operand->flags & MN10300_OPERAND_PCREL) != 0) | |
498 | (*info->print_address_func) ((long) value + memaddr, info); | |
499 | ||
500 | else if ((operand->flags & MN10300_OPERAND_MEMADDR) != 0) | |
501 | (*info->print_address_func) (value, info); | |
502 | ||
503 | else if ((operand->flags & MN10300_OPERAND_REG_LIST) != 0) | |
504 | { | |
505 | int comma = 0; | |
506 | ||
507 | (*info->fprintf_func) (info->stream, "["); | |
508 | if (value & 0x80) | |
509 | { | |
510 | (*info->fprintf_func) (info->stream, "d2"); | |
511 | comma = 1; | |
512 | } | |
513 | ||
514 | if (value & 0x40) | |
515 | { | |
516 | if (comma) | |
517 | (*info->fprintf_func) (info->stream, ","); | |
518 | (*info->fprintf_func) (info->stream, "d3"); | |
519 | comma = 1; | |
520 | } | |
521 | ||
522 | if (value & 0x20) | |
523 | { | |
524 | if (comma) | |
525 | (*info->fprintf_func) (info->stream, ","); | |
526 | (*info->fprintf_func) (info->stream, "a2"); | |
527 | comma = 1; | |
528 | } | |
529 | ||
530 | if (value & 0x10) | |
531 | { | |
532 | if (comma) | |
533 | (*info->fprintf_func) (info->stream, ","); | |
534 | (*info->fprintf_func) (info->stream, "a3"); | |
535 | comma = 1; | |
536 | } | |
537 | ||
538 | if (value & 0x08) | |
539 | { | |
540 | if (comma) | |
541 | (*info->fprintf_func) (info->stream, ","); | |
542 | (*info->fprintf_func) (info->stream, "other"); | |
543 | comma = 1; | |
544 | } | |
545 | ||
a9af5e04 JL |
546 | if (value & 0x04) |
547 | { | |
548 | if (comma) | |
549 | (*info->fprintf_func) (info->stream, ","); | |
550 | (*info->fprintf_func) (info->stream, "exreg0"); | |
551 | comma = 1; | |
552 | } | |
553 | if (value & 0x02) | |
554 | { | |
555 | if (comma) | |
556 | (*info->fprintf_func) (info->stream, ","); | |
557 | (*info->fprintf_func) (info->stream, "exreg1"); | |
558 | comma = 1; | |
559 | } | |
560 | if (value & 0x01) | |
561 | { | |
562 | if (comma) | |
563 | (*info->fprintf_func) (info->stream, ","); | |
564 | (*info->fprintf_func) (info->stream, "exother"); | |
565 | comma = 1; | |
566 | } | |
252b5132 RH |
567 | (*info->fprintf_func) (info->stream, "]"); |
568 | } | |
569 | ||
33822a8e KH |
570 | else |
571 | (*info->fprintf_func) (info->stream, "%ld", (long) value); | |
252b5132 RH |
572 | } |
573 | /* All done. */ | |
574 | break; | |
575 | } | |
576 | op++; | |
577 | } | |
578 | ||
579 | if (!match) | |
47b0e7ad | 580 | /* xgettext:c-format */ |
0fd3a477 | 581 | (*info->fprintf_func) (info->stream, _("unknown\t0x%04lx"), insn); |
47b0e7ad NC |
582 | } |
583 | ||
584 | int | |
585 | print_insn_mn10300 (bfd_vma memaddr, struct disassemble_info *info) | |
586 | { | |
587 | int status; | |
588 | bfd_byte buffer[4]; | |
589 | unsigned long insn; | |
590 | unsigned int consume; | |
591 | ||
592 | /* First figure out how big the opcode is. */ | |
593 | status = (*info->read_memory_func) (memaddr, buffer, 1, info); | |
594 | if (status != 0) | |
595 | { | |
596 | (*info->memory_error_func) (status, memaddr, info); | |
597 | return -1; | |
598 | } | |
599 | insn = *(unsigned char *) buffer; | |
600 | ||
601 | /* These are one byte insns. */ | |
602 | if ((insn & 0xf3) == 0x00 | |
603 | || (insn & 0xf0) == 0x10 | |
604 | || (insn & 0xfc) == 0x3c | |
605 | || (insn & 0xf3) == 0x41 | |
606 | || (insn & 0xf3) == 0x40 | |
607 | || (insn & 0xfc) == 0x50 | |
608 | || (insn & 0xfc) == 0x54 | |
609 | || (insn & 0xf0) == 0x60 | |
610 | || (insn & 0xf0) == 0x70 | |
611 | || ((insn & 0xf0) == 0x80 | |
612 | && (insn & 0x0c) >> 2 != (insn & 0x03)) | |
613 | || ((insn & 0xf0) == 0x90 | |
614 | && (insn & 0x0c) >> 2 != (insn & 0x03)) | |
615 | || ((insn & 0xf0) == 0xa0 | |
616 | && (insn & 0x0c) >> 2 != (insn & 0x03)) | |
617 | || ((insn & 0xf0) == 0xb0 | |
618 | && (insn & 0x0c) >> 2 != (insn & 0x03)) | |
619 | || (insn & 0xff) == 0xcb | |
620 | || (insn & 0xfc) == 0xd0 | |
621 | || (insn & 0xfc) == 0xd4 | |
622 | || (insn & 0xfc) == 0xd8 | |
623 | || (insn & 0xf0) == 0xe0 | |
624 | || (insn & 0xff) == 0xff) | |
252b5132 | 625 | { |
47b0e7ad | 626 | consume = 1; |
252b5132 | 627 | } |
47b0e7ad NC |
628 | |
629 | /* These are two byte insns. */ | |
630 | else if ((insn & 0xf0) == 0x80 | |
631 | || (insn & 0xf0) == 0x90 | |
632 | || (insn & 0xf0) == 0xa0 | |
633 | || (insn & 0xf0) == 0xb0 | |
634 | || (insn & 0xfc) == 0x20 | |
635 | || (insn & 0xfc) == 0x28 | |
636 | || (insn & 0xf3) == 0x43 | |
637 | || (insn & 0xf3) == 0x42 | |
638 | || (insn & 0xfc) == 0x58 | |
639 | || (insn & 0xfc) == 0x5c | |
640 | || ((insn & 0xf0) == 0xc0 | |
641 | && (insn & 0xff) != 0xcb | |
642 | && (insn & 0xff) != 0xcc | |
643 | && (insn & 0xff) != 0xcd) | |
644 | || (insn & 0xff) == 0xf0 | |
645 | || (insn & 0xff) == 0xf1 | |
646 | || (insn & 0xff) == 0xf2 | |
647 | || (insn & 0xff) == 0xf3 | |
648 | || (insn & 0xff) == 0xf4 | |
649 | || (insn & 0xff) == 0xf5 | |
650 | || (insn & 0xff) == 0xf6) | |
651 | { | |
652 | status = (*info->read_memory_func) (memaddr, buffer, 2, info); | |
653 | if (status != 0) | |
654 | { | |
655 | (*info->memory_error_func) (status, memaddr, info); | |
656 | return -1; | |
657 | } | |
658 | insn = bfd_getb16 (buffer); | |
659 | consume = 2; | |
660 | } | |
661 | ||
662 | /* These are three byte insns. */ | |
663 | else if ((insn & 0xff) == 0xf8 | |
664 | || (insn & 0xff) == 0xcc | |
665 | || (insn & 0xff) == 0xf9 | |
666 | || (insn & 0xf3) == 0x01 | |
667 | || (insn & 0xf3) == 0x02 | |
668 | || (insn & 0xf3) == 0x03 | |
669 | || (insn & 0xfc) == 0x24 | |
670 | || (insn & 0xfc) == 0x2c | |
671 | || (insn & 0xfc) == 0x30 | |
672 | || (insn & 0xfc) == 0x34 | |
673 | || (insn & 0xfc) == 0x38 | |
674 | || (insn & 0xff) == 0xde | |
675 | || (insn & 0xff) == 0xdf | |
676 | || (insn & 0xff) == 0xf9 | |
677 | || (insn & 0xff) == 0xcc) | |
678 | { | |
679 | status = (*info->read_memory_func) (memaddr, buffer, 2, info); | |
680 | if (status != 0) | |
681 | { | |
682 | (*info->memory_error_func) (status, memaddr, info); | |
683 | return -1; | |
684 | } | |
685 | insn = bfd_getb16 (buffer); | |
686 | insn <<= 8; | |
687 | status = (*info->read_memory_func) (memaddr + 2, buffer, 1, info); | |
688 | if (status != 0) | |
689 | { | |
690 | (*info->memory_error_func) (status, memaddr, info); | |
691 | return -1; | |
692 | } | |
693 | insn |= *(unsigned char *) buffer; | |
694 | consume = 3; | |
695 | } | |
696 | ||
697 | /* These are four byte insns. */ | |
698 | else if ((insn & 0xff) == 0xfa | |
699 | || (insn & 0xff) == 0xf7 | |
700 | || (insn & 0xff) == 0xfb) | |
701 | { | |
702 | status = (*info->read_memory_func) (memaddr, buffer, 4, info); | |
703 | if (status != 0) | |
704 | { | |
705 | (*info->memory_error_func) (status, memaddr, info); | |
706 | return -1; | |
707 | } | |
708 | insn = bfd_getb32 (buffer); | |
709 | consume = 4; | |
710 | } | |
711 | ||
712 | /* These are five byte insns. */ | |
713 | else if ((insn & 0xff) == 0xcd | |
714 | || (insn & 0xff) == 0xdc) | |
715 | { | |
716 | status = (*info->read_memory_func) (memaddr, buffer, 4, info); | |
717 | if (status != 0) | |
718 | { | |
719 | (*info->memory_error_func) (status, memaddr, info); | |
720 | return -1; | |
721 | } | |
722 | insn = bfd_getb32 (buffer); | |
723 | consume = 5; | |
724 | } | |
725 | ||
726 | /* These are six byte insns. */ | |
727 | else if ((insn & 0xff) == 0xfd | |
728 | || (insn & 0xff) == 0xfc) | |
729 | { | |
730 | status = (*info->read_memory_func) (memaddr, buffer, 4, info); | |
731 | if (status != 0) | |
732 | { | |
733 | (*info->memory_error_func) (status, memaddr, info); | |
734 | return -1; | |
735 | } | |
736 | ||
737 | insn = bfd_getb32 (buffer); | |
738 | consume = 6; | |
739 | } | |
740 | ||
741 | /* Else its a seven byte insns (in theory). */ | |
742 | else | |
743 | { | |
744 | status = (*info->read_memory_func) (memaddr, buffer, 4, info); | |
745 | if (status != 0) | |
746 | { | |
747 | (*info->memory_error_func) (status, memaddr, info); | |
748 | return -1; | |
749 | } | |
750 | ||
751 | insn = bfd_getb32 (buffer); | |
752 | consume = 7; | |
753 | /* Handle the 5-byte extended instruction codes. */ | |
754 | if ((insn & 0xfff80000) == 0xfe800000) | |
755 | consume = 5; | |
756 | } | |
757 | ||
758 | disassemble (memaddr, info, insn, consume); | |
759 | ||
760 | return consume; | |
252b5132 | 761 | } |