projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* m68k-opc.c: Use #W rather than #w.
[deliverable/binutils-gdb.git] / opcodes / m68k-dis.c
CommitLineData
5d0734a7
JK		 1/* Print Motorola 68k instructions.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
3
4This file is free software; you can redistribute it and/or modify
5it under the terms of the GNU General Public License as published by
6the Free Software Foundation; either version 2 of the License, or
7(at your option) any later version.
8
9This program is distributed in the hope that it will be useful,
10but WITHOUT ANY WARRANTY; without even the implied warranty of
11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12GNU General Public License for more details.
13
14You should have received a copy of the GNU General Public License
15along with this program; if not, write to the Free Software
dbf7e45f 16Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
5d0734a7
JK		 17
18#include "dis-asm.h"
029e2524 19#include "floatformat.h"
5d0734a7 20
5d0734a7
JK		 21#include "opcode/m68k.h"
22
5d0734a7
JK		 23/* Local function prototypes */
24
25static int
cbe61cc6 26fetch_arg PARAMS ((unsigned char *, int, int, disassemble_info *));
5d0734a7
JK		 27
28static void
dbf7e45f 29print_base PARAMS ((int, bfd_vma, disassemble_info*));
5d0734a7
JK		 30
31static unsigned char *
32print_indexed PARAMS ((int, unsigned char *, bfd_vma, disassemble_info *));
33
029e2524 34static int
dbf7e45f
ILT		 35print_insn_arg PARAMS ((const char *, unsigned char *, unsigned char *,
36 bfd_vma, disassemble_info *));
5d0734a7 37
5d0734a7 38CONST char * CONST fpcr_names[] = {
dbf7e45f
ILT		 39 "", "%fpiar", "%fpsr", "%fpiar/%fpsr", "%fpcr",
40 "%fpiar/%fpcr", "%fpsr/%fpcr", "%fpiar/%fpsr/%fpcr"};
5d0734a7 41
dbf7e45f
ILT		 42static char *const reg_names[] = {
43 "%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7",
44 "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%fp", "%sp",
45 "%ps", "%pc"};
5d0734a7 46
029e2524
KR		 47/* Sign-extend an (unsigned char). */
48#if __STDC__ == 1
49#define COERCE_SIGNED_CHAR(ch) ((signed char)(ch))
50#else
51#define COERCE_SIGNED_CHAR(ch) ((int)(((ch) ^ 0x80) & 0xFF) - 128)
52#endif
5d0734a7 53
029e2524 54/* Get a 1 byte signed integer. */
5d0734a7
JK		 55#define NEXTBYTE(p) (p += 2, FETCH_DATA (info, p), COERCE_SIGNED_CHAR(p[-1]))
56
029e2524
KR		 57/* Get a 2 byte signed integer. */
58#define COERCE16(x) ((int) (((x) ^ 0x8000) - 0x8000))
5d0734a7
JK		 59#define NEXTWORD(p) \
60 (p += 2, FETCH_DATA (info, p), \
029e2524 61 COERCE16 ((p[-2] << 8) + p[-1]))
5d0734a7 62
029e2524
KR		 63/* Get a 4 byte signed integer. */
64#define COERCE32(x) ((int) (((x) ^ 0x80000000) - 0x80000000))
5d0734a7
JK		 65#define NEXTLONG(p) \
66 (p += 4, FETCH_DATA (info, p), \
029e2524 67 (COERCE32 ((((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])))
5d0734a7
JK		 68
69/* NEXTSINGLE and NEXTDOUBLE handle alignment problems, but not
70 * byte-swapping or other float format differences. FIXME! */
71
72union number {
73 double d;
74 float f;
75 char c[10];
76};
77
78#define NEXTSINGLE(val, p) \
79 { int i; union number u;\
80 FETCH_DATA (info, p + sizeof (float));\
81 for (i = 0; i < sizeof(float); i++) u.c[i] = *p++; \
82 val = u.f; }
83
84#define NEXTDOUBLE(val, p) \
85 { int i; union number u;\
86 FETCH_DATA (info, p + sizeof (double));\
87 for (i = 0; i < sizeof(double); i++) u.c[i] = *p++; \
88 val = u.d; }
89
90/* Need a function to convert from extended to double precision... */
91#define NEXTEXTEND(p) \
92 (p += 12, FETCH_DATA (info, p), 0.0)
93
94/* Need a function to convert from packed to double
95 precision. Actually, it's easier to print a
96 packed number than a double anyway, so maybe
97 there should be a special case to handle this... */
98#define NEXTPACKED(p) \
99 (p += 12, FETCH_DATA (info, p), 0.0)
100
101\f
102/* Maximum length of an instruction. */
103#define MAXLEN 22
104
105#include <setjmp.h>
106
107struct private
108{
109 /* Points to first byte not fetched. */
110 bfd_byte *max_fetched;
111 bfd_byte the_buffer[MAXLEN];
112 bfd_vma insn_start;
113 jmp_buf bailout;
114};
115
116/* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
117 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
118 on error. */
119#define FETCH_DATA(info, addr) \
120 ((addr) <= ((struct private *)(info->private_data))->max_fetched \
121 ? 1 : fetch_data ((info), (addr)))
122
123static int
124fetch_data (info, addr)
125 struct disassemble_info *info;
126 bfd_byte *addr;
127{
128 int status;
129 struct private *priv = (struct private *)info->private_data;
130 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
131
132 status = (*info->read_memory_func) (start,
133 priv->max_fetched,
134 addr - priv->max_fetched,
135 info);
136 if (status != 0)
137 {
138 (*info->memory_error_func) (status, start, info);
05545edc 139 longjmp (priv->bailout, 1);
5d0734a7
JK		 140 }
141 else
142 priv->max_fetched = addr;
143 return 1;
144}
145\f
029e2524
KR		 146/* This function is used to print to the bit-bucket. */
147static int
148#ifdef __STDC__
149dummy_printer (FILE * file, const char * format, ...)
150#else
151dummy_printer (file) FILE *file;
152#endif
153 { return 0; }
154
155void
156dummy_print_address (vma, info)
157 bfd_vma vma;
5d0734a7 158 struct disassemble_info *info;
5d0734a7 159{
029e2524
KR		 160}
161
5d0734a7 162/* Print the m68k instruction at address MEMADDR in debugged memory,
029e2524 163 on INFO->STREAM. Returns length of the instruction, in bytes. */
5d0734a7
JK		 164
165int
166print_insn_m68k (memaddr, info)
167 bfd_vma memaddr;
168 disassemble_info *info;
169{
170 register int i;
171 register unsigned char *p;
029e2524 172 unsigned char *save_p;
dbf7e45f 173 register const char *d;
5d0734a7 174 register unsigned long bestmask;
029e2524 175 const struct m68k_opcode *best = 0;
5d0734a7
JK		 176 struct private priv;
177 bfd_byte *buffer = priv.the_buffer;
029e2524
KR		 178 fprintf_ftype save_printer = info->fprintf_func;
179 void (*save_print_address) PARAMS((bfd_vma, struct disassemble_info*))
180 = info->print_address_func;
5d0734a7
JK		 181
182 info->private_data = (PTR) &priv;
183 priv.max_fetched = priv.the_buffer;
184 priv.insn_start = memaddr;
185 if (setjmp (priv.bailout) != 0)
186 /* Error return. */
187 return -1;
188
189 bestmask = 0;
5d0734a7 190 FETCH_DATA (info, buffer + 2);
dbf7e45f 191 for (i = 0; i < m68k_numopcodes; i++)
5d0734a7 192 {
dbf7e45f 193 const struct m68k_opcode *opc = &m68k_opcodes[i];
029e2524
KR		 194 unsigned long opcode = opc->opcode;
195 unsigned long match = opc->match;
196
5d0734a7
JK		 197 if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
198 && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
199 /* Only fetch the next two bytes if we need to. */
200 && (((0xffff & match) == 0)
201 ||
202 (FETCH_DATA (info, buffer + 4)
203 && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8)))
204 && ((0xff & buffer[3] & match) == (0xff & opcode)))
205 ))
206 {
207 /* Don't use for printout the variants of divul and divsl
208 that have the same register number in two places.
209 The more general variants will match instead. */
029e2524 210 for (d = opc->args; *d; d += 2)
5d0734a7
JK		 211 if (d[1] == 'D')
212 break;
213
214 /* Don't use for printout the variants of most floating
215 point coprocessor instructions which use the same
216 register number in two places, as above. */
217 if (*d == 0)
029e2524 218 for (d = opc->args; *d; d += 2)
5d0734a7
JK		 219 if (d[1] == 't')
220 break;
221
222 if (*d == 0 && match > bestmask)
223 {
029e2524 224 best = opc;
5d0734a7
JK		 225 bestmask = match;
226 }
227 }
228 }
229
029e2524
KR		 230 if (best == 0)
231 goto invalid;
5d0734a7
JK		 232
233 /* Point at first word of argument data,
234 and at descriptor for first argument. */
235 p = buffer + 2;
236
e6fb7139
JK		 237 /* Figure out how long the fixed-size portion of the instruction is.
238 The only place this is stored in the opcode table is
239 in the arguments--look for arguments which specify fields in the 2nd
240 or 3rd words of the instruction. */
029e2524 241 for (d = best->args; *d; d += 2)
5d0734a7 242 {
e6fb7139
JK		 243 /* I don't think it is necessary to be checking d[0] here; I suspect
244 all this could be moved to the case statement below. */
5d0734a7
JK		 245 if (d[0] == '#')
246 {
247 if (d[1] == 'l' && p - buffer < 6)
248 p = buffer + 6;
249 else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' )
250 p = buffer + 4;
251 }
5d0734a7
JK		 252 if ((d[0] == 'L' || d[0] == 'l') && d[1] == 'w' && p - buffer < 4)
253 p = buffer + 4;
e6fb7139
JK		 254 switch (d[1])
255 {
256 case '1':
257 case '2':
258 case '3':
259 case '7':
260 case '8':
261 case '9':
029e2524 262 case 'i':
e6fb7139
JK		 263 if (p - buffer < 4)
264 p = buffer + 4;
265 break;
266 case '4':
267 case '5':
268 case '6':
269 if (p - buffer < 6)
270 p = buffer + 6;
271 break;
272 default:
273 break;
274 }
5d0734a7 275 }
dbf7e45f
ILT		 276 /* Some opcodes like pflusha and lpstop are exceptions; they take no
277 arguments but are two words long. Recognize them by looking at
278 the lower 16 bits of the mask. */
279 if (p - buffer < 4 && (best->match & 0xFFFF) != 0)
e6fb7139 280 p = buffer + 4;
5d0734a7
JK		 281
282 FETCH_DATA (info, p);
283
029e2524
KR		 284 d = best->args;
285
286 /* We can the operands twice. The first time we don't print anything,
287 but look for errors. */
288
289 save_p = p;
290 info->print_address_func = dummy_print_address;
291 info->fprintf_func = (fprintf_ftype)dummy_printer;
292 for ( ; *d; d += 2)
293 {
294 int eaten = print_insn_arg (d, buffer, p, memaddr + p - buffer, info);
295 if (eaten >= 0)
296 p += eaten;
297 else if (eaten == -1)
298 goto invalid;
299 else
300 {
301 (*info->fprintf_func)(info->stream,
302 "<internal error in opcode table: %s %s>\n",
303 best->name,
304 best->args);
305 goto invalid;
306 }
307
308 }
309 p = save_p;
310 info->fprintf_func = save_printer;
311 info->print_address_func = save_print_address;
312
313 d = best->args;
314
315 (*info->fprintf_func) (info->stream, "%s", best->name);
5d0734a7
JK		 316
317 if (*d)
318 (*info->fprintf_func) (info->stream, " ");
319
320 while (*d)
321 {
029e2524 322 p += print_insn_arg (d, buffer, p, memaddr + p - buffer, info);
5d0734a7
JK		 323 d += 2;
324 if (*d && *(d - 2) != 'I' && *d != 'k')
325 (*info->fprintf_func) (info->stream, ",");
326 }
327 return p - buffer;
029e2524
KR		 328
329 invalid:
330 /* Handle undefined instructions. */
331 info->fprintf_func = save_printer;
332 info->print_address_func = save_print_address;
333 (*info->fprintf_func) (info->stream, "0%o",
334 (buffer[0] << 8) + buffer[1]);
335 return 2;
5d0734a7
JK		 336}
337
029e2524
KR		 338/* Returns number of bytes "eaten" by the operand, or
339 return -1 if an invalid operand was found, or -2 if
340 an opcode tabe error was found. */
341
342static int
343print_insn_arg (d, buffer, p0, addr, info)
dbf7e45f 344 const char *d;
5d0734a7 345 unsigned char *buffer;
029e2524 346 unsigned char *p0;
5d0734a7
JK		 347 bfd_vma addr; /* PC for this arg to be relative to */
348 disassemble_info *info;
349{
350 register int val = 0;
351 register int place = d[1];
029e2524 352 register unsigned char *p = p0;
5d0734a7
JK		 353 int regno;
354 register CONST char *regname;
355 register unsigned char *p1;
356 double flval;
357 int flt_p;
358
359 switch (*d)
360 {
361 case 'c': /* cache identifier */
362 {
dbf7e45f 363 static char *const cacheFieldName[] = { "nc", "dc", "ic", "bc" };
5d0734a7
JK		 364 val = fetch_arg (buffer, place, 2, info);
365 (*info->fprintf_func) (info->stream, cacheFieldName[val]);
366 break;
367 }
368
369 case 'a': /* address register indirect only. Cf. case '+'. */
370 {
371 (*info->fprintf_func)
372 (info->stream,
373 "%s@",
374 reg_names [fetch_arg (buffer, place, 3, info) + 8]);
375 break;
376 }
377
378 case '_': /* 32-bit absolute address for move16. */
379 {
380 val = NEXTLONG (p);
e6fb7139 381 (*info->print_address_func) (val, info);
5d0734a7
JK		 382 break;
383 }
384
385 case 'C':
dbf7e45f 386 (*info->fprintf_func) (info->stream, "%%ccr");
5d0734a7
JK		 387 break;
388
389 case 'S':
dbf7e45f 390 (*info->fprintf_func) (info->stream, "%%sr");
5d0734a7
JK		 391 break;
392
393 case 'U':
dbf7e45f 394 (*info->fprintf_func) (info->stream, "%%usp");
5d0734a7
JK		 395 break;
396
397 case 'J':
398 {
dbf7e45f
ILT		 399 static const struct { char *name; int value; } names[]
400 = {{"%sfc", 0x000}, {"%dfc", 0x001}, {"%cacr", 0x002},
401 {"%tc", 0x003}, {"%itt0",0x004}, {"%itt1", 0x005},
402 {"%dtt0",0x006}, {"%dtt1",0x007}, {"%buscr",0x008},
403 {"%usp", 0x800}, {"%vbr", 0x801}, {"%caar", 0x802},
404 {"%msp", 0x803}, {"%ibsp", 0x804},
e6fb7139
JK		 405
406 /* Should we be calling this psr like we do in case 'Y'? */
dbf7e45f 407 {"%mmusr",0x805},
e6fb7139 408
dbf7e45f 409 {"%urp", 0x806}, {"%srp", 0x807}, {"%pcr", 0x808}};
5d0734a7
JK		 410
411 val = fetch_arg (buffer, place, 12, info);
412 for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
413 if (names[regno].value == val)
414 {
dbf7e45f 415 (*info->fprintf_func) (info->stream, "%s", names[regno].name);
5d0734a7
JK		 416 break;
417 }
418 if (regno < 0)
419 (*info->fprintf_func) (info->stream, "%d", val);
420 }
421 break;
422
423 case 'Q':
424 val = fetch_arg (buffer, place, 3, info);
425 /* 0 means 8, except for the bkpt instruction... */
426 if (val == 0 && d[1] != 's')
427 val = 8;
428 (*info->fprintf_func) (info->stream, "#%d", val);
429 break;
430
431 case 'M':
432 val = fetch_arg (buffer, place, 8, info);
433 if (val & 0x80)
434 val = val - 0x100;
435 (*info->fprintf_func) (info->stream, "#%d", val);
436 break;
437
438 case 'T':
439 val = fetch_arg (buffer, place, 4, info);
440 (*info->fprintf_func) (info->stream, "#%d", val);
441 break;
442
443 case 'D':
444 (*info->fprintf_func) (info->stream, "%s",
445 reg_names[fetch_arg (buffer, place, 3, info)]);
446 break;
447
448 case 'A':
449 (*info->fprintf_func)
450 (info->stream, "%s",
451 reg_names[fetch_arg (buffer, place, 3, info) + 010]);
452 break;
453
454 case 'R':
455 (*info->fprintf_func)
456 (info->stream, "%s",
457 reg_names[fetch_arg (buffer, place, 4, info)]);
458 break;
459
460 case 'r':
dbf7e45f
ILT		 461 regno = fetch_arg (buffer, place, 4, info);
462 if (regno > 7)
463 (*info->fprintf_func) (info->stream, "%s@", reg_names[regno]);
464 else
465 (*info->fprintf_func) (info->stream, "@(%s)", reg_names[regno]);
5d0734a7
JK		 466 break;
467
468 case 'F':
469 (*info->fprintf_func)
dbf7e45f 470 (info->stream, "%%fp%d",
5d0734a7
JK		 471 fetch_arg (buffer, place, 3, info));
472 break;
473
474 case 'O':
475 val = fetch_arg (buffer, place, 6, info);
476 if (val & 0x20)
477 (*info->fprintf_func) (info->stream, "%s", reg_names [val & 7]);
478 else
479 (*info->fprintf_func) (info->stream, "%d", val);
480 break;
481
482 case '+':
483 (*info->fprintf_func)
484 (info->stream, "%s@+",
485 reg_names[fetch_arg (buffer, place, 3, info) + 8]);
486 break;
487
488 case '-':
489 (*info->fprintf_func)
490 (info->stream, "%s@-",
491 reg_names[fetch_arg (buffer, place, 3, info) + 8]);
492 break;
493
494 case 'k':
495 if (place == 'k')
496 (*info->fprintf_func)
497 (info->stream, "{%s}",
498 reg_names[fetch_arg (buffer, place, 3, info)]);
499 else if (place == 'C')
500 {
501 val = fetch_arg (buffer, place, 7, info);
502 if ( val > 63 ) /* This is a signed constant. */
503 val -= 128;
504 (*info->fprintf_func) (info->stream, "{#%d}", val);
505 }
506 else
029e2524 507 return -2;
5d0734a7
JK		 508 break;
509
510 case '#':
511 case '^':
512 p1 = buffer + (*d == '#' ? 2 : 4);
513 if (place == 's')
514 val = fetch_arg (buffer, place, 4, info);
515 else if (place == 'C')
516 val = fetch_arg (buffer, place, 7, info);
517 else if (place == '8')
518 val = fetch_arg (buffer, place, 3, info);
519 else if (place == '3')
520 val = fetch_arg (buffer, place, 8, info);
521 else if (place == 'b')
522 val = NEXTBYTE (p1);
dbf7e45f 523 else if (place == 'w' || place == 'W')
5d0734a7
JK		 524 val = NEXTWORD (p1);
525 else if (place == 'l')
526 val = NEXTLONG (p1);
527 else
029e2524 528 return -2;
5d0734a7
JK		 529 (*info->fprintf_func) (info->stream, "#%d", val);
530 break;
531
532 case 'B':
533 if (place == 'b')
534 val = NEXTBYTE (p);
535 else if (place == 'B')
536 val = COERCE_SIGNED_CHAR(buffer[1]);
537 else if (place == 'w' || place == 'W')
538 val = NEXTWORD (p);
dbf7e45f 539 else if (place == 'l' || place == 'L' || place == 'C')
5d0734a7
JK		 540 val = NEXTLONG (p);
541 else if (place == 'g')
542 {
543 val = NEXTBYTE (buffer);
544 if (val == 0)
545 val = NEXTWORD (p);
546 else if (val == -1)
547 val = NEXTLONG (p);
548 }
549 else if (place == 'c')
550 {
551 if (buffer[1] & 0x40) /* If bit six is one, long offset */
552 val = NEXTLONG (p);
553 else
554 val = NEXTWORD (p);
555 }
556 else
029e2524 557 return -2;
5d0734a7 558
e6fb7139 559 (*info->print_address_func) (addr + val, info);
5d0734a7
JK		 560 break;
561
562 case 'd':
563 val = NEXTWORD (p);
564 (*info->fprintf_func)
565 (info->stream, "%s@(%d)",
566 reg_names[fetch_arg (buffer, place, 3, info)], val);
567 break;
568
569 case 's':
570 (*info->fprintf_func) (info->stream, "%s",
571 fpcr_names[fetch_arg (buffer, place, 3, info)]);
572 break;
573
574 case 'I':
575 /* Get coprocessor ID... */
576 val = fetch_arg (buffer, 'd', 3, info);
577
578 if (val != 1) /* Unusual coprocessor ID? */
579 (*info->fprintf_func) (info->stream, "(cpid=%d) ", val);
5d0734a7
JK		 580 break;
581
582 case '*':
583 case '~':
584 case '%':
585 case ';':
586 case '@':
587 case '!':
588 case '$':
589 case '?':
590 case '/':
591 case '&':
592 case '`':
e6fb7139 593 case '|':
5d0734a7
JK		 594
595 if (place == 'd')
596 {
597 val = fetch_arg (buffer, 'x', 6, info);
598 val = ((val & 7) << 3) + ((val >> 3) & 7);
599 }
600 else
601 val = fetch_arg (buffer, 's', 6, info);
602
603 /* Get register number assuming address register. */
604 regno = (val & 7) + 8;
605 regname = reg_names[regno];
606 switch (val >> 3)
607 {
608 case 0:
609 (*info->fprintf_func) (info->stream, "%s", reg_names[val]);
610 break;
611
612 case 1:
613 (*info->fprintf_func) (info->stream, "%s", regname);
614 break;
615
616 case 2:
617 (*info->fprintf_func) (info->stream, "%s@", regname);
618 break;
619
620 case 3:
621 (*info->fprintf_func) (info->stream, "%s@+", regname);
622 break;
623
624 case 4:
625 (*info->fprintf_func) (info->stream, "%s@-", regname);
626 break;
627
628 case 5:
629 val = NEXTWORD (p);
630 (*info->fprintf_func) (info->stream, "%s@(%d)", regname, val);
631 break;
632
633 case 6:
634 p = print_indexed (regno, p, addr, info);
635 break;
636
637 case 7:
638 switch (val & 7)
639 {
640 case 0:
641 val = NEXTWORD (p);
e6fb7139 642 (*info->print_address_func) (val, info);
5d0734a7
JK		 643 break;
644
645 case 1:
646 val = NEXTLONG (p);
e6fb7139 647 (*info->print_address_func) (val, info);
5d0734a7
JK		 648 break;
649
650 case 2:
651 val = NEXTWORD (p);
e6fb7139 652 (*info->print_address_func) (addr + val, info);
5d0734a7
JK		 653 break;
654
655 case 3:
656 p = print_indexed (-1, p, addr, info);
657 break;
658
659 case 4:
660 flt_p = 1; /* Assume it's a float... */
661 switch( place )
662 {
663 case 'b':
664 val = NEXTBYTE (p);
665 flt_p = 0;
666 break;
667
668 case 'w':
669 val = NEXTWORD (p);
670 flt_p = 0;
671 break;
672
673 case 'l':
674 val = NEXTLONG (p);
675 flt_p = 0;
676 break;
677
678 case 'f':
679 NEXTSINGLE(flval, p);
680 break;
681
682 case 'F':
683 NEXTDOUBLE(flval, p);
684 break;
685
686 case 'x':
029e2524
KR		 687 FETCH_DATA (info, p + 12);
688 floatformat_to_double (&floatformat_m68881_ext,
689 (char *) p, &flval);
5d0734a7
JK		 690 p += 12;
691 break;
692
693 case 'p':
694 flval = NEXTPACKED(p);
695 break;
696
697 default:
029e2524 698 return -1;
5d0734a7
JK		 699 }
700 if ( flt_p ) /* Print a float? */
701 (*info->fprintf_func) (info->stream, "#%g", flval);
702 else
703 (*info->fprintf_func) (info->stream, "#%d", val);
704 break;
705
706 default:
029e2524 707 return -1;
5d0734a7
JK		 708 }
709 }
710 break;
711
712 case 'L':
713 case 'l':
714 if (place == 'w')
715 {
716 char doneany;
717 p1 = buffer + 2;
718 val = NEXTWORD (p1);
719 /* Move the pointer ahead if this point is farther ahead
720 than the last. */
721 p = p1 > p ? p1 : p;
722 if (val == 0)
723 {
724 (*info->fprintf_func) (info->stream, "#0");
725 break;
726 }
727 if (*d == 'l')
728 {
729 register int newval = 0;
730 for (regno = 0; regno < 16; ++regno)
731 if (val & (0x8000 >> regno))
732 newval |= 1 << regno;
733 val = newval;
734 }
735 val &= 0xffff;
736 doneany = 0;
737 for (regno = 0; regno < 16; ++regno)
738 if (val & (1 << regno))
739 {
740 int first_regno;
741 if (doneany)
742 (*info->fprintf_func) (info->stream, "/");
743 doneany = 1;
744 (*info->fprintf_func) (info->stream, "%s", reg_names[regno]);
745 first_regno = regno;
746 while (val & (1 << (regno + 1)))
747 ++regno;
748 if (regno > first_regno)
749 (*info->fprintf_func) (info->stream, "-%s",
750 reg_names[regno]);
751 }
752 }
753 else if (place == '3')
754 {
755 /* `fmovem' insn. */
756 char doneany;
757 val = fetch_arg (buffer, place, 8, info);
758 if (val == 0)
759 {
760 (*info->fprintf_func) (info->stream, "#0");
761 break;
762 }
763 if (*d == 'l')
764 {
765 register int newval = 0;
766 for (regno = 0; regno < 8; ++regno)
767 if (val & (0x80 >> regno))
768 newval |= 1 << regno;
769 val = newval;
770 }
771 val &= 0xff;
772 doneany = 0;
773 for (regno = 0; regno < 8; ++regno)
774 if (val & (1 << regno))
775 {
776 int first_regno;
777 if (doneany)
778 (*info->fprintf_func) (info->stream, "/");
779 doneany = 1;
dbf7e45f 780 (*info->fprintf_func) (info->stream, "%%fp%d", regno);
5d0734a7
JK		 781 first_regno = regno;
782 while (val & (1 << (regno + 1)))
783 ++regno;
784 if (regno > first_regno)
dbf7e45f 785 (*info->fprintf_func) (info->stream, "-%%fp%d", regno);
5d0734a7
JK		 786 }
787 }
788 else
029e2524 789 return -2;
5d0734a7
JK		 790 break;
791
e6fb7139
JK		 792 case 'X':
793 place = '8';
794 case 'Y':
795 case 'Z':
796 case 'W':
dbf7e45f
ILT		 797 case '0':
798 case '1':
799 case '2':
e6fb7139 800 case '3':
e6fb7139
JK		 801 {
802 int val = fetch_arg (buffer, place, 5, info);
803 char *name = 0;
804 switch (val)
805 {
dbf7e45f
ILT		 806 case 2: name = "%tt0"; break;
807 case 3: name = "%tt1"; break;
808 case 0x10: name = "%tc"; break;
809 case 0x11: name = "%drp"; break;
810 case 0x12: name = "%srp"; break;
811 case 0x13: name = "%crp"; break;
812 case 0x14: name = "%cal"; break;
813 case 0x15: name = "%val"; break;
814 case 0x16: name = "%scc"; break;
815 case 0x17: name = "%ac"; break;
816 case 0x18: name = "%psr"; break;
817 case 0x19: name = "%pcsr"; break;
e6fb7139
JK		 818 case 0x1c:
819 case 0x1d:
820 {
821 int break_reg = ((buffer[3] >> 2) & 7);
822 (*info->fprintf_func)
dbf7e45f 823 (info->stream, val == 0x1c ? "%%bad%d" : "%%bac%d",
e6fb7139
JK		 824 break_reg);
825 }
826 break;
827 default:
828 (*info->fprintf_func) (info->stream, "<mmu register %d>", val);
829 }
830 if (name)
dbf7e45f 831 (*info->fprintf_func) (info->stream, "%s", name);
e6fb7139
JK		 832 }
833 break;
834
835 case 'f':
836 {
837 int fc = fetch_arg (buffer, place, 5, info);
838 if (fc == 1)
dbf7e45f 839 (*info->fprintf_func) (info->stream, "%%dfc");
e6fb7139 840 else if (fc == 0)
dbf7e45f 841 (*info->fprintf_func) (info->stream, "%%sfc");
e6fb7139
JK		 842 else
843 (*info->fprintf_func) (info->stream, "<function code %d>", fc);
844 }
845 break;
846
847 case 'V':
dbf7e45f 848 (*info->fprintf_func) (info->stream, "%%val");
e6fb7139
JK		 849 break;
850
851 case 't':
852 {
853 int level = fetch_arg (buffer, place, 3, info);
854 (*info->fprintf_func) (info->stream, "%d", level);
855 }
856 break;
857
029e2524
KR		 858 default:
859 return -2;
5d0734a7
JK		 860 }
861
029e2524 862 return p - p0;
5d0734a7
JK		 863}
864
865/* Fetch BITS bits from a position in the instruction specified by CODE.
866 CODE is a "place to put an argument", or 'x' for a destination
867 that is a general address (mode and register).
868 BUFFER contains the instruction. */
869
870static int
871fetch_arg (buffer, code, bits, info)
872 unsigned char *buffer;
873 int code;
874 int bits;
875 disassemble_info *info;
876{
877 register int val = 0;
878 switch (code)
879 {
880 case 's':
881 val = buffer[1];
882 break;
883
884 case 'd': /* Destination, for register or quick. */
885 val = (buffer[0] << 8) + buffer[1];
886 val >>= 9;
887 break;
888
889 case 'x': /* Destination, for general arg */
890 val = (buffer[0] << 8) + buffer[1];
891 val >>= 6;
892 break;
893
894 case 'k':
895 FETCH_DATA (info, buffer + 3);
896 val = (buffer[3] >> 4);
897 break;
898
899 case 'C':
900 FETCH_DATA (info, buffer + 3);
901 val = buffer[3];
902 break;
903
904 case '1':
905 FETCH_DATA (info, buffer + 3);
906 val = (buffer[2] << 8) + buffer[3];
907 val >>= 12;
908 break;
909
910 case '2':
911 FETCH_DATA (info, buffer + 3);
912 val = (buffer[2] << 8) + buffer[3];
913 val >>= 6;
914 break;
915
916 case '3':
917 case 'j':
918 FETCH_DATA (info, buffer + 3);
919 val = (buffer[2] << 8) + buffer[3];
920 break;
921
922 case '4':
923 FETCH_DATA (info, buffer + 5);
924 val = (buffer[4] << 8) + buffer[5];
925 val >>= 12;
926 break;
927
928 case '5':
929 FETCH_DATA (info, buffer + 5);
930 val = (buffer[4] << 8) + buffer[5];
931 val >>= 6;
932 break;
933
934 case '6':
935 FETCH_DATA (info, buffer + 5);
936 val = (buffer[4] << 8) + buffer[5];
937 break;
938
939 case '7':
940 FETCH_DATA (info, buffer + 3);
941 val = (buffer[2] << 8) + buffer[3];
942 val >>= 7;
943 break;
944
945 case '8':
946 FETCH_DATA (info, buffer + 3);
947 val = (buffer[2] << 8) + buffer[3];
948 val >>= 10;
949 break;
950
951 case '9':
952 FETCH_DATA (info, buffer + 3);
953 val = (buffer[2] << 8) + buffer[3];
954 val >>= 5;
955 break;
956
957 case 'e':
958 val = (buffer[1] >> 6);
959 break;
960
961 default:
962 abort ();
963 }
964
965 switch (bits)
966 {
967 case 2:
968 return val & 3;
969 case 3:
970 return val & 7;
971 case 4:
972 return val & 017;
973 case 5:
974 return val & 037;
975 case 6:
976 return val & 077;
977 case 7:
978 return val & 0177;
979 case 8:
980 return val & 0377;
981 case 12:
982 return val & 07777;
983 default:
984 abort ();
985 }
986}
987
988/* Print an indexed argument. The base register is BASEREG (-1 for pc).
989 P points to extension word, in buffer.
990 ADDR is the nominal core address of that extension word. */
991
992static unsigned char *
993print_indexed (basereg, p, addr, info)
994 int basereg;
995 unsigned char *p;
996 bfd_vma addr;
997 disassemble_info *info;
998{
999 register int word;
dbf7e45f
ILT		 1000 static char *const scales[] = {"", ":2", ":4", ":8"};
1001 bfd_vma base_disp;
1002 bfd_vma outer_disp;
5d0734a7 1003 char buf[40];
dbf7e45f 1004 char vmabuf[50];
5d0734a7
JK		 1005
1006 word = NEXTWORD (p);
1007
1008 /* Generate the text for the index register.
1009 Where this will be output is not yet determined. */
dbf7e45f 1010 sprintf (buf, "%s:%c%s",
5d0734a7
JK		 1011 reg_names[(word >> 12) & 0xf],
1012 (word & 0x800) ? 'l' : 'w',
1013 scales[(word >> 9) & 3]);
1014
1015 /* Handle the 68000 style of indexing. */
1016
1017 if ((word & 0x100) == 0)
1018 {
dbf7e45f
ILT		 1019 word &= 0xff;
1020 if ((word & 0x80) != 0)
1021 word -= 0x100;
1022 if (basereg == -1)
1023 word += addr;
1024 print_base (basereg, word, info);
1025 (*info->fprintf_func) (info->stream, ",%s)", buf);
5d0734a7
JK		 1026 return p;
1027 }
1028
1029 /* Handle the generalized kind. */
1030 /* First, compute the displacement to add to the base register. */
1031
1032 if (word & 0200)
dbf7e45f
ILT		 1033 {
1034 if (basereg == -1)
1035 basereg = -3;
1036 else
1037 basereg = -2;
1038 }
5d0734a7 1039 if (word & 0100)
dbf7e45f 1040 buf[0] = '\0';
5d0734a7
JK		 1041 base_disp = 0;
1042 switch ((word >> 4) & 3)
1043 {
1044 case 2:
1045 base_disp = NEXTWORD (p);
1046 break;
1047 case 3:
1048 base_disp = NEXTLONG (p);
1049 }
1050 if (basereg == -1)
1051 base_disp += addr;
1052
1053 /* Handle single-level case (not indirect) */
1054
1055 if ((word & 7) == 0)
1056 {
1057 print_base (basereg, base_disp, info);
dbf7e45f
ILT		 1058 if (buf[0] != '\0')
1059 (*info->fprintf_func) (info->stream, ",%s", buf);
1060 (*info->fprintf_func) (info->stream, ")");
5d0734a7
JK		 1061 return p;
1062 }
1063
1064 /* Two level. Compute displacement to add after indirection. */
1065
1066 outer_disp = 0;
1067 switch (word & 3)
1068 {
1069 case 2:
1070 outer_disp = NEXTWORD (p);
1071 break;
1072 case 3:
1073 outer_disp = NEXTLONG (p);
1074 }
1075
5d0734a7 1076 print_base (basereg, base_disp, info);
dbf7e45f
ILT		 1077 if ((word & 4) == 0 && buf[0] != '\0')
1078 {
1079 (*info->fprintf_func) (info->stream, ",%s", buf);
1080 buf[0] = '\0';
1081 }
1082 sprintf_vma (vmabuf, outer_disp);
1083 (*info->fprintf_func) (info->stream, ")@(%s", vmabuf);
1084 if (buf[0] != '\0')
1085 (*info->fprintf_func) (info->stream, ",%s", buf);
1086 (*info->fprintf_func) (info->stream, ")");
5d0734a7
JK		 1087
1088 return p;
1089}
1090
1091/* Print a base register REGNO and displacement DISP, on INFO->STREAM.
1092 REGNO = -1 for pc, -2 for none (suppressed). */
1093
1094static void
1095print_base (regno, disp, info)
1096 int regno;
dbf7e45f 1097 bfd_vma disp;
5d0734a7
JK		 1098 disassemble_info *info;
1099{
dbf7e45f
ILT		 1100 if (regno == -1)
1101 {
1102 (*info->fprintf_func) (info->stream, "%%pc@(");
1103 (*info->print_address_func) (disp, info);
1104 }
5d0734a7 1105 else
dbf7e45f
ILT		 1106 {
1107 char buf[50];
1108
1109 if (regno == -2)
1110 (*info->fprintf_func) (info->stream, "@(");
1111 else if (regno == -3)
1112 (*info->fprintf_func) (info->stream, "%%zpc@(");
1113 else
1114 (*info->fprintf_func) (info->stream, "%s@(", reg_names[regno]);
1115
1116 sprintf_vma (buf, disp);
1117 (*info->fprintf_func) (info->stream, "%s", buf);
1118 }
5d0734a7 1119}
GDB Binutils - Deliverables
This page took 0.157693 seconds and 4 git commands to generate.