OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [opcodes/] [m68hc11-dis.c] - Blame information for rev 1776

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom 
/* m68hc11-dis.c -- Motorola 68HC11 & 68HC12 disassembly
2 
   Copyright 1999, 2000 Free Software Foundation, Inc.
3 
   Written by Stephane Carrez (stcarrez@worldnet.fr)
4 
 
5 
This program is free software; you can redistribute it and/or modify
6 
it under the terms of the GNU General Public License as published by
7 
the Free Software Foundation; either version 2 of the License, or
8 
(at your option) any later version.
9 
 
10 
This program is distributed in the hope that it will be useful,
11 
but WITHOUT ANY WARRANTY; without even the implied warranty of
12 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 
GNU General Public License for more details.
14 
 
15 
You should have received a copy of the GNU General Public License
16 
along with this program; if not, write to the Free Software
17 
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
18 
 
19 
#include <stdio.h>
20 
 
21 
#include "ansidecl.h"
22 
#include "opcode/m68hc11.h"
23 
#include "dis-asm.h"
24 
 
25 
static const char *const reg_name[] = {
26 
  "X", "Y", "SP", "PC"
27 
};
28 
 
29 
static const char *const reg_src_table[] = {
30 
  "A", "B", "CCR", "TMP3", "D", "X", "Y", "SP"
31 
};
32 
 
33 
static const char *const reg_dst_table[] = {
34 
  "A", "B", "CCR", "TMP2", "D", "X", "Y", "SP"
35 
};
36 
 
37 
#define OP_PAGE_MASK (M6811_OP_PAGE2|M6811_OP_PAGE3|M6811_OP_PAGE4)
38 
 
39 
static int
40 
read_memory (memaddr, buffer, size, info)
41 
     bfd_vma memaddr;
42 
     bfd_byte *buffer;
43 
     int size;
44 
     struct disassemble_info *info;
45 
{
46 
  int status;
47 
 
48 
  /* Get first byte.  Only one at a time because we don't know the
49 
     size of the insn.  */
50 
  status = (*info->read_memory_func) (memaddr, buffer, size, info);
51 
  if (status != 0)
52 
    {
53 
      (*info->memory_error_func) (status, memaddr, info);
54 
      return -1;
55 
    }
56 
  return 0;
57 
}
58 
 
59 
 
60 
/* Read the 68HC12 indexed operand byte and print the corresponding mode.
61 
   Returns the number of bytes read or -1 if failure.  */
62 
static int
63 
print_indexed_operand (memaddr, info, mov_insn)
64 
     bfd_vma memaddr;
65 
     struct disassemble_info *info;
66 
     int mov_insn;
