Display hex equivalent of rotated ARM constants.

[deliverable/binutils-gdb.git] / opcodes / z8k-dis.c

diff --git a/opcodes/z8k-dis.c b/opcodes/z8k-dis.c
index 858d5a2102e006c063c722268cea13a0ab5ae257..7123622a291cb49d5ec09a7a1d74e75ba2e2bb29 100644 (file)
--- a/opcodes/z8k-dis.c
+++ b/opcodes/z8k-dis.c
@@ -1,4 +1,6 @@
-/*
+/* Disassemble z8000 code.
+   Copyright 1992, 1993, 1995, 1998 Free Software Foundation, Inc.
+
 This file is part of GNU Binutils.
 
 This program is free software; you can redistribute it and/or modify
@@ -13,7 +15,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include <ansidecl.h>
 #include "sysdep.h"
@@ -56,7 +58,7 @@ instr_data_s;
    to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
    on error.  */
 #define FETCH_DATA(info, nibble) \
-  ((nibble) <= ((instr_data_s *)(info->private_data))->max_fetched \
+  ((nibble) < ((instr_data_s *)(info->private_data))->max_fetched \
    ? 1 : fetch_data ((info), (nibble)))
 
 static int
@@ -67,25 +69,25 @@ fetch_data (info, nibble)
   unsigned char mybuf[20];
   int status;
   instr_data_s *priv = (instr_data_s *)info->private_data;
-  bfd_vma start = priv->insn_start + priv->max_fetched / 2;
 
   if ((nibble % 4) != 0)
     abort ();
-  status = (*info->read_memory_func) (start,
+
+  status = (*info->read_memory_func) (priv->insn_start,
                                      (bfd_byte *) mybuf,
-                                     (nibble - priv->max_fetched) / 2,
+                                     nibble / 2,
                                      info);
   if (status != 0)
     {
-      (*info->memory_error_func) (status, start, info);
+      (*info->memory_error_func) (status, priv->insn_start, info);
       longjmp (priv->bailout, 1);
     }
 
   {
     int i;
-    char *p = mybuf + priv->max_fetched / 2;
+    unsigned char *p = mybuf ;
     
-    for (i = priv->max_fetched; i < nibble;)
+    for (i = 0; i < nibble;)
       {
        priv->words[i] = (p[0] << 8) | p[1];
        
@@ -133,7 +135,7 @@ static void unparse_instr PARAMS ((instr_data_s *));
 
 static int
 print_insn_z8k (addr, info, is_segmented)
-     unsigned long addr;
+     bfd_vma addr;
      disassemble_info *info;
      int is_segmented;
 {
@@ -163,15 +165,17 @@ print_insn_z8k (addr, info, is_segmented)
     }
 }
 
+int
 print_insn_z8001 (addr, info)
-     unsigned long addr;
+     bfd_vma addr;
      disassemble_info *info;
 {
   return print_insn_z8k (addr, info, 1);
 }
 
+int
 print_insn_z8002 (addr, info)
-     unsigned long addr;
+     bfd_vma addr;
      disassemble_info *info;
 {
   return print_insn_z8k (addr, info, 0);
@@ -367,8 +371,9 @@ unpack_instr (instr_data, is_segmented, info)
            case ARG_IMMN:
              instr_data->immediate = instr_nibl - 1;
              break;
-             /* ????? */
-             /* missing ARG_IMMNMINUS1 */
+           case ARG_IMM4M1:
+             instr_data->immediate = instr_nibl + 1;
+             break;
            case ARG_IMM_1:
              instr_data->immediate = 1;
              break;
@@ -493,26 +498,26 @@ unparse_instr (instr_data)
       switch (datum_class)
        {
        case CLASS_X:
-         sprintf (tmp_str, "0x%0x(R%d)", instr_data->address,
+         sprintf (tmp_str, "0x%0lx(R%ld)", instr_data->address,
                   instr_data->arg_reg[datum_value]);
          strcat (out_str, tmp_str);
          break;
        case CLASS_BA:
-         sprintf (tmp_str, "r%d(#%x)", instr_data->arg_reg[datum_value],
+         sprintf (tmp_str, "r%ld(#%lx)", instr_data->arg_reg[datum_value],
                   instr_data->immediate);
          strcat (out_str, tmp_str);
          break;
        case CLASS_BX:
-         sprintf (tmp_str, "r%d(R%d)", instr_data->arg_reg[datum_value],
+         sprintf (tmp_str, "r%ld(R%ld)", instr_data->arg_reg[datum_value],
                   instr_data->arg_reg[ARG_RX]);
          strcat (out_str, tmp_str);
          break;
        case CLASS_DISP:
-         sprintf (tmp_str, "#0x%0x", instr_data->displacement);
+         sprintf (tmp_str, "#0x%0lx", instr_data->displacement);
          strcat (out_str, tmp_str);
          break;
        case CLASS_IMM:
-         sprintf (tmp_str, "#0x%0x", instr_data->immediate);
+         sprintf (tmp_str, "#0x%0lx", instr_data->immediate);
          strcat (out_str, tmp_str);
          break;
        case CLASS_CC:
@@ -520,44 +525,44 @@ unparse_instr (instr_data)
          strcat (out_str, tmp_str);
          break;
        case CLASS_CTRL:
-         sprintf (tmp_str, "0x%0x", instr_data->ctrl_code);
+         sprintf (tmp_str, "0x%0lx", instr_data->ctrl_code);
          strcat (out_str, tmp_str);
          break;
        case CLASS_DA:
        case CLASS_ADDRESS:
-         sprintf (tmp_str, "#0x%0x", instr_data->address);
+         sprintf (tmp_str, "#0x%0lx", instr_data->address);
          strcat (out_str, tmp_str);
          break;
        case CLASS_IR:
-         sprintf (tmp_str, "@R%d", instr_data->arg_reg[datum_value]);
+         sprintf (tmp_str, "@R%ld", instr_data->arg_reg[datum_value]);
          strcat (out_str, tmp_str);
          break;
        case CLASS_FLAGS:
-         sprintf (tmp_str, "0x%0x", instr_data->flags);
+         sprintf (tmp_str, "0x%0lx", instr_data->flags);
          strcat (out_str, tmp_str);
          break;
        case CLASS_REG_BYTE:
          if (instr_data->arg_reg[datum_value] >= 0x8)
            {
-             sprintf (tmp_str, "rl%d",
+             sprintf (tmp_str, "rl%ld",
                       instr_data->arg_reg[datum_value] - 0x8);
            }
          else
            {
-             sprintf (tmp_str, "rh%d", instr_data->arg_reg[datum_value]);
+             sprintf (tmp_str, "rh%ld", instr_data->arg_reg[datum_value]);
            }
          strcat (out_str, tmp_str);
          break;
        case CLASS_REG_WORD:
-         sprintf (tmp_str, "r%d", instr_data->arg_reg[datum_value]);
+         sprintf (tmp_str, "r%ld", instr_data->arg_reg[datum_value]);
          strcat (out_str, tmp_str);
          break;
        case CLASS_REG_QUAD:
-         sprintf (tmp_str, "rq%d", instr_data->arg_reg[datum_value]);
+         sprintf (tmp_str, "rq%ld", instr_data->arg_reg[datum_value]);
          strcat (out_str, tmp_str);
          break;
        case CLASS_REG_LONG:
-         sprintf (tmp_str, "rr%d", instr_data->arg_reg[datum_value]);
+         sprintf (tmp_str, "rr%ld", instr_data->arg_reg[datum_value]);
          strcat (out_str, tmp_str);
          break;
        default: