projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* config/tc-h8300.c (md_assemble): Make sure characters after
[deliverable/binutils-gdb.git] / gas / config / tc-w65.c
diff --git a/gas/config/tc-w65.c b/gas/config/tc-w65.c
index 2c6d85a3a619da1db0886c131a308a7b990b8604..82f39f865c9f2c3d64e6fa35be1eae3c9c32561a 100644 (file)
--- a/gas/config/tc-w65.c
+++ b/gas/config/tc-w65.c
@@ -1,5 +1,5 @@
 /* tc-w65.c -- Assemble code for the W65816
 /* tc-w65.c -- Assemble code for the W65816
-   Copyright (C) 1995, 1998, 2000 Free Software Foundation.
+   Copyright 1995, 1998, 2000, 2001, 2002 Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.
 
 
    This file is part of GAS, the GNU Assembler.
 
@@ -18,10 +18,7 @@
    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    02111-1307, USA.  */
 
    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    02111-1307, USA.  */
 
-/*
-   Written By Steve Chamberlain
-   sac@cygnus.com
- */
+/* Written By Steve Chamberlain <sac@cygnus.com>.  */
 
 #include <stdio.h>
 #include "as.h"
 
 #include <stdio.h>
 #include "as.h"
@@ -29,18 +26,17 @@
 #include "subsegs.h"
 #define DEFINE_TABLE
 #include "../opcodes/w65-opc.h"
 #include "subsegs.h"
 #define DEFINE_TABLE
 #include "../opcodes/w65-opc.h"
-#include <ctype.h>
 
 const char comment_chars[] = "!";
 
 const char comment_chars[] = "!";
-CONST char line_separator_chars[] = ";";
+const char line_separator_chars[] = ";";
 const char line_comment_chars[] = "!#";
 
 /* This table describes all the machine specific pseudo-ops the assembler
    has to support.  The fields are:
 const char line_comment_chars[] = "!#";
 
 /* This table describes all the machine specific pseudo-ops the assembler
    has to support.  The fields are:
+
    pseudo-op name without dot
    function to call to execute this pseudo-op
    pseudo-op name without dot
    function to call to execute this pseudo-op
-   Integer arg to pass to the function
- */
+   Integer arg to pass to the function  */
 
 #define OP_BCC 0x90
 #define OP_BCS 0xB0
 
 #define OP_BCC 0x90
 #define OP_BCS 0xB0
@@ -53,9 +49,14 @@ const char line_comment_chars[] = "!#";
 #define OP_BVC 0x50
 #define OP_BVS 0x70
 
 #define OP_BVC 0x50
 #define OP_BVS 0x70
 
-void s_longa ();
-const pseudo_typeS md_pseudo_table[] =
-{
+static void s_longa PARAMS ((int));
+static char *parse_exp PARAMS ((char *));
+static char *get_operands PARAMS ((const struct opinfo *, char *));
+static const struct opinfo *get_specific PARAMS ((const struct opinfo *));
+static void build_Mytes PARAMS ((const struct opinfo *));
+
+
+const pseudo_typeS md_pseudo_table[] = {
   {"int", cons, 2},
   {"word", cons, 2},
   {"longa", s_longa, 0},
   {"int", cons, 2},
   {"word", cons, 2},
   {"longa", s_longa, 0},
@@ -63,32 +64,23 @@ const pseudo_typeS md_pseudo_table[] =
   {0, 0, 0}
 };
 
   {0, 0, 0}
 };
 
-
-void cons ();
-void s_align_bytes ();
-
-
-/*int md_reloc_size; */
-
-static int relax;              /* set if -relax seen */
+#if 0
+int md_reloc_size;
+#endif
 
 const char EXP_CHARS[] = "eE";
 
 
 const char EXP_CHARS[] = "eE";
 
-/* Chars that mean this number is a floating point constant */
+/* Chars that mean this number is a floating point constant.  */
 /* As in 0f12.456 */
 /* or    0d1.2345e12 */
 const char FLT_CHARS[] = "rRsSfFdDxXpP";
 
 /* As in 0f12.456 */
 /* or    0d1.2345e12 */
 const char FLT_CHARS[] = "rRsSfFdDxXpP";
 
-
-
-static struct hash_control *opcode_hash_control;       /* Opcode mnemonics */
+/* Opcode mnemonics */
+static struct hash_control *opcode_hash_control;
 
 int M;                         /* M flag */
 int X;                         /* X flag */
 
 
 int M;                         /* M flag */
 int X;                         /* X flag */
 
