include/opcode/

[deliverable/binutils-gdb.git] / gas / read.c

diff --git a/gas/read.c b/gas/read.c
index 209ab6ad08aa1cad465aa1c7549d982658aace0b..d51835e3cecfcc22f8f5af4d7c62f438a0533eb2 100644 (file)
--- a/gas/read.c
+++ b/gas/read.c
@@ -1,6 +1,7 @@
 /* read.c - read a source file -
    Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
 /* read.c - read a source file -
    Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,

-   1998, 1999, 2000 Free Software Foundation, Inc.
+   1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.

 
 This file is part of GAS, the GNU Assembler.
 
 
 This file is part of GAS, the GNU Assembler.
 


@@ -16,53 +17,48 @@ GNU General Public License for more details.
 
 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.  */

 
 

-#if 0
-/* If your chars aren't 8 bits, you will change this a bit.
+/* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).

    But then, GNU isn't spozed to run on your machine anyway.
    (RMS is so shortsighted sometimes.)  */
    But then, GNU isn't spozed to run on your machine anyway.
    (RMS is so shortsighted sometimes.)  */

-#define MASK_CHAR (0xFF)
-#else

 #define MASK_CHAR ((int)(unsigned char) -1)
 #define MASK_CHAR ((int)(unsigned char) -1)

-#endif

 
 /* This is the largest known floating point format (for now). It will
    grow when we do 4361 style flonums.  */
 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
 
 
 /* This is the largest known floating point format (for now). It will
    grow when we do 4361 style flonums.  */
 #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
 

-/* Routines that read assembler source text to build spagetti in memory.
+/* Routines that read assembler source text to build spaghetti in memory.

    Another group of these functions is in the expr.c module.  */
 
    Another group of these functions is in the expr.c module.  */
 

-/* For isdigit ().  */
-#include <ctype.h>
-

 #include "as.h"
 #include "as.h"

+#include "safe-ctype.h"

 #include "subsegs.h"
 #include "sb.h"
 #include "macro.h"
 #include "obstack.h"
 #include "listing.h"
 #include "ecoff.h"
 #include "subsegs.h"
 #include "sb.h"
 #include "macro.h"
 #include "obstack.h"
 #include "listing.h"
 #include "ecoff.h"

+#include "dw2gencfi.h"

 
 #ifndef TC_START_LABEL
 
 #ifndef TC_START_LABEL

-#define TC_START_LABEL(x,y) (x==':')
+#define TC_START_LABEL(x,y) (x == ':')

 #endif
 
 /* Set by the object-format or the target.  */
 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
 #endif
 
 /* Set by the object-format or the target.  */
 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT

-#define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR)               \
+#define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR)               \

   do                                                           \
   do                                                           \

-    {                                                          \
-      if ((SIZE) >= 8)                                         \
-       (P2VAR) = 3;                                            \
-      else if ((SIZE) >= 4)                                    \
-       (P2VAR) = 2;                                            \
-      else if ((SIZE) >= 2)                                    \
-       (P2VAR) = 1;                                            \
-      else                                                     \
-       (P2VAR) = 0;                                            \
+    {                                                          \
+      if ((SIZE) >= 8)                                         \
+       (P2VAR) = 3;                                            \
+      else if ((SIZE) >= 4)                                    \
+       (P2VAR) = 2;                                            \
+      else if ((SIZE) >= 2)                                    \
+       (P2VAR) = 1;                                            \
+      else                                                     \
+       (P2VAR) = 0;                                            \

     }                                                          \
   while (0)
 #endif
     }                                                          \
   while (0)
 #endif


@@ -76,7 +72,6 @@ die horribly;
 #endif
 
 #ifndef LEX_AT
 #endif
 
 #ifndef LEX_AT

-/* The m88k unfortunately uses @ as a label beginner.  */

 #define LEX_AT 0
 #endif
 
 #define LEX_AT 0
 #endif
 


@@ -102,7 +97,6 @@ die horribly;
 #endif
 
 #ifndef LEX_DOLLAR
 #endif
 
 #ifndef LEX_DOLLAR

-/* The a29k assembler does not permits labels to start with $.  */

 #define LEX_DOLLAR 3
 #endif
 
 #define LEX_DOLLAR 3
 #endif
 


@@ -156,7 +150,7 @@ char is_end_of_line[256] = {
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0       /* */
 };
 
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0       /* */
 };
 

-#ifdef  IGNORE_OPCODE_CASE
+#ifndef TC_CASE_SENSITIVE

 char original_case_string[128];
 #endif
 
 char original_case_string[128];
 #endif
 


@@ -170,10 +164,6 @@ static char *buffer_limit; /*->1 + last char in buffer.  */
    internals manual.  */
 int target_big_endian = TARGET_BYTES_BIG_ENDIAN;
 
    internals manual.  */
 int target_big_endian = TARGET_BYTES_BIG_ENDIAN;
 

-static char *old_buffer;       /* JF a hack.  */
-static char *old_input;
-static char *old_limit;
-

 /* Variables for handling include file directory table.  */
 
 /* Table of pointers to directories to search for .include's.  */
 /* Variables for handling include file directory table.  */
 
 /* Table of pointers to directories to search for .include's.  */


@@ -219,29 +209,20 @@ static int dwarf_file_string;
 #endif
 #endif
 
 #endif
 #endif
 

-static void cons_worker PARAMS ((int, int));
-static int scrub_from_string PARAMS ((char *, int));
-static void do_align PARAMS ((int, char *, int, int));
-static void s_align PARAMS ((int, int));
-static void s_lcomm_internal PARAMS ((int, int));
-static int hex_float PARAMS ((int, char *));
-static inline int sizeof_sleb128 PARAMS ((offsetT));
-static inline int sizeof_uleb128 PARAMS ((valueT));
-static inline int output_sleb128 PARAMS ((char *, offsetT));
-static inline int output_uleb128 PARAMS ((char *, valueT));
-static inline int output_big_sleb128 PARAMS ((char *, LITTLENUM_TYPE *, int));
-static inline int output_big_uleb128 PARAMS ((char *, LITTLENUM_TYPE *, int));
-static int output_big_leb128 PARAMS ((char *, LITTLENUM_TYPE *, int, int));
-static void do_org PARAMS ((segT, expressionS *, int));
-char *demand_copy_string PARAMS ((int *lenP));
-static segT get_segmented_expression PARAMS ((expressionS *expP));
-static segT get_known_segmented_expression PARAMS ((expressionS * expP));
-static void pobegin PARAMS ((void));
-static int get_line_sb PARAMS ((sb *));
-static void generate_file_debug PARAMS ((void));
+static void do_s_func (int end_p, const char *default_prefix);
+static void do_align (int, char *, int, int);
+static void s_align (int, int);
+static void s_altmacro (int);
+static void s_bad_end (int);
+static int hex_float (int, char *);
+static segT get_known_segmented_expression (expressionS * expP);
+static void pobegin (void);
+static int get_line_sb (sb *);
+static void generate_file_debug (void);
+static char *_find_end_of_line (char *, int, int);

 \f
 void
 \f
 void

-read_begin ()
+read_begin (void)

 {
   const char *p;
 
 {
   const char *p;
 


@@ -262,6 +243,22 @@ read_begin ()
     lex_type['?'] = 3;
 }
 \f
     lex_type['?'] = 3;
 }
 \f

+#ifndef TC_ADDRESS_BYTES
+#define TC_ADDRESS_BYTES address_bytes
+
+static inline int
+address_bytes (void)
+{
+  /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
+     contain an address.  */
+  int n = (stdoutput->arch_info->bits_per_address - 1) / 8;
+  n |= n >> 1;
+  n |= n >> 2;
+  n += 1;
+  return n;
+}
+#endif
+

 /* Set up pseudo-op tables.  */
 
 static struct hash_control *po_hash;
 /* Set up pseudo-op tables.  */
 
 static struct hash_control *po_hash;