67 
{
68 
  bfd_byte buffer[4];
69 
  int reg;
70 
  int status;
71 
  short sval;
72 
  int pos = 1;
73 
 
74 
  status = read_memory (memaddr, &buffer[0], 1, info);
75 
  if (status != 0)
76 
    {
77 
      return status;
78 
    }
79 
 
80 
  /* n,r with 5-bits signed constant.  */
81 
  if ((buffer[0] & 0x20) == 0)
82 
    {
83 
      reg = (buffer[0] >> 6) & 3;
84 
      sval = (buffer[0] & 0x1f);
85 
      if (sval & 0x10)
86 
        sval |= 0xfff0;
87 
      (*info->fprintf_func) (info->stream, "%d,%s",
88 
                             (int) sval, reg_name[reg]);
89 
    }
90 
 
91 
  /* Auto pre/post increment/decrement.  */
92 
  else if ((buffer[0] & 0xc0) != 0xc0)
93 
    {
94 
      const char *mode;
95 
 
96 
      reg = (buffer[0] >> 6) & 3;
97 
      sval = (buffer[0] & 0x0f);
98 
      if (sval & 0x8)
99 
        {
100 
          sval |= 0xfff0;
101 
          sval = -sval;
102 
          mode = "-";
103 
        }
104 
      else
105 
        {
106 
          sval = sval + 1;
107 
          mode = "+";
108 
        }
109 
      (*info->fprintf_func) (info->stream, "%d,%s%s%s",
110 
                             (int) sval,
111 
                             (buffer[0] & 0x10 ? "" : mode),
112 
                             reg_name[reg], (buffer[0] & 0x10 ? mode : ""));
113 
    }
114 
 
115 
  /* [n,r] 16-bits offset indexed indirect.  */
116 
  else if ((buffer[0] & 0x07) == 3)
117 
    {
118 
      if (mov_insn)
119 
        {
120 
          (*info->fprintf_func) (info->stream, "<invalid op: 0x%x>",
121 
                                 buffer[0] & 0x0ff);
122 
          return 0;
123 
        }
124 
      reg = (buffer[0] >> 3) & 0x03;
125 
      status = read_memory (memaddr + pos, &buffer[0], 2, info);
126 
      if (status != 0)
127 
        {
128 
          return status;
129 
        }
130 
 
131 
      pos += 2;
132 
      sval = ((buffer[0] << 8) | (buffer[1] & 0x0FF));
133 
      (*info->fprintf_func) (info->stream, "[%u,%s]",
134 
                             sval & 0x0ffff, reg_name[reg]);
135 
    }
136 
  else if ((buffer[0] & 0x4) == 0)
137 
    {
138 
      if (mov_insn)
139 
        {
140 
          (*info->fprintf_func) (info->stream, "<invalid op: 0x%x>",
141 
                                 buffer[0] & 0x0ff);
142 
          return 0;
143 
        }
144 
      reg = (buffer[0] >> 3) & 0x03;
145 
      status = read_memory (memaddr + pos,
146 
                            &buffer[1], (buffer[0] & 0x2 ? 2 : 1), info);
147 
      if (status != 0)
148 
        {
149 
          return status;
150 
        }
151 
      if (buffer[0] & 2)
152 
        {
153 
          sval = ((buffer[1] << 8) | (buffer[2] & 0x0FF));
154 
          sval &= 0x0FFFF;
155 
          pos += 2;
156 
        }
157 
      else
158 
        {
159 
          sval = buffer[1] & 0x00ff;
160 
          if (buffer[0] & 0x01)
161 
            sval |= 0xff00;
162 
          pos++;
163 
        }
164 
      (*info->fprintf_func) (info->stream, "%d,%s",
165 
                             (int) sval, reg_name[reg]);
166 
    }
167 
  else
168 
    {
169 
      reg = (buffer[0] >> 3) & 0x03;
170 
      switch (buffer[0] & 3)
171 
        {
172 
        case 0:
173 
          (*info->fprintf_func) (info->stream, "A,%s", reg_name[reg]);
174 
          break;
175 
        case 1:
176 
          (*info->fprintf_func) (info->stream, "B,%s", reg_name[reg]);
177 
          break;
178 
        case 2:
179 
          (*info->fprintf_func) (info->stream, "D,%s", reg_name[reg]);
180 
          break;
181 
        case 3:
182 
        default:
183 
          (*info->fprintf_func) (info->stream, "[D,%s]", reg_name[reg]);
184 
          break;
185 
        }
186 
    }
187 
 
188 
  return pos;
189 
}
190 
 
191 
/* Disassemble one instruction at address 'memaddr'.  Returns the number
192 
   of bytes used by that instruction.  */
193 
static int
194 
print_insn (memaddr, info, arch)
195 
     bfd_vma memaddr;
196 
     struct disassemble_info *info;
197 
     int arch;