-
-
-
 #define C(a,b) ENCODE_RELAX(a,b)
 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
 
 #define C(a,b) ENCODE_RELAX(a,b)
 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
 
@@ -108,16 +100,33 @@ int X;                            /* X flag */
 #define WORD_F 32767
 #define WORD_B 32768
 
 #define WORD_F 32767
 #define WORD_B 32768
 
-relax_typeS md_relax_table[C (END, 0)];
+relax_typeS md_relax_table[C (END, 0)] = {
+  { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 },
 
 
-/*
-   This function is called once, at assembler startup time.  This should
-   set up all the tables, etc that the MD part of the assembler needs
- */
+  /* COND_BRANCH */
+  { 0,       0,       0,  0 },                         /* UNDEF_BYTE_DISP */
+  { BYTE_F,  BYTE_B,  2,  C (COND_BRANCH, WORD_DISP) },        /* BYTE_DISP */
+  { WORD_F,  WORD_B,  5,  0 },                         /* WORD_DISP */
+  { 0,       0,       5,  0 },                         /* UNDEF_WORD_DISP */
 
 
+  /* UNCOND_BRANCH */
+  { 0,       0,       0,  0 },                           /* UNDEF_BYTE_DISP */
+  { BYTE_F,  BYTE_B,  2,  C (UNCOND_BRANCH, WORD_DISP) }, /* BYTE_DISP */
+  { WORD_F,  WORD_B,  3,  0 },                           /* WORD_DISP */
+  { 0,       0,       3,  0 }                            /* UNDEF_WORD_DISP */
 
 
-void
+};
+
+/* This function is called once, at assembler startup time.  This
+   should set up all the tables, etc that the MD part of the assembler
+   needs.  */
+
+static void
 s_longa (xmode)
 s_longa (xmode)
+     int xmode;
 {
   int *p = xmode ? &X : &M;
   while (*input_line_pointer == ' ')
 {
   int *p = xmode ? &X : &M;
   while (*input_line_pointer == ' ')
@@ -136,16 +145,16 @@ s_longa (xmode)
     as_bad (_("need on or off."));
   demand_empty_rest_of_line ();
 }
     as_bad (_("need on or off."));
   demand_empty_rest_of_line ();
 }
+
 void
 md_begin ()
 {
 void
 md_begin ()
 {
-  relax_typeS *table;
-  struct opinfo *opcode;
+  const struct opinfo *opcode;
   char *prev_name = "";
 
   opcode_hash_control = hash_new ();
 
   char *prev_name = "";
 
   opcode_hash_control = hash_new ();
 
-  /* Insert unique names into hash table */
+  /* Insert unique names into hash table.  */
   for (opcode = optable; opcode->name; opcode++)
     {
       if (strcmp (prev_name, opcode->name))
   for (opcode = optable; opcode->name; opcode++)
     {
       if (strcmp (prev_name, opcode->name))
@@ -153,67 +162,20 @@ md_begin ()
          prev_name = opcode->name;
          hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
        }
          prev_name = opcode->name;
          hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
        }
-      else
-       {
-         /* Make all the opcodes with the same name point to the same
-            string */
-         opcode->name = prev_name;
-       }
     }
 
     }
 