@@ -269,6 +266,7 @@ static struct hash_control *po_hash;
 static const pseudo_typeS potable[] = {
   {"abort", s_abort, 0},
   {"align", s_align_ptwo, 0},
 static const pseudo_typeS potable[] = {
   {"abort", s_abort, 0},
   {"align", s_align_ptwo, 0},

+  {"altmacro", s_altmacro, 1},

   {"ascii", stringer, 0},
   {"asciz", stringer, 1},
   {"balign", s_align_bytes, 0},
   {"ascii", stringer, 0},
   {"asciz", stringer, 1},
   {"balign", s_align_bytes, 0},


@@ -281,6 +279,9 @@ static const pseudo_typeS potable[] = {
   {"common.s", s_mri_common, 1},
   {"data", s_data, 0},
   {"dc", cons, 2},
   {"common.s", s_mri_common, 1},
   {"data", s_data, 0},
   {"dc", cons, 2},

+#ifdef TC_ADDRESS_BYTES
+  {"dc.a", cons, 0},
+#endif

   {"dc.b", cons, 1},
   {"dc.d", float_cons, 'd'},
   {"dc.l", cons, 4},
   {"dc.b", cons, 1},
   {"dc.d", float_cons, 'd'},
   {"dc.l", cons, 4},


@@ -317,10 +318,14 @@ static const pseudo_typeS potable[] = {
   {"endc", s_endif, 0},
   {"endfunc", s_func, 1},
   {"endif", s_endif, 0},
   {"endc", s_endif, 0},
   {"endfunc", s_func, 1},
   {"endif", s_endif, 0},

+  {"endm", s_bad_end, 0},
+  {"endr", s_bad_end, 1},

 /* endef  */
   {"equ", s_set, 0},
   {"equiv", s_set, 1},
 /* endef  */
   {"equ", s_set, 0},
   {"equiv", s_set, 1},

+  {"eqv", s_set, -1},

   {"err", s_err, 0},
   {"err", s_err, 0},

+  {"error", s_errwarn, 1},

   {"exitm", s_mexit, 0},
 /* extend  */
   {"extern", s_ignore, 0},     /* We treat all undef as ext.  */
   {"exitm", s_mexit, 0},
 /* extend  */
   {"extern", s_ignore, 0},     /* We treat all undef as ext.  */


@@ -336,6 +341,7 @@ static const pseudo_typeS potable[] = {
   {"globl", s_globl, 0},
   {"hword", cons, 2},
   {"if", s_if, (int) O_ne},
   {"globl", s_globl, 0},
   {"hword", cons, 2},
   {"if", s_if, (int) O_ne},

+  {"ifb", s_ifb, 1},

   {"ifc", s_ifc, 0},
   {"ifdef", s_ifdef, 0},
   {"ifeq", s_if, (int) O_eq},
   {"ifc", s_ifc, 0},
   {"ifdef", s_ifdef, 0},
   {"ifeq", s_if, (int) O_eq},


@@ -344,11 +350,13 @@ static const pseudo_typeS potable[] = {
   {"ifgt", s_if, (int) O_gt},
   {"ifle", s_if, (int) O_le},
   {"iflt", s_if, (int) O_lt},
   {"ifgt", s_if, (int) O_gt},
   {"ifle", s_if, (int) O_le},
   {"iflt", s_if, (int) O_lt},

+  {"ifnb", s_ifb, 0},

   {"ifnc", s_ifc, 1},
   {"ifndef", s_ifdef, 1},
   {"ifne", s_if, (int) O_ne},
   {"ifnes", s_ifeqs, 1},
   {"ifnotdef", s_ifdef, 1},
   {"ifnc", s_ifc, 1},
   {"ifndef", s_ifdef, 1},
   {"ifne", s_if, (int) O_ne},
   {"ifnes", s_ifeqs, 1},
   {"ifnotdef", s_ifdef, 1},

+  {"incbin", s_incbin, 0},

   {"include", s_include, 0},
   {"int", cons, 4},
   {"irp", s_irp, 0},
   {"include", s_include, 0},
   {"int", cons, 4},
   {"irp", s_irp, 0},


@@ -367,6 +375,7 @@ static const pseudo_typeS potable[] = {
   {"mri", s_mri, 0},
   {".mri", s_mri, 0},  /* Special case so .mri works in MRI mode.  */
   {"name", s_ignore, 0},
   {"mri", s_mri, 0},
   {".mri", s_mri, 0},  /* Special case so .mri works in MRI mode.  */
   {"name", s_ignore, 0},

+  {"noaltmacro", s_altmacro, 0},

   {"noformat", s_ignore, 0},
   {"nolist", listing_list, 0}, /* Turn listing off.  */
   {"nopage", listing_nopage, 0},
   {"noformat", s_ignore, 0},
   {"nolist", listing_list, 0}, /* Turn listing off.  */
   {"nopage", listing_nopage, 0},


@@ -424,17 +433,39 @@ static const pseudo_typeS potable[] = {
   {"xdef", s_globl, 0},
   {"xref", s_ignore, 0},
   {"xstabs", s_xstab, 's'},
   {"xdef", s_globl, 0},
   {"xref", s_ignore, 0},
   {"xstabs", s_xstab, 's'},

+  {"warning", s_errwarn, 0},
+  {"weakref", s_weakref, 0},

   {"word", cons, 2},
   {"zero", s_space, 0},
   {NULL, NULL, 0}                      /* End sentinel.  */
 };
 
   {"word", cons, 2},
   {"zero", s_space, 0},
   {NULL, NULL, 0}                      /* End sentinel.  */
 };
 

+static offsetT
+get_absolute_expr (expressionS *exp)
+{
+  expression_and_evaluate (exp);
+  if (exp->X_op != O_constant)
+    {
+      if (exp->X_op != O_absent)
+       as_bad (_("bad or irreducible absolute expression"));
+      exp->X_add_number = 0;
+    }
+  return exp->X_add_number;
+}
+
+offsetT
+get_absolute_expression (void)
+{
+  expressionS exp;
+
+  return get_absolute_expr (&exp);
+}
+

 static int pop_override_ok = 0;
 static const char *pop_table_name;
 
 void
 static int pop_override_ok = 0;
 static const char *pop_table_name;
 
 void

-pop_insert (table)
-     const pseudo_typeS *table;
+pop_insert (const pseudo_typeS *table)

 {
   const char *errtxt;
   const pseudo_typeS *pop;
 {
   const char *errtxt;
   const pseudo_typeS *pop;


@@ -455,8 +486,12 @@ pop_insert (table)
 #define obj_pop_insert()       pop_insert(obj_pseudo_table)
 #endif
 
 #define obj_pop_insert()       pop_insert(obj_pseudo_table)
 #endif
 

+#ifndef cfi_pop_insert
+#define cfi_pop_insert()       pop_insert(cfi_pseudo_table)
+#endif
+

 static void
 static void

-pobegin ()
+pobegin (void)

 {
   po_hash = hash_new ();
 
 {
   po_hash = hash_new ();
 


@@ -472,14 +507,22 @@ pobegin ()
   /* Now portable ones.  Skip any that we've seen already.  */
   pop_table_name = "standard";
   pop_insert (potable);
   /* Now portable ones.  Skip any that we've seen already.  */
   pop_table_name = "standard";
   pop_insert (potable);

+
+#ifdef TARGET_USE_CFIPOP
+  pop_table_name = "cfi";
+  pop_override_ok = 1;
+  cfi_pop_insert ();
+#endif

 }
 \f
 #define HANDLE_CONDITIONAL_ASSEMBLY()                                  \
   if (ignore_input ())                                                 \
     {                                                                  \
 }
 \f
 #define HANDLE_CONDITIONAL_ASSEMBLY()                                  \
   if (ignore_input ())                                                 \
     {                                                                  \

-      while (!is_end_of_line[(unsigned char) *input_line_pointer++])   \
-       if (input_line_pointer == buffer_limit)                         \
-         break;                                                        \
+      char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri);        \
+      input_line_pointer = (input_line_pointer <= buffer_limit         \
+                           && eol >= buffer_limit)                     \
+                          ? buffer_limit                               \
+                          : eol + 1;                                   \

       continue;                                                                \
     }
 
       continue;                                                                \
     }
 


@@ -490,9 +533,7 @@ static char *scrub_string;
 static char *scrub_string_end;
 
 static int
 static char *scrub_string_end;
 
 static int

-scrub_from_string (buf, buflen)
-     char *buf;
-     int buflen;
+scrub_from_string (char *buf, int buflen)

 {
   int copy;
 
 {
   int copy;
 


@@ -504,11 +545,36 @@ scrub_from_string (buf, buflen)
   return copy;
 }
 
   return copy;
 }
 

+/* Helper function of read_a_source_file, which tries to expand a macro.  */
+static int
+try_macro (char term, const char *line)
+{
+  sb out;
+  const char *err;
+  macro_entry *macro;
+
+  if (check_macro (line, &out, &err, &macro))
+    {
+      if (err != NULL)
+       as_bad ("%s", err);
+      *input_line_pointer++ = term;
+      input_scrub_include_sb (&out,
+                             input_line_pointer, 1);
+      sb_kill (&out);
+      buffer_limit =
+       input_scrub_next_buffer (&input_line_pointer);
+#ifdef md_macro_info
+      md_macro_info (macro);
+#endif
+      return 1;
+    }
+  return 0;
+}
+

 /* We read the file, putting things into a web that represents what we
    have been reading.  */
 void
 /* We read the file, putting things into a web that represents what we
    have been reading.  */
 void

-read_a_source_file (name)
-     char *name;
+read_a_source_file (char *name)

 {
   register char c;
   register char *s;            /* String of symbol, '\0' appended.  */
 {
   register char c;
   register char *s;            /* String of symbol, '\0' appended.  */


@@ -532,10 +598,15 @@ read_a_source_file (name)
 
   while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
     {                          /* We have another line to parse.  */
 
   while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
     {                          /* We have another line to parse.  */

+#ifndef NO_LISTING
+      /* In order to avoid listing macro expansion lines with labels
+        multiple times, keep track of which line was last issued.  */
+      static char *last_eol;
+
+      last_eol = NULL;
+#endif

       know (buffer_limit[-1] == '\n'); /* Must have a sentinel.  */
       know (buffer_limit[-1] == '\n'); /* Must have a sentinel.  */

-    contin:                    /* JF this goto is my fault I admit it.
-                                  Someone brave please re-write the whole
-                                  input section here?  Pleeze???  */
+

       while (input_line_pointer < buffer_limit)
        {
          /* We have more of this buffer to parse.  */
       while (input_line_pointer < buffer_limit)
        {
          /* We have more of this buffer to parse.  */


@@ -596,8 +667,8 @@ read_a_source_file (name)
                        }
 
                      /* In MRI mode, we need to handle the MACRO
                        }
 
                      /* In MRI mode, we need to handle the MACRO

-                         pseudo-op specially: we don't want to put the
-                         symbol in the symbol table.  */
+                        pseudo-op specially: we don't want to put the
+                        symbol in the symbol table.  */

                      if (!mri_line_macro
 #ifdef TC_START_LABEL_WITHOUT_COLON
                          && TC_START_LABEL_WITHOUT_COLON(c,
                      if (!mri_line_macro
 #ifdef TC_START_LABEL_WITHOUT_COLON
                          && TC_START_LABEL_WITHOUT_COLON(c,


@@ -618,7 +689,7 @@ read_a_source_file (name)
                }
            }
 
                }
            }
 

-         /* We are at the begining of a line, or similar place.
+         /* We are at the beginning of a line, or similar place.

             We expect a well-formed assembler statement.
             A "symbol-name:" is a statement.
 
             We expect a well-formed assembler statement.
             A "symbol-name:" is a statement.
 


@@ -649,21 +720,23 @@ read_a_source_file (name)
                  int len;
 
                  /* Find the end of the current expanded macro line.  */
                  int len;
 
                  /* Find the end of the current expanded macro line.  */

-                 for (s = input_line_pointer - 1; *s; ++s)
-                   if (is_end_of_line[(unsigned char) *s])
-                     break;
+                 s = find_end_of_line (input_line_pointer - 1, flag_m68k_mri);

 
 

-                 /* Copy it for safe keeping.  Also give an indication of
-                    how much macro nesting is involved at this point.  */
-                 len = s - (input_line_pointer - 1);
-                 copy = (char *) xmalloc (len + macro_nest + 2);
-                 memset (copy, '>', macro_nest);
-                 copy[macro_nest] = ' ';
-                 memcpy (copy + macro_nest + 1, input_line_pointer - 1, len);
-                 copy[macro_nest + 1 + len] = '\0';
-
-                 /* Install the line with the listing facility.  */
-                 listing_newline (copy);
+                 if (s != last_eol)
+                   {
+                     last_eol = s;
+                     /* Copy it for safe keeping.  Also give an indication of
+                        how much macro nesting is involved at this point.  */
+                     len = s - (input_line_pointer - 1);
+                     copy = (char *) xmalloc (len + macro_nest + 2);
+                     memset (copy, '>', macro_nest);
+                     copy[macro_nest] = ' ';
+                     memcpy (copy + macro_nest + 1, input_line_pointer - 1, len);
+                     copy[macro_nest + 1 + len] = '\0';
+
+                     /* Install the line with the listing facility.  */
+                     listing_newline (copy);
+                   }

                }
              else
                listing_newline (NULL);
                }
              else
                listing_newline (NULL);


@@ -680,10 +753,10 @@ read_a_source_file (name)
              c = get_symbol_end ();    /* name's delimiter.  */
 
              /* C is character after symbol.
              c = get_symbol_end ();    /* name's delimiter.  */
 
              /* C is character after symbol.

-                That character's place in the input line is now '\0'.
-                S points to the beginning of the symbol.
-                  [In case of pseudo-op, s->'.'.]
-                Input_line_pointer->'\0' where c was.  */
+                That character's place in the input line is now '\0'.
+                S points to the beginning of the symbol.
+                  [In case of pseudo-op, s->'.'.]
+                Input_line_pointer->'\0' where c was.  */

              if (TC_START_LABEL (c, input_line_pointer))
                {
                  if (flag_m68k_mri)
              if (TC_START_LABEL (c, input_line_pointer))
                {
                  if (flag_m68k_mri)


@@ -710,16 +783,27 @@ read_a_source_file (name)
                  line_label = colon (s);       /* User-defined label.  */
                  /* Put ':' back for error messages' sake.  */
                  *input_line_pointer++ = ':';
                  line_label = colon (s);       /* User-defined label.  */
                  /* Put ':' back for error messages' sake.  */
                  *input_line_pointer++ = ':';

+#ifdef tc_check_label
+                 tc_check_label (line_label);
+#endif

                  /* Input_line_pointer->after ':'.  */
                  SKIP_WHITESPACE ();
                }
                  /* Input_line_pointer->after ':'.  */
                  SKIP_WHITESPACE ();
                }

-             else if (c == '='
-                      || ((c == ' ' || c == '\t')
-                          && input_line_pointer[1] == '='
+              else if (input_line_pointer[1] == '='
+                      && (c == '='
+                          || ((c == ' ' || c == '\t')
+                              && input_line_pointer[2] == '=')))
+               {
+                 equals (s, -1);
+                 demand_empty_rest_of_line ();
+               }
+              else if ((c == '='
+                       || ((c == ' ' || c == '\t')
+                            && input_line_pointer[1] == '='))

 #ifdef TC_EQUAL_IN_INSN
 #ifdef TC_EQUAL_IN_INSN

-                          && !TC_EQUAL_IN_INSN (c, input_line_pointer)
+                           && !TC_EQUAL_IN_INSN (c, s)

 #endif
 #endif

-                          ))
+                           )

                {
                  equals (s, 1);
                  demand_empty_rest_of_line ();
                {
                  equals (s, 1);
                  demand_empty_rest_of_line ();


@@ -729,7 +813,7 @@ read_a_source_file (name)
                  /* Expect pseudo-op or machine instruction.  */
                  pop = NULL;
 
                  /* Expect pseudo-op or machine instruction.  */
                  pop = NULL;
 

-#ifdef IGNORE_OPCODE_CASE
+#ifndef TC_CASE_SENSITIVE

                  {
                    char *s2 = s;
 
                  {
                    char *s2 = s;
 


@@ -738,16 +822,15 @@ read_a_source_file (name)
 
                    while (*s2)
                      {
 
                    while (*s2)
                      {

-                       if (isupper ((unsigned char) *s2))
-                         *s2 = tolower (*s2);
+                       *s2 = TOLOWER (*s2);

                        s2++;
                      }
                  }
 #endif
                  if (NO_PSEUDO_DOT || flag_m68k_mri)
                    {
                        s2++;
                      }
                  }
 #endif
                  if (NO_PSEUDO_DOT || flag_m68k_mri)
                    {

-                     /* The MRI assembler and the m88k use pseudo-ops
-                         without a period.  */
+                     /* The MRI assembler uses pseudo-ops without
+                        a period.  */

                      pop = (pseudo_typeS *) hash_find (po_hash, s);
                      if (pop != NULL && pop->poc_handler == NULL)
                        pop = NULL;
                      pop = (pseudo_typeS *) hash_find (po_hash, s);
                      if (pop != NULL && pop->poc_handler == NULL)
                        pop = NULL;


@@ -758,16 +841,18 @@ read_a_source_file (name)
                    {
                      /* PSEUDO - OP.
 
                    {
                      /* PSEUDO - OP.
 

-                        WARNING: c has next char, which may be end-of-line.
-                        We lookup the pseudo-op table with s+1 because we
-                        already know that the pseudo-op begins with a '.'.  */
+                        WARNING: c has next char, which may be end-of-line.
+                        We lookup the pseudo-op table with s+1 because we
+                        already know that the pseudo-op begins with a '.'.  */

 
                      if (pop == NULL)
                        pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
 
                      if (pop == NULL)
                        pop = (pseudo_typeS *) hash_find (po_hash, s + 1);

+                     if (pop && !pop->poc_handler)
+                       pop = NULL;

 
                      /* In MRI mode, we may need to insert an
 
                      /* In MRI mode, we may need to insert an

-                         automatic alignment directive.  What a hack
-                         this is.  */
+                        automatic alignment directive.  What a hack
+                        this is.  */

                      if (mri_pending_align
                          && (pop == NULL
                              || !((pop->poc_handler == cons
                      if (mri_pending_align
                          && (pop == NULL
                              || !((pop->poc_handler == cons


@@ -799,9 +884,18 @@ read_a_source_file (name)
                      /* Print the error msg now, while we still can.  */
                      if (pop == NULL)
                        {
                      /* Print the error msg now, while we still can.  */
                      if (pop == NULL)
                        {

-                         as_bad (_("Unknown pseudo-op:  `%s'"), s);
+                         char *end = input_line_pointer;
+

                          *input_line_pointer = c;
                          s_ignore (0);
                          *input_line_pointer = c;
                          s_ignore (0);

+                         c = *--input_line_pointer;
+                         *input_line_pointer = '\0';
+                         if (! macro_defined || ! try_macro (c, s))
+                           {
+                             *end = '\0';
+                             as_bad (_("unknown pseudo-op: `%s'"), s);
+                             *input_line_pointer++ = c;
+                           }

                          continue;
                        }
 
                          continue;
                        }
 


@@ -814,8 +908,8 @@ read_a_source_file (name)
                        input_line_pointer++;
 
                      /* Input_line is restored.
                        input_line_pointer++;
 
                      /* Input_line is restored.

-                        Input_line_pointer->1st non-blank char
-                        after pseudo-operation.  */
+                        Input_line_pointer->1st non-blank char
+                        after pseudo-operation.  */

                      (*pop->poc_handler) (pop->poc_val);
 
                      /* If that was .end, just get out now.  */
                      (*pop->poc_handler) (pop->poc_val);
 
                      /* If that was .end, just get out now.  */


@@ -824,61 +918,17 @@ read_a_source_file (name)
                    }
                  else
                    {
                    }
                  else
                    {

-                     int inquote = 0;
-#ifdef QUOTES_IN_INSN
-                     int inescape = 0;
-#endif
-

                      /* WARNING: c has char, which may be end-of-line.  */
                      /* Also: input_line_pointer->`\0` where c was.  */
                      *input_line_pointer = c;
                      /* WARNING: c has char, which may be end-of-line.  */
                      /* Also: input_line_pointer->`\0` where c was.  */
                      *input_line_pointer = c;

-                     while (!is_end_of_line[(unsigned char) *input_line_pointer]
-                            || inquote
-#ifdef TC_EOL_IN_INSN
-                            || TC_EOL_IN_INSN (input_line_pointer)
-#endif
-                            )
-                       {
-                         if (flag_m68k_mri && *input_line_pointer == '\'')
-                           inquote = !inquote;
-#ifdef QUOTES_IN_INSN
-                         if (inescape)
-                           inescape = 0;
-                         else if (*input_line_pointer == '"')
-                           inquote = !inquote;
-                         else if (*input_line_pointer == '\\')
-                           inescape = 1;
-#endif
-                         input_line_pointer++;
-                       }
-
+                     input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1);

                      c = *input_line_pointer;
                      *input_line_pointer = '\0';
 
                      generate_lineno_debug ();
 
                      c = *input_line_pointer;
                      *input_line_pointer = '\0';
 
                      generate_lineno_debug ();
 

-                     if (macro_defined)
-                       {
-                         sb out;
-                         const char *err;
-                         macro_entry *macro;
-
-                         if (check_macro (s, &out, '\0', &err, &macro))
-                           {
-                             if (err != NULL)
-                               as_bad ("%s", err);
-                             *input_line_pointer++ = c;
-                             input_scrub_include_sb (&out,
-                                                     input_line_pointer, 1);
-                             sb_kill (&out);
-                             buffer_limit =
-                               input_scrub_next_buffer (&input_line_pointer);
-#ifdef md_macro_info
-                             md_macro_info (macro);
-#endif
-                             continue;
-                           }
-                       }
+                     if (macro_defined && try_macro (c, s))
+                       continue;

 
                      if (mri_pending_align)
                        {
 
                      if (mri_pending_align)
                        {


@@ -906,8 +956,7 @@ read_a_source_file (name)
          if (is_end_of_line[(unsigned char) c])
            continue;
 
          if (is_end_of_line[(unsigned char) c])
            continue;
 

-         if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB)
-             && isdigit ((unsigned char) c))
+         if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (c))

            {
              /* local label  ("4:")  */
              char *backup = input_line_pointer;
            {
              /* local label  ("4:")  */
              char *backup = input_line_pointer;


@@ -917,7 +966,7 @@ read_a_source_file (name)
              temp = c - '0';
 
              /* Read the whole number.  */
              temp = c - '0';
 
              /* Read the whole number.  */

-             while (isdigit ((unsigned char) *input_line_pointer))
+             while (ISDIGIT (*input_line_pointer))

                {
                  temp = (temp * 10) + *input_line_pointer - '0';
                  ++input_line_pointer;
                {
                  temp = (temp * 10) + *input_line_pointer - '0';
                  ++input_line_pointer;


@@ -952,6 +1001,7 @@ read_a_source_file (name)
 
          if (c && strchr (line_comment_chars, c))
            {                   /* Its a comment.  Better say APP or NO_APP.  */
 
          if (c && strchr (line_comment_chars, c))
            {                   /* Its a comment.  Better say APP or NO_APP.  */

+             sb sbuf;

              char *ends;
              char *new_buf;
              char *new_tmp;
              char *ends;
              char *new_buf;
              char *new_tmp;


@@ -964,6 +1014,7 @@ read_a_source_file (name)
                continue;       /* We ignore it */
              s += 4;
 
                continue;       /* We ignore it */
              s += 4;
 

+             sb_new (&sbuf);

              ends = strstr (s, "#NO_APP\n");
 
              if (!ends)
              ends = strstr (s, "#NO_APP\n");
 
              if (!ends)


@@ -974,7 +1025,7 @@ read_a_source_file (name)
                  /* The end of the #APP wasn't in this buffer.  We
                     keep reading in buffers until we find the #NO_APP
                     that goes with this #APP  There is one.  The specs
                  /* The end of the #APP wasn't in this buffer.  We
                     keep reading in buffers until we find the #NO_APP
                     that goes with this #APP  There is one.  The specs

-                    guarentee it...  */
+                    guarantee it...  */

                  tmp_len = buffer_limit - s;
                  tmp_buf = xmalloc (tmp_len + 1);
                  memcpy (tmp_buf, s, tmp_len);
                  tmp_len = buffer_limit - s;
                  tmp_buf = xmalloc (tmp_len + 1);
                  memcpy (tmp_buf, s, tmp_len);


@@ -1025,7 +1076,7 @@ read_a_source_file (name)
 
                  if (size < space)
                    {
 
                  if (size < space)
                    {

-                     new_tmp += size;
+                     new_tmp[size] = 0;

                      break;
                    }
 
                      break;
                    }
 


@@ -1036,13 +1087,19 @@ read_a_source_file (name)
 
              if (tmp_buf)
                free (tmp_buf);
 
              if (tmp_buf)
                free (tmp_buf);

-             old_buffer = buffer;
-             old_input = input_line_pointer;
-             old_limit = buffer_limit;
-             buffer = new_buf;
-             input_line_pointer = new_buf;
-             buffer_limit = new_tmp;

 
 

+             /* We've "scrubbed" input to the preferred format.  In the
+                process we may have consumed the whole of the remaining
+                file (and included files).  We handle this formatted
+                input similar to that of macro expansion, letting
+                actual macro expansion (possibly nested) and other
+                input expansion work.  Beware that in messages, line
+                numbers and possibly file names will be incorrect.  */
+             sb_add_string (&sbuf, new_buf);
+             input_scrub_include_sb (&sbuf, input_line_pointer, 0);
+             sb_kill (&sbuf);
+             buffer_limit = input_scrub_next_buffer (&input_line_pointer);
+             free (new_buf);

              continue;
            }
 
              continue;
            }
 


@@ -1052,28 +1109,14 @@ read_a_source_file (name)
          if (tc_unrecognized_line (c))
            continue;
 #endif
          if (tc_unrecognized_line (c))
            continue;
 #endif

-         /* as_warn (_("Junk character %d."),c); Now done by ignore_rest.  */
-         input_line_pointer--; /* Report unknown char as ignored.  */
-         ignore_rest_of_line ();
+         input_line_pointer--;
+         /* Report unknown char as ignored.  */
+         demand_empty_rest_of_line ();

        }
 
 #ifdef md_after_pass_hook
       md_after_pass_hook ();
 #endif
        }
 
 #ifdef md_after_pass_hook
       md_after_pass_hook ();
 #endif

-
-      if (old_buffer)
-       {
-         free (buffer);
-         bump_line_counters ();
-         if (old_input != 0)
-           {
-             buffer = old_buffer;
-             input_line_pointer = old_input;
-             buffer_limit = old_limit;
-             old_buffer = 0;
-             goto contin;
-           }
-       }

     }
 
  quit:
     }
 
  quit:


@@ -1092,6 +1135,29 @@ read_a_source_file (name)
 #endif
 }
 
 #endif
 }
 

+/* Convert O_constant expression EXP into the equivalent O_big representation.
+   Take the sign of the number from X_unsigned rather than X_add_number.  */
+
+static void
+convert_to_bignum (expressionS *exp)
+{
+  valueT value;
+  unsigned int i;
+
+  value = exp->X_add_number;
+  for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++)
+    {
+      generic_bignum[i] = value & LITTLENUM_MASK;
+      value >>= LITTLENUM_NUMBER_OF_BITS;
+    }
+  /* Add a sequence of sign bits if the top bit of X_add_number is not
+     the sign of the original value.  */
+  if ((exp->X_add_number < 0) != !exp->X_unsigned)
+    generic_bignum[i++] = exp->X_unsigned ? 0 : LITTLENUM_MASK;
+  exp->X_op = O_big;
+  exp->X_add_number = i;
+}
+

 /* For most MRI pseudo-ops, the line actually ends at the first
    nonquoted space.  This function looks for that point, stuffs a null
    in, and sets *STOPCP to the character that used to be there, and
 /* For most MRI pseudo-ops, the line actually ends at the first
    nonquoted space.  This function looks for that point, stuffs a null
    in, and sets *STOPCP to the character that used to be there, and


@@ -1101,8 +1167,7 @@ read_a_source_file (name)
    for the m68k MRI assembler.  */
 
 char *
    for the m68k MRI assembler.  */
 
 char *

-mri_comment_field (stopcp)
-     char *stopcp;
+mri_comment_field (char *stopcp)

 {
   char *s;
 #ifdef TC_M68K
 {
   char *s;
 #ifdef TC_M68K


@@ -1133,9 +1198,7 @@ mri_comment_field (stopcp)
 /* Skip to the end of an MRI comment field.  */
 
 void
 /* Skip to the end of an MRI comment field.  */
 
 void

-mri_comment_end (stop, stopc)
-     char *stop;
-     int stopc;
+mri_comment_end (char *stop, int stopc)

 {
   know (flag_mri);
 
 {
   know (flag_mri);
 


@@ -1146,8 +1209,7 @@ mri_comment_end (stop, stopc)
 }
 
 void
 }
 
 void

-s_abort (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_abort (int ignore ATTRIBUTE_UNUSED)

 {
   as_fatal (_(".abort detected.  Abandoning ship."));
 }
 {
   as_fatal (_(".abort detected.  Abandoning ship."));
 }


@@ -1159,12 +1221,24 @@ s_abort (ignore)
    or 0 if there is no maximum.  */
 
 static void
    or 0 if there is no maximum.  */
 
 static void

-do_align (n, fill, len, max)
-     int n;
-     char *fill;
-     int len;
-     int max;
+do_align (int n, char *fill, int len, int max)

 {
 {

+  if (now_seg == absolute_section)
+    {
+      if (fill != NULL)
+       while (len-- > 0)
+         if (*fill++ != '\0')
+           {
+             as_warn (_("ignoring fill value in absolute section"));
+             break;
+           }
+      fill = NULL;
+      len = 0;
+    }
+
+#ifdef md_flush_pending_output
+  md_flush_pending_output ();
+#endif

 #ifdef md_do_align
   md_do_align (n, fill, len, max, just_record_alignment);
 #endif
 #ifdef md_do_align
   md_do_align (n, fill, len, max, just_record_alignment);
 #endif


@@ -1186,7 +1260,7 @@ do_align (n, fill, len, max)
     }
 
 #ifdef md_do_align
     }
 
 #ifdef md_do_align

- just_record_alignment:
+ just_record_alignment: ATTRIBUTE_UNUSED_LABEL

 #endif
 
   record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);
 #endif
 
   record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);


@@ -1197,12 +1271,13 @@ do_align (n, fill, len, max)
    fill pattern.  BYTES_P is non-zero if the alignment value should be
    interpreted as the byte boundary, rather than the power of 2.  */
 
    fill pattern.  BYTES_P is non-zero if the alignment value should be
    interpreted as the byte boundary, rather than the power of 2.  */
 

+#define ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
+

 static void
 static void

-s_align (arg, bytes_p)
-     int arg;
-     int bytes_p;
+s_align (int arg, int bytes_p)

 {
 {

-  register unsigned int align;
+  unsigned int align_limit = ALIGN_LIMIT;
+  unsigned int align;

   char *stop = NULL;
   char stopc;
   offsetT fill = 0;
   char *stop = NULL;
   char stopc;
   offsetT fill = 0;


@@ -1235,16 +1310,16 @@ s_align (arg, bytes_p)
          for (i = 0; (align & 1) == 0; align >>= 1, ++i)
            ;
          if (align != 1)
          for (i = 0; (align & 1) == 0; align >>= 1, ++i)
            ;
          if (align != 1)

-           as_bad (_("Alignment not a power of 2"));
+           as_bad (_("alignment not a power of 2"));

 
          align = i;
        }
     }
 
 
          align = i;
        }
     }
 

-  if (align > 15)
+  if (align > align_limit)

     {
     {

-      align = 15;
-      as_bad (_("Alignment too large: %u assumed"), align);
+      align = align_limit;
+      as_warn (_("alignment too large: %u assumed"), align);

     }
 
   if (*input_line_pointer != ',')
     }
 
   if (*input_line_pointer != ',')


@@ -1315,8 +1390,7 @@ s_align (arg, bytes_p)
    align to a 4 byte boundary.  */
 
 void
    align to a 4 byte boundary.  */
 
 void

-s_align_bytes (arg)
-     int arg;
+s_align_bytes (int arg)

 {
   s_align (arg, 1);
 }
 {
   s_align (arg, 1);
 }


@@ -1325,23 +1399,32 @@ s_align_bytes (arg)
    to a 2**4 boundary.  */
 
 void
    to a 2**4 boundary.  */
 
 void

-s_align_ptwo (arg)
-     int arg;
+s_align_ptwo (int arg)

 {
   s_align (arg, 0);
 }
 
 {
   s_align (arg, 0);
 }
 

+/* Switch in and out of alternate macro mode.  */
+

 void
 void

-s_comm (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_altmacro (int on)

 {
 {

-  register char *name;
-  register char c;
-  register char *p;
-  offsetT temp;
-  register symbolS *symbolP;
+  demand_empty_rest_of_line ();
+  macro_set_alternate (on);
+}
+
+symbolS *
+s_comm_internal (int param,
+                symbolS *(*comm_parse_extra) (int, symbolS *, addressT))
+{
+  char *name;
+  char c;
+  char *p;
+  offsetT temp, size;
+  symbolS *symbolP = NULL;

   char *stop = NULL;
   char stopc;
   char *stop = NULL;
   char stopc;

+  expressionS exp;

 
   if (flag_mri)
     stop = mri_comment_field (&stopc);
 
   if (flag_mri)
     stop = mri_comment_field (&stopc);


@@ -1351,77 +1434,100 @@ s_comm (ignore)
   /* Just after name is now '\0'.  */
   p = input_line_pointer;
   *p = c;
   /* Just after name is now '\0'.  */
   p = input_line_pointer;
   *p = c;

-  SKIP_WHITESPACE ();

 
 

-  if (*input_line_pointer != ',')
+  if (name == p)

     {
     {

-      as_bad (_("Expected comma after symbol-name: rest of line ignored."));
+      as_bad (_("expected symbol name"));

       ignore_rest_of_line ();
       ignore_rest_of_line ();

-      if (flag_mri)
-       mri_comment_end (stop, stopc);
-      return;
+      goto out;

     }
 
     }
 

-  input_line_pointer++;                /* skip ',' */
+  SKIP_WHITESPACE ();
+
+  /* Accept an optional comma after the name.  The comma used to be
+     required, but Irix 5 cc does not generate it for .lcomm.  */
+  if (*input_line_pointer == ',')
+    input_line_pointer++;

 
 

-  if ((temp = get_absolute_expression ()) < 0)
+  temp = get_absolute_expr (&exp);
+  size = temp;
+  size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
+  if (exp.X_op == O_absent)

     {
     {

-      as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp);
+      as_bad (_("missing size expression"));

       ignore_rest_of_line ();
       ignore_rest_of_line ();

-      if (flag_mri)
-       mri_comment_end (stop, stopc);
-      return;
+      goto out;

     }
     }

-
-  *p = 0;
-  symbolP = symbol_find_or_make (name);
-  *p = c;
-
-  if (S_IS_DEFINED (symbolP) && !S_IS_COMMON (symbolP))
+  else if (temp != size || !exp.X_unsigned)

     {
     {

-      as_bad (_("Ignoring attempt to re-define symbol `%s'."),
-             S_GET_NAME (symbolP));
+      as_warn (_("size (%ld) out of range, ignored"), (long) temp);

       ignore_rest_of_line ();
       ignore_rest_of_line ();

-      if (flag_mri)
-       mri_comment_end (stop, stopc);
-      return;
+      goto out;

     }
 
     }
 

-  if (S_GET_VALUE (symbolP))
+  *p = 0;
+  symbolP = symbol_find_or_make (name);
+  if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
+      && !S_IS_COMMON (symbolP))

     {
     {

-      if (S_GET_VALUE (symbolP) != (valueT) temp)
-       as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
-               S_GET_NAME (symbolP),
-               (long) S_GET_VALUE (symbolP),
-               (long) temp);
+      if (!S_IS_VOLATILE (symbolP))
+       {
+         symbolP = NULL;
+         as_bad (_("symbol `%s' is already defined"), name);
+         *p = c;
+         ignore_rest_of_line ();
+         goto out;
+       }
+      symbolP = symbol_clone (symbolP, 1);
+      S_SET_SEGMENT (symbolP, undefined_section);
+      S_SET_VALUE (symbolP, 0);
+      symbol_set_frag (symbolP, &zero_address_frag);
+      S_CLEAR_VOLATILE (symbolP);

     }
     }

+
+  size = S_GET_VALUE (symbolP);
+  if (size == 0)
+    size = temp;
+  else if (size != temp)
+    as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
+            name, (long) size, (long) temp);
+
+  *p = c;
+  if (comm_parse_extra != NULL)
+    symbolP = (*comm_parse_extra) (param, symbolP, size);

   else
     {
   else
     {

-      S_SET_VALUE (symbolP, (valueT) temp);
+      S_SET_VALUE (symbolP, (valueT) size);

       S_SET_EXTERNAL (symbolP);
       S_SET_EXTERNAL (symbolP);

-    }
+      S_SET_SEGMENT (symbolP, bfd_com_section_ptr);

 #ifdef OBJ_VMS
 #ifdef OBJ_VMS

-  {
-    extern int flag_one;
-    if (!temp || !flag_one)
-      S_GET_OTHER(symbolP) = const_flag;
-  }
-#endif /* not OBJ_VMS */
-  know (symbolP->sy_frag == &zero_address_frag);
+      {
+       extern int flag_one;
+       if (size == 0 || !flag_one)
+         S_GET_OTHER (symbolP) = const_flag;
+      }
+#endif
+    }

 
   demand_empty_rest_of_line ();
 
   demand_empty_rest_of_line ();

-
+ out:

   if (flag_mri)
     mri_comment_end (stop, stopc);
   if (flag_mri)
     mri_comment_end (stop, stopc);

-}                              /* s_comm() */
+  return symbolP;
+}
+
+void
+s_comm (int ignore)
+{
+  s_comm_internal (ignore, NULL);
+}

 
 /* The MRI COMMON pseudo-op.  We handle this by creating a common
    symbol with the appropriate name.  We make s_space do the right
    thing by increasing the size.  */
 
 void
 
 /* The MRI COMMON pseudo-op.  We handle this by creating a common
    symbol with the appropriate name.  We make s_space do the right
    thing by increasing the size.  */
 
 void

-s_mri_common (small)
-     int small ATTRIBUTE_UNUSED;
+s_mri_common (int small ATTRIBUTE_UNUSED)

 {
   char *name;
   char c;
 {
   char *name;
   char c;


@@ -1442,7 +1548,7 @@ s_mri_common (small)
   SKIP_WHITESPACE ();
 
   name = input_line_pointer;
   SKIP_WHITESPACE ();
 
   name = input_line_pointer;

-  if (!isdigit ((unsigned char) *name))
+  if (!ISDIGIT (*name))

     c = get_symbol_end ();
   else
     {
     c = get_symbol_end ();
   else
     {


@@ -1450,7 +1556,7 @@ s_mri_common (small)
        {
          ++input_line_pointer;
        }
        {
          ++input_line_pointer;
        }

-      while (isdigit ((unsigned char) *input_line_pointer));
+      while (ISDIGIT (*input_line_pointer));

 
       c = *input_line_pointer;
       *input_line_pointer = '\0';
 
       c = *input_line_pointer;
       *input_line_pointer = '\0';


@@ -1480,13 +1586,14 @@ s_mri_common (small)
 
   if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
     {
 
   if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
     {

-      as_bad (_("attempt to re-define symbol `%s'"), S_GET_NAME (sym));
+      as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym));

       ignore_rest_of_line ();
       mri_comment_end (stop, stopc);
       return;
     }
 
   S_SET_EXTERNAL (sym);
       ignore_rest_of_line ();
       mri_comment_end (stop, stopc);
       return;
     }
 
   S_SET_EXTERNAL (sym);

+  S_SET_SEGMENT (sym, bfd_com_section_ptr);

   mri_common_symbol = sym;
 
 #ifdef S_SET_ALIGN
   mri_common_symbol = sym;
 
 #ifdef S_SET_ALIGN


@@ -1520,8 +1627,7 @@ s_mri_common (small)
 }
 
 void
 }
 
 void

-s_data (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_data (int ignore ATTRIBUTE_UNUSED)

 {
   segT section;
   register int temp;
 {
   segT section;
   register int temp;


@@ -1551,8 +1657,20 @@ s_data (ignore)
    .file.  */
 
 void
    .file.  */
 
 void

-s_app_file (appfile)
-     int appfile;
+s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
+{
+#ifdef LISTING
+  if (listing)
+    listing_source_file (file);
+#endif
+  register_dependency (file);
+#ifdef obj_app_file
+  obj_app_file (file, appfile);
+#endif
+}
+
+void
+s_app_file (int appfile)

 {
   register char *s;
   int length;
 {
   register char *s;
   int length;


@@ -1567,7 +1685,7 @@ s_app_file (appfile)
        = (!new_logical_line (s, appfile ? -2 : -1) && appfile);
 
       /* In MRI mode, the preprocessor may have inserted an extraneous
        = (!new_logical_line (s, appfile ? -2 : -1) && appfile);
 
       /* In MRI mode, the preprocessor may have inserted an extraneous

-         backquote.  */
+        backquote.  */

       if (flag_m68k_mri
          && *input_line_pointer == '\''
          && is_end_of_line[(unsigned char) input_line_pointer[1]])
       if (flag_m68k_mri
          && *input_line_pointer == '\''
          && is_end_of_line[(unsigned char) input_line_pointer[1]])


@@ -1575,16 +1693,7 @@ s_app_file (appfile)
 
       demand_empty_rest_of_line ();
       if (!may_omit)
 
       demand_empty_rest_of_line ();
       if (!may_omit)

-       {
-#ifdef LISTING
-         if (listing)
-           listing_source_file (s);
-#endif
-         register_dependency (s);
-#ifdef obj_app_file
-         obj_app_file (s);
-#endif
-       }
+       s_app_file_string (s, appfile);

     }
 }
 
     }
 }
 


@@ -1594,17 +1703,24 @@ s_app_file (appfile)
    pseudo-ops.  */
 
 void
    pseudo-ops.  */
 
 void

-s_app_line (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_app_line (int ignore ATTRIBUTE_UNUSED)

 {
   int l;
 
   /* The given number is that of the next line.  */
   l = get_absolute_expression () - 1;
 {
   int l;
 
   /* The given number is that of the next line.  */
   l = get_absolute_expression () - 1;

-  if (l < 0)
+
+  if (l < -1)

     /* Some of the back ends can't deal with non-positive line numbers.
     /* Some of the back ends can't deal with non-positive line numbers.

-       Besides, it's silly.  */
-    as_warn (_("Line numbers must be positive; line number %d rejected."),
+       Besides, it's silly.  GCC however will generate a line number of
+       zero when it is pre-processing builtins for assembler-with-cpp files:
+
+          # 0 "<built-in>"
+
+       We do not want to barf on this, especially since such files are used
+       in the GCC and GDB testsuites.  So we check for negative line numbers
+       rather than non-positive line numbers.  */
+    as_warn (_("line numbers must be positive; line number %d rejected"),

             l + 1);
   else
     {
             l + 1);
   else
     {


@@ -1621,13 +1737,12 @@ s_app_line (ignore)
    read_a_source_file.  */
 
 void
    read_a_source_file.  */
 
 void

-s_end (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_end (int ignore ATTRIBUTE_UNUSED)

 {
   if (flag_mri)
     {
       /* The MRI assembler permits the start symbol to follow .end,
 {
   if (flag_mri)
     {
       /* The MRI assembler permits the start symbol to follow .end,

-         but we don't support that.  */
+        but we don't support that.  */

       SKIP_WHITESPACE ();
       if (!is_end_of_line[(unsigned char) *input_line_pointer]
          && *input_line_pointer != '*'
       SKIP_WHITESPACE ();
       if (!is_end_of_line[(unsigned char) *input_line_pointer]
          && *input_line_pointer != '*'


@@ -1639,18 +1754,53 @@ s_end (ignore)
 /* Handle the .err pseudo-op.  */
 
 void
 /* Handle the .err pseudo-op.  */
 
 void

-s_err (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_err (int ignore ATTRIBUTE_UNUSED)

 {
   as_bad (_(".err encountered"));
   demand_empty_rest_of_line ();
 }
 
 {
   as_bad (_(".err encountered"));
   demand_empty_rest_of_line ();
 }
 

+/* Handle the .error and .warning pseudo-ops.  */
+
+void
+s_errwarn (int err)
+{
+  int len;
+  /* The purpose for the conditional assignment is not to
+     internationalize the directive itself, but that we need a
+     self-contained message, one that can be passed like the
+     demand_copy_C_string return value, and with no assumption on the
+     location of the name of the directive within the message.  */
+  char *msg
+    = (err ? _(".error directive invoked in source file")
+       : _(".warning directive invoked in source file"));
+
+  if (!is_it_end_of_statement ())
+    {
+      if (*input_line_pointer != '\"')
+       {
+         as_bad (_("%s argument must be a string"),
+                 err ? ".error" : ".warning");
+         ignore_rest_of_line ();
+         return;
+       }
+
+      msg = demand_copy_C_string (&len);
+      if (msg == NULL)
+       return;
+    }
+
+  if (err)
+    as_bad ("%s", msg);
+  else
+    as_warn ("%s", msg);
+  demand_empty_rest_of_line ();
+}
+

 /* Handle the MRI fail pseudo-op.  */
 
 void
 /* Handle the MRI fail pseudo-op.  */
 
 void

-s_fail (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_fail (int ignore ATTRIBUTE_UNUSED)

 {
   offsetT temp;
   char *stop = NULL;
 {
   offsetT temp;
   char *stop = NULL;


@@ -1672,8 +1822,7 @@ s_fail (ignore)
 }
 
 void
 }
 
 void

-s_fill (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_fill (int ignore ATTRIBUTE_UNUSED)

 {
   expressionS rep_exp;
   long size = 1;
 {
   expressionS rep_exp;
   long size = 1;


@@ -1700,18 +1849,18 @@ s_fill (ignore)
 #define BSD_FILL_SIZE_CROCK_8 (8)
   if (size > BSD_FILL_SIZE_CROCK_8)
     {
 #define BSD_FILL_SIZE_CROCK_8 (8)
   if (size > BSD_FILL_SIZE_CROCK_8)
     {

-      as_warn (_(".fill size clamped to %d."), BSD_FILL_SIZE_CROCK_8);
+      as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8);

       size = BSD_FILL_SIZE_CROCK_8;
     }
   if (size < 0)
     {
       size = BSD_FILL_SIZE_CROCK_8;
     }
   if (size < 0)
     {

-      as_warn (_("Size negative: .fill ignored."));
+      as_warn (_("size negative; .fill ignored"));

       size = 0;
     }
   else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
     {
       if (rep_exp.X_add_number < 0)
       size = 0;
     }
   else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
     {
       if (rep_exp.X_add_number < 0)

-       as_warn (_("Repeat < 0, .fill ignored"));
+       as_warn (_("repeat < 0; .fill ignored"));

       size = 0;
     }
 
       size = 0;
     }
 


@@ -1753,26 +1902,25 @@ s_fill (ignore)
       memset (p, 0, (unsigned int) size);
 
       /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
       memset (p, 0, (unsigned int) size);
 
       /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX

-         flavoured AS.  The following bizzare behaviour is to be
-         compatible with above.  I guess they tried to take up to 8
-         bytes from a 4-byte expression and they forgot to sign
-         extend. Un*x Sux.  */
+        flavoured AS.  The following bizarre behaviour is to be
+        compatible with above.  I guess they tried to take up to 8
+        bytes from a 4-byte expression and they forgot to sign
+        extend.  */

 #define BSD_FILL_SIZE_CROCK_4 (4)
       md_number_to_chars (p, (valueT) fill,
                          (size > BSD_FILL_SIZE_CROCK_4
                           ? BSD_FILL_SIZE_CROCK_4
                           : (int) size));
       /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
 #define BSD_FILL_SIZE_CROCK_4 (4)
       md_number_to_chars (p, (valueT) fill,
                          (size > BSD_FILL_SIZE_CROCK_4
                           ? BSD_FILL_SIZE_CROCK_4
                           : (int) size));
       /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)

-         but emits no error message because it seems a legal thing to do.
-         It is a degenerate case of .fill but could be emitted by a
+        but emits no error message because it seems a legal thing to do.
+        It is a degenerate case of .fill but could be emitted by a

         compiler.  */
     }
   demand_empty_rest_of_line ();
 }
 
 void
         compiler.  */
     }
   demand_empty_rest_of_line ();
 }
 
 void

-s_globl (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_globl (int ignore ATTRIBUTE_UNUSED)

 {
   char *name;
   int c;
 {
   char *name;
   int c;


@@ -1797,7 +1945,7 @@ s_globl (ignore)
        {
          input_line_pointer++;
          SKIP_WHITESPACE ();
        {
          input_line_pointer++;
          SKIP_WHITESPACE ();

-         if (*input_line_pointer == '\n')
+         if (is_end_of_line[(unsigned char) *input_line_pointer])

            c = '\n';
        }
     }
            c = '\n';
        }
     }


@@ -1812,10 +1960,9 @@ s_globl (ignore)
 /* Handle the MRI IRP and IRPC pseudo-ops.  */
 
 void
 /* Handle the MRI IRP and IRPC pseudo-ops.  */
 
 void

-s_irp (irpc)
-     int irpc;
+s_irp (int irpc)

 {
 {

-  char *file;
+  char *file, *eol;

   unsigned int line;
   sb s;
   const char *err;
   unsigned int line;
   sb s;
   const char *err;


@@ -1824,12 +1971,13 @@ s_irp (irpc)
   as_where (&file, &line);
 
   sb_new (&s);
   as_where (&file, &line);
 
   sb_new (&s);

-  while (!is_end_of_line[(unsigned char) *input_line_pointer])
-    sb_add_char (&s, *input_line_pointer++);
+  eol = find_end_of_line (input_line_pointer, 0);
+  sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
+  input_line_pointer = eol;

 
   sb_new (&out);
 
 
   sb_new (&out);
 

-  err = expand_irp (irpc, 0, &s, &out, get_line_sb, '\0');
+  err = expand_irp (irpc, 0, &s, &out, get_line_sb);

   if (err != NULL)
     as_bad_where (file, line, "%s", err);
 
   if (err != NULL)
     as_bad_where (file, line, "%s", err);
 


@@ -1846,8 +1994,7 @@ s_irp (irpc)
    which is what to do about duplicates.  */
 
 void
    which is what to do about duplicates.  */
 
 void

-s_linkonce (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_linkonce (int ignore ATTRIBUTE_UNUSED)

 {
   enum linkonce_type type;
 
 {
   enum linkonce_type type;
 


@@ -1879,7 +2026,6 @@ s_linkonce (ignore)
 #ifdef obj_handle_link_once
   obj_handle_link_once (type);
 #else /* ! defined (obj_handle_link_once) */
 #ifdef obj_handle_link_once
   obj_handle_link_once (type);
 #else /* ! defined (obj_handle_link_once) */

-#ifdef BFD_ASSEMBLER

   {
     flagword flags;
 
   {
     flagword flags;
 


@@ -1909,227 +2055,150 @@ s_linkonce (ignore)
       as_bad (_("bfd_set_section_flags: %s"),
              bfd_errmsg (bfd_get_error ()));
   }
       as_bad (_("bfd_set_section_flags: %s"),
              bfd_errmsg (bfd_get_error ()));
   }

-#else /* ! defined (BFD_ASSEMBLER) */
-  as_warn (_(".linkonce is not supported for this object file format"));
-#endif /* ! defined (BFD_ASSEMBLER) */

 #endif /* ! defined (obj_handle_link_once) */
 
   demand_empty_rest_of_line ();
 }
 
 #endif /* ! defined (obj_handle_link_once) */
 
   demand_empty_rest_of_line ();
 }
 

-static void
-s_lcomm_internal (needs_align, bytes_p)
-     /* 1 if this was a ".bss" directive, which may require a 3rd argument
-       (alignment); 0 if it was an ".lcomm" (2 args only).  */
-     int needs_align;
-     /* 1 if the alignment value should be interpreted as the byte boundary,
-       rather than the power of 2.  */
-     int bytes_p;
+void
+bss_alloc (symbolS *symbolP, addressT size, int align)

 {
 {

-  register char *name;
-  register char c;
-  register char *p;
-  register int temp;
-  register symbolS *symbolP;
+  char *pfrag;

   segT current_seg = now_seg;
   subsegT current_subseg = now_subseg;
   segT current_seg = now_seg;
   subsegT current_subseg = now_subseg;

-  const int max_alignment = 15;
-  int align = 0;

   segT bss_seg = bss_section;
 
   segT bss_seg = bss_section;
 

-  name = input_line_pointer;
-  c = get_symbol_end ();
-  p = input_line_pointer;
-  *p = c;
-  SKIP_WHITESPACE ();
-
-  /* Accept an optional comma after the name.  The comma used to be
-     required, but Irix 5 cc does not generate it.  */
-  if (*input_line_pointer == ',')
-    {
-      ++input_line_pointer;
-      SKIP_WHITESPACE ();
-    }
-
-  if (*input_line_pointer == '\n')
-    {
-      as_bad (_("Missing size expression"));
-      return;
-    }
-
-  if ((temp = get_absolute_expression ()) < 0)
-    {
-      as_warn (_("BSS length (%d.) <0! Ignored."), temp);
-      ignore_rest_of_line ();
-      return;
-    }
-

 #if defined (TC_MIPS) || defined (TC_ALPHA)
   if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
       || OUTPUT_FLAVOR == bfd_target_elf_flavour)
     {
       /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss.  */
 #if defined (TC_MIPS) || defined (TC_ALPHA)
   if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
       || OUTPUT_FLAVOR == bfd_target_elf_flavour)
     {
       /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss.  */

-      if (temp <= bfd_get_gp_size (stdoutput))
+      if (size <= bfd_get_gp_size (stdoutput))

        {
          bss_seg = subseg_new (".sbss", 1);
          seg_info (bss_seg)->bss = 1;
        {
          bss_seg = subseg_new (".sbss", 1);
          seg_info (bss_seg)->bss = 1;

-#ifdef BFD_ASSEMBLER

          if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
            as_warn (_("error setting flags for \".sbss\": %s"),
                     bfd_errmsg (bfd_get_error ()));
          if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
            as_warn (_("error setting flags for \".sbss\": %s"),
                     bfd_errmsg (bfd_get_error ()));

-#endif

        }
     }
 #endif
        }
     }
 #endif

+  subseg_set (bss_seg, 1);

 
 

-  if (!needs_align)
+  if (align)

     {
     {

-      TC_IMPLICIT_LCOMM_ALIGNMENT (temp, align);
+      record_alignment (bss_seg, align);
+      frag_align (align, 0, 0);
+    }
+
+  /* Detach from old frag.  */
+  if (S_GET_SEGMENT (symbolP) == bss_seg)
+    symbol_get_frag (symbolP)->fr_symbol = NULL;
+
+  symbol_set_frag (symbolP, frag_now);
+  pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
+  *pfrag = 0;
+
+#ifdef S_SET_SIZE
+  S_SET_SIZE (symbolP, size);
+#endif
+  S_SET_SEGMENT (symbolP, bss_seg);

 
 

-      /* Still zero unless TC_IMPLICIT_LCOMM_ALIGNMENT set it.  */
-      if (align)
-       record_alignment (bss_seg, align);
+#ifdef OBJ_COFF
+  /* The symbol may already have been created with a preceding
+     ".globl" directive -- be careful not to step on storage class
+     in that case.  Otherwise, set it to static.  */
+  if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
+    S_SET_STORAGE_CLASS (symbolP, C_STAT);
+#endif /* OBJ_COFF */
+
+  subseg_set (current_seg, current_subseg);
+}
+
+offsetT
+parse_align (int align_bytes)
+{
+  expressionS exp;
+  addressT align;
+
+  SKIP_WHITESPACE ();
+  if (*input_line_pointer != ',')
+    {
+    no_align:
+      as_bad (_("expected alignment after size"));
+      ignore_rest_of_line ();
+      return -1;

     }
 
     }
 

-  if (needs_align)
+  input_line_pointer++;
+  SKIP_WHITESPACE ();
+
+  align = get_absolute_expr (&exp);
+  if (exp.X_op == O_absent)
+    goto no_align;
+
+  if (!exp.X_unsigned)

     {
     {

+      as_warn (_("alignment negative; 0 assumed"));

       align = 0;
       align = 0;

-      SKIP_WHITESPACE ();
+    }

 
 

-      if (*input_line_pointer != ',')
+  if (align_bytes && align != 0)
+    {
+      /* convert to a power of 2 alignment */
+      unsigned int alignp2 = 0;
+      while ((align & 1) == 0)
+       align >>= 1, ++alignp2;
+      if (align != 1)

        {
        {

-         as_bad (_("Expected comma after size"));
+         as_bad (_("alignment not a power of 2"));

          ignore_rest_of_line ();
          ignore_rest_of_line ();

-         return;
+         return -1;

        }
        }

+      align = alignp2;
+    }
+  return align;
+}

 
 

-      input_line_pointer++;
-      SKIP_WHITESPACE ();
+/* Called from s_comm_internal after symbol name and size have been
+   parsed.  NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
+   1 if this was a ".bss" directive which has a 3rd argument
+   (alignment as a power of 2), or 2 if this was a ".bss" directive
+   with alignment in bytes.  */

 
 

-      if (*input_line_pointer == '\n')
-       {
-         as_bad (_("Missing alignment"));
-         return;
-       }
-
-      align = get_absolute_expression ();
-
-      if (bytes_p)
-       {
-         /* Convert to a power of 2.  */
-         if (align != 0)
-           {
-             unsigned int i;
-
-             for (i = 0; (align & 1) == 0; align >>= 1, ++i)
-               ;
-             if (align != 1)
-               as_bad (_("Alignment not a power of 2"));
-             align = i;
-           }
-       }
-
-      if (align > max_alignment)
-       {
-         align = max_alignment;
-         as_warn (_("Alignment too large: %d. assumed."), align);
-       }
-      else if (align < 0)
-       {
-         align = 0;
-         as_warn (_("Alignment negative. 0 assumed."));
-       }
-
-      record_alignment (bss_seg, align);
-    }
-  else
-    {
-      /* Assume some objects may require alignment on some systems.  */
-#if defined (TC_ALPHA) && ! defined (VMS)
-      if (temp > 1)
-       {
-         align = ffs (temp) - 1;
-         if (temp % (1 << align))
-           abort ();
-       }
-#endif
-    }
-
-  *p = 0;
-  symbolP = symbol_find_or_make (name);
-  *p = c;
+symbolS *
+s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
+{
+  addressT align = 0;

 
 

-  if (
-#if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT) \
-     || defined (OBJ_BOUT) || defined (OBJ_MAYBE_BOUT))
-#ifdef BFD_ASSEMBLER
-      (OUTPUT_FLAVOR != bfd_target_aout_flavour
-       || (S_GET_OTHER (symbolP) == 0 && S_GET_DESC (symbolP) == 0)) &&
-#else
-      (S_GET_OTHER (symbolP) == 0 && S_GET_DESC (symbolP) == 0) &&
-#endif
-#endif
-      (S_GET_SEGMENT (symbolP) == bss_seg
-       || (!S_IS_DEFINED (symbolP) && S_GET_VALUE (symbolP) == 0)))
+  if (needs_align)

     {
     {

-      char *pfrag;
-
-      subseg_set (bss_seg, 1);
-
-      if (align)
-       frag_align (align, 0, 0);
-
-      /* Detach from old frag.  */
-      if (S_GET_SEGMENT (symbolP) == bss_seg)
-       symbol_get_frag (symbolP)->fr_symbol = NULL;
-
-      symbol_set_frag (symbolP, frag_now);
-      pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
-                       (offsetT) temp, (char *) 0);
-      *pfrag = 0;
-
-      S_SET_SEGMENT (symbolP, bss_seg);
-
-#ifdef OBJ_COFF
-      /* The symbol may already have been created with a preceding
-         ".globl" directive -- be careful not to step on storage class
-         in that case.  Otherwise, set it to static.  */
-      if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
-       {
-         S_SET_STORAGE_CLASS (symbolP, C_STAT);
-       }
-#endif /* OBJ_COFF */
-
-#ifdef S_SET_SIZE
-      S_SET_SIZE (symbolP, temp);
-#endif
+      align = parse_align (needs_align - 1);
+      if (align == (addressT) -1)
+       return NULL;

     }
   else
     }
   else

-    as_bad (_("Ignoring attempt to re-define symbol `%s'."),
-           S_GET_NAME (symbolP));
+    /* Assume some objects may require alignment on some systems.  */
+    TC_IMPLICIT_LCOMM_ALIGNMENT (size, align);

 
 

-  subseg_set (current_seg, current_subseg);
-
-  demand_empty_rest_of_line ();
+  bss_alloc (symbolP, size, align);
+  return symbolP;

 }
 
 void
 }
 
 void

-s_lcomm (needs_align)
-     int needs_align;
+s_lcomm (int needs_align)

 {
 {

-  s_lcomm_internal (needs_align, 0);
+  s_comm_internal (needs_align, s_lcomm_internal);

 }
 
 void
 }
 
 void

-s_lcomm_bytes (needs_align)
-     int needs_align;
+s_lcomm_bytes (int needs_align)

 {
 {

-  s_lcomm_internal (needs_align, 1);
+  s_comm_internal (needs_align * 2, s_lcomm_internal);

 }
 
 void
 }
 
 void

-s_lsym (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_lsym (int ignore ATTRIBUTE_UNUSED)

 {
   register char *name;
   register char c;
 {
   register char *name;
   register char c;


@@ -2142,19 +2211,27 @@ s_lsym (ignore)
   c = get_symbol_end ();
   p = input_line_pointer;
   *p = c;
   c = get_symbol_end ();
   p = input_line_pointer;
   *p = c;

+
+  if (name == p)
+    {
+      as_bad (_("expected symbol name"));
+      ignore_rest_of_line ();
+      return;
+    }
+

   SKIP_WHITESPACE ();
 
   if (*input_line_pointer != ',')
     {
       *p = 0;
   SKIP_WHITESPACE ();
 
   if (*input_line_pointer != ',')
     {
       *p = 0;

-      as_bad (_("Expected comma after name \"%s\""), name);
+      as_bad (_("expected comma after \"%s\""), name);

       *p = c;
       ignore_rest_of_line ();
       return;
     }
 
   input_line_pointer++;
       *p = c;
       ignore_rest_of_line ();
       return;
     }
 
   input_line_pointer++;

-  expression (&exp);
+  expression_and_evaluate (&exp);

 
   if (exp.X_op != O_constant
       && exp.X_op != O_register)
 
   if (exp.X_op != O_constant
       && exp.X_op != O_register)


@@ -2167,15 +2244,7 @@ s_lsym (ignore)
   *p = 0;
   symbolP = symbol_find_or_make (name);
 
   *p = 0;
   symbolP = symbol_find_or_make (name);
 

-  /* FIXME-SOON I pulled a (&& symbolP->sy_other == 0 &&
-     symbolP->sy_desc == 0) out of this test because coff doesn't have
-     those fields, and I can't see when they'd ever be tripped.  I
-     don't think I understand why they were here so I may have
-     introduced a bug. As recently as 1.37 didn't have this test
-     anyway.  xoxorich.  */
-
-  if (S_GET_SEGMENT (symbolP) == undefined_section
-      && S_GET_VALUE (symbolP) == 0)
+  if (S_GET_SEGMENT (symbolP) == undefined_section)

     {
       /* The name might be an undefined .global symbol; be sure to
         keep the "external" bit.  */
     {
       /* The name might be an undefined .global symbol; be sure to
         keep the "external" bit.  */


@@ -2187,20 +2256,20 @@ s_lsym (ignore)
     }
   else
     {
     }
   else
     {

-      as_bad (_("Symbol %s already defined"), name);
+      as_bad (_("symbol `%s' is already defined"), name);

     }
 
   *p = c;
   demand_empty_rest_of_line ();
 }
 
     }
 
   *p = c;
   demand_empty_rest_of_line ();
 }
 

-/* Read a line into an sb.  */
+/* Read a line into an sb.  Returns the character that ended the line
+   or zero if there are no more lines.  */

 
 static int
 
 static int

-get_line_sb (line)
-     sb *line;
+get_line_sb (sb *line)

 {
 {

-  char quote1, quote2, inquote;
+  char *eol;

 
   if (input_line_pointer[-1] == '\n')
     bump_line_counters ();
 
   if (input_line_pointer[-1] == '\n')
     bump_line_counters ();


@@ -2212,81 +2281,54 @@ get_line_sb (line)
        return 0;
     }
 
        return 0;
     }
 

-  /* If app.c sets any other characters to LEX_IS_STRINGQUOTE, this
-     code needs to be changed.  */
-  if (!flag_m68k_mri)
-    quote1 = '"';
-  else
-    quote1 = '\0';
-
-  quote2 = '\0';
-  if (flag_m68k_mri)
-    quote2 = '\'';
-#ifdef LEX_IS_STRINGQUOTE
-  quote2 = '\'';
-#endif
+  eol = find_end_of_line (input_line_pointer, flag_m68k_mri);
+  sb_add_buffer (line, input_line_pointer, eol - input_line_pointer);
+  input_line_pointer = eol;

 
 

-  inquote = '\0';
-
-  while (!is_end_of_line[(unsigned char) *input_line_pointer]
-        || (inquote != '\0' && *input_line_pointer != '\n'))
-    {
-      if (inquote == *input_line_pointer)
-       inquote = '\0';
-      else if (inquote == '\0')
-       {
-         if (*input_line_pointer == quote1)
-           inquote = quote1;
-         else if (*input_line_pointer == quote2)
-           inquote = quote2;
-       }
-
-      sb_add_char (line, *input_line_pointer++);
-    }
-
-  while (input_line_pointer < buffer_limit
-        && is_end_of_line[(unsigned char) *input_line_pointer])
-    {
-      if (input_line_pointer[-1] == '\n')
-       bump_line_counters ();
-      ++input_line_pointer;
-    }
-
-  return 1;
+  /* Don't skip multiple end-of-line characters, because that breaks support
+     for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
+     characters but isn't.  Instead just skip one end of line character and
+     return the character skipped so that the caller can re-insert it if
+     necessary.   */
+  return *input_line_pointer++;

 }
 
 }
 

-/* Define a macro.  This is an interface to macro.c, which is shared
-   between gas and gasp.  */
+/* Define a macro.  This is an interface to macro.c.  */

 
 void
 
 void

-s_macro (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_macro (int ignore ATTRIBUTE_UNUSED)

 {
 {

-  char *file;
+  char *file, *eol;

   unsigned int line;
   sb s;
   unsigned int line;
   sb s;

-  sb label;

   const char *err;
   const char *name;
 
   as_where (&file, &line);
 
   sb_new (&s);
   const char *err;
   const char *name;
 
   as_where (&file, &line);
 
   sb_new (&s);

-  while (!is_end_of_line[(unsigned char) *input_line_pointer])
-    sb_add_char (&s, *input_line_pointer++);
+  eol = find_end_of_line (input_line_pointer, 0);
+  sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
+  input_line_pointer = eol;

 
 

-  sb_new (&label);

   if (line_label != NULL)
   if (line_label != NULL)

-    sb_add_string (&label, S_GET_NAME (line_label));
+    {
+      sb label;

 
 

-  err = define_macro (0, &s, &label, get_line_sb, &name);
+      sb_new (&label);
+      sb_add_string (&label, S_GET_NAME (line_label));
+      err = define_macro (0, &s, &label, get_line_sb, file, line, &name);
+      sb_kill (&label);
+    }
+  else
+    err = define_macro (0, &s, NULL, get_line_sb, file, line, &name);

   if (err != NULL)
   if (err != NULL)

-    as_bad_where (file, line, "%s", err);
+    as_bad_where (file, line, err, name);

   else
     {
       if (line_label != NULL)
        {
   else
     {
       if (line_label != NULL)
        {

-         S_SET_SEGMENT (line_label, undefined_section);
+         S_SET_SEGMENT (line_label, absolute_section);

          S_SET_VALUE (line_label, 0);
          symbol_set_frag (line_label, &zero_address_frag);
        }
          S_SET_VALUE (line_label, 0);
          symbol_set_frag (line_label, &zero_address_frag);
        }


@@ -2296,7 +2338,9 @@ s_macro (ignore)
          || (!flag_m68k_mri
              && *name == '.'
              && hash_find (po_hash, name + 1) != NULL))
          || (!flag_m68k_mri
              && *name == '.'
              && hash_find (po_hash, name + 1) != NULL))

-       as_warn (_("attempt to redefine pseudo-op `%s' ignored"),
+       as_warn_where (file,
+                line,
+                _("attempt to redefine pseudo-op `%s' ignored"),

                 name);
     }
 
                 name);
     }
 


@@ -2307,8 +2351,7 @@ s_macro (ignore)
    expansion.  */
 
 void
    expansion.  */
 
 void

-s_mexit (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_mexit (int ignore ATTRIBUTE_UNUSED)

 {
   cond_exit_macro (macro_nest);
   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
 {
   cond_exit_macro (macro_nest);
   buffer_limit = input_scrub_next_buffer (&input_line_pointer);


@@ -2317,8 +2360,7 @@ s_mexit (ignore)
 /* Switch in and out of MRI mode.  */
 
 void
 /* Switch in and out of MRI mode.  */
 
 void

-s_mri (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_mri (int ignore ATTRIBUTE_UNUSED)

 {
   int on, old_flag;
 
 {
   int on, old_flag;
 


@@ -2356,14 +2398,10 @@ s_mri (ignore)
 /* Handle changing the location counter.  */
 
 static void
 /* Handle changing the location counter.  */
 
 static void

-do_org (segment, exp, fill)
-     segT segment;
-     expressionS *exp;
-     int fill;
+do_org (segT segment, expressionS *exp, int fill)

 {
   if (segment != now_seg && segment != absolute_section)
 {
   if (segment != now_seg && segment != absolute_section)

-    as_bad (_("invalid segment \"%s\"; segment \"%s\" assumed"),
-           segment_name (segment), segment_name (now_seg));
+    as_bad (_("invalid segment \"%s\""), segment_name (segment));

 
   if (now_seg == absolute_section)
     {
 
   if (now_seg == absolute_section)
     {


@@ -2395,8 +2433,7 @@ do_org (segment, exp, fill)
 }
 
 void
 }
 
 void

-s_org (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_org (int ignore ATTRIBUTE_UNUSED)

 {
   register segT segment;
   expressionS exp;
 {
   register segT segment;
   expressionS exp;


@@ -2447,12 +2484,10 @@ s_org (ignore)
    called by the obj-format routine which handles section changing
    when in MRI mode.  It will create a new section, and return it.  It
    will set *TYPE to the section type: one of 'C' (code), 'D' (data),
    called by the obj-format routine which handles section changing
    when in MRI mode.  It will create a new section, and return it.  It
    will set *TYPE to the section type: one of 'C' (code), 'D' (data),

-   'M' (mixed), or 'R' (romable).  If BFD_ASSEMBLER is defined, the
-   flags will be set in the section.  */
+   'M' (mixed), or 'R' (romable).  The flags will be set in the section.  */

 
 void
 
 void

-s_mri_sect (type)
-     char *type ATTRIBUTE_UNUSED;
+s_mri_sect (char *type ATTRIBUTE_UNUSED)

 {
 #ifdef TC_M68K
 
 {
 #ifdef TC_M68K
 


@@ -2463,7 +2498,7 @@ s_mri_sect (type)
   SKIP_WHITESPACE ();
 
   name = input_line_pointer;
   SKIP_WHITESPACE ();
 
   name = input_line_pointer;

-  if (!isdigit ((unsigned char) *name))
+  if (!ISDIGIT (*name))

     c = get_symbol_end ();
   else
     {
     c = get_symbol_end ();
   else
     {


@@ -2471,7 +2506,7 @@ s_mri_sect (type)
        {
          ++input_line_pointer;
        }
        {
          ++input_line_pointer;
        }

-      while (isdigit ((unsigned char) *input_line_pointer));
+      while (ISDIGIT (*input_line_pointer));

 
       c = *input_line_pointer;
       *input_line_pointer = '\0';
 
       c = *input_line_pointer;
       *input_line_pointer = '\0';


@@ -2496,14 +2531,13 @@ s_mri_sect (type)
   if (*input_line_pointer == ',')
     {
       c = *++input_line_pointer;
   if (*input_line_pointer == ',')
     {
       c = *++input_line_pointer;

-      c = toupper ((unsigned char) c);
+      c = TOUPPER (c);

       if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
        *type = c;
       else
        as_bad (_("unrecognized section type"));
       ++input_line_pointer;
 
       if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
        *type = c;
       else
        as_bad (_("unrecognized section type"));
       ++input_line_pointer;
 

-#ifdef BFD_ASSEMBLER

       {
        flagword flags;
 
       {
        flagword flags;
 


@@ -2522,7 +2556,6 @@ s_mri_sect (type)
                       bfd_errmsg (bfd_get_error ()));
          }
       }
                       bfd_errmsg (bfd_get_error ()));
          }
       }

-#endif

     }
 
   /* Ignore the HP type.  */
     }
 
   /* Ignore the HP type.  */


@@ -2616,22 +2649,21 @@ s_mri_sect (type)
 /* Handle the .print pseudo-op.  */
 
 void
 /* Handle the .print pseudo-op.  */
 
 void

-s_print (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_print (int ignore ATTRIBUTE_UNUSED)

 {
   char *s;
   int len;
 
   s = demand_copy_C_string (&len);
 {
   char *s;
   int len;
 
   s = demand_copy_C_string (&len);

-  printf ("%s\n", s);
+  if (s != NULL)
+    printf ("%s\n", s);

   demand_empty_rest_of_line ();
 }
 
 /* Handle the .purgem pseudo-op.  */
 
 void
   demand_empty_rest_of_line ();
 }
 
 /* Handle the .purgem pseudo-op.  */
 
 void

-s_purgem (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_purgem (int ignore ATTRIBUTE_UNUSED)

 {
   if (is_it_end_of_statement ())
     {
 {
   if (is_it_end_of_statement ())
     {


@@ -2657,11 +2689,21 @@ s_purgem (ignore)
   demand_empty_rest_of_line ();
 }
 
   demand_empty_rest_of_line ();
 }
 

+/* Handle the .endm/.endr pseudo-ops.  */
+
+static void
+s_bad_end (int endr)
+{
+  as_warn (_(".end%c encountered without preceeding %s"),
+          endr ? 'r' : 'm',
+          endr ? ".rept, .irp, or .irpc" : ".macro");
+  demand_empty_rest_of_line ();
+}
+

 /* Handle the .rept pseudo-op.  */
 
 void
 /* Handle the .rept pseudo-op.  */
 
 void

-s_rept (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+s_rept (int ignore ATTRIBUTE_UNUSED)

 {
   int count;
 
 {
   int count;
 


@@ -2674,10 +2716,7 @@ s_rept (ignore)
    different directives to be used as the start/end keys.  */
 
 void
    different directives to be used as the start/end keys.  */
 
 void

-do_repeat (count, start, end)
-     int count;
-     const char *start;
-     const char *end;
+do_repeat (int count, const char *start, const char *end)

 {
   sb one;
   sb many;
 {
   sb one;
   sb many;


@@ -2709,52 +2748,22 @@ do_repeat (count, start, end)
    such as line substitutions.  */
 
 void
    such as line substitutions.  */
 
 void

-end_repeat (extra)
-     int extra;
+end_repeat (int extra)

 {
   cond_exit_macro (macro_nest);
   while (extra-- >= 0)
     buffer_limit = input_scrub_next_buffer (&input_line_pointer);
 }
 
 {
   cond_exit_macro (macro_nest);
   while (extra-- >= 0)
     buffer_limit = input_scrub_next_buffer (&input_line_pointer);
 }
 

-/* Handle the .equ, .equiv and .set directives.  If EQUIV is 1, then
-   this is .equiv, and it is an error if the symbol is already
-   defined.  */
-
-void
-s_set (equiv)
-     int equiv;
+static void
+assign_symbol (char *name, int mode)

 {
 {

-  register char *name;
-  register char delim;
-  register char *end_name;
-  register symbolS *symbolP;
-
-  /* Especial apologies for the random logic:
-     this just grew, and could be parsed much more simply!
-     Dean in haste.  */
-  name = input_line_pointer;
-  delim = get_symbol_end ();
-  end_name = input_line_pointer;
-  *end_name = delim;
-  SKIP_WHITESPACE ();
-
-  if (*input_line_pointer != ',')
-    {
-      *end_name = 0;
-      as_bad (_("Expected comma after name \"%s\""), name);
-      *end_name = delim;
-      ignore_rest_of_line ();
-      return;
-    }
-
-  input_line_pointer++;
-  *end_name = 0;
+  symbolS *symbolP;

 
   if (name[0] == '.' && name[1] == '\0')
     {
       /* Turn '. = mumble' into a .org mumble.  */
 
   if (name[0] == '.' && name[1] == '\0')
     {
       /* Turn '. = mumble' into a .org mumble.  */

-      register segT segment;
+      segT segment;

       expressionS exp;
 
       segment = get_known_segmented_expression (&exp);
       expressionS exp;
 
       segment = get_known_segmented_expression (&exp);


@@ -2762,53 +2771,105 @@ s_set (equiv)
       if (!need_pass_2)
        do_org (segment, &exp, 0);
 
       if (!need_pass_2)
        do_org (segment, &exp, 0);
 

-      *end_name = delim;

       return;
     }
 
   if ((symbolP = symbol_find (name)) == NULL
       && (symbolP = md_undefined_symbol (name)) == NULL)
     {
       return;
     }
 
   if ((symbolP = symbol_find (name)) == NULL
       && (symbolP = md_undefined_symbol (name)) == NULL)
     {

+      symbolP = symbol_find_or_make (name);

 #ifndef NO_LISTING
       /* When doing symbol listings, play games with dummy fragments living
         outside the normal fragment chain to record the file and line info
 #ifndef NO_LISTING
       /* When doing symbol listings, play games with dummy fragments living
         outside the normal fragment chain to record the file and line info

-         for this symbol.  */
+        for this symbol.  */

       if (listing & LISTING_SYMBOLS)
        {
          extern struct list_info_struct *listing_tail;
       if (listing & LISTING_SYMBOLS)
        {
          extern struct list_info_struct *listing_tail;

-         fragS *dummy_frag = (fragS *) xmalloc (sizeof (fragS));
-         memset (dummy_frag, 0, sizeof (fragS));
-         dummy_frag->fr_type = rs_fill;
+         fragS *dummy_frag = (fragS *) xcalloc (1, sizeof (fragS));

          dummy_frag->line = listing_tail;
          dummy_frag->line = listing_tail;

-         symbolP = symbol_new (name, undefined_section, 0, dummy_frag);

          dummy_frag->fr_symbol = symbolP;
          dummy_frag->fr_symbol = symbolP;

+         symbol_set_frag (symbolP, dummy_frag);

        }
        }

-      else

 #endif
 #endif

-       symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
-

 #ifdef OBJ_COFF
       /* "set" symbols are local unless otherwise specified.  */
       SF_SET_LOCAL (symbolP);
 #ifdef OBJ_COFF
       /* "set" symbols are local unless otherwise specified.  */
       SF_SET_LOCAL (symbolP);

-#endif /* OBJ_COFF */
+#endif
+    }
+
+  if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
+    {
+      /* Permit register names to be redefined.  */
+      if ((mode != 0 || !S_IS_VOLATILE (symbolP))
+         && S_GET_SEGMENT (symbolP) != reg_section)
+       {
+         as_bad (_("symbol `%s' is already defined"), name);
+         symbolP = symbol_clone (symbolP, 0);
+       }
+      /* If the symbol is volatile, copy the symbol and replace the
+        original with the copy, so that previous uses of the symbol will
+        retain the value of the symbol at the point of use.  */
+      else if (S_IS_VOLATILE (symbolP))
+       symbolP = symbol_clone (symbolP, 1);

     }
 
     }
 

-  symbol_table_insert (symbolP);
+  if (mode == 0)
+    S_SET_VOLATILE (symbolP);
+  else if (mode < 0)
+    S_SET_FORWARD_REF (symbolP);

 
 

+  pseudo_set (symbolP);
+}
+
+/* Handle the .equ, .equiv, .eqv, and .set directives.  If EQUIV is 1,
+   then this is .equiv, and it is an error if the symbol is already
+   defined.  If EQUIV is -1, the symbol additionally is a forward
+   reference.  */
+
+void
+s_set (int equiv)
+{
+  char *name;
+  char delim;
+  char *end_name;
+
+  /* Especial apologies for the random logic:
+     this just grew, and could be parsed much more simply!
+     Dean in haste.  */
+  name = input_line_pointer;
+  delim = get_symbol_end ();
+  end_name = input_line_pointer;

   *end_name = delim;
 
   *end_name = delim;
 

-  if (equiv
-      && S_IS_DEFINED (symbolP)
-      && S_GET_SEGMENT (symbolP) != reg_section)
-    as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
+  if (name == end_name)
+    {
+      as_bad (_("expected symbol name"));
+      ignore_rest_of_line ();
+      return;
+    }
+
+  SKIP_WHITESPACE ();
+
+  if (*input_line_pointer != ',')
+    {
+      *end_name = 0;
+      as_bad (_("expected comma after \"%s\""), name);
+      *end_name = delim;
+      ignore_rest_of_line ();
+      return;
+    }
+
+  input_line_pointer++;
+  *end_name = 0;
+
+  assign_symbol (name, equiv);
+  *end_name = delim;

 
 

-  pseudo_set (symbolP);

   demand_empty_rest_of_line ();
 }
 
 void
   demand_empty_rest_of_line ();
 }
 
 void

-s_space (mult)
-     int mult;
+s_space (int mult)

 {
   expressionS exp;
   expressionS val;
 {
   expressionS exp;
   expressionS val;


@@ -2885,8 +2946,9 @@ s_space (mult)
       || val.X_add_number > 0xff
       || (mult != 0 && mult != 1 && val.X_add_number != 0))
     {
       || val.X_add_number > 0xff
       || (mult != 0 && mult != 1 && val.X_add_number != 0))
     {

+      resolve_expression (&exp);

       if (exp.X_op != O_constant)
       if (exp.X_op != O_constant)

-       as_bad (_("Unsupported variable size or fill value"));
+       as_bad (_("unsupported variable size or fill value"));

       else
        {
          offsetT i;
       else
        {
          offsetT i;


@@ -2900,6 +2962,9 @@ s_space (mult)
     }
   else
     {
     }
   else
     {

+      if (now_seg == absolute_section || mri_common_symbol != NULL)
+       resolve_expression (&exp);
+

       if (exp.X_op == O_constant)
        {
          long repeat;
       if (exp.X_op == O_constant)
        {
          long repeat;


@@ -2980,8 +3045,7 @@ s_space (mult)
    friends.  */
 
 void
    friends.  */
 
 void

-s_float_space (float_type)
-     int float_type;
+s_float_space (int float_type)

 {
   offsetT count;
   int flen;
 {
   offsetT count;
   int flen;


@@ -3011,123 +3075,244 @@ s_float_space (float_type)
   /* Skip any 0{letter} that may be present.  Don't even check if the
    * letter is legal.  */
   if (input_line_pointer[0] == '0'
   /* Skip any 0{letter} that may be present.  Don't even check if the
    * letter is legal.  */
   if (input_line_pointer[0] == '0'

-      && isalpha ((unsigned char) input_line_pointer[1]))
+      && ISALPHA (input_line_pointer[1]))

     input_line_pointer += 2;
 
   /* Accept :xxxx, where the x's are hex digits, for a floating point
      with the exact digits specified.  */
   if (input_line_pointer[0] == ':')
     {
     input_line_pointer += 2;
 
   /* Accept :xxxx, where the x's are hex digits, for a floating point
      with the exact digits specified.  */
   if (input_line_pointer[0] == ':')
     {

-      flen = hex_float (float_type, temp);
-      if (flen < 0)
-       {
-         ignore_rest_of_line ();
-         if (flag_mri)
-           mri_comment_end (stop, stopc);
-         return;
-       }
+      flen = hex_float (float_type, temp);
+      if (flen < 0)
+       {
+         ignore_rest_of_line ();
+         if (flag_mri)
+           mri_comment_end (stop, stopc);
+         return;
+       }
+    }
+  else
+    {
+      char *err;
+
+      err = md_atof (float_type, temp, &flen);
+      know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
+      know (flen > 0);
+      if (err)
+       {
+         as_bad (_("bad floating literal: %s"), err);
+         ignore_rest_of_line ();
+         if (flag_mri)
+           mri_comment_end (stop, stopc);
+         return;
+       }
+    }
+
+  while (--count >= 0)
+    {
+      char *p;
+
+      p = frag_more (flen);
+      memcpy (p, temp, (unsigned int) flen);
+    }
+
+  demand_empty_rest_of_line ();
+
+  if (flag_mri)
+    mri_comment_end (stop, stopc);
+}
+
+/* Handle the .struct pseudo-op, as found in MIPS assemblers.  */
+
+void
+s_struct (int ignore ATTRIBUTE_UNUSED)
+{
+  char *stop = NULL;
+  char stopc;
+
+  if (flag_mri)
+    stop = mri_comment_field (&stopc);
+  abs_section_offset = get_absolute_expression ();
+  subseg_set (absolute_section, 0);
+  demand_empty_rest_of_line ();
+  if (flag_mri)
+    mri_comment_end (stop, stopc);
+}
+
+void
+s_text (int ignore ATTRIBUTE_UNUSED)
+{
+  register int temp;
+
+  temp = get_absolute_expression ();
+  subseg_set (text_section, (subsegT) temp);
+  demand_empty_rest_of_line ();
+#ifdef OBJ_VMS
+  const_flag &= ~IN_DEFAULT_SECTION;
+#endif
+}
+
+/* .weakref x, y sets x as an alias to y that, as long as y is not
+   referenced directly, will cause y to become a weak symbol.  */
+void
+s_weakref (int ignore ATTRIBUTE_UNUSED)
+{
+  char *name;
+  char delim;
+  char *end_name;
+  symbolS *symbolP;
+  symbolS *symbolP2;
+  expressionS exp;
+
+  name = input_line_pointer;
+  delim = get_symbol_end ();
+  end_name = input_line_pointer;
+
+  if (name == end_name)
+    {
+      as_bad (_("expected symbol name"));
+      *end_name = delim;
+      ignore_rest_of_line ();
+      return;
+    }
+
+  symbolP = symbol_find_or_make (name);
+
+  if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
+    {
+      if (!S_IS_VOLATILE (symbolP))
+       {
+         as_bad (_("symbol `%s' is already defined"), name);
+         *end_name = delim;
+         ignore_rest_of_line ();
+         return;
+       }
+      symbolP = symbol_clone (symbolP, 1);
+      S_CLEAR_VOLATILE (symbolP);
+    }
+
+  *end_name = delim;
+
+  SKIP_WHITESPACE ();
+
+  if (*input_line_pointer != ',')
+    {
+      *end_name = 0;
+      as_bad (_("expected comma after \"%s\""), name);
+      *end_name = delim;
+      ignore_rest_of_line ();
+      return;
+    }
+
+  input_line_pointer++;
+
+  SKIP_WHITESPACE ();
+
+  name = input_line_pointer;
+  delim = get_symbol_end ();
+  end_name = input_line_pointer;
+
+  if (name == end_name)
+    {
+      as_bad (_("expected symbol name"));
+      ignore_rest_of_line ();
+      return;
+    }
+
+  if ((symbolP2 = symbol_find_noref (name, 1)) == NULL
+      && (symbolP2 = md_undefined_symbol (name)) == NULL)
+    {
+      symbolP2 = symbol_find_or_make (name);
+      S_SET_WEAKREFD (symbolP2);

     }
   else
     {
     }
   else
     {

-      char *err;
+      symbolS *symp = symbolP2;

 
 

-      err = md_atof (float_type, temp, &flen);
-      know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
-      know (flen > 0);
-      if (err)
+      while (S_IS_WEAKREFR (symp) && symp != symbolP)

        {
        {

-         as_bad (_("Bad floating literal: %s"), err);
-         ignore_rest_of_line ();
-         if (flag_mri)
-           mri_comment_end (stop, stopc);
-         return;
+         expressionS *expP = symbol_get_value_expression (symp);
+
+         assert (expP->X_op == O_symbol
+                 && expP->X_add_number == 0);
+         symp = expP->X_add_symbol;

        }
        }

-    }
+      if (symp == symbolP)
+       {
+         char *loop;

 
 

-  while (--count >= 0)
-    {
-      char *p;
+         loop = concat (S_GET_NAME (symbolP),
+                        " => ", S_GET_NAME (symbolP2), NULL);

 
 

-      p = frag_more (flen);
-      memcpy (p, temp, (unsigned int) flen);
-    }
+         symp = symbolP2;
+         while (symp != symbolP)
+           {
+             char *old_loop = loop;
+             symp = symbol_get_value_expression (symp)->X_add_symbol;
+             loop = concat (loop, " => ", S_GET_NAME (symp), NULL);
+             free (old_loop);
+           }

 
 

-  demand_empty_rest_of_line ();
+         as_bad (_("%s: would close weakref loop: %s"),
+                 S_GET_NAME (symbolP), loop);

 
 

-  if (flag_mri)
-    mri_comment_end (stop, stopc);
-}
+         free (loop);

 
 

-/* Handle the .struct pseudo-op, as found in MIPS assemblers.  */
+         *end_name = delim;
+         ignore_rest_of_line ();
+         return;
+       }

 
 

-void
-s_struct (ignore)
-     int ignore ATTRIBUTE_UNUSED;
-{
-  char *stop = NULL;
-  char stopc;
+      /* Short-circuiting instead of just checking here might speed
+        things up a tiny little bit, but loop error messages would
+        miss intermediate links.  */
+      /* symbolP2 = symp; */
+    }

 
 

-  if (flag_mri)
-    stop = mri_comment_field (&stopc);
-  abs_section_offset = get_absolute_expression ();
-  subseg_set (absolute_section, 0);
-  demand_empty_rest_of_line ();
-  if (flag_mri)
-    mri_comment_end (stop, stopc);
-}
+  *end_name = delim;

 
 

-void
-s_text (ignore)
-     int ignore ATTRIBUTE_UNUSED;
-{
-  register int temp;
+  memset (&exp, 0, sizeof (exp));
+  exp.X_op = O_symbol;
+  exp.X_add_symbol = symbolP2;
+
+  S_SET_SEGMENT (symbolP, undefined_section);
+  symbol_set_value_expression (symbolP, &exp);
+  symbol_set_frag (symbolP, &zero_address_frag);
+  S_SET_WEAKREFR (symbolP);

 
 

-  temp = get_absolute_expression ();
-  subseg_set (text_section, (subsegT) temp);

   demand_empty_rest_of_line ();
   demand_empty_rest_of_line ();

-#ifdef OBJ_VMS
-  const_flag &= ~IN_DEFAULT_SECTION;
-#endif

 }
 \f
 }
 \f

+
+/* Verify that we are at the end of a line.  If not, issue an error and
+   skip to EOL.  */
+

 void
 void

-demand_empty_rest_of_line ()
+demand_empty_rest_of_line (void)

 {
   SKIP_WHITESPACE ();
   if (is_end_of_line[(unsigned char) *input_line_pointer])
     input_line_pointer++;
   else
 {
   SKIP_WHITESPACE ();
   if (is_end_of_line[(unsigned char) *input_line_pointer])
     input_line_pointer++;
   else

-    ignore_rest_of_line ();
-
-  /* Return having already swallowed end-of-line.  */
-}
-
-void
-ignore_rest_of_line ()
-{
-  /* For suspect lines: gives warning.  */
-  if (!is_end_of_line[(unsigned char) *input_line_pointer])

     {
     {

-      if (isprint ((unsigned char) *input_line_pointer))
-       as_bad (_("Rest of line ignored. First ignored character is `%c'."),
-               *input_line_pointer);
+      if (ISPRINT (*input_line_pointer))
+       as_bad (_("junk at end of line, first unrecognized character is `%c'"),
+                *input_line_pointer);

       else
       else

-       as_bad (_("Rest of line ignored. First ignored character valued 0x%x."),
-               *input_line_pointer);
-
-      while (input_line_pointer < buffer_limit
-            && !is_end_of_line[(unsigned char) *input_line_pointer])
-       input_line_pointer++;
+       as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
+                *input_line_pointer);
+      ignore_rest_of_line ();

     }
     }

-
-  input_line_pointer++;
-
+  

   /* Return pointing just after end-of-line.  */
   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
 }
 
   /* Return pointing just after end-of-line.  */
   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
 }
 

+/* Silently advance to the end of line.  Use this after already having
+   issued an error about something bad.  */
+

 void
 void

-discard_rest_of_line ()
+ignore_rest_of_line (void)

 {
   while (input_line_pointer < buffer_limit
         && !is_end_of_line[(unsigned char) *input_line_pointer])
 {
   while (input_line_pointer < buffer_limit
         && !is_end_of_line[(unsigned char) *input_line_pointer])


@@ -3139,43 +3324,49 @@ discard_rest_of_line ()
   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
 }
 
   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
 }
 

+/* Sets frag for given symbol to zero_address_frag, except when the
+   symbol frag is already set to a dummy listing frag.  */
+
+static void
+set_zero_frag (symbolS *symbolP)
+{
+  if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
+    symbol_set_frag (symbolP, &zero_address_frag);
+}
+

 /* In: Pointer to a symbol.
 /* In: Pointer to a symbol.

-       Input_line_pointer->expression.
+       Input_line_pointer->expression.

 
    Out:        Input_line_pointer->just after any whitespace after expression.
 
    Out:        Input_line_pointer->just after any whitespace after expression.

-       Tried to set symbol to value of expression.
-       Will change symbols type, value, and frag;  */
+       Tried to set symbol to value of expression.
+       Will change symbols type, value, and frag;  */

 
 void
 
 void

-pseudo_set (symbolP)
-     symbolS *symbolP;
+pseudo_set (symbolS *symbolP)

 {
   expressionS exp;
 {
   expressionS exp;

-#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
-  int ext;
-#endif /* OBJ_AOUT or OBJ_BOUT */
+  segT seg;

 
   know (symbolP);              /* NULL pointer is logic error.  */
 
   know (symbolP);              /* NULL pointer is logic error.  */

-#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
-  ext = S_IS_EXTERNAL (symbolP);
-#endif /* OBJ_AOUT or OBJ_BOUT */

 
 

-  (void) expression (&exp);
+  if (!S_IS_FORWARD_REF (symbolP))
+    (void) expression (&exp);
+  else
+    (void) deferred_expression (&exp);

 
   if (exp.X_op == O_illegal)
 
   if (exp.X_op == O_illegal)

-    as_bad (_("illegal expression; zero assumed"));
+    as_bad (_("illegal expression"));

   else if (exp.X_op == O_absent)
   else if (exp.X_op == O_absent)

-    as_bad (_("missing expression; zero assumed"));
+    as_bad (_("missing expression"));

   else if (exp.X_op == O_big)
     {
       if (exp.X_add_number > 0)
   else if (exp.X_op == O_big)
     {
       if (exp.X_add_number > 0)

-       as_bad (_("bignum invalid; zero assumed"));
+       as_bad (_("bignum invalid"));

       else
       else

-       as_bad (_("floating point number invalid; zero assumed"));
+       as_bad (_("floating point number invalid"));

     }
   else if (exp.X_op == O_subtract
     }
   else if (exp.X_op == O_subtract

-          && (S_GET_SEGMENT (exp.X_add_symbol)
-              == S_GET_SEGMENT (exp.X_op_symbol))
+          && !S_IS_FORWARD_REF (symbolP)

           && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
           && (symbol_get_frag (exp.X_add_symbol)
               == symbol_get_frag (exp.X_op_symbol)))
           && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
           && (symbol_get_frag (exp.X_add_symbol)
               == symbol_get_frag (exp.X_op_symbol)))


@@ -3185,6 +3376,12 @@ pseudo_set (symbolP)
                          - S_GET_VALUE (exp.X_op_symbol));
     }
 
                          - S_GET_VALUE (exp.X_op_symbol));
     }
 

+  if (symbol_section_p (symbolP))
+    {
+      as_bad ("attempt to set value of section symbol");
+      return;
+    }
+

   switch (exp.X_op)
     {
     case O_illegal:
   switch (exp.X_op)
     {
     case O_illegal:


@@ -3194,56 +3391,57 @@ pseudo_set (symbolP)
       /* Fall through.  */
     case O_constant:
       S_SET_SEGMENT (symbolP, absolute_section);
       /* Fall through.  */
     case O_constant:
       S_SET_SEGMENT (symbolP, absolute_section);

-#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
-      if (ext)
-       S_SET_EXTERNAL (symbolP);
-      else
-       S_CLEAR_EXTERNAL (symbolP);
-#endif /* OBJ_AOUT or OBJ_BOUT */

       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);

-      if (exp.X_op != O_constant)
-       symbol_set_frag (symbolP, &zero_address_frag);
+      set_zero_frag (symbolP);

       break;
 
     case O_register:
       S_SET_SEGMENT (symbolP, reg_section);
       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
       break;
 
     case O_register:
       S_SET_SEGMENT (symbolP, reg_section);
       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);

-      symbol_set_frag (symbolP, &zero_address_frag);
+      set_zero_frag (symbolP);

       break;
 
     case O_symbol:
       break;
 
     case O_symbol:

-      if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section
-         || exp.X_add_number != 0)
-       symbol_set_value_expression (symbolP, &exp);
-      else if (symbol_section_p (symbolP))
-       as_bad ("invalid attempt to set value of section symbol");
-      else
+      seg = S_GET_SEGMENT (exp.X_add_symbol);
+      /* For x=undef+const, create an expression symbol.
+        For x=x+const, just update x except when x is an undefined symbol
+        For x=defined+const, evaluate x.  */
+      if (symbolP == exp.X_add_symbol
+         && (seg != undefined_section
+             || !symbol_constant_p (symbolP)))
+       {
+         *symbol_X_add_number (symbolP) += exp.X_add_number;
+         break;
+       }
+      else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section)

        {
          symbolS *s = exp.X_add_symbol;
 
        {
          symbolS *s = exp.X_add_symbol;
 

-         S_SET_SEGMENT (symbolP, S_GET_SEGMENT (s));
-#if (defined (OBJ_AOUT) || defined (OBJ_BOUT)) && ! defined (BFD_ASSEMBLER)
-         if (ext)
-           S_SET_EXTERNAL (symbolP);
-         else
-           S_CLEAR_EXTERNAL (symbolP);
-#endif /* OBJ_AOUT or OBJ_BOUT */
-         S_SET_VALUE (symbolP,
-                      exp.X_add_number + S_GET_VALUE (s));
+         if (S_IS_COMMON (s))
+           as_bad (_("`%s' can't be equated to common symbol '%s'"),
+                   S_GET_NAME (symbolP), S_GET_NAME (s));
+
+         S_SET_SEGMENT (symbolP, seg);
+         S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));

          symbol_set_frag (symbolP, symbol_get_frag (s));
          copy_symbol_attributes (symbolP, s);
          symbol_set_frag (symbolP, symbol_get_frag (s));
          copy_symbol_attributes (symbolP, s);

+         break;

        }
        }

+      S_SET_SEGMENT (symbolP, undefined_section);
+      symbol_set_value_expression (symbolP, &exp);
+      set_zero_frag (symbolP);

       break;
 
     default:
       break;
 
     default:

-      /* The value is some complex expression.
-        FIXME: Should we set the segment to anything?  */
+      /* The value is some complex expression.  */
+      S_SET_SEGMENT (symbolP, expr_section);

       symbol_set_value_expression (symbolP, &exp);
       symbol_set_value_expression (symbolP, &exp);

+      set_zero_frag (symbolP);

       break;
     }
 }
 \f
       break;
     }
 }
 \f

-/*                     cons()
+/*                     cons()

 
    CONStruct more frag of .bytes, or .words etc.
    Should need_pass_2 be 1 then emit no frag(s).
 
    CONStruct more frag of .bytes, or .words etc.
    Should need_pass_2 be 1 then emit no frag(s).


@@ -3268,19 +3466,19 @@ pseudo_set (symbolP)
 
 #ifdef TC_M68K
 static void
 
 #ifdef TC_M68K
 static void

-parse_mri_cons PARAMS ((expressionS *exp, unsigned int nbytes));
+parse_mri_cons (expressionS *exp, unsigned int nbytes);

 #endif
 
 #ifndef TC_PARSE_CONS_EXPRESSION
 #ifdef BITFIELD_CONS_EXPRESSIONS
 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
 static void
 #endif
 
 #ifndef TC_PARSE_CONS_EXPRESSION
 #ifdef BITFIELD_CONS_EXPRESSIONS
 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
 static void

-parse_bitfield_cons PARAMS ((expressionS *exp, unsigned int nbytes));
+parse_bitfield_cons (expressionS *exp, unsigned int nbytes);

 #endif
 #ifdef REPEAT_CONS_EXPRESSIONS
 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
 static void
 #endif
 #ifdef REPEAT_CONS_EXPRESSIONS
 #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
 static void

-parse_repeat_cons PARAMS ((expressionS *exp, unsigned int nbytes));
+parse_repeat_cons (expressionS *exp, unsigned int nbytes);

 #endif
 
 /* If we haven't gotten one yet, just call expression.  */
 #endif
 
 /* If we haven't gotten one yet, just call expression.  */


@@ -3289,13 +3487,20 @@ parse_repeat_cons PARAMS ((expressionS *exp, unsigned int nbytes));
 #endif
 #endif
 
 #endif
 #endif
 

+void
+do_parse_cons_expression (expressionS *exp,
+                         int nbytes ATTRIBUTE_UNUSED)
+{
+  TC_PARSE_CONS_EXPRESSION (exp, nbytes);
+}
+
+

 /* Worker to do .byte etc statements.
    Clobbers input_line_pointer and checks end-of-line.  */
 
 static void
 /* Worker to do .byte etc statements.
    Clobbers input_line_pointer and checks end-of-line.  */
 
 static void

-cons_worker (nbytes, rva)
-     register int nbytes;      /* 1=.byte, 2=.word, 4=.long.  */
-     int rva;
+cons_worker (register int nbytes,      /* 1=.byte, 2=.word, 4=.long.  */
+            int rva)

 {
   int c;
   expressionS exp;
 {
   int c;
   expressionS exp;


@@ -3317,6 +3522,11 @@ cons_worker (nbytes, rva)
       return;
     }
 
       return;
     }
 

+#ifdef TC_ADDRESS_BYTES
+  if (nbytes == 0)
+    nbytes = TC_ADDRESS_BYTES ();
+#endif
+

 #ifdef md_cons_align
   md_cons_align (nbytes);
 #endif
 #ifdef md_cons_align
   md_cons_align (nbytes);
 #endif


@@ -3358,15 +3568,13 @@ cons_worker (nbytes, rva)
 }
 
 void
 }
 
 void

-cons (size)
-     int size;
+cons (int size)

 {
   cons_worker (size, 0);
 }
 
 void
 {
   cons_worker (size, 0);
 }
 
 void

-s_rva (size)
-     int size;
+s_rva (int size)

 {
   cons_worker (size, 1);
 }
 {
   cons_worker (size, 1);
 }


@@ -3375,9 +3583,7 @@ s_rva (size)
    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
 
 void
    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
 
 void

-emit_expr (exp, nbytes)
-     expressionS *exp;
-     unsigned int nbytes;
+emit_expr (expressionS *exp, unsigned int nbytes)

 {
   operatorT op;
   register char *p;
 {
   operatorT op;
   register char *p;


@@ -3387,6 +3593,8 @@ emit_expr (exp, nbytes)
   if (need_pass_2)
     return;
 
   if (need_pass_2)
     return;
 

+  dot_value = frag_now_fix ();
+

 #ifndef NO_LISTING
 #ifdef OBJ_ELF
   /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
 #ifndef NO_LISTING
 #ifdef OBJ_ELF
   /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will


@@ -3504,7 +3712,7 @@ emit_expr (exp, nbytes)
     }
   else if (op == O_big && exp->X_add_number <= 0)
     {
     }
   else if (op == O_big && exp->X_add_number <= 0)
     {

-      as_bad (_("floating point number invalid; zero assumed"));
+      as_bad (_("floating point number invalid"));

       exp->X_add_number = 0;
       op = O_constant;
     }
       exp->X_add_number = 0;
       op = O_constant;
     }


@@ -3535,6 +3743,7 @@ emit_expr (exp, nbytes)
       x->sub = exp->X_op_symbol;
       x->addnum = exp->X_add_number;
       x->added = 0;
       x->sub = exp->X_op_symbol;
       x->addnum = exp->X_add_number;
       x->added = 0;

+      x->use_jump = 0;

       new_broken_words++;
       return;
     }
       new_broken_words++;
       return;
     }


@@ -3544,22 +3753,9 @@ emit_expr (exp, nbytes)
      pass to md_number_to_chars, handle it as a bignum.  */
   if (op == O_constant && nbytes > sizeof (valueT))
     {
      pass to md_number_to_chars, handle it as a bignum.  */
   if (op == O_constant && nbytes > sizeof (valueT))
     {

-      valueT val;
-      int gencnt;
-
-      if (!exp->X_unsigned && exp->X_add_number < 0)
-       extra_digit = (valueT) -1;
-      val = (valueT) exp->X_add_number;
-      gencnt = 0;
-      do
-       {
-         generic_bignum[gencnt] = val & LITTLENUM_MASK;
-         val >>= LITTLENUM_NUMBER_OF_BITS;
-         ++gencnt;
-       }
-      while (val != 0);
-      op = exp->X_op = O_big;
-      exp->X_add_number = gencnt;
+      extra_digit = exp->X_unsigned ? 0 : -1;
+      convert_to_bignum (exp);
+      op = O_big;

     }
 
   if (op == O_constant)
     }
 
   if (op == O_constant)


@@ -3600,7 +3796,7 @@ emit_expr (exp, nbytes)
          && ((get & mask) != mask
              || (get & hibit) == 0))
        {               /* Leading bits contain both 0s & 1s.  */
          && ((get & mask) != mask
              || (get & hibit) == 0))
        {               /* Leading bits contain both 0s & 1s.  */

-         as_warn (_("Value 0x%lx truncated to 0x%lx."),
+         as_warn (_("value 0x%lx truncated to 0x%lx"),

                   (unsigned long) get, (unsigned long) use);
        }
       /* Put bytes in right order.  */
                   (unsigned long) get, (unsigned long) use);
        }
       /* Put bytes in right order.  */


@@ -3616,7 +3812,7 @@ emit_expr (exp, nbytes)
       size = exp->X_add_number * CHARS_PER_LITTLENUM;
       if (nbytes < size)
        {
       size = exp->X_add_number * CHARS_PER_LITTLENUM;
       if (nbytes < size)
        {

-         as_warn (_("Bignum truncated to %d bytes"), nbytes);
+         as_warn (_("bignum truncated to %d bytes"), nbytes);

          size = nbytes;
        }
 
          size = nbytes;
        }
 


@@ -3630,7 +3826,7 @@ emit_expr (exp, nbytes)
            }
 
          nums = generic_bignum + size / CHARS_PER_LITTLENUM;
            }
 
          nums = generic_bignum + size / CHARS_PER_LITTLENUM;

-         while (size > 0)
+         while (size >= CHARS_PER_LITTLENUM)

            {
              --nums;
              md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
            {
              --nums;
              md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);


@@ -3641,7 +3837,7 @@ emit_expr (exp, nbytes)
       else
        {
          nums = generic_bignum;
       else
        {
          nums = generic_bignum;

-         while (size > 0)
+         while (size >= CHARS_PER_LITTLENUM)

            {
              md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
              ++nums;
            {
              md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
              ++nums;


@@ -3650,7 +3846,7 @@ emit_expr (exp, nbytes)
              nbytes -= CHARS_PER_LITTLENUM;
            }
 
              nbytes -= CHARS_PER_LITTLENUM;
            }
 

-         while (nbytes > 0)
+         while (nbytes >= CHARS_PER_LITTLENUM)

            {
              md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
              nbytes -= CHARS_PER_LITTLENUM;
            {
              md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
              nbytes -= CHARS_PER_LITTLENUM;


@@ -3662,16 +3858,8 @@ emit_expr (exp, nbytes)
     {
       memset (p, 0, nbytes);
 
     {
       memset (p, 0, nbytes);
 

-      /* Now we need to generate a fixS to record the symbol value.
-        This is easy for BFD.  For other targets it can be more
-        complex.  For very complex cases (currently, the HPPA and
-        NS32K), you can define TC_CONS_FIX_NEW to do whatever you
-        want.  For simpler cases, you can define TC_CONS_RELOC to be
-        the name of the reloc code that should be stored in the fixS.
-        If neither is defined, the code uses NO_RELOC if it is
-        defined, and otherwise uses 0.  */
+      /* Now we need to generate a fixS to record the symbol value.  */

 
 

-#ifdef BFD_ASSEMBLER

 #ifdef TC_CONS_FIX_NEW
       TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
 #else
 #ifdef TC_CONS_FIX_NEW
       TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
 #else


@@ -3701,24 +3889,6 @@ emit_expr (exp, nbytes)
                     0, r);
       }
 #endif
                     0, r);
       }
 #endif

-#else
-#ifdef TC_CONS_FIX_NEW
-      TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
-#else
-      /* Figure out which reloc number to use.  Use TC_CONS_RELOC if
-        it is defined, otherwise use NO_RELOC if it is defined,
-        otherwise use 0.  */
-#ifndef TC_CONS_RELOC
-#ifdef NO_RELOC
-#define TC_CONS_RELOC NO_RELOC
-#else
-#define TC_CONS_RELOC 0
-#endif
-#endif
-      fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
-                  TC_CONS_RELOC);
-#endif /* TC_CONS_FIX_NEW */
-#endif /* BFD_ASSEMBLER */

     }
 }
 \f
     }
 }
 \f


@@ -3730,7 +3900,7 @@ emit_expr (exp, nbytes)
    them in words, longs, etc. and we'll pack them in target byte order
    for you.
 
    them in words, longs, etc. and we'll pack them in target byte order
    for you.
 

-   The rules are: pack least significat bit first, if a field doesn't
+   The rules are: pack least significant bit first, if a field doesn't

    entirely fit, put it in the next unit.  Overflowing the bitfield is
    explicitly *not* even a warning.  The bitwidth should be considered
    a "mask".
    entirely fit, put it in the next unit.  Overflowing the bitfield is
    explicitly *not* even a warning.  The bitwidth should be considered
    a "mask".


@@ -3947,7 +4117,7 @@ parse_repeat_cons (exp, nbytes)
   if (count.X_op != O_constant
       || count.X_add_number <= 0)
     {
   if (count.X_op != O_constant
       || count.X_add_number <= 0)
     {

-      as_warn (_("Unresolvable or nonpositive repeat count; using 1"));
+      as_warn (_("unresolvable or nonpositive repeat count; using 1"));

       return;
     }
 
       return;
     }
 


@@ -3964,9 +4134,7 @@ parse_repeat_cons (exp, nbytes)
    point number.  */
 
 static int
    point number.  */
 
 static int

-hex_float (float_type, bytes)
-     int float_type;
-     char *bytes;
+hex_float (int float_type, char *bytes)

 {
   int length;
   int i;
 {
   int length;
   int i;


@@ -3998,7 +4166,7 @@ hex_float (float_type, bytes)
       break;
 
     default:
       break;
 
     default:

-      as_bad (_("Unknown floating type type '%c'"), float_type);
+      as_bad (_("unknown floating type type '%c'"), float_type);

       return -1;
     }
 
       return -1;
     }
 


@@ -4020,7 +4188,7 @@ hex_float (float_type, bytes)
 
       if (i >= length)
        {
 
       if (i >= length)
        {

-         as_warn (_("Floating point constant too large"));
+         as_warn (_("floating point constant too large"));

          return -1;
        }
       d = hex_value (*input_line_pointer) << 4;
          return -1;
        }
       d = hex_value (*input_line_pointer) << 4;


@@ -4050,7 +4218,7 @@ hex_float (float_type, bytes)
   return length;
 }
 
   return length;
 }
 

-/*                     float_cons()
+/*                     float_cons()

 
    CONStruct some more frag chars of .floats .ffloats etc.
    Makes 0 or more new frags.
 
    CONStruct some more frag chars of .floats .ffloats etc.
    Makes 0 or more new frags.


@@ -4061,16 +4229,15 @@ hex_float (float_type, bytes)
    by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
    reading, I decided to be incompatible. This always tries to give you
    rounded bits to the precision of the pseudo-op. Former AS did premature
    by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
    reading, I decided to be incompatible. This always tries to give you
    rounded bits to the precision of the pseudo-op. Former AS did premature

-   truncatation, restored noisy bits instead of trailing 0s AND gave you
+   truncation, restored noisy bits instead of trailing 0s AND gave you

    a choice of 2 flavours of noise according to which of 2 floating-point
    scanners you directed AS to use.
 
    In: input_line_pointer->whitespace before, or '0' of flonum.  */
 
 void
    a choice of 2 flavours of noise according to which of 2 floating-point
    scanners you directed AS to use.
 
    In: input_line_pointer->whitespace before, or '0' of flonum.  */
 
 void

-float_cons (float_type)
-     /* Clobbers input_line-pointer, checks end-of-line.  */
-     register int float_type;  /* 'f':.ffloat ... 'F':.float ...  */
+float_cons (/* Clobbers input_line-pointer, checks end-of-line.  */
+           register int float_type     /* 'f':.ffloat ... 'F':.float ...  */)

 {
   register char *p;
   int length;                  /* Number of chars in an object.  */
 {
   register char *p;
   int length;                  /* Number of chars in an object.  */


@@ -4093,15 +4260,15 @@ float_cons (float_type)
       SKIP_WHITESPACE ();
 
       /* Skip any 0{letter} that may be present. Don't even check if the
       SKIP_WHITESPACE ();
 
       /* Skip any 0{letter} that may be present. Don't even check if the

-         letter is legal. Someone may invent a "z" format and this routine
-         has no use for such information. Lusers beware: you get
-         diagnostics if your input is ill-conditioned.  */
+        letter is legal. Someone may invent a "z" format and this routine
+        has no use for such information. Lusers beware: you get
+        diagnostics if your input is ill-conditioned.  */

       if (input_line_pointer[0] == '0'
       if (input_line_pointer[0] == '0'

-         && isalpha ((unsigned char) input_line_pointer[1]))
+         && ISALPHA (input_line_pointer[1]))

        input_line_pointer += 2;
 
       /* Accept :xxxx, where the x's are hex digits, for a floating
        input_line_pointer += 2;
 
       /* Accept :xxxx, where the x's are hex digits, for a floating

-         point with the exact digits specified.  */
+        point with the exact digits specified.  */

       if (input_line_pointer[0] == ':')
        {
          ++input_line_pointer;
       if (input_line_pointer[0] == ':')
        {
          ++input_line_pointer;


@@ -4119,7 +4286,7 @@ float_cons (float_type)
          know (length > 0);
          if (err)
            {
          know (length > 0);
          if (err)
            {

-             as_bad (_("Bad floating literal: %s"), err);
+             as_bad (_("bad floating literal: %s"), err);

              ignore_rest_of_line ();
              return;
            }
              ignore_rest_of_line ();
              return;
            }


@@ -4165,8 +4332,7 @@ float_cons (float_type)
 /* Return the size of a LEB128 value.  */
 
 static inline int
 /* Return the size of a LEB128 value.  */
 
 static inline int

-sizeof_sleb128 (value)
-     offsetT value;
+sizeof_sleb128 (offsetT value)

 {
   register int size = 0;
   register unsigned byte;
 {
   register int size = 0;
   register unsigned byte;


@@ -4187,8 +4353,7 @@ sizeof_sleb128 (value)
 }
 
 static inline int
 }
 
 static inline int

-sizeof_uleb128 (value)
-     valueT value;
+sizeof_uleb128 (valueT value)

 {
   register int size = 0;
   register unsigned byte;
 {
   register int size = 0;
   register unsigned byte;


@@ -4205,9 +4370,7 @@ sizeof_uleb128 (value)
 }
 
 int
 }
 
 int

-sizeof_leb128 (value, sign)
-     valueT value;
-     int sign;
+sizeof_leb128 (valueT value, int sign)

 {
   if (sign)
     return sizeof_sleb128 ((offsetT) value);
 {
   if (sign)
     return sizeof_sleb128 ((offsetT) value);


@@ -4218,9 +4381,7 @@ sizeof_leb128 (value, sign)
 /* Output a LEB128 value.  */
 
 static inline int
 /* Output a LEB128 value.  */
 
 static inline int

-output_sleb128 (p, value)
-     char *p;
-     offsetT value;
+output_sleb128 (char *p, offsetT value)

 {
   register char *orig = p;
   register int more;
 {
   register char *orig = p;
   register int more;


@@ -4247,9 +4408,7 @@ output_sleb128 (p, value)
 }
 
 static inline int
 }
 
 static inline int

-output_uleb128 (p, value)
-     char *p;
-     valueT value;
+output_uleb128 (char *p, valueT value)

 {
   char *orig = p;
 
 {
   char *orig = p;
 


@@ -4269,10 +4428,7 @@ output_uleb128 (p, value)
 }
 
 int
 }
 
 int

-output_leb128 (p, value, sign)
-     char *p;
-     valueT value;
-     int sign;
+output_leb128 (char *p, valueT value, int sign)

 {
   if (sign)
     return output_sleb128 (p, (offsetT) value);
 {
   if (sign)
     return output_sleb128 (p, (offsetT) value);


@@ -4285,10 +4441,7 @@ output_leb128 (p, value, sign)
    for "normal" values that this be streamlined.  */
 
 static inline int
    for "normal" values that this be streamlined.  */
 
 static inline int

-output_big_sleb128 (p, bignum, size)
-     char *p;
-     LITTLENUM_TYPE *bignum;
-     int size;
+output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)

 {
   char *orig = p;
   valueT val = 0;
 {
   char *orig = p;
   valueT val = 0;


@@ -4296,45 +4449,54 @@ output_big_sleb128 (p, bignum, size)
   unsigned byte;
 
   /* Strip leading sign extensions off the bignum.  */
   unsigned byte;
 
   /* Strip leading sign extensions off the bignum.  */

-  while (size > 0 && bignum[size - 1] == (LITTLENUM_TYPE) -1)
+  while (size > 1
+        && bignum[size - 1] == LITTLENUM_MASK
+        && bignum[size - 2] > LITTLENUM_MASK / 2)

     size--;
 
   do
     {
     size--;
 
   do
     {

-      if (loaded < 7 && size > 0)
-       {
-         val |= (*bignum << loaded);
-         loaded += 8 * CHARS_PER_LITTLENUM;
-         size--;
-         bignum++;
-       }
-
-      byte = val & 0x7f;
-      loaded -= 7;
-      val >>= 7;
+      /* OR in the next part of the littlenum.  */
+      val |= (*bignum << loaded);
+      loaded += LITTLENUM_NUMBER_OF_BITS;
+      size--;
+      bignum++;

 
 

-      if (size == 0)
+      /* Add bytes until there are less than 7 bits left in VAL
+        or until every non-sign bit has been written.  */
+      do

        {
        {

-         if ((val == 0 && (byte & 0x40) == 0)
-             || (~(val | ~(((valueT) 1 << loaded) - 1)) == 0
-                 && (byte & 0x40) != 0))
+         byte = val & 0x7f;
+         loaded -= 7;
+         val >>= 7;
+         if (size > 0
+             || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))

            byte |= 0x80;
            byte |= 0x80;

+
+         if (orig)
+           *p = byte;
+         p++;

        }
        }

+      while ((byte & 0x80) != 0 && loaded >= 7);
+    }
+  while (size > 0);

 
 

+  /* Mop up any left-over bits (of which there will be less than 7).  */
+  if ((byte & 0x80) != 0)
+    {
+      /* Sign-extend VAL.  */
+      if (val & (1 << (loaded - 1)))
+       val |= ~0 << loaded;

       if (orig)
       if (orig)

-       *p = byte;
+       *p = val & 0x7f;

       p++;
     }
       p++;
     }

-  while (byte & 0x80);

 
   return p - orig;
 }
 
 static inline int
 
   return p - orig;
 }
 
 static inline int

-output_big_uleb128 (p, bignum, size)
-     char *p;
-     LITTLENUM_TYPE *bignum;
-     int size;
+output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)

 {
   char *orig = p;
   valueT val = 0;
 {
   char *orig = p;
   valueT val = 0;


@@ -4373,10 +4535,7 @@ output_big_uleb128 (p, bignum, size)
 }
 
 static int
 }
 
 static int

-output_big_leb128 (p, bignum, size, sign)
-     char *p;
-     LITTLENUM_TYPE *bignum;
-     int size, sign;
+output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)

 {
   if (sign)
     return output_big_sleb128 (p, bignum, size);
 {
   if (sign)
     return output_big_sleb128 (p, bignum, size);


@@ -4387,13 +4546,11 @@ output_big_leb128 (p, bignum, size, sign)
 /* Generate the appropriate fragments for a given expression to emit a
    leb128 value.  */
 
 /* Generate the appropriate fragments for a given expression to emit a
    leb128 value.  */
 

-void
-emit_leb128_expr (exp, sign)
-     expressionS *exp;
-     int sign;
+static void
+emit_leb128_expr (expressionS *exp, int sign)

 {
   operatorT op = exp->X_op;
 {
   operatorT op = exp->X_op;

-  int nbytes;
+  unsigned int nbytes;

 
   if (op == O_absent || op == O_illegal)
     {
 
   if (op == O_absent || op == O_illegal)
     {


@@ -4403,7 +4560,7 @@ emit_leb128_expr (exp, sign)
     }
   else if (op == O_big && exp->X_add_number <= 0)
     {
     }
   else if (op == O_big && exp->X_add_number <= 0)
     {

-      as_bad (_("floating point number invalid; zero assumed"));
+      as_bad (_("floating point number invalid"));

       exp->X_add_number = 0;
       op = O_constant;
     }
       exp->X_add_number = 0;
       op = O_constant;
     }


@@ -4412,13 +4569,28 @@ emit_leb128_expr (exp, sign)
       as_warn (_("register value used as expression"));
       op = O_constant;
     }
       as_warn (_("register value used as expression"));
       op = O_constant;
     }

+  else if (op == O_constant
+          && sign
+          && (exp->X_add_number < 0) != !exp->X_unsigned)
+    {
+      /* We're outputting a signed leb128 and the sign of X_add_number
+        doesn't reflect the sign of the original value.  Convert EXP
+        to a correctly-extended bignum instead.  */
+      convert_to_bignum (exp);
+      op = O_big;
+    }

 
   /* Let check_eh_frame know that data is being emitted.  nbytes == -1 is
      a signal that this is leb128 data.  It shouldn't optimize this away.  */
 
   /* Let check_eh_frame know that data is being emitted.  nbytes == -1 is
      a signal that this is leb128 data.  It shouldn't optimize this away.  */

-  nbytes = -1;
+  nbytes = (unsigned int) -1;

   if (check_eh_frame (exp, &nbytes))
     abort ();
 
   if (check_eh_frame (exp, &nbytes))
     abort ();
 

+  /* Let the backend know that subsequent data may be byte aligned.  */
+#ifdef md_cons_align
+  md_cons_align (1);
+#endif
+

   if (op == O_constant)
     {
       /* If we've got a constant, emit the thing directly right now.  */
   if (op == O_constant)
     {
       /* If we've got a constant, emit the thing directly right now.  */


@@ -4455,11 +4627,14 @@ emit_leb128_expr (exp, sign)
 /* Parse the .sleb128 and .uleb128 pseudos.  */
 
 void
 /* Parse the .sleb128 and .uleb128 pseudos.  */
 
 void

-s_leb128 (sign)
-     int sign;
+s_leb128 (int sign)

 {
   expressionS exp;
 
 {
   expressionS exp;
 

+#ifdef md_flush_pending_output
+  md_flush_pending_output ();
+#endif
+

   do
     {
       expression (&exp);
   do
     {
       expression (&exp);


@@ -4476,9 +4651,9 @@ s_leb128 (sign)
    check it.  */
 
 void
    check it.  */
 
 void

-stringer (append_zero)         /* Worker to do .ascii etc statements.  */
-     /* Checks end-of-line.  */
-     register int append_zero; /* 0: don't append '\0', else 1.  */
+stringer (/* Worker to do .ascii etc statements.  */
+         /* Checks end-of-line.  */
+         register int append_zero      /* 0: don't append '\0', else 1.  */)

 {
   register unsigned int c;
   char *start;
 {
   register unsigned int c;
   char *start;


@@ -4501,6 +4676,15 @@ stringer (append_zero)           /* Worker to do .ascii etc statements.  */
     {
       c = ',';                 /* Do loop.  */
     }
     {
       c = ',';                 /* Do loop.  */
     }

+  /* If we have been switched into the abs_section then we
+     will not have an obstack onto which we can hang strings.  */
+  if (now_seg == absolute_section)
+    {
+      as_bad (_("strings must be placed into a section"));
+      c = 0;
+      ignore_rest_of_line ();
+    }
+

   while (c == ',' || c == '<' || c == '"')
     {
       SKIP_WHITESPACE ();
   while (c == ',' || c == '<' || c == '"')
     {
       SKIP_WHITESPACE ();


@@ -4522,11 +4706,11 @@ stringer (append_zero)          /* Worker to do .ascii etc statements.  */
 #ifndef NO_LISTING
 #ifdef OBJ_ELF
          /* In ELF, when gcc is emitting DWARF 1 debugging output, it
 #ifndef NO_LISTING
 #ifdef OBJ_ELF
          /* In ELF, when gcc is emitting DWARF 1 debugging output, it

-             will emit .string with a filename in the .debug section
-             after a sequence of constants.  See the comment in
-             emit_expr for the sequence.  emit_expr will set
-             dwarf_file_string to non-zero if this string might be a
-             source file name.  */
+            will emit .string with a filename in the .debug section
+            after a sequence of constants.  See the comment in
+            emit_expr for the sequence.  emit_expr will set
+            dwarf_file_string to non-zero if this string might be a
+            source file name.  */

          if (strcmp (segment_name (now_seg), ".debug") != 0)
            dwarf_file_string = 0;
          else if (dwarf_file_string)
          if (strcmp (segment_name (now_seg), ".debug") != 0)
            dwarf_file_string = 0;
          else if (dwarf_file_string)


@@ -4546,7 +4730,7 @@ stringer (append_zero)            /* Worker to do .ascii etc statements.  */
          FRAG_APPEND_1_CHAR (c);
          if (*input_line_pointer != '>')
            {
          FRAG_APPEND_1_CHAR (c);
          if (*input_line_pointer != '>')
            {

-             as_bad (_("Expected <nn>"));
+             as_bad (_("expected <nn>"));

            }
          input_line_pointer++;
          break;
            }
          input_line_pointer++;
          break;


@@ -4567,7 +4751,7 @@ stringer (append_zero)            /* Worker to do .ascii etc statements.  */
     returning values bigger than 1 byte.  xoxorich.  */
 
 unsigned int
     returning values bigger than 1 byte.  xoxorich.  */
 
 unsigned int

-next_char_of_string ()
+next_char_of_string (void)

 {
   register unsigned int c;
 
 {
   register unsigned int c;
 


@@ -4579,7 +4763,7 @@ next_char_of_string ()
       break;
 
     case '\n':
       break;
 
     case '\n':

-      as_warn (_("Unterminated string: Newline inserted."));
+      as_warn (_("unterminated string; newline inserted"));

       bump_line_counters ();
       break;
 
       bump_line_counters ();
       break;
 


@@ -4630,7 +4814,7 @@ next_char_of_string ()
            int i;
 
            for (i = 0, number = 0;
            int i;
 
            for (i = 0, number = 0;

-                isdigit (c) && i < 3;
+                ISDIGIT (c) && i < 3;

                 c = *input_line_pointer++, i++)
              {
                number = number * 8 + c - '0';
                 c = *input_line_pointer++, i++)
              {
                number = number * 8 + c - '0';


@@ -4648,11 +4832,11 @@ next_char_of_string ()
 
            number = 0;
            c = *input_line_pointer++;
 
            number = 0;
            c = *input_line_pointer++;

-           while (isxdigit (c))
+           while (ISXDIGIT (c))

              {
              {

-               if (isdigit (c))
+               if (ISDIGIT (c))

                  number = number * 16 + c - '0';
                  number = number * 16 + c - '0';

-               else if (isupper (c))
+               else if (ISUPPER (c))

                  number = number * 16 + c - 'A' + 10;
                else
                  number = number * 16 + c - 'a' + 10;
                  number = number * 16 + c - 'A' + 10;
                else
                  number = number * 16 + c - 'a' + 10;


@@ -4665,7 +4849,7 @@ next_char_of_string ()
 
        case '\n':
          /* To be compatible with BSD 4.2 as: give the luser a linefeed!!  */
 
        case '\n':
          /* To be compatible with BSD 4.2 as: give the luser a linefeed!!  */

-         as_warn (_("Unterminated string: Newline inserted."));
+         as_warn (_("unterminated string; newline inserted"));

          c = '\n';
          bump_line_counters ();
          break;
          c = '\n';
          bump_line_counters ();
          break;


@@ -4673,7 +4857,7 @@ next_char_of_string ()
        default:
 
 #ifdef ONLY_STANDARD_ESCAPES
        default:
 
 #ifdef ONLY_STANDARD_ESCAPES

-         as_bad (_("Bad escaped character in string, '?' assumed"));
+         as_bad (_("bad escaped character in string"));

          c = '?';
 #endif /* ONLY_STANDARD_ESCAPES */
 
          c = '?';
 #endif /* ONLY_STANDARD_ESCAPES */
 


@@ -4689,8 +4873,7 @@ next_char_of_string ()
 }
 \f
 static segT
 }
 \f
 static segT

-get_segmented_expression (expP)
-     register expressionS *expP;
+get_segmented_expression (register expressionS *expP)

 {
   register segT retval;
 
 {
   register segT retval;
 


@@ -4699,7 +4882,7 @@ get_segmented_expression (expP)
       || expP->X_op == O_absent
       || expP->X_op == O_big)
     {
       || expP->X_op == O_absent
       || expP->X_op == O_big)
     {

-      as_bad (_("expected address expression; zero assumed"));
+      as_bad (_("expected address expression"));

       expP->X_op = O_constant;
       expP->X_add_number = 0;
       retval = absolute_section;
       expP->X_op = O_constant;
       expP->X_add_number = 0;
       retval = absolute_section;


@@ -4708,8 +4891,7 @@ get_segmented_expression (expP)
 }
 
 static segT
 }
 
 static segT

-get_known_segmented_expression (expP)
-     register expressionS *expP;
+get_known_segmented_expression (register expressionS *expP)

 {
   register segT retval;
 
 {
   register segT retval;
 


@@ -4731,24 +4913,8 @@ get_known_segmented_expression (expP)
   return (retval);
 }
 
   return (retval);
 }
 

-offsetT
-get_absolute_expression ()
-{
-  expressionS exp;
-
-  expression (&exp);
-  if (exp.X_op != O_constant)
-    {
-      if (exp.X_op != O_absent)
-       as_bad (_("bad or irreducible absolute expression; zero assumed"));
-      exp.X_add_number = 0;
-    }
-  return exp.X_add_number;
-}
-

 char                           /* Return terminator.  */
 char                           /* Return terminator.  */

-get_absolute_expression_and_terminator (val_pointer)
-     long *val_pointer;                /* Return value of expression.  */
+get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression.  */)

 {
   /* FIXME: val_pointer should probably be offsetT *.  */
   *val_pointer = (long) get_absolute_expression ();
 {
   /* FIXME: val_pointer should probably be offsetT *.  */
   *val_pointer = (long) get_absolute_expression ();


@@ -4759,8 +4925,7 @@ get_absolute_expression_and_terminator (val_pointer)
    Give a warning if that happens.  */
 
 char *
    Give a warning if that happens.  */
 
 char *

-demand_copy_C_string (len_pointer)
-     int *len_pointer;
+demand_copy_C_string (int *len_pointer)

 {
   register char *s;
 
 {
   register char *s;
 


@@ -4775,7 +4940,7 @@ demand_copy_C_string (len_pointer)
              s = 0;
              len = 1;
              *len_pointer = 0;
              s = 0;
              len = 1;
              *len_pointer = 0;

-             as_bad (_("This string may not contain \'\\0\'"));
+             as_bad (_("this string may not contain \'\\0\'"));

            }
        }
     }
            }
        }
     }


@@ -4787,8 +4952,7 @@ demand_copy_C_string (len_pointer)
    Return NULL if we can't read a string here.  */
 
 char *
    Return NULL if we can't read a string here.  */
 
 char *

-demand_copy_string (lenP)
-     int *lenP;
+demand_copy_string (int *lenP)

 {
   register unsigned int c;
   register int len;
 {
   register unsigned int c;
   register int len;


@@ -4812,7 +4976,7 @@ demand_copy_string (lenP)
     }
   else
     {
     }
   else
     {

-      as_warn (_("Missing string"));
+      as_bad (_("missing string"));

       retval = NULL;
       ignore_rest_of_line ();
     }
       retval = NULL;
       ignore_rest_of_line ();
     }


@@ -4827,24 +4991,23 @@ demand_copy_string (lenP)
    Out:        1 if input_line_pointer->end-of-line.  */
 
 int
    Out:        1 if input_line_pointer->end-of-line.  */
 
 int

-is_it_end_of_statement ()
+is_it_end_of_statement (void)

 {
   SKIP_WHITESPACE ();
   return (is_end_of_line[(unsigned char) *input_line_pointer]);
 }
 
 void
 {
   SKIP_WHITESPACE ();
   return (is_end_of_line[(unsigned char) *input_line_pointer]);
 }
 
 void

-equals (sym_name, reassign)
-     char *sym_name;
-     int reassign;
+equals (char *sym_name, int reassign)

 {
 {

-  register symbolS *symbolP;   /* Symbol we are working with.  */

   char *stop = NULL;
   char stopc;
 
   input_line_pointer++;
   if (*input_line_pointer == '=')
     input_line_pointer++;
   char *stop = NULL;
   char stopc;
 
   input_line_pointer++;
   if (*input_line_pointer == '=')
     input_line_pointer++;

+  if (reassign < 0 && *input_line_pointer == '=')
+    input_line_pointer++;

 
   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
     input_line_pointer++;
 
   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
     input_line_pointer++;


@@ -4852,54 +5015,135 @@ equals (sym_name, reassign)
   if (flag_mri)
     stop = mri_comment_field (&stopc);
 
   if (flag_mri)
     stop = mri_comment_field (&stopc);
 

-  if (sym_name[0] == '.' && sym_name[1] == '\0')
+  assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);
+
+  if (flag_mri)

     {
     {

-      /* Turn '. = mumble' into a .org mumble.  */
-      register segT segment;
-      expressionS exp;
+      demand_empty_rest_of_line ();
+      mri_comment_end (stop, stopc);
+    }
+}

 
 

-      segment = get_known_segmented_expression (&exp);
-      if (!need_pass_2)
-       do_org (segment, &exp, 0);
+/* .incbin -- include a file verbatim at the current location.  */
+
+void
+s_incbin (int x ATTRIBUTE_UNUSED)
+{
+  FILE * binfile;
+  char * path;
+  char * filename;
+  char * binfrag;
+  long   skip = 0;
+  long   count = 0;
+  long   bytes;
+  int    len;
+
+#ifdef md_flush_pending_output
+  md_flush_pending_output ();
+#endif
+
+  SKIP_WHITESPACE ();
+  filename = demand_copy_string (& len);
+  if (filename == NULL)
+    return;
+
+  SKIP_WHITESPACE ();
+
+  /* Look for optional skip and count.  */
+  if (* input_line_pointer == ',')
+    {
+      ++ input_line_pointer;
+      skip = get_absolute_expression ();
+
+      SKIP_WHITESPACE ();
+
+      if (* input_line_pointer == ',')
+       {
+         ++ input_line_pointer;
+
+         count = get_absolute_expression ();
+         if (count == 0)
+           as_warn (_(".incbin count zero, ignoring `%s'"), filename);
+
+         SKIP_WHITESPACE ();
+       }

     }
     }

-  else
+
+  demand_empty_rest_of_line ();
+
+  /* Try opening absolute path first, then try include dirs.  */
+  binfile = fopen (filename, FOPEN_RB);
+  if (binfile == NULL)

     {
     {

-#ifdef OBJ_COFF
-      int local;
+      int i;

 
 

-      symbolP = symbol_find (sym_name);
-      local = symbolP == NULL;
-      if (local)
-#endif /* OBJ_COFF */
-      symbolP = symbol_find_or_make (sym_name);
-      /* Permit register names to be redefined.  */
-      if (!reassign
-         && S_IS_DEFINED (symbolP)
-         && S_GET_SEGMENT (symbolP) != reg_section)
-       as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
+      path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);

 
 

-#ifdef OBJ_COFF
-      /* "set" symbols are local unless otherwise specified.  */
-      if (local)
-       SF_SET_LOCAL (symbolP);
-#endif /* OBJ_COFF */
+      for (i = 0; i < include_dir_count; i++)
+       {
+         sprintf (path, "%s/%s", include_dirs[i], filename);

 
 

-      pseudo_set (symbolP);
+         binfile = fopen (path, FOPEN_RB);
+         if (binfile != NULL)
+           break;
+       }
+
+      if (binfile == NULL)
+       as_bad (_("file not found: %s"), filename);

     }
     }

+  else
+    path = xstrdup (filename);

 
 

-  if (flag_mri)
+  if (binfile)

     {
     {

-      /* Check garbage after the expression.  */
-      ignore_rest_of_line ();
-      mri_comment_end (stop, stopc);
+      long   file_len;
+
+      register_dependency (path);
+
+      /* Compute the length of the file.  */
+      if (fseek (binfile, 0, SEEK_END) != 0)
+       {
+         as_bad (_("seek to end of .incbin file failed `%s'"), path);
+         goto done;
+       }
+      file_len = ftell (binfile);
+
+      /* If a count was not specified use the remainder of the file.  */
+      if (count == 0)
+       count = file_len - skip;
+
+      if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
+       {
+         as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
+                 skip, count, file_len);
+         goto done;
+       }
+
+      if (fseek (binfile, skip, SEEK_SET) != 0)
+       {
+         as_bad (_("could not skip to %ld in file `%s'"), skip, path);
+         goto done;
+       }
+
+      /* Allocate frag space and store file contents in it.  */
+      binfrag = frag_more (count);
+
+      bytes = fread (binfrag, 1, count, binfile);
+      if (bytes < count)
+       as_warn (_("truncated file `%s', %ld of %ld bytes read"),
+                path, bytes, count);

     }
     }

+done:
+  if (binfile != NULL)
+    fclose (binfile);
+  if (path)
+    free (path);

 }
 
 /* .include -- include a file at this point.  */
 
 void
 }
 
 /* .include -- include a file at this point.  */
 
 void

-s_include (arg)
-     int arg ATTRIBUTE_UNUSED;
+s_include (int arg ATTRIBUTE_UNUSED)

 {
   char *filename;
   int i;
 {
   char *filename;
   int i;


@@ -4912,7 +5156,7 @@ s_include (arg)
       if (filename == NULL)
        {
          /* demand_copy_string has already printed an error and
       if (filename == NULL)
        {
          /* demand_copy_string has already printed an error and

-             called ignore_rest_of_line.  */
+            called ignore_rest_of_line.  */

          return;
        }
     }
          return;
        }
     }


@@ -4943,7 +5187,7 @@ s_include (arg)
       strcpy (path, include_dirs[i]);
       strcat (path, "/");
       strcat (path, filename);
       strcpy (path, include_dirs[i]);
       strcat (path, "/");
       strcat (path, filename);

-      if (0 != (try = fopen (path, "r")))
+      if (0 != (try = fopen (path, FOPEN_RT)))

        {
          fclose (try);
          goto gotit;
        {
          fclose (try);
          goto gotit;


@@ -4959,8 +5203,7 @@ gotit:
 }
 
 void
 }
 
 void

-add_include_dir (path)
-     char *path;
+add_include_dir (char *path)

 {
   int i;
 
 {
   int i;
 


@@ -4988,7 +5231,7 @@ add_include_dir (path)
 /* Output debugging information to denote the source file.  */
 
 static void
 /* Output debugging information to denote the source file.  */
 
 static void

-generate_file_debug ()
+generate_file_debug (void)

 {
   if (debug_type == DEBUG_STABS)
     stabs_generate_asm_file ();
 {
   if (debug_type == DEBUG_STABS)
     stabs_generate_asm_file ();


@@ -4997,7 +5240,7 @@ generate_file_debug ()
 /* Output line number debugging information for the current source line.  */
 
 void
 /* Output line number debugging information for the current source line.  */
 
 void

-generate_lineno_debug ()
+generate_lineno_debug (void)

 {
   switch (debug_type)
     {
 {
   switch (debug_type)
     {


@@ -5024,8 +5267,7 @@ generate_lineno_debug ()
    END_P is zero for .func, and non-zero for .endfunc.  */
 
 void
    END_P is zero for .func, and non-zero for .endfunc.  */
 
 void

-s_func (end_p)
-     int end_p;
+s_func (int end_p)

 {
   do_s_func (end_p, NULL);
 }
 {
   do_s_func (end_p, NULL);
 }


@@ -5033,10 +5275,8 @@ s_func (end_p)
 /* Subroutine of s_func so targets can choose a different default prefix.
    If DEFAULT_PREFIX is NULL, use the target's "leading char".  */
 
 /* Subroutine of s_func so targets can choose a different default prefix.
    If DEFAULT_PREFIX is NULL, use the target's "leading char".  */
 

-void
-do_s_func (end_p, default_prefix)
-     int end_p;
-     const char *default_prefix;
+static void
+do_s_func (int end_p, const char *default_prefix)

 {
   /* Record the current function so that we can issue an error message for
      misplaced .func,.endfunc, and also so that .endfunc needs no
 {
   /* Record the current function so that we can issue an error message for
      misplaced .func,.endfunc, and also so that .endfunc needs no


@@ -5081,10 +5321,7 @@ do_s_func (end_p, default_prefix)
            asprintf (&label, "%s%s", default_prefix, name);
          else
            {
            asprintf (&label, "%s%s", default_prefix, name);
          else
            {

-             char leading_char = 0;
-#ifdef BFD_ASSEMBLER
-             leading_char = bfd_get_symbol_leading_char (stdoutput);
-#endif
+             char leading_char = bfd_get_symbol_leading_char (stdoutput);

              /* Missing entry point, use function's name with the leading
                 char prepended.  */
              if (leading_char)
              /* Missing entry point, use function's name with the leading
                 char prepended.  */
              if (leading_char)


@@ -5114,19 +5351,13 @@ do_s_func (end_p, default_prefix)
 }
 \f
 void
 }
 \f
 void

-s_ignore (arg)
-     int arg ATTRIBUTE_UNUSED;
+s_ignore (int arg ATTRIBUTE_UNUSED)

 {
 {

-  while (!is_end_of_line[(unsigned char) *input_line_pointer])
-    {
-      ++input_line_pointer;
-    }
-  ++input_line_pointer;
+  ignore_rest_of_line ();

 }
 
 void
 }
 
 void

-read_print_statistics (file)
-     FILE *file;
+read_print_statistics (FILE *file)

 {
   hash_print_statistics (file, "pseudo-op table", po_hash);
 }
 {
   hash_print_statistics (file, "pseudo-op table", po_hash);
 }


@@ -5136,13 +5367,12 @@ read_print_statistics (file)
    This call avoids macro/conditionals nesting checking, since the contents of
    the line are assumed to replace the contents of a line already scanned.
 
    This call avoids macro/conditionals nesting checking, since the contents of
    the line are assumed to replace the contents of a line already scanned.
 

-   An appropriate use of this function would be substition of input lines when
+   An appropriate use of this function would be substitution of input lines when

    called by md_start_line_hook().  The given line is assumed to already be
    properly scrubbed.  */
 
 void
    called by md_start_line_hook().  The given line is assumed to already be
    properly scrubbed.  */
 
 void

-input_scrub_insert_line (line)
-     const char *line;
+input_scrub_insert_line (const char *line)

 {
   sb newline;
   sb_new (&newline);
 {
   sb newline;
   sb_new (&newline);


@@ -5156,9 +5386,56 @@ input_scrub_insert_line (line)
    file; no include path searching or dependency registering is performed.  */
 
 void
    file; no include path searching or dependency registering is performed.  */
 
 void

-input_scrub_insert_file (path)
-     char *path;
+input_scrub_insert_file (char *path)

 {
   input_scrub_include_file (path, input_line_pointer);
   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
 }
 {
   input_scrub_include_file (path, input_line_pointer);
   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
 }

+
+/* Find the end of a line, considering quotation and escaping of quotes.  */
+
+#if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
+# define TC_SINGLE_QUOTE_STRINGS 1
+#endif
+
+static char *
+_find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED)
+{
+  char inquote = '\0';
+  int inescape = 0;
+
+  while (!is_end_of_line[(unsigned char) *s]
+        || (inquote && !ISCNTRL (*s))
+        || (inquote == '\'' && flag_mri)
+#ifdef TC_EOL_IN_INSN
+        || (insn && TC_EOL_IN_INSN (s))
+#endif
+       )
+    {
+      if (mri_string && *s == '\'')
+       inquote ^= *s;
+      else if (inescape)
+       inescape = 0;
+      else if (*s == '\\')
+       inescape = 1;
+      else if (!inquote
+              ? *s == '"'
+#ifdef TC_SINGLE_QUOTE_STRINGS
+                || (TC_SINGLE_QUOTE_STRINGS && *s == '\'')
+#endif
+              : *s == inquote)
+       inquote ^= *s;
+      ++s;
+    }
+  if (inquote)
+    as_warn (_("missing closing `%c'"), inquote);
+  if (inescape)
+    as_warn (_("stray `\\'"));
+  return s;
+}
+
+char *
+find_end_of_line (char *s, int mri_string)
+{
+  return _find_end_of_line (s, mri_string, 0);
+}