198 
{
199 
  int status;
200 
  bfd_byte buffer[4];
201 
  unsigned char code;
202 
  long format, pos, i;
203 
  short sval;
204 
  const struct m68hc11_opcode *opcode;
205 
 
206 
  /* Get first byte.  Only one at a time because we don't know the
207 
     size of the insn.  */
208 
  status = read_memory (memaddr, buffer, 1, info);
209 
  if (status != 0)
210 
    {
211 
      return status;
212 
    }
213 
 
214 
  format = 0;
215 
  code = buffer[0];
216 
  pos = 0;
217 
 
218 
  /* Look for page2,3,4 opcodes.  */
219 
  if (code == M6811_OPCODE_PAGE2)
220 
    {
221 
      pos++;
222 
      format = M6811_OP_PAGE2;
223 
    }
224 
  else if (code == M6811_OPCODE_PAGE3 && arch == cpu6811)
225 
    {
226 
      pos++;
227 
      format = M6811_OP_PAGE3;
228 
    }
229 
  else if (code == M6811_OPCODE_PAGE4 && arch == cpu6811)
230 
    {
231 
      pos++;
232 
      format = M6811_OP_PAGE4;
233 
    }
234 
 
235 
  /* We are in page2,3,4; get the real opcode.  */
236 
  if (pos == 1)
237 
    {
238 
      status = read_memory (memaddr + pos, &buffer[1], 1, info);
239 
      if (status != 0)
240 
        {
241 
          return status;
242 
        }
243 
      code = buffer[1];
244 
    }
245 
 
246 
 
247 
  /* Look first for a 68HC12 alias.  All of them are 2-bytes long and
248 
     in page 1.  There is no operand to print.  We read the second byte
249 
     only when we have a possible match.  */
250 
  if ((arch & cpu6812) && format == 0)
251 
    {
252 
      int must_read = 1;
253 
 
254 
      /* Walk the alias table to find a code1+code2 match.  */
255 
      for (i = 0; i < m68hc12_num_alias; i++)
256 
        {
257 
          if (m68hc12_alias[i].code1 == code)
258 
            {
259 
              if (must_read)
260 
                {
261 
                  status = read_memory (memaddr + pos + 1,
262 
                                        &buffer[1], 1, info);
263 
                  if (status != 0)
264 
                    break;
265 
 
266 
                  must_read = 1;
267 
                }
268 
              if (m68hc12_alias[i].code2 == (unsigned char) buffer[1])
269 
                {
270 
                  (*info->fprintf_func) (info->stream, "%s",
271 
                                         m68hc12_alias[i].name);
272 
                  return 2;
273 
                }
274 
            }
275 
        }
276 
    }
277 
 
278 
  pos++;
279 
 
280 
  /* Scan the opcode table until we find the opcode
281 
     with the corresponding page.  */
282 
  opcode = m68hc11_opcodes;
283 
  for (i = 0; i < m68hc11_num_opcodes; i++, opcode++)
284 
    {
285 
      int offset;
286 
 
287 
      if ((opcode->arch & arch) == 0)
288 
        continue;
289 
      if (opcode->opcode != code)
290 
        continue;
291 
      if ((opcode->format & OP_PAGE_MASK) != format)
292 
        continue;
293 
 
294 
      if (opcode->format & M6812_OP_REG)
295 
        {
296 
          int j;
297 
          int is_jump;
298 
 
299 
          if (opcode->format & M6811_OP_JUMP_REL)
300 
            is_jump = 1;
301 
          else
302 
            is_jump = 0;
303 
 
304 
          status = read_memory (memaddr + pos, &buffer[0], 1, info);
305 
          if (status != 0)
306 
            {
307 
              return status;
308 
            }
309 
          for (j = 0; i + j < m68hc11_num_opcodes; j++)
310 
            {
311 
              if ((opcode[j].arch & arch) == 0)
312 
                continue;
313 
              if (opcode[j].opcode != code)
314 
                continue;
315 
              if (is_jump)
316 
                {
317 
                  if (!(opcode[j].format & M6811_OP_JUMP_REL))
318 
                    continue;
319 
 
320 
                  if ((opcode[j].format & M6812_OP_IBCC_MARKER)
321 
                      && (buffer[0] & 0xc0) != 0x80)
322 
                    continue;
323 
                  if ((opcode[j].format & M6812_OP_TBCC_MARKER)
324 
                      && (buffer[0] & 0xc0) != 0x40)
325 
                    continue;
326 
                  if ((opcode[j].format & M6812_OP_DBCC_MARKER)
327 
                      && (buffer[0] & 0xc0) != 0)
328 
                    continue;
329 
                  if ((opcode[j].format & M6812_OP_EQ_MARKER)
330 
                      && (buffer[0] & 0x20) == 0)
331 
                    break;
332 
                  if (!(opcode[j].format & M6812_OP_EQ_MARKER)
333 
                      && (buffer[0] & 0x20) != 0)
334 
                    break;
335 
                  continue;
336 
                }
337 
              if (opcode[j].format & M6812_OP_EXG_MARKER && buffer[0] & 0x80)
338 
                break;
339 
              if ((opcode[j].format & M6812_OP_SEX_MARKER)
340 
                  && (((buffer[0] & 0x07) >= 3 && (buffer[0] & 7) <= 7))
341 
                  && ((buffer[0] & 0x0f0) <= 0x20))
342 
                break;
343 
              if (opcode[j].format & M6812_OP_TFR_MARKER
344 
                  && !(buffer[0] & 0x80))
345 
                break;
346 
            }
347 
          if (i + j < m68hc11_num_opcodes)
348 
            opcode = &opcode[j];
349 
        }
350 
 
351 
      /* We have found the opcode.  Extract the operand and print it.  */
352 
      (*info->fprintf_func) (info->stream, "%s", opcode->name);
353 
 
354 
      format = opcode->format;
355 
      if (format & (M6811_OP_MASK | M6811_OP_BITMASK
356 
                    | M6811_OP_JUMP_REL | M6812_OP_JUMP_REL16))
357 
        {
358 
          (*info->fprintf_func) (info->stream, "\t");
359 
        }
360 
 
361 
      /* The movb and movw must be handled in a special way...  */
362 
      offset = 0;
363 
      if (format & (M6812_OP_IDX_P2 | M6812_OP_IND16_P2))
364 
        {
365 
          if ((format & M6812_OP_IDX_P2)
366 
              && (format & (M6811_OP_IMM8 | M6811_OP_IMM16 | M6811_OP_IND16)))
367 
            offset = 1;
368 
        }
369 
 
370 
      /* Operand with one more byte: - immediate, offset,
371 
         direct-low address.  */
372 
      if (format &
373 
          (M6811_OP_IMM8 | M6811_OP_IX | M6811_OP_IY | M6811_OP_DIRECT))
374 
        {
375 
          status = read_memory (memaddr + pos + offset, &buffer[0], 1, info);
376 
          if (status != 0)
377 
            {
378 
              return status;
379 
            }
380 
 
381 
          pos++;
382 
          offset = -1;
383 
          if (format & M6811_OP_IMM8)
384 
            {
385 
              (*info->fprintf_func) (info->stream, "#%d", (int) buffer[0]);
386 
              format &= ~M6811_OP_IMM8;
387 
            }
388 
          else if (format & M6811_OP_IX)
389 
            {
390 
              /* Offsets are in range 0..255, print them unsigned.  */
391 
              (*info->fprintf_func) (info->stream, "%u,x", buffer[0] & 0x0FF);
392 
              format &= ~M6811_OP_IX;
393 
            }
394 
          else if (format & M6811_OP_IY)
395 
            {
396 
              (*info->fprintf_func) (info->stream, "%u,y", buffer[0] & 0x0FF);
397 
              format &= ~M6811_OP_IY;
398 
            }
399 
          else if (format & M6811_OP_DIRECT)
400 
            {
401 
              (*info->fprintf_func) (info->stream, "*");
402 
              (*info->print_address_func) (buffer[0] & 0x0FF, info);
403 
              format &= ~M6811_OP_DIRECT;
404 
            }
405 
        }
406 
 
407 
#define M6812_INDEXED_FLAGS (M6812_OP_IDX|M6812_OP_IDX_1|M6812_OP_IDX_2)
408 
      /* Analyze the 68HC12 indexed byte.  */
409 
      if (format & M6812_INDEXED_FLAGS)
410 
        {
411 
          status = print_indexed_operand (memaddr + pos, info, 0);
412 
          if (status < 0)
413 
            {
414 
              return status;
415 
            }
416 
          pos += status;
417 
        }
418 
 
419 
      /* 68HC12 dbcc/ibcc/tbcc operands.  */
420 
      if ((format & M6812_OP_REG) && (format & M6811_OP_JUMP_REL))
421 
        {
422 
          status = read_memory (memaddr + pos, &buffer[0], 2, info);
423 
          if (status != 0)
424 
            {
425 
              return status;
426 
            }
427 
          (*info->fprintf_func) (info->stream, "%s,",
428 
                                 reg_src_table[buffer[0] & 0x07]);
429 
          sval = buffer[1] & 0x0ff;
430 
          if (buffer[0] & 0x10)
431 
            sval |= 0xff00;
432 
 
433 
          pos += 2;
434 
          (*info->print_address_func) (memaddr + pos + sval, info);
435 
          format &= ~(M6812_OP_REG | M6811_OP_JUMP_REL);
436 
        }
437 
      else if (format & (M6812_OP_REG | M6812_OP_REG_2))
438 
        {
439 
          status = read_memory (memaddr + pos, &buffer[0], 1, info);
440 
          if (status != 0)
441 
            {
442 
              return status;
443 
            }
444 
 
445 
          pos++;
446 
          (*info->fprintf_func) (info->stream, "%s,%s",
447 
                                 reg_src_table[(buffer[0] >> 4) & 7],
448 
                                 reg_dst_table[(buffer[0] & 7)]);
449 
        }
450 
 
451 
      /* M6811_OP_BITMASK and M6811_OP_JUMP_REL must be treated separately
452 
         and in that order.  The brset/brclr insn have a bitmask and then
453 
         a relative branch offset.  */
454 
      if (format & M6811_OP_BITMASK)
455 
        {
456 
          status = read_memory (memaddr + pos, &buffer[0], 1, info);
457 
          if (status != 0)
458 
            {
459 
              return status;
460 
            }
461 
          pos++;
462 
          (*info->fprintf_func) (info->stream, " #$%02x%s",
463 
                                 buffer[0] & 0x0FF,
464 
                                 (format & M6811_OP_JUMP_REL ? " " : ""));
465 
          format &= ~M6811_OP_BITMASK;
466 
        }
467 
      if (format & M6811_OP_JUMP_REL)
468 
        {
469 
          int val;
470 
 
471 
          status = read_memory (memaddr + pos, &buffer[0], 1, info);
472 
          if (status != 0)
473 
            {
474 
              return status;
475 
            }
476 
 
477 
          pos++;
478 
          val = (buffer[0] & 0x80) ? buffer[0] | 0xFFFFFF00 : buffer[0];
479 
          (*info->print_address_func) (memaddr + pos + val, info);
480 
          format &= ~M6811_OP_JUMP_REL;
481 
        }
482 
      else if (format & M6812_OP_JUMP_REL16)
483 
        {
484 
          int val;
485 
 
486 
          status = read_memory (memaddr + pos, &buffer[0], 2, info);
487 
          if (status != 0)
488 
            {
489 
              return status;
490 
            }
491 
 
492 
          pos += 2;
493 
          val = ((buffer[0] << 8) | (buffer[1] & 0x0FF));
494 
          if (val & 0x8000)
495 
            val |= 0xffff0000;
496 
 
497 
          (*info->print_address_func) (memaddr + pos + val, info);
498 
          format &= ~M6812_OP_JUMP_REL16;
499 
        }
500 
      if (format & (M6811_OP_IMM16 | M6811_OP_IND16))
501 
        {
502 
          int val;
503 
 
504 
          status = read_memory (memaddr + pos + offset, &buffer[0], 2, info);
505 
          if (status != 0)
506 
            {
507 
              return status;
508 
            }
509 
          if (format & M6812_OP_IDX_P2)
510 
            offset = -2;
511 
          else
512 
            offset = 0;
513 
          pos += 2;
514 
 
515 
          val = ((buffer[0] << 8) | (buffer[1] & 0x0FF));
516 
          val &= 0x0FFFF;
517 
          if (format & M6811_OP_IMM16)
518 
            {
519 
              format &= ~M6811_OP_IMM16;
520 
              (*info->fprintf_func) (info->stream, "#");
521 
            }
522 
          else
523 
            format &= ~M6811_OP_IND16;
524 
 
525 
          (*info->print_address_func) (val, info);
526 
        }
527 
 
528 
      if (format & M6812_OP_IDX_P2)
529 
        {
530 
          (*info->fprintf_func) (info->stream, ", ");
531 
          status = print_indexed_operand (memaddr + pos + offset, info, 1);
532 
          if (status < 0)
533 
            return status;
534 
          pos += status;
535 
        }
536 
 
537 
      if (format & M6812_OP_IND16_P2)
538 
        {
539 
          int val;
540 
 
541 
          (*info->fprintf_func) (info->stream, ", ");
542 
 
543 
          status = read_memory (memaddr + pos + offset, &buffer[0], 2, info);
544 
          if (status != 0)
545 
            {
546 
              return status;
547 
            }
548 
          pos += 2;
549 
 
550 
          val = ((buffer[0] << 8) | (buffer[1] & 0x0FF));
551 
          val &= 0x0FFFF;
552 
          (*info->print_address_func) (val, info);
553 
        }
554 
 
555 
#ifdef DEBUG
556 
      /* Consistency check.  'format' must be 0, so that we have handled
557 
         all formats; and the computed size of the insn must match the
558 
         opcode table content.  */
559 
      if (format & ~(M6811_OP_PAGE4 | M6811_OP_PAGE3 | M6811_OP_PAGE2))
560 
        {
561 
          (*info->fprintf_func) (info->stream, "; Error, format: %x", format);
562 
        }
563 
      if (pos != opcode->size)
564 
        {
565 
          (*info->fprintf_func) (info->stream, "; Error, size: %d expect %d",
566 
                                 pos, opcode->size);
567 
        }
568 
#endif
569 
      return pos;
570 
    }
571 
 
572 
  /* Opcode not recognized.  */
573 
  if (format == M6811_OP_PAGE2 && arch & cpu6812
574 
      && ((code >= 0x30 && code <= 0x39) || (code >= 0x40 && code <= 0xff)))
575 
    (*info->fprintf_func) (info->stream, "trap\t#%d", code & 0x0ff);
576 
 
577 
  else if (format == M6811_OP_PAGE2)
578 
    (*info->fprintf_func) (info->stream, ".byte\t0x%02x, 0x%02x",
579 
                           M6811_OPCODE_PAGE2, code);
580 
  else if (format == M6811_OP_PAGE3)
581 
    (*info->fprintf_func) (info->stream, ".byte\t0x%02x, 0x%02x",
582 
                           M6811_OPCODE_PAGE3, code);
583 
  else if (format == M6811_OP_PAGE4)
584 
    (*info->fprintf_func) (info->stream, ".byte\t0x%02x, 0x%02x",
585 
                           M6811_OPCODE_PAGE4, code);
586 
  else
587 
    (*info->fprintf_func) (info->stream, ".byte\t0x%02x", code);
588 
 
589 
  return pos;
590 
}
591 
 
592 
/* Disassemble one instruction at address 'memaddr'.  Returns the number
593 
   of bytes used by that instruction.  */
594 
int
595 
print_insn_m68hc11 (memaddr, info)
596 
     bfd_vma memaddr;
597 
     struct disassemble_info *info;
598 
{
599 
  return print_insn (memaddr, info, cpu6811);
600 
}
601 
 
602 
int
603 
print_insn_m68hc12 (memaddr, info)
604 
     bfd_vma memaddr;
605 
     struct disassemble_info *info;
606 
{
607 
  return print_insn (memaddr, info, cpu6812);
608 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.