-
-  /* Initialize the relax table.  We use a local variable to avoid
-     warnings about modifying a supposedly const data structure.  */
-  table = (relax_typeS *) md_relax_table;
-  table[C (COND_BRANCH, BYTE_DISP)].rlx_forward = BYTE_F;
-  table[C (COND_BRANCH, BYTE_DISP)].rlx_backward = BYTE_B;
-  table[C (COND_BRANCH, BYTE_DISP)].rlx_length = 2;
-  table[C (COND_BRANCH, BYTE_DISP)].rlx_more = C (COND_BRANCH, WORD_DISP);
-
-  table[C (COND_BRANCH, WORD_DISP)].rlx_forward = WORD_F;
-  table[C (COND_BRANCH, WORD_DISP)].rlx_backward = WORD_B;
-  table[C (COND_BRANCH, WORD_DISP)].rlx_length = 5;
-  table[C (COND_BRANCH, WORD_DISP)].rlx_more = 0;
-
-  table[C (UNCOND_BRANCH, BYTE_DISP)].rlx_forward = BYTE_F;
-  table[C (UNCOND_BRANCH, BYTE_DISP)].rlx_backward = BYTE_B;
-  table[C (UNCOND_BRANCH, BYTE_DISP)].rlx_length = 2;
-  table[C (UNCOND_BRANCH, BYTE_DISP)].rlx_more = C (UNCOND_BRANCH, WORD_DISP);
-
-  table[C (UNCOND_BRANCH, WORD_DISP)].rlx_forward = WORD_F;
-  table[C (UNCOND_BRANCH, WORD_DISP)].rlx_backward = WORD_B;
-  table[C (UNCOND_BRANCH, WORD_DISP)].rlx_length = 3;
-  table[C (UNCOND_BRANCH, WORD_DISP)].rlx_more = 0;
-
   flag_signed_overflow_ok = 1;
 }
 
 static expressionS immediate;  /* absolute expression */
 static expressionS immediate1; /* absolute expression */
   flag_signed_overflow_ok = 1;
 }
 
 static expressionS immediate;  /* absolute expression */
 static expressionS immediate1; /* absolute expression */
-
-
-static symbolS *
-dot ()
-{
-  const char *fake;
-
-  /* JF: '.' is pseudo symbol with value of current location
-     in current segment.  */
-  fake = FAKE_LABEL_NAME;
-  return symbol_new (fake,
-                    now_seg,
-                    (valueT) frag_now_fix (),
-                    frag_now);
-
-}
-
 int expr_size;
 int expr_shift;
 int tc_cons_reloc;
 int expr_size;
 int expr_shift;
 int tc_cons_reloc;
+
 void
 void
-w65_expression (dest, bytes)
+w65_expression (dest)
      expressionS *dest;
      expressionS *dest;
-     unsigned int bytes;
 {
   expr_size = 0;
   expr_shift = 0;
 {
   expr_size = 0;
   expr_shift = 0;
@@ -241,18 +203,17 @@ w65_expression (dest, bytes)
 }
 
 int amode;
 }
 
 int amode;
-static
-char *
-parse_exp (s, bytes)
+
+static char *
+parse_exp (s)
      char *s;
      char *s;
-     int bytes;
 {
   char *save;
   char *new;
 
   save = input_line_pointer;
   input_line_pointer = s;
 {
   char *save;
   char *new;
 
   save = input_line_pointer;
   input_line_pointer = s;
-  w65_expression (&immediate, bytes);
+  w65_expression (&immediate);
   if (immediate.X_op == O_absent)
     as_bad (_("missing operand"));
   new = input_line_pointer;
   if (immediate.X_op == O_absent)
     as_bad (_("missing operand"));
   new = input_line_pointer;
@@ -260,15 +221,14 @@ parse_exp (s, bytes)
   return new;
 }
 
   return new;
 }
 
-
-static
-char *
+static char *
 get_operands (info, ptr)
 get_operands (info, ptr)
-     struct opinfo *info;
+     const struct opinfo *info;
      char *ptr;
 {
   register int override_len = 0;
   register int bytes = 0;
      char *ptr;
 {
   register int override_len = 0;
   register int bytes = 0;
+
   while (*ptr == ' ')
     ptr++;
 
   while (*ptr == ' ')
     ptr++;
 
@@ -429,7 +389,8 @@ get_operands (info, ptr)
                  bytes = 2;
                }
            }
                  bytes = 2;
                }
            }
-         else if (ptr[0] == 's' && ptr[1] == ')' && ptr[2] == ',' && ptr[3] == 'y')
+         else if (ptr[0] == 's' && ptr[1] == ')'
+                  && ptr[2] == ',' && ptr[3] == 'y')
            {
              amode = ADDR_STACK_REL_INDX_IDX;
              bytes = 1;
            {
              amode = ADDR_STACK_REL_INDX_IDX;
              bytes = 1;
@@ -460,7 +421,6 @@ get_operands (info, ptr)
 
            }
        }
 
            }
        }
