projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
gdb: rename displaced_step_closure to displaced_step_copy_insn_closure
[deliverable/binutils-gdb.git] / gas / config / tc-z8k.c
diff --git a/gas/config/tc-z8k.c b/gas/config/tc-z8k.c
index b914a14f4b6c968478cac35aaf763c721f1605e7..ea4ee3a6b1f3be1d4944621b67eaa74008434199 100644 (file)
--- a/gas/config/tc-z8k.c
+++ b/gas/config/tc-z8k.c
@@ -1,12 +1,11 @@
 /* tc-z8k.c -- Assemble code for the Zilog Z800n
 /* tc-z8k.c -- Assemble code for the Zilog Z800n
-   Copyright 1992, 1993, 1994, 1995, 1996, 1998, 2000, 2001, 2002, 2003,
-   2005 Free Software Foundation, Inc.
+   Copyright (C) 1992-2020 Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.
 
    GAS is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GAS, the GNU Assembler.
 
    GAS is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
+   the Free Software Foundation; either version 3, or (at your option)
    any later version.
 
    GAS is distributed in the hope that it will be useful,
    any later version.
 
    GAS is distributed in the hope that it will be useful,
@@ -16,17 +15,14 @@
 
    You should have received a copy of the GNU General Public License
    along with GAS; see the file COPYING.  If not, write to the Free
 
    You should have received a copy of the GNU General Public License
    along with GAS; see the file COPYING.  If not, write to the Free
-   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA.  */
+   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
+   02110-1301, USA.  */
 
 /* Written By Steve Chamberlain <sac@cygnus.com>.  */
 
 
 /* Written By Steve Chamberlain <sac@cygnus.com>.  */
 
-#define DEFINE_TABLE
-#include <stdio.h>
-
 #include "as.h"
 #include "as.h"
-#include "bfd.h"
 #include "safe-ctype.h"
 #include "safe-ctype.h"
+#define DEFINE_TABLE
 #include "opcodes/z8k-opc.h"
 
 const char comment_chars[] = "!";
 #include "opcodes/z8k-opc.h"
 
 const char comment_chars[] = "!";
@@ -36,9 +32,9 @@ const char line_separator_chars[] = ";";
 extern int machine;
 extern int coff_flags;
 int segmented_mode;
 extern int machine;
 extern int coff_flags;
 int segmented_mode;
-const int md_reloc_size;
 
 
-/* This is non-zero if target was set from the command line.  */
+/* This is non-zero if target was set from the command line.
+   If non-zero, 1 means Z8002 (non-segmented), 2 means Z8001 (segmented).  */
 static int z8k_target_from_cmdline;
 
 static void
 static int z8k_target_from_cmdline;
 
 static void
@@ -47,14 +43,12 @@ s_segm (int segm)
   if (segm)
     {
       segmented_mode = 1;
   if (segm)
     {
       segmented_mode = 1;
-      machine = bfd_mach_z8001;
-      coff_flags = F_Z8001;
+      bfd_set_arch_mach (stdoutput, TARGET_ARCH, bfd_mach_z8001);
     }
   else
     {
       segmented_mode = 0;
     }
   else
     {
       segmented_mode = 0;
-      machine = bfd_mach_z8002;
-      coff_flags = F_Z8002;
+      bfd_set_arch_mach (stdoutput, TARGET_ARCH, bfd_mach_z8002);
     }
 }
 
     }
 }
 
@@ -149,7 +143,7 @@ void
 md_begin (void)
 {
   const opcode_entry_type *opcode;
 md_begin (void)
 {
   const opcode_entry_type *opcode;
-  int idx = -1;
+  unsigned int idx = -1u;
 
   opcode_hash_control = hash_new ();
 
 
   opcode_hash_control = hash_new ();
 
@@ -162,14 +156,13 @@ md_begin (void)
     }
 
   /* Default to z8002.  */
     }
 
   /* Default to z8002.  */
-  if (! z8k_target_from_cmdline)
-    s_segm (0);
+  s_segm (z8k_target_from_cmdline ? z8k_target_from_cmdline - 1 : 0);
 
   /* Insert the pseudo ops, too.  */
   for (idx = 0; md_pseudo_table[idx].poc_name; idx++)
     {
       opcode_entry_type *fake_opcode;
 
   /* Insert the pseudo ops, too.  */
   for (idx = 0; md_pseudo_table[idx].poc_name; idx++)
     {
       opcode_entry_type *fake_opcode;
-      fake_opcode = (opcode_entry_type *) malloc (sizeof (opcode_entry_type));
+      fake_opcode = XNEW (opcode_entry_type);
       fake_opcode->name = md_pseudo_table[idx].poc_name;
       fake_opcode->func = (void *) (md_pseudo_table + idx);
       fake_opcode->opcode = 250;
       fake_opcode->name = md_pseudo_table[idx].poc_name;
       fake_opcode->func = (void *) (md_pseudo_table + idx);
       fake_opcode->opcode = 250;
@@ -202,19 +195,34 @@ static int the_ctrl;
 static int the_flags;
 static int the_interrupt;
 
 static int the_flags;
 static int the_interrupt;
 
+/* Determine register number.  src points to the ascii number
+   (after "rl", "rh", "r", "rr", or "rq").  If a character
+   outside the set of {0,',',')','('} follows the number,
+   return NULL to indicate that it's not a valid register
+   number.  */
+
 static char *
 static char *
-whatreg (int *reg, char *src)
+whatreg (unsigned int *preg, char *src)
 {
 {
+  unsigned int new_reg;
+
+  /* src[0] is already known to be a digit.  */
   if (ISDIGIT (src[1]))
     {
   if (ISDIGIT (src[1]))
     {
-      *reg = (src[0] - '0') * 10 + src[1] - '0';
-      return src + 2;
+      new_reg = (src[0] - '0') * 10 + src[1] - '0';
+      src += 2;
     }
   else
     {
     }
   else
     {
-      *reg = (src[0] - '0');
-      return src + 1;
+      new_reg = (src[0] - '0');
+      src += 1;
     }
     }
+
+  if (src[0] != 0 && src[0] != ',' && src[0] != '(' && src[0] != ')')
+    return NULL;
+
+  *preg = new_reg;
+  return src;
 }
 
 /* Parse operands
 }
 
 /* Parse operands
@@ -235,9 +243,9 @@ whatreg (int *reg, char *src)
    in SRC after the reg name.  */
 
 static char *
    in SRC after the reg name.  */
 
 static char *
-parse_reg (char *src, int *mode, unsigned int *reg)
+parse_reg (char *src, int *mode, unsigned int *preg)
 {
 {
-  char *res = 0;
+  char *res = NULL;
   char regno;
 
   /* Check for stack pointer "sp" alias.  */
   char regno;
 
   /* Check for stack pointer "sp" alias.  */
@@ -248,12 +256,12 @@ parse_reg (char *src, int *mode, unsigned int *reg)
       if (segmented_mode)
        {
          *mode = CLASS_REG_LONG;
       if (segmented_mode)
        {
          *mode = CLASS_REG_LONG;
-         *reg = 14;
+         *preg = 14;
        }
       else
        {
          *mode = CLASS_REG_WORD;
        }
       else
        {
          *mode = CLASS_REG_WORD;
-         *reg = 15;
+         *preg = 15;
        }
       return src + 2;
     }
        }
       return src + 2;
     }
@@ -263,10 +271,12 @@ parse_reg (char *src, int *mode, unsigned int *reg)
       if (src[1] == 'r' || src[1] == 'R')
        {
          if (src[2] < '0' || src[2] > '9')
       if (src[1] == 'r' || src[1] == 'R')
        {
          if (src[2] < '0' || src[2] > '9')
-           return res;  /* Assume no register name but a label starting with 'rr'.  */
+           return NULL;        /* Assume no register name but a label starting with 'rr'.  */
          *mode = CLASS_REG_LONG;
          *mode = CLASS_REG_LONG;
-         res = whatreg (reg, src + 2);
-         regno = *reg;
+         res = whatreg (preg, src + 2);
+         if (res == NULL)
+           return NULL;        /* Not a valid register name.  */
+         regno = *preg;
          if (regno > 14)
            as_bad (_("register rr%d out of range"), regno);
          if (regno & 1)
          if (regno > 14)
            as_bad (_("register rr%d out of range"), regno);
          if (regno & 1)
@@ -275,31 +285,37 @@ parse_reg (char *src, int *mode, unsigned int *reg)
       else if (src[1] == 'h' || src[1] == 'H')
        {
          if (src[2] < '0' || src[2] > '9')
       else if (src[1] == 'h' || src[1] == 'H')
        {
          if (src[2] < '0' || src[2] > '9')
-           return res;  /* Assume no register name but a label starting with 'rh'.  */
+           return NULL;        /* Assume no register name but a label starting with 'rh'.  */
          *mode = CLASS_REG_BYTE;
          *mode = CLASS_REG_BYTE;
-         res = whatreg (reg, src + 2);
-         regno = *reg;
+         res = whatreg (preg, src + 2);
+         if (res == NULL)
+           return NULL;        /* Not a valid register name.  */
+         regno = *preg;
          if (regno > 7)
            as_bad (_("register rh%d out of range"), regno);
        }
       else if (src[1] == 'l' || src[1] == 'L')
        {
          if (src[2] < '0' || src[2] > '9')
          if (regno > 7)
            as_bad (_("register rh%d out of range"), regno);
        }
       else if (src[1] == 'l' || src[1] == 'L')
        {
          if (src[2] < '0' || src[2] > '9')
-           return res;  /* Assume no register name but a label starting with 'rl'.  */
+           return NULL;        /* Assume no register name but a label starting with 'rl'.  */
          *mode = CLASS_REG_BYTE;
          *mode = CLASS_REG_BYTE;
-         res = whatreg (reg, src + 2);
-         regno = *reg;
+         res = whatreg (preg, src + 2);
+         if (res == NULL)
+           return NULL;        /* Not a valid register name.  */
+         regno = *preg;
          if (regno > 7)
            as_bad (_("register rl%d out of range"), regno);
          if (regno > 7)
            as_bad (_("register rl%d out of range"), regno);
-         *reg += 8;
+         *preg += 8;
        }
       else if (src[1] == 'q' || src[1] == 'Q')
        {
          if (src[2] < '0' || src[2] > '9')
        }
       else if (src[1] == 'q' || src[1] == 'Q')
        {
          if (src[2] < '0' || src[2] > '9')
-           return res;  /* Assume no register name but a label starting with 'rq'.  */
+           return NULL;        /* Assume no register name but a label starting with 'rq'.  */
          *mode = CLASS_REG_QUAD;
          *mode = CLASS_REG_QUAD;
-         res = whatreg (reg, src + 2);
-         regno = *reg;
+         res = whatreg (preg, src + 2);
+         if (res == NULL)
+           return NULL;        /* Not a valid register name.  */
+         regno = *preg;
          if (regno > 12)
            as_bad (_("register rq%d out of range"), regno);
          if (regno & 3)
          if (regno > 12)
            as_bad (_("register rq%d out of range"), regno);
          if (regno & 3)
@@ -308,10 +324,12 @@ parse_reg (char *src, int *mode, unsigned int *reg)
       else
        {
          if (src[1] < '0' || src[1] > '9')
       else
        {
          if (src[1] < '0' || src[1] > '9')
-           return res;  /* Assume no register name but a label starting with 'r'.  */
+           return NULL;        /* Assume no register name but a label starting with 'r'.  */
          *mode = CLASS_REG_WORD;
          *mode = CLASS_REG_WORD;
-         res = whatreg (reg, src + 1);
-         regno = *reg;
+         res = whatreg (preg, src + 1);
+         if (res == NULL)
+           return NULL;        /* Not a valid register name.  */
+         regno = *preg;
          if (regno > 15)
            as_bad (_("register r%d out of range"), regno);
        }
          if (regno > 15)
            as_bad (_("register r%d out of range"), regno);
        }
@@ -323,15 +341,15 @@ static char *
 parse_exp (char *s, expressionS *op)
 {
   char *save = input_line_pointer;
 parse_exp (char *s, expressionS *op)
 {
   char *save = input_line_pointer;
-  char *new;
+  char *new_pointer;
 
   input_line_pointer = s;
   expression (op);
   if (op->X_op == O_absent)
     as_bad (_("missing operand"));
 
   input_line_pointer = s;
   expression (op);
   if (op->X_op == O_absent)
     as_bad (_("missing operand"));
-  new = input_line_pointer;
+  new_pointer = input_line_pointer;
   input_line_pointer = save;
   input_line_pointer = save;
-  return new;
+  return new_pointer;
 }
 
 /* The many forms of operand:
 }
 
 /* The many forms of operand:
@@ -362,7 +380,7 @@ checkfor (char *ptr, char what)
 /* Make sure the mode supplied is the size of a word.  */
 
 static void
 /* Make sure the mode supplied is the size of a word.  */
 
 static void
-regword (int mode, char *string)
+regword (int mode, const char *string)
 {
   int ok;
 
 {
   int ok;
 
@@ -376,7 +394,7 @@ regword (int mode, char *string)
 /* Make sure the mode supplied is the size of an address.  */
 
 static void
 /* Make sure the mode supplied is the size of an address.  */
 
 static void
-regaddr (int mode, char *string)
+regaddr (int mode, const char *string)
 {
   int ok;
 
 {
   int ok;
 
@@ -389,7 +407,7 @@ regaddr (int mode, char *string)
 
 struct ctrl_names {
   int value;
 
 struct ctrl_names {
   int value;
-  char *name;
+  const char *name;
 };
 
 static struct ctrl_names ctrl_table[] = {
 };
 
 static struct ctrl_names ctrl_table[] = {
@@ -432,7 +450,7 @@ get_ctrl_operand (char **ptr, struct z8k_op *mode, unsigned int dst ATTRIBUTE_UN
 
 struct flag_names {
   int value;
 
 struct flag_names {
   int value;
-  char *name;
+  const char *name;
 };
 
 static struct flag_names flag_table[] = {
 };
 
 static struct flag_names flag_table[] = {
@@ -482,7 +500,7 @@ get_flags_operand (char **ptr, struct z8k_op *mode, unsigned int dst ATTRIBUTE_U
 
 struct interrupt_names {
   int value;
 
 struct interrupt_names {
   int value;
-  char *name;
+  const char *name;
 };
 
 static struct interrupt_names intr_table[] = {
 };
 
 static struct interrupt_names intr_table[] = {
@@ -546,7 +564,7 @@ get_interrupt_operand (char **ptr, struct z8k_op *mode, unsigned int dst ATTRIBU
 
 struct cc_names {
   int value;
 
 struct cc_names {
   int value;
-  char *name;
+  const char *name;
 };
 
 static struct cc_names table[] = {
 };
 
 static struct cc_names table[] = {
@@ -631,13 +649,14 @@ get_operand (char **ptr, struct z8k_op *mode, unsigned int dst ATTRIBUTE_UNUSED)
     }
   else
     {
     }
   else
     {
-      int regn;
+      unsigned int regn;
 
       end = parse_reg (src, &mode->mode, &regn);
 
       if (end)
        {
 
       end = parse_reg (src, &mode->mode, &regn);
 
       if (end)
        {
-         int nw, nr;
+         int nw;
+         unsigned int nr;
 
          src = end;
          if (*src == '(')
 
          src = end;
          if (*src == '(')
@@ -655,9 +674,6 @@ get_operand (char **ptr, struct z8k_op *mode, unsigned int dst ATTRIBUTE_UNUSED)
                    src++;
 
                  regaddr (mode->mode, "ra(rb) ra");
                    src++;
 
                  regaddr (mode->mode, "ra(rb) ra");
-#if 0
-                 regword (mode->mode, "ra(rb) rb");
-#endif
                  mode->mode = CLASS_BX;
                  mode->reg = regn;
                  mode->x_reg = nr;
                  mode->mode = CLASS_BX;
                  mode->reg = regn;
                  mode->x_reg = nr;
@@ -845,7 +861,7 @@ get_specific (opcode_entry_type *opcode, op_type *operands)
   int found = 0;
   unsigned int noperands = opcode->noperands;
 
   int found = 0;
   unsigned int noperands = opcode->noperands;
 
-  int this_index = opcode->idx;
+  unsigned int this_index = opcode->idx;
 
   while (this_index == opcode->idx && !found)
     {
 
   while (this_index == opcode->idx && !found)
     {
@@ -940,34 +956,37 @@ get_specific (opcode_entry_type *opcode, op_type *operands)
 static char buffer[20];
 
 static void
 static char buffer[20];
 
 static void
-newfix (int ptr, int type, int size, expressionS *operand)
+newfix (int ptr, bfd_reloc_code_real_type type, int size, expressionS *operand)
 {
 {
-  int is_pcrel = 0;
-
-  /* size is in nibbles.  */
+  fixS *fixP;
 
 
+  /* Size is in nibbles.  */
   if (operand->X_add_symbol
       || operand->X_op_symbol
       || operand->X_add_number)
     {
   if (operand->X_add_symbol
       || operand->X_op_symbol
       || operand->X_add_number)
     {
+      int is_pcrel;
       switch(type)
         {
       switch(type)
         {
-        case R_JR:
-        case R_DISP7:
-        case R_CALLR:
+        case BFD_RELOC_8_PCREL:
+        case BFD_RELOC_Z8K_CALLR:
+        case BFD_RELOC_Z8K_DISP7:
           is_pcrel = 1;
           is_pcrel = 1;
+         break;
+       default:
+         is_pcrel = 0;
+         break;
         }
         }
-      fix_new_exp (frag_now,
-                  ptr,
-                  size / 2,
-                  operand,
-                  is_pcrel,
-                  type);
+      fixP = fix_new_exp (frag_now, ptr, size / 2,
+                          operand, is_pcrel, type);
+      if (is_pcrel)
+       fixP->fx_no_overflow = 1;
     }
 }
 
 static char *
     }
 }
 
 static char *
-apply_fix (char *ptr, int type, expressionS *operand, int size)
+apply_fix (char *ptr, bfd_reloc_code_real_type type, expressionS *operand,
+          int size)
 {
   long n = operand->X_add_number;
 
 {
   long n = operand->X_add_number;
 
@@ -981,11 +1000,14 @@ apply_fix (char *ptr, int type, expressionS *operand, int size)
       *ptr++ = n >> 24;
       *ptr++ = n >> 20;
       *ptr++ = n >> 16;
       *ptr++ = n >> 24;
       *ptr++ = n >> 20;
       *ptr++ = n >> 16;
+      /* Fall through.  */
     case 4:                    /* 4 nibbles == 16 bits.  */
       *ptr++ = n >> 12;
       *ptr++ = n >> 8;
     case 4:                    /* 4 nibbles == 16 bits.  */
       *ptr++ = n >> 12;
       *ptr++ = n >> 8;
+      /* Fall through.  */
     case 2:
       *ptr++ = n >> 4;
     case 2:
       *ptr++ = n >> 4;
+      /* Fall through.  */
     case 1:
       *ptr++ = n >> 0;
       break;
     case 1:
       *ptr++ = n >> 0;
       break;
@@ -1006,6 +1028,9 @@ build_bytes (opcode_entry_type *this_try, struct z8k_op *operand ATTRIBUTE_UNUSE
   frag_wane (frag_now);
   frag_new (0);
 
   frag_wane (frag_now);
   frag_new (0);
 
+  if (frag_room () < 8)
+    frag_grow (8);  /* Make room for maximum instruction size.  */
+
   memset (buffer, 0, sizeof (buffer));
   class_ptr = this_try->byte_info;
 
   memset (buffer, 0, sizeof (buffer));
   class_ptr = this_try->byte_info;
 
@@ -1022,31 +1047,31 @@ build_bytes (opcode_entry_type *this_try, struct z8k_op *operand ATTRIBUTE_UNUSE
          if (segmented_mode)
            {
              /* da_operand->X_add_number |= 0x80000000;  --  Now set at relocation time.  */
          if (segmented_mode)
            {
              /* da_operand->X_add_number |= 0x80000000;  --  Now set at relocation time.  */
-             output_ptr = apply_fix (output_ptr, R_IMM32, da_operand, 8);
+             output_ptr = apply_fix (output_ptr, BFD_RELOC_32, da_operand, 8);
            }
          else
            {
            }
          else
            {
-             output_ptr = apply_fix (output_ptr, R_IMM16, da_operand, 4);
+             output_ptr = apply_fix (output_ptr, BFD_RELOC_16, da_operand, 4);
            }
          da_operand = 0;
          break;
        case CLASS_DISP8:
          /* pc rel 8 bit  */
            }
          da_operand = 0;
          break;
        case CLASS_DISP8:
          /* pc rel 8 bit  */
-         output_ptr = apply_fix (output_ptr, R_JR, da_operand, 2);
+         output_ptr = apply_fix (output_ptr, BFD_RELOC_8_PCREL, da_operand, 2);
          da_operand = 0;
          break;
 
        case CLASS_0DISP7:
          /* pc rel 7 bit  */
          *output_ptr = 0;
          da_operand = 0;
          break;
 
        case CLASS_0DISP7:
          /* pc rel 7 bit  */
          *output_ptr = 0;
-         output_ptr = apply_fix (output_ptr, R_DISP7, da_operand, 2);
+         output_ptr = apply_fix (output_ptr, BFD_RELOC_Z8K_DISP7, da_operand, 2);
          da_operand = 0;
          break;
 
        case CLASS_1DISP7:
          /* pc rel 7 bit  */
          *output_ptr = 0x80;
          da_operand = 0;
          break;
 
        case CLASS_1DISP7:
          /* pc rel 7 bit  */
          *output_ptr = 0x80;
-         output_ptr = apply_fix (output_ptr, R_DISP7, da_operand, 2);
+         output_ptr = apply_fix (output_ptr, BFD_RELOC_Z8K_DISP7, da_operand, 2);
          output_ptr[-2] = 0x8;
          da_operand = 0;
          break;
          output_ptr[-2] = 0x8;
          da_operand = 0;
          break;
@@ -1099,20 +1124,20 @@ build_bytes (opcode_entry_type *this_try, struct z8k_op *operand ATTRIBUTE_UNUSE
        case CLASS_REG_WORD:
        case CLASS_REG_LONG:
        case CLASS_REG_QUAD:
        case CLASS_REG_WORD:
        case CLASS_REG_LONG:
        case CLASS_REG_QUAD:
-         /* Insert bit mattern of right reg.  */
+         /* Insert bit pattern of right reg.  */
          *output_ptr++ = reg[c & 0xf];
          break;
        case CLASS_DISP:
           switch (c & ARG_MASK)
             {
             case ARG_DISP12:
          *output_ptr++ = reg[c & 0xf];
          break;
        case CLASS_DISP:
           switch (c & ARG_MASK)
             {
             case ARG_DISP12:
-              output_ptr = apply_fix (output_ptr, R_CALLR, da_operand, 4);
+              output_ptr = apply_fix (output_ptr, BFD_RELOC_Z8K_CALLR, da_operand, 4);
               break;
             case ARG_DISP16:
               break;
             case ARG_DISP16:
-             output_ptr = apply_fix (output_ptr, R_REL16, da_operand, 4);
+             output_ptr = apply_fix (output_ptr, BFD_RELOC_16_PCREL, da_operand, 4);
              break;
            default:
              break;
            default:
-             output_ptr = apply_fix (output_ptr, R_IMM16, da_operand, 4);
+             output_ptr = apply_fix (output_ptr, BFD_RELOC_16, da_operand, 4);
            }
          da_operand = 0;
          break;
            }
          da_operand = 0;
          break;
@@ -1123,34 +1148,30 @@ build_bytes (opcode_entry_type *this_try, struct z8k_op *operand ATTRIBUTE_UNUSE
              {
              case ARG_NIM4:
                 if (imm_operand->X_add_number > 15)
              {
              case ARG_NIM4:
                 if (imm_operand->X_add_number > 15)
-                  {
-                    as_bad (_("immediate value out of range"));
-                  }
+                 as_bad (_("immediate value out of range"));
                imm_operand->X_add_number = -imm_operand->X_add_number;
                imm_operand->X_add_number = -imm_operand->X_add_number;
-               output_ptr = apply_fix (output_ptr, R_IMM4L, imm_operand, 1);
+               output_ptr = apply_fix (output_ptr, BFD_RELOC_Z8K_IMM4L, imm_operand, 1);
                break;
               /*case ARG_IMMNMINUS1: not used.  */
              case ARG_IMM4M1:
                imm_operand->X_add_number--;
                break;
               /*case ARG_IMMNMINUS1: not used.  */
              case ARG_IMM4M1:
                imm_operand->X_add_number--;
-                /* Drop through.  */
+                /* Fall through.  */
              case ARG_IMM4:
                 if (imm_operand->X_add_number > 15)
              case ARG_IMM4:
                 if (imm_operand->X_add_number > 15)
-                  {
-                    as_bad (_("immediate value out of range"));
-                  }
-               output_ptr = apply_fix (output_ptr, R_IMM4L, imm_operand, 1);
+                 as_bad (_("immediate value out of range"));
+               output_ptr = apply_fix (output_ptr, BFD_RELOC_Z8K_IMM4L, imm_operand, 1);
                break;
              case ARG_NIM8:
                imm_operand->X_add_number = -imm_operand->X_add_number;
                break;
              case ARG_NIM8:
                imm_operand->X_add_number = -imm_operand->X_add_number;
-                /* Drop through.  */
+                /* Fall through.  */
              case ARG_IMM8:
              case ARG_IMM8:
-               output_ptr = apply_fix (output_ptr, R_IMM8, imm_operand, 2);
+               output_ptr = apply_fix (output_ptr, BFD_RELOC_8, imm_operand, 2);
                break;
              case ARG_IMM16:
                break;
              case ARG_IMM16:
-               output_ptr = apply_fix (output_ptr, R_IMM16, imm_operand, 4);
+               output_ptr = apply_fix (output_ptr, BFD_RELOC_16, imm_operand, 4);
                break;
              case ARG_IMM32:
                break;
              case ARG_IMM32:
-               output_ptr = apply_fix (output_ptr, R_IMM32, imm_operand, 8);
+               output_ptr = apply_fix (output_ptr, BFD_RELOC_32, imm_operand, 8);
                break;
              default:
                abort ();
                break;
              default:
                abort ();
@@ -1184,7 +1205,7 @@ md_assemble (char *str)
   char c;
   char *op_start;
   char *op_end;
   char c;
   char *op_start;
   char *op_end;
-  struct z8k_op operand[3];
+  struct z8k_op operand[4];
   opcode_entry_type *opcode;
 
   /* Drop leading whitespace.  */
   opcode_entry_type *opcode;
 
   /* Drop leading whitespace.  */
@@ -1241,11 +1262,12 @@ md_assemble (char *str)
 
       new_input_line_pointer = get_operands (opcode, op_end, operand);
       if (new_input_line_pointer)
 
       new_input_line_pointer = get_operands (opcode, op_end, operand);
       if (new_input_line_pointer)
-        input_line_pointer = new_input_line_pointer;
-
-      opcode = get_specific (opcode, operand);
+        {
+          input_line_pointer = new_input_line_pointer;
+          opcode = get_specific (opcode, operand);
+        }
 
 
-      if (opcode == 0)
+      if (new_input_line_pointer == NULL || opcode == NULL)
        {
          /* Couldn't find an opcode which matched the operands.  */
          char *where = frag_more (2);
        {
          /* Couldn't find an opcode which matched the operands.  */
          char *where = frag_more (2);
@@ -1261,12 +1283,6 @@ md_assemble (char *str)
     }
 }
 
     }
 }
 
-void
-tc_crawl_symbol_chain (object_headers *headers ATTRIBUTE_UNUSED)
-{
-  printf (_("call to tc_crawl_symbol_chain \n"));
-}
-
 /* We have no need to default values of symbols.  */
 
 symbolS *
 /* We have no need to default values of symbols.  */
 
 symbolS *
@@ -1275,70 +1291,12 @@ md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
   return 0;
 }
 
   return 0;
 }
 
-void
-tc_headers_hook (object_headers *headers ATTRIBUTE_UNUSED)
-{
-  printf (_("call to tc_headers_hook \n"));
-}
-
 /* Various routines to kill one day.  */
 /* Various routines to kill one day.  */
-/* Equal to MAX_PRECISION in atof-ieee.c.  */
-#define MAX_LITTLENUMS 6
-
-/* Turn a string in input_line_pointer into a floating point constant
-   of type TYPE, and store the appropriate bytes in *LITP.  The number
-   of LITTLENUMS emitted is stored in *SIZEP.  An error message is
-   returned, or NULL on OK.  */
 
 
-char *
+const char *
 md_atof (int type, char *litP, int *sizeP)
 {
 md_atof (int type, char *litP, int *sizeP)
 {
-  int prec;
-  LITTLENUM_TYPE words[MAX_LITTLENUMS];
-  LITTLENUM_TYPE *wordP;
-  char *t;
-
-  switch (type)
-    {
-    case 'f':
-    case 'F':
-    case 's':
-    case 'S':
-      prec = 2;
-      break;
-
-    case 'd':
-    case 'D':
-    case 'r':
-    case 'R':
-      prec = 4;
-      break;
-
-    case 'x':
-    case 'X':
-      prec = 6;
-      break;
-
-    case 'p':
-    case 'P':
-      prec = 6;
-      break;
-
-    default:
-      *sizeP = 0;
-      return _("Bad call to MD_ATOF()");
-    }
-  t = atof_ieee (input_line_pointer, type, words);
-  if (t)
-    input_line_pointer = t;
-
-  *sizeP = prec * sizeof (LITTLENUM_TYPE);
-  for (wordP = words; prec--;)
-    {
-      md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
-      litP += sizeof (LITTLENUM_TYPE);
-    }
-  return 0;
+  return ieee_md_atof (type, litP, sizeP, TRUE);
 }
 \f
 const char *md_shortopts = "z:";
 }
 \f
 const char *md_shortopts = "z:";
@@ -1353,21 +1311,20 @@ struct option md_longopts[] =
 size_t md_longopts_size = sizeof (md_longopts);
 
 int
 size_t md_longopts_size = sizeof (md_longopts);
 
 int
-md_parse_option (int c, char *arg)
+md_parse_option (int c, const char *arg)
 {
   switch (c)
     {
     case 'z':
       if (!strcmp (arg, "8001"))
 {
   switch (c)
     {
     case 'z':
       if (!strcmp (arg, "8001"))
-       s_segm (1);
+       z8k_target_from_cmdline = 2;
       else if (!strcmp (arg, "8002"))
       else if (!strcmp (arg, "8002"))
-       s_segm (0);
+       z8k_target_from_cmdline = 1;
       else
        {
          as_bad (_("invalid architecture -z%s"), arg);
          return 0;
        }
       else
        {
          as_bad (_("invalid architecture -z%s"), arg);
          return 0;
        }
-      z8k_target_from_cmdline = 1;
       break;
 
     case OPTION_RELAX:
       break;
 
     case OPTION_RELAX:
@@ -1392,37 +1349,108 @@ md_show_usage (FILE *stream)
 }
 \f
 void
 }
 \f
 void
-md_convert_frag (object_headers *headers ATTRIBUTE_UNUSED,
-                 segT seg ATTRIBUTE_UNUSED,
+md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
+                 segT sec ATTRIBUTE_UNUSED,
                  fragS *fragP ATTRIBUTE_UNUSED)
 {
   printf (_("call to md_convert_frag\n"));
   abort ();
 }
 
                  fragS *fragP ATTRIBUTE_UNUSED)
 {
   printf (_("call to md_convert_frag\n"));
   abort ();
 }
 
+/* Generate a machine dependent reloc from a fixup.  */
+
+arelent*
+tc_gen_reloc (asection *section ATTRIBUTE_UNUSED,
+             fixS *fixp      ATTRIBUTE_UNUSED)
+{
+  arelent *reloc;
+
+  reloc = XNEW (arelent);
+  reloc->sym_ptr_ptr = XNEW (asymbol *);
+  *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
+  reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
+  reloc->addend = fixp->fx_offset;
+  reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
+
+  if (! reloc->howto)
+    {
+      as_bad_where (fixp->fx_file, fixp->fx_line,
+                    _("Cannot represent %s relocation in object file"),
+                    bfd_get_reloc_code_name (fixp->fx_r_type));
+      abort ();
+    }
+  return reloc;
+}
+
 valueT
 md_section_align (segT seg, valueT size)
 {
 valueT
 md_section_align (segT seg, valueT size)
 {
-  return ((size + (1 << section_alignment[(int) seg]) - 1)
-         & (-1 << section_alignment[(int) seg]));
+  int align = bfd_section_alignment (seg);
+  valueT mask = ((valueT) 1 << align) - 1;
+
+  return (size + mask) & ~mask;
 }
 
 /* Attempt to simplify or eliminate a fixup. To indicate that a fixup
    has been eliminated, set fix->fx_done. If fix->fx_addsy is non-NULL,
    we will have to generate a reloc entry.  */
 void
 }
 
 /* Attempt to simplify or eliminate a fixup. To indicate that a fixup
    has been eliminated, set fix->fx_done. If fix->fx_addsy is non-NULL,
    we will have to generate a reloc entry.  */
 void
-md_apply_fix3 (fixS *fixP, valueT *valP, segT segment ATTRIBUTE_UNUSED)
+md_apply_fix (fixS *fixP, valueT *valP, segT segment ATTRIBUTE_UNUSED)
 {
   long val = * (long *) valP;
   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
 
   switch (fixP->fx_r_type)
     {
 {
   long val = * (long *) valP;
   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
 
   switch (fixP->fx_r_type)
     {
-    case R_IMM4L:
-      buf[0] = (buf[0] & 0xf0) | (val & 0xf);
+    case BFD_RELOC_Z8K_IMM4L:
+      if (fixP->fx_addsy)
+        {
+          fixP->fx_no_overflow = 1;
+          fixP->fx_done = 0;
+        }
+      else
+       buf[0] = (buf[0] & 0xf0) | (val & 0xf);
+      break;
+
+    case BFD_RELOC_8:
+      if (fixP->fx_addsy)
+        {
+          fixP->fx_no_overflow = 1;
+          fixP->fx_done = 0;
+        }
+      else
+       *buf++ = val;
       break;
 
       break;
 
-    case R_JR:
+    case BFD_RELOC_16:
+      if (fixP->fx_addsy)
+        {
+          fixP->fx_no_overflow = 1;
+          fixP->fx_done = 0;
+        }
+      else
+        {
+          *buf++ = (val >> 8);
+          *buf++ = val;
+        }
+      break;
+
+    case BFD_RELOC_32:
+      if (fixP->fx_addsy)
+        {
+          fixP->fx_no_overflow = 1;
+          fixP->fx_done = 0;
+        }
+      else
+        {
+          *buf++ = (val >> 24);
+          *buf++ = (val >> 16);
+          *buf++ = (val >> 8);
+          *buf++ = val;
+        }
+      break;
+
+    case BFD_RELOC_8_PCREL:
       if (fixP->fx_addsy)
         {
           fixP->fx_no_overflow = 1;
       if (fixP->fx_addsy)
         {
           fixP->fx_no_overflow = 1;
@@ -1443,7 +1471,7 @@ md_apply_fix3 (fixS *fixP, valueT *valP, segT segment ATTRIBUTE_UNUSED)
         }
       break;
 
         }
       break;
 
-    case R_DISP7:
+    case BFD_RELOC_16_PCREL:
       if (fixP->fx_addsy)
         {
           fixP->fx_no_overflow = 1;
       if (fixP->fx_addsy)
         {
           fixP->fx_no_overflow = 1;
@@ -1451,20 +1479,18 @@ md_apply_fix3 (fixS *fixP, valueT *valP, segT segment ATTRIBUTE_UNUSED)
         }
       else
         {
         }
       else
         {
-          if (val & 1)
+          val = val - fixP->fx_frag->fr_address + fixP->fx_where - fixP->fx_size;
+          if (val > 32767 || val < -32768)
             as_bad_where (fixP->fx_file, fixP->fx_line,
             as_bad_where (fixP->fx_file, fixP->fx_line,
-                          _("cannot branch to odd address"));
-          val /= 2;
-          if (val > 0 || val < -127)
-            as_bad_where (fixP->fx_file, fixP->fx_line,
-                          _("relative jump out of range"));
-          *buf = (*buf & 0x80) | (-val & 0x7f);
+                          _("relative address out of range"));
+          *buf++ = (val >> 8);
+          *buf++ = val;
           fixP->fx_no_overflow = 1;
           fixP->fx_done = 1;
         }
       break;
 
           fixP->fx_no_overflow = 1;
           fixP->fx_done = 1;
         }
       break;
 
-    case R_CALLR:
+    case BFD_RELOC_Z8K_CALLR:
       if (fixP->fx_addsy)
         {
           fixP->fx_no_overflow = 1;
       if (fixP->fx_addsy)
         {
           fixP->fx_no_overflow = 1;
@@ -1487,47 +1513,29 @@ md_apply_fix3 (fixS *fixP, valueT *valP, segT segment ATTRIBUTE_UNUSED)
         }
       break;
 
         }
       break;
 
-    case R_IMM8:
-      *buf++ = val;
-      break;
-
-    case R_IMM16:
-      *buf++ = (val >> 8);
-      *buf++ = val;
-      break;
-
-    case R_IMM32:
-      *buf++ = (val >> 24);
-      *buf++ = (val >> 16);
-      *buf++ = (val >> 8);
-      *buf++ = val;
-      break;
-
-    case R_REL16:
-      val = val - fixP->fx_frag->fr_address + fixP->fx_where - fixP->fx_size;
-      if (val > 32767 || val < -32768)
-        as_bad_where (fixP->fx_file, fixP->fx_line,
-                      _("relative address out of range"));
-      *buf++ = (val >> 8);
-      *buf++ = val;
-      fixP->fx_no_overflow = 1;
-      break;
-
-#if 0
-    case R_DA | R_SEG:
-      *buf++ = (val >> 16);
-      *buf++ = 0x00;
-      *buf++ = (val >> 8);
-      *buf++ = val;
-      break;
-#endif
-
-    case 0:
-      md_number_to_chars (buf, val, fixP->fx_size);
+    case BFD_RELOC_Z8K_DISP7:
+      if (fixP->fx_addsy)
+        {
+          fixP->fx_no_overflow = 1;
+          fixP->fx_done = 0;
+        }
+      else
+        {
+          if (val & 1)
+            as_bad_where (fixP->fx_file, fixP->fx_line,
+                          _("cannot branch to odd address"));
+          val /= 2;
+          if (val > 0 || val < -127)
+            as_bad_where (fixP->fx_file, fixP->fx_line,
+                          _("relative jump out of range"));
+          *buf = (*buf & 0x80) | (-val & 0x7f);
+          fixP->fx_no_overflow = 1;
+          fixP->fx_done = 1;
+        }
       break;
 
     default:
       break;
 
     default:
-      printf(_("md_apply_fix3: unknown r_type 0x%x\n"), fixP->fx_r_type);
+      printf(_("md_apply_fix: unknown r_type 0x%x\n"), fixP->fx_r_type);
       abort ();
     }
 
       abort ();
     }
 
@@ -1563,60 +1571,3 @@ void
 tc_coff_symbol_emit_hook (symbolS *s ATTRIBUTE_UNUSED)
 {
 }
 tc_coff_symbol_emit_hook (symbolS *s ATTRIBUTE_UNUSED)
 {
 }
-
-void
-tc_reloc_mangle (fixS *fix_ptr, struct internal_reloc *intr, bfd_vma base)
-{
-  symbolS *symbol_ptr;
-
-  if (fix_ptr->fx_addsy
-      && fix_ptr->fx_subsy)
-    {
-      symbolS *add = fix_ptr->fx_addsy;
-      symbolS *sub = fix_ptr->fx_subsy;
-
-      if (S_GET_SEGMENT (add) != S_GET_SEGMENT (sub))
-       as_bad (_("Can't subtract symbols in different sections %s %s"),
-               S_GET_NAME (add), S_GET_NAME (sub));
-      else
-       {
-         int diff = S_GET_VALUE (add) - S_GET_VALUE (sub);
-
-         fix_ptr->fx_addsy = 0;
-         fix_ptr->fx_subsy = 0;
-         fix_ptr->fx_offset += diff;
-       }
-    }
-  symbol_ptr = fix_ptr->fx_addsy;
-
-  /* If this relocation is attached to a symbol then it's ok
-     to output it.  */
-  if (fix_ptr->fx_r_type == 0)
-    {
-      /* cons likes to create reloc32's whatever the size of the reloc.  */
-      switch (fix_ptr->fx_size)
-       {
-       case 2:
-         intr->r_type = R_IMM16;
-         break;
-       case 1:
-         intr->r_type = R_IMM8;
-         break;
-       case 4:
-         intr->r_type = R_IMM32;
-         break;
-       default:
-         abort ();
-       }
-    }
-  else
-    intr->r_type = fix_ptr->fx_r_type;
-
-  intr->r_vaddr = fix_ptr->fx_frag->fr_address + fix_ptr->fx_where + base;
-  intr->r_offset = fix_ptr->fx_offset;
-
-  if (symbol_ptr)
-    intr->r_symndx = symbol_ptr->sy_number;
-  else
-    intr->r_symndx = -1;
-}
GDB Binutils - Deliverables
This page took 0.069104 seconds and 4 git commands to generate.