-
     }
   else if (ptr[0] == '[')
     {
     }
   else if (ptr[0] == '[')
     {
@@ -476,23 +436,22 @@ get_operands (info, ptr)
            }
          else
            {
            }
          else
            {
-             if (info->code == O_jmp) 
+             if (info->code == O_jmp)
                {
                {
-               bytes = 2;
-               amode = ADDR_ABS_IND_LONG;
-             } 
-             else 
-{
-               bytes = 1;
-             
-               amode = ADDR_DIR_IND_LONG;
-             }
+                 bytes = 2;
+                 amode = ADDR_ABS_IND_LONG;
+               }
+             else
+               {
+                 bytes = 1;
+                 amode = ADDR_DIR_IND_LONG;
+               }
            }
        }
     }
   else
     {
            }
        }
     }
   else
     {
-      ptr = parse_exp (ptr, 2);
+      ptr = parse_exp (ptr);
       if (ptr[0] == ',')
        {
          if (ptr[1] == 'y')
       if (ptr[0] == ',')
        {
          if (ptr[1] == 'y')
@@ -576,9 +535,9 @@ get_operands (info, ptr)
        {
        case 0:
          if (amode == ADDR_DIR)
        {
        case 0:
          if (amode == ADDR_DIR)
-       tc_cons_reloc = R_W65_DP;
+           tc_cons_reloc = R_W65_DP;
          else
          else
-tc_cons_reloc = R_W65_ABS8;
+           tc_cons_reloc = R_W65_ABS8;
          break;
        case 1:
          tc_cons_reloc = R_W65_ABS8S8;
          break;
        case 1:
          tc_cons_reloc = R_W65_ABS8S8;
@@ -607,13 +566,11 @@ tc_cons_reloc = R_W65_ABS8;
 
 /* Passed a pointer to a list of opcodes which use different
    addressing modes, return the opcode which matches the opcodes
 
 /* Passed a pointer to a list of opcodes which use different
    addressing modes, return the opcode which matches the opcodes
-   provided
- */
+   provided.  */
 
 
-static
-struct opinfo *
+static const struct opinfo *
 get_specific (opcode)
 get_specific (opcode)
-     struct opinfo *opcode;
+     const struct opinfo *opcode;
 {
   int ocode = opcode->code;
 
 {
   int ocode = opcode->code;
 
@@ -625,30 +582,11 @@ get_specific (opcode)
   return 0;
 }
 
   return 0;
 }
 
-int
-check (operand, low, high)
-     expressionS *operand;
-     int low;
-     int high;
-{
-  if (operand->X_op != O_constant
-      || operand->X_add_number < low
-      || operand->X_add_number > high)
-    {
-      as_bad ("operand must be absolute in range %d..%d", low, high);
-    }
-  return operand->X_add_number;
-}
-
-
-static int log2[] =
-{0, 0, 1, 0, 2};
+/* Now we know what sort of opcodes it is, let's build the bytes.  */
 
 
-/* Now we know what sort of opcodes it is, lets build the bytes -
- */
 static void
 build_Mytes (opcode)
 static void
 build_Mytes (opcode)
-     struct opinfo *opcode;
+     const struct opinfo *opcode;
 {
   int size;
   int type;
 {
   int size;
   int type;
@@ -662,7 +600,8 @@ build_Mytes (opcode)
   else if (opcode->amode == ADDR_PC_REL)
     {
       int type;
   else if (opcode->amode == ADDR_PC_REL)
     {
       int type;
-      /* This is a relaxable insn, so we do some special handling */
+
+      /* This is a relaxable insn, so we do some special handling.  */
       type = opcode->val == OP_BRA ? UNCOND_BRANCH : COND_BRANCH;
       output = frag_var (rs_machine_dependent,
                         md_relax_table[C (type, WORD_DISP)].rlx_length,
       type = opcode->val == OP_BRA ? UNCOND_BRANCH : COND_BRANCH;
       output = frag_var (rs_machine_dependent,
                         md_relax_table[C (type, WORD_DISP)].rlx_length,
@@ -677,23 +616,21 @@ build_Mytes (opcode)
       switch (opcode->amode)
        {
          GETINFO (size, type, pcrel);
       switch (opcode->amode)
        {
          GETINFO (size, type, pcrel);
+       default:
+         abort ();
        }
 
        }
 
-      /* If something special was done in the
-        expression modify the reloc type */
+      /* If something special was done in the expression modify the
+        reloc type.  */
       if (tc_cons_reloc)
       if (tc_cons_reloc)
-       {
-         type = tc_cons_reloc;
-       }
-
-
+       type = tc_cons_reloc;
 
 
-      /* 1 byte for the opcode + the bytes for the addrmode */
+      /* 1 byte for the opcode + the bytes for the addrmode.  */
       output = frag_more (size + 1);
 
       if (opcode->amode == ADDR_BLOCK_MOVE)
        {
       output = frag_more (size + 1);
 
       if (opcode->amode == ADDR_BLOCK_MOVE)
        {
-         /* Two relocs for this one */
+         /* Two relocs for this one.  */
          fix_new_exp (frag_now,
                       output + 1 - frag_now->fr_literal,
                       1,
          fix_new_exp (frag_now,
                       output + 1 - frag_now->fr_literal,
                       1,
@@ -724,21 +661,16 @@ build_Mytes (opcode)
   output[0] = opcode->val;
 }
 
   output[0] = opcode->val;
 }
 
-/* This is the guts of the machine-dependent assembler.  STR points to a
-   machine dependent instruction.  This function is supposed to emit
-   the frags/bytes it assembles to.
- */
+/* This is the guts of the machine-dependent assembler.  STR points to
+   a machine dependent instruction.  This function is supposed to emit
+   the frags/bytes it assembles to.  */
 
 void
 md_assemble (str)
      char *str;
 {
 
 void
 md_assemble (str)
      char *str;
 {
-  unsigned char *op_start;
-  unsigned char *op_end;
-  struct opinfo *opcode;
+  const struct opinfo *opcode;
   char name[20];
   char name[20];
-  int nlen = 0;
-  char *p;
 
   /* Drop leading whitespace */
   while (*str == ' ')
 
   /* Drop leading whitespace */
   while (*str == ' ')
@@ -769,8 +701,7 @@ md_assemble (str)
 
   if (opcode == 0)
     {
 
   if (opcode == 0)
     {
-      /* Couldn't find an opcode which matched the operands */
-
+      /* Couldn't find an opcode which matched the operands.  */
 
       char *where = frag_more (1);
 
 
       char *where = frag_more (1);
 
@@ -783,36 +714,22 @@ md_assemble (str)
   build_Mytes (opcode);
 }
 
   build_Mytes (opcode);
 }
 
-
-void
-tc_crawl_symbol_chain (headers)
-     object_headers *headers;
-{
-  printf (_("call to tc_crawl_symbol_chain \n"));
-}
-
 symbolS *
 md_undefined_symbol (name)
 symbolS *
 md_undefined_symbol (name)
-     char *name;
+     char *name ATTRIBUTE_UNUSED;
 {
   return 0;
 }
 
 {
   return 0;
 }
 
-void
-tc_headers_hook (headers)
-     object_headers *headers;
-{
-  printf (_("call to tc_headers_hook \n"));
-}
-
-/* Various routines to kill one day */
-/* Equal to MAX_PRECISION in atof-ieee.c */
+/* Various routines to kill one day.  */
+/* Equal to MAX_PRECISION in atof-ieee.c.  */
 #define MAX_LITTLENUMS 6
 
 #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.
- */
+/* 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 *
 md_atof (type, litP, sizeP)
      char type;
 char *
 md_atof (type, litP, sizeP)
      char type;
@@ -823,7 +740,6 @@ md_atof (type, litP, sizeP)
   LITTLENUM_TYPE words[MAX_LITTLENUMS];
   LITTLENUM_TYPE *wordP;
   char *t;
   LITTLENUM_TYPE words[MAX_LITTLENUMS];
   LITTLENUM_TYPE *wordP;
   char *t;
-  char *atof_ieee ();
 
   switch (type)
     {
 
   switch (type)
     {
@@ -869,33 +785,26 @@ md_atof (type, litP, sizeP)
 }
 
 int
 }
 
 int
-md_parse_option (c,a)
-    int c;
-    char *a;
-
+md_parse_option (c, a)
+     int c ATTRIBUTE_UNUSED;
+     char *a ATTRIBUTE_UNUSED;
 {
 {
-  return 1;
+  return 0;
 }
 
 }
 
-void
-tc_Nout_fix_to_chars ()
-{
-  printf (_("call to tc_Nout_fix_to_chars \n"));
-  abort ();
-}
+/* Called after relaxing, change the frags so they know how big they
+   are.  */
 
 
-/*
-called after relaxing, change the frags so they know how big they are
-*/
 void
 md_convert_frag (headers, seg, fragP)
 void
 md_convert_frag (headers, seg, fragP)
-     object_headers *headers;
-     segT seg;
+     object_headers *headers ATTRIBUTE_UNUSED;
+     segT seg ATTRIBUTE_UNUSED;
      fragS *fragP;
 {
   int disp_size = 0;
   int inst_size = 0;
      fragS *fragP;
 {
   int disp_size = 0;
   int inst_size = 0;
-  unsigned char *buffer = (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
+  unsigned char *buffer =
+    (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
 
   switch (fragP->fr_subtype)
     {
 
   switch (fragP->fr_subtype)
     {
@@ -905,7 +814,7 @@ md_convert_frag (headers, seg, fragP)
       inst_size = 1;
       break;
 
       inst_size = 1;
       break;
 
-      /* cond branches to a known 16 bit displacement */
+      /* Conditional branches to a known 16 bit displacement.  */
     case C (COND_BRANCH, WORD_DISP):
       switch (buffer[0])
        {
     case C (COND_BRANCH, WORD_DISP):
       switch (buffer[0])
        {
@@ -931,7 +840,7 @@ md_convert_frag (headers, seg, fragP)
        }
       break;
     case C (UNCOND_BRANCH, WORD_DISP):
        }
       break;
     case C (UNCOND_BRANCH, WORD_DISP):
-      /* Unconditional branches to a known 16 bit displacement */
+      /* Unconditional branches to a known 16 bit displacement.  */
 
       switch (buffer[0])
        {
 
       switch (buffer[0])
        {
@@ -944,7 +853,7 @@ md_convert_frag (headers, seg, fragP)
          abort ();
        }
       break;
          abort ();
        }
       break;
-      /* got to create a branch over a reloc here */
+      /* Got to create a branch over a reloc here.  */
     case C (COND_BRANCH, UNDEF_WORD_DISP):
       buffer[0] ^= 0x20;       /* invert test */
       buffer[1] = 3;
     case C (COND_BRANCH, UNDEF_WORD_DISP):
       buffer[0] ^= 0x20;       /* invert test */
       buffer[1] = 3;
@@ -982,8 +891,9 @@ md_convert_frag (headers, seg, fragP)
     }
   if (inst_size)
     {
     }
   if (inst_size)
     {
-      /* Get the address of the end of the instruction */
-      int next_inst = fragP->fr_fix + fragP->fr_address + disp_size + inst_size;
+      /* Get the address of the end of the instruction.  */
+      int next_inst = (fragP->fr_fix + fragP->fr_address
+                      + disp_size + inst_size);
       int targ_addr = (S_GET_VALUE (fragP->fr_symbol) +
                       fragP->fr_offset);
       int disp = targ_addr - next_inst;
       int targ_addr = (S_GET_VALUE (fragP->fr_symbol) +
                       fragP->fr_offset);
       int disp = targ_addr - next_inst;
@@ -994,7 +904,6 @@ md_convert_frag (headers, seg, fragP)
     }
 }
 
     }
 }
 
-
 valueT
 md_section_align (seg, size)
      segT seg;
 valueT
 md_section_align (seg, size)
      segT seg;
@@ -1002,14 +911,15 @@ md_section_align (seg, size)
 {
   return ((size + (1 << section_alignment[(int) seg]) - 1)
          & (-1 << section_alignment[(int) seg]));
 {
   return ((size + (1 << section_alignment[(int) seg]) - 1)
          & (-1 << section_alignment[(int) seg]));
-
 }
 
 void
 }
 
 void
-md_apply_fix (fixP, val)
+md_apply_fix3 (fixP, valP, seg)
      fixS *fixP;
      fixS *fixP;
-     long val;
+     valueT * valP;
+     segT seg ATTRIBUTE_UNUSED;
 {
 {
+  long val = * (long *) valP;
   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
   int addr = fixP->fx_frag->fr_address + fixP->fx_where;
 
   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
   int addr = fixP->fx_frag->fr_address + fixP->fx_where;
 
@@ -1058,9 +968,12 @@ md_apply_fix (fixP, val)
     default:
       abort ();
     }
     default:
       abort ();
     }
+
+  if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
+    fixP->fx_done = 1;
 }
 
 }
 
-/* Put number into target byte order */
+/* Put number into target byte order.  */
 
 void
 md_number_to_chars (ptr, use, nbytes)
 
 void
 md_number_to_chars (ptr, use, nbytes)
@@ -1081,7 +994,7 @@ md_pcrel_from (fixP)
 
 void
 tc_coff_symbol_emit_hook (x)
 
 void
 tc_coff_symbol_emit_hook (x)
-    symbolS *x;
+     symbolS *x ATTRIBUTE_UNUSED;
 {
 }
 
 {
 }
 
@@ -1161,49 +1074,55 @@ tc_coff_sizemachdep (frag)
   return md_relax_table[frag->fr_subtype].rlx_length;
 }
 
   return md_relax_table[frag->fr_subtype].rlx_length;
 }
 
+/* Called just before address relaxation, return the length by which a
+   fragment must grow to reach it's destination.  */
 
 
-
-
-
-/*
-called just before address relaxation, return the length
-by which a fragment must grow to reach it's destination
-*/
 int
 md_estimate_size_before_relax (fragP, segment_type)
      register fragS *fragP;
      register segT segment_type;
 {
 int
 md_estimate_size_before_relax (fragP, segment_type)
      register fragS *fragP;
      register segT segment_type;
 {
-  int what = GET_WHAT (fragP->fr_subtype);
+  int what;
 
   switch (fragP->fr_subtype)
     {
     default:
       abort ();
 
   switch (fragP->fr_subtype)
     {
     default:
       abort ();
+
     case C (COND_BRANCH, UNDEF_BYTE_DISP):
     case C (UNCOND_BRANCH, UNDEF_BYTE_DISP):
     case C (COND_BRANCH, UNDEF_BYTE_DISP):
     case C (UNCOND_BRANCH, UNDEF_BYTE_DISP):
-      /* used to be a branch to somewhere which was unknown */
+      what = GET_WHAT (fragP->fr_subtype);
+      /* Used to be a branch to somewhere which was unknown.  */
       if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
        {
          /* Got a symbol and it's defined in this segment, become byte
       if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
        {
          /* Got a symbol and it's defined in this segment, become byte
-        sized - maybe it will fix up */
+            sized - maybe it will fix up.  */
          fragP->fr_subtype = C (what, BYTE_DISP);
          fragP->fr_subtype = C (what, BYTE_DISP);
-         fragP->fr_var = md_relax_table[C (what, BYTE_DISP)].rlx_length;
        }
       else
        {
        }
       else
        {
-         /* Its got a segment, but its not ours, so it will always be long */
+         /* Its got a segment, but its not ours, so it will always be
+             long.  */
          fragP->fr_subtype = C (what, UNDEF_WORD_DISP);
          fragP->fr_subtype = C (what, UNDEF_WORD_DISP);
-         fragP->fr_var = md_relax_table[C (what, WORD_DISP)].rlx_length;
-         return md_relax_table[C (what, WORD_DISP)].rlx_length;
        }
        }
+      break;
+
+    case C (COND_BRANCH, BYTE_DISP):
+    case C (COND_BRANCH, WORD_DISP):
+    case C (COND_BRANCH, UNDEF_WORD_DISP):
+    case C (UNCOND_BRANCH, BYTE_DISP):
+    case C (UNCOND_BRANCH, WORD_DISP):
+    case C (UNCOND_BRANCH, UNDEF_WORD_DISP):
+      /* When relaxing a section for the second time, we don't need to
+        do anything besides return the current size.  */
+      break;
     }
     }
+
+  fragP->fr_var = md_relax_table[fragP->fr_subtype].rlx_length;
   return fragP->fr_var;
 }
 
   return fragP->fr_var;
 }
 
-
-
-CONST char *md_shortopts = "";
+const char *md_shortopts = "";
 struct option md_longopts[] = {
 #define OPTION_RELAX (OPTION_MD_BASE)
   {NULL, no_argument, NULL, 0}
 struct option md_longopts[] = {
 #define OPTION_RELAX (OPTION_MD_BASE)
   {NULL, no_argument, NULL, 0}
@@ -1211,9 +1130,8 @@ struct option md_longopts[] = {
 
 void
 md_show_usage (stream)
 
 void
 md_show_usage (stream)
-     FILE *stream;
+     FILE *stream ATTRIBUTE_UNUSED;
 {
 {
-
 }
 
 }
 
-size_t md_longopts_size = sizeof(md_longopts);
+size_t md_longopts_size = sizeof (md_longopts);
GDB Binutils - Deliverables
This page took 0.052104 seconds and 4 git commands to generate.