* dwarf2read.c (partial_read_comp_unit_head): Set header->offset,
[deliverable/binutils-gdb.git] / gas / read.c
index f2b01be804253caaae2f0719b7fe679677b34f25..2ab58ecbc308c2e8e4298431951326b2a283414e 100644 (file)
@@ -1,24 +1,24 @@
 /* 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, 2001, 2002, 2003, 2004, 2005
-   Free Software Foundation, Inc.
+   1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+   2010, 2011  Free Software Foundation, Inc.
 
 
-This file is part of GAS, the GNU Assembler.
+   This file is part of GAS, the GNU Assembler.
 
 
-GAS is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
+   GAS is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
 
 
-GAS is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   GAS is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+   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, 51 Franklin Street - Fifth Floor, Boston, MA
+   02110-1301, USA.  */
 
 /* 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.
 
 /* 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.
@@ -38,12 +38,11 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "sb.h"
 #include "macro.h"
 #include "obstack.h"
 #include "sb.h"
 #include "macro.h"
 #include "obstack.h"
-#include "listing.h"
 #include "ecoff.h"
 #include "dw2gencfi.h"
 
 #ifndef TC_START_LABEL
 #include "ecoff.h"
 #include "dw2gencfi.h"
 
 #ifndef TC_START_LABEL
-#define TC_START_LABEL(x,y) (x == ':')
+#define TC_START_LABEL(x,y,z) (x == ':')
 #endif
 
 /* Set by the object-format or the target.  */
 #endif
 
 /* Set by the object-format or the target.  */
@@ -72,7 +71,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
 
@@ -98,7 +96,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
 
@@ -128,7 +125,8 @@ char lex_type[256] = {
 };
 
 /* In: a character.
 };
 
 /* In: a character.
-   Out: 1 if this character ends a line.  */
+   Out: 1 if this character ends a line.
+       2 if this character is a line separator.  */
 char is_end_of_line[256] = {
 #ifdef CR_EOL
   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,      /* @abcdefghijklmno */
 char is_end_of_line[256] = {
 #ifdef CR_EOL
   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,      /* @abcdefghijklmno */
@@ -211,15 +209,21 @@ static int dwarf_file_string;
 #endif
 #endif
 
 #endif
 #endif
 
+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 void do_align (int, char *, int, int);
 static void s_align (int, int);
 static void s_altmacro (int);
 static void s_bad_end (int);
+#ifdef OBJ_ELF
+static void s_gnu_attribute (int);
+#endif
+static void s_reloc (int);
 static int hex_float (int, char *);
 static segT get_known_segmented_expression (expressionS * expP);
 static void pobegin (void);
 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 int get_non_macro_line_sb (sb *);
 static void generate_file_debug (void);
 static void generate_file_debug (void);
+static char *_find_end_of_line (char *, int, int, int);
 \f
 void
 read_begin (void)
 \f
 void
 read_begin (void)
@@ -236,7 +240,7 @@ read_begin (void)
 
   /* Use machine dependent syntax.  */
   for (p = line_separator_chars; *p; p++)
 
   /* Use machine dependent syntax.  */
   for (p = line_separator_chars; *p; p++)
-    is_end_of_line[(unsigned char) *p] = 1;
+    is_end_of_line[(unsigned char) *p] = 2;
   /* Use more.  FIXME-SOMEDAY.  */
 
   if (flag_mri)
   /* Use more.  FIXME-SOMEDAY.  */
 
   if (flag_mri)
@@ -244,7 +248,6 @@ read_begin (void)
 }
 \f
 #ifndef TC_ADDRESS_BYTES
 }
 \f
 #ifndef TC_ADDRESS_BYTES
-#ifdef BFD_ASSEMBLER
 #define TC_ADDRESS_BYTES address_bytes
 
 static inline int
 #define TC_ADDRESS_BYTES address_bytes
 
 static inline int
@@ -259,7 +262,6 @@ address_bytes (void)
   return n;
 }
 #endif
   return n;
 }
 #endif
-#endif
 
 /* Set up pseudo-op tables.  */
 
 
 /* Set up pseudo-op tables.  */
 
@@ -269,8 +271,8 @@ static const pseudo_typeS potable[] = {
   {"abort", s_abort, 0},
   {"align", s_align_ptwo, 0},
   {"altmacro", s_altmacro, 1},
   {"abort", s_abort, 0},
   {"align", s_align_ptwo, 0},
   {"altmacro", s_altmacro, 1},
-  {"ascii", stringer, 0},
-  {"asciz", stringer, 1},
+  {"ascii", stringer, 8+0},
+  {"asciz", stringer, 8+1},
   {"balign", s_align_bytes, 0},
   {"balignw", s_align_bytes, -2},
   {"balignl", s_align_bytes, -4},
   {"balign", s_align_bytes, 0},
   {"balignw", s_align_bytes, -2},
   {"balignl", s_align_bytes, -4},
@@ -325,13 +327,14 @@ static const pseudo_typeS potable[] = {
 /* 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},
   {"error", s_errwarn, 1},
   {"exitm", s_mexit, 0},
 /* extend  */
   {"extern", s_ignore, 0},     /* We treat all undef as ext.  */
   {"appfile", s_app_file, 1},
   {"err", s_err, 0},
   {"error", s_errwarn, 1},
   {"exitm", s_mexit, 0},
 /* extend  */
   {"extern", s_ignore, 0},     /* We treat all undef as ext.  */
   {"appfile", s_app_file, 1},
-  {"appline", s_app_line, 0},
+  {"appline", s_app_line, 1},
   {"fail", s_fail, 0},
   {"file", s_app_file, 0},
   {"fill", s_fill, 0},
   {"fail", s_fail, 0},
   {"file", s_app_file, 0},
   {"fill", s_fill, 0},
@@ -340,8 +343,12 @@ static const pseudo_typeS potable[] = {
   {"func", s_func, 0},
   {"global", s_globl, 0},
   {"globl", s_globl, 0},
   {"func", s_func, 0},
   {"global", s_globl, 0},
   {"globl", s_globl, 0},
+#ifdef OBJ_ELF
+  {"gnu_attribute", s_gnu_attribute, 0},
+#endif
   {"hword", cons, 2},
   {"if", s_if, (int) O_ne},
   {"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},
@@ -350,6 +357,7 @@ 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},
   {"ifnc", s_ifc, 1},
   {"ifndef", s_ifdef, 1},
   {"ifne", s_if, (int) O_ne},
@@ -363,7 +371,8 @@ static const pseudo_typeS potable[] = {
   {"irpc", s_irp, 1},
   {"irepc", s_irp, 1},
   {"lcomm", s_lcomm, 0},
   {"irpc", s_irp, 1},
   {"irepc", s_irp, 1},
   {"lcomm", s_lcomm, 0},
-  {"lflags", listing_flags, 0},        /* Listing flags.  */
+  {"lflags", s_ignore, 0},     /* Listing flags.  */
+  {"linefile", s_app_line, 0},
   {"linkonce", s_linkonce, 0},
   {"list", listing_list, 1},   /* Turn listing on.  */
   {"llen", listing_psize, 1},
   {"linkonce", s_linkonce, 0},
   {"list", listing_list, 1},   /* Turn listing on.  */
   {"llen", listing_psize, 1},
@@ -390,6 +399,7 @@ static const pseudo_typeS potable[] = {
   {"psize", listing_psize, 0}, /* Set paper size.  */
   {"purgem", s_purgem, 0},
   {"quad", cons, 8},
   {"psize", listing_psize, 0}, /* Set paper size.  */
   {"purgem", s_purgem, 0},
   {"quad", cons, 8},
+  {"reloc", s_reloc, 0},
   {"rep", s_rept, 0},
   {"rept", s_rept, 0},
   {"rva", s_rva, 4},
   {"rep", s_rept, 0},
   {"rept", s_rept, 0},
   {"rva", s_rva, 4},
@@ -407,7 +417,11 @@ static const pseudo_typeS potable[] = {
   {"stabd", s_stab, 'd'},
   {"stabn", s_stab, 'n'},
   {"stabs", s_stab, 's'},
   {"stabd", s_stab, 'd'},
   {"stabn", s_stab, 'n'},
   {"stabs", s_stab, 's'},
-  {"string", stringer, 1},
+  {"string", stringer, 8+1},
+  {"string8", stringer, 8+1},
+  {"string16", stringer, 16+1},
+  {"string32", stringer, 32+1},
+  {"string64", stringer, 64+1},
   {"struct", s_struct, 0},
 /* tag  */
   {"text", s_text, 0},
   {"struct", s_struct, 0},
 /* tag  */
   {"text", s_text, 0},
@@ -433,11 +447,33 @@ static const pseudo_typeS potable[] = {
   {"xref", s_ignore, 0},
   {"xstabs", s_xstab, 's'},
   {"warning", s_errwarn, 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;
 
 static int pop_override_ok = 0;
 static const char *pop_table_name;
 
@@ -485,19 +521,20 @@ pobegin (void)
   pop_table_name = "standard";
   pop_insert (potable);
 
   pop_table_name = "standard";
   pop_insert (potable);
 
-#ifdef TARGET_USE_CFIPOP
+  /* Now CFI ones.  */
   pop_table_name = "cfi";
   pop_override_ok = 1;
   cfi_pop_insert ();
   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;                                                                \
     }
 
@@ -520,14 +557,40 @@ scrub_from_string (char *buf, int 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
 read_a_source_file (char *name)
 {
 /* We read the file, putting things into a web that represents what we
    have been reading.  */
 void
 read_a_source_file (char *name)
 {
-  register char c;
-  register char *s;            /* String of symbol, '\0' appended.  */
-  register int temp;
+  char c;
+  char *s;             /* String of symbol, '\0' appended.  */
+  int temp;
   pseudo_typeS *pop;
 
 #ifdef WARN_COMMENTS
   pseudo_typeS *pop;
 
 #ifdef WARN_COMMENTS
@@ -547,23 +610,67 @@ read_a_source_file (char *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.  */
-      know (buffer_limit[-1] == '\n'); /* Must have a sentinel.  */
+#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
       while (input_line_pointer < buffer_limit)
        {
       while (input_line_pointer < buffer_limit)
        {
+         bfd_boolean was_new_line;
          /* We have more of this buffer to parse.  */
 
          /* We now have input_line_pointer->1st char of next line.
             If input_line_pointer [-1] == '\n' then we just
             scanned another line: so bump line counters.  */
          /* We have more of this buffer to parse.  */
 
          /* We now have input_line_pointer->1st char of next line.
             If input_line_pointer [-1] == '\n' then we just
             scanned another line: so bump line counters.  */
-         if (is_end_of_line[(unsigned char) input_line_pointer[-1]])
+         was_new_line = is_end_of_line[(unsigned char) input_line_pointer[-1]];
+         if (was_new_line)
            {
            {
+             symbol_set_value_now (&dot_symbol);
 #ifdef md_start_line_hook
              md_start_line_hook ();
 #endif
              if (input_line_pointer[-1] == '\n')
                bump_line_counters ();
 #ifdef md_start_line_hook
              md_start_line_hook ();
 #endif
              if (input_line_pointer[-1] == '\n')
                bump_line_counters ();
+           }
+
+#ifndef NO_LISTING
+         /* If listing is on, and we are expanding a macro, then give
+            the listing code the contents of the expanded line.  */
+         if (listing)
+           {
+             if ((listing & LISTING_MACEXP) && macro_nest > 0)
+               {
+                 /* Find the end of the current expanded macro line.  */
+                 s = find_end_of_line (input_line_pointer, flag_m68k_mri);
 
 
+                 if (s != last_eol)
+                   {
+                     char *copy;
+                     int len;
+
+                     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;
+                     copy = (char *) xmalloc (len + macro_nest + 2);
+                     memset (copy, '>', macro_nest);
+                     copy[macro_nest] = ' ';
+                     memcpy (copy + macro_nest + 1, input_line_pointer, len);
+                     copy[macro_nest + 1 + len] = '\0';
+
+                     /* Install the line with the listing facility.  */
+                     listing_newline (copy);
+                   }
+               }
+             else
+               listing_newline (NULL);
+           }
+#endif
+         if (was_new_line)
+           {
              line_label = NULL;
 
              if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
              line_label = NULL;
 
              if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
@@ -573,10 +680,8 @@ read_a_source_file (char *name)
                  if (is_name_beginner (*input_line_pointer))
                    {
                      char *line_start = input_line_pointer;
                  if (is_name_beginner (*input_line_pointer))
                    {
                      char *line_start = input_line_pointer;
-                     char c;
                      int mri_line_macro;
 
                      int mri_line_macro;
 
-                     LISTING_NEWLINE ();
                      HANDLE_CONDITIONAL_ASSEMBLY ();
 
                      c = get_symbol_end ();
                      HANDLE_CONDITIONAL_ASSEMBLY ();
 
                      c = get_symbol_end ();
@@ -637,51 +742,12 @@ read_a_source_file (char *name)
 
             Depending on what compiler is used, the order of these tests
             may vary to catch most common case 1st.
 
             Depending on what compiler is used, the order of these tests
             may vary to catch most common case 1st.
-            Each test is independent of all other tests at the (top) level.
-            PLEASE make a compiler that doesn't use this assembler.
-            It is crufty to waste a compiler's time encoding things for this
-            assembler, which then wastes more time decoding it.
-            (And communicating via (linear) files is silly!
-            If you must pass stuff, please pass a tree!)  */
-         if ((c = *input_line_pointer++) == '\t'
-             || c == ' '
-             || c == '\f'
-             || c == 0)
+            Each test is independent of all other tests at the (top)
+            level.  */
+         do
            c = *input_line_pointer++;
            c = *input_line_pointer++;
+         while (c == '\t' || c == ' ' || c == '\f');
 
 
-         know (c != ' ');      /* No further leading whitespace.  */
-
-#ifndef NO_LISTING
-         /* If listing is on, and we are expanding a macro, then give
-            the listing code the contents of the expanded line.  */
-         if (listing)
-           {
-             if ((listing & LISTING_MACEXP) && macro_nest > 0)
-               {
-                 char *copy;
-                 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;
-
-                 /* 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);
-           }
-#endif
          /* C is the 1st significant character.
             Input_line_pointer points after that character.  */
          if (is_name_beginner (c))
          /* C is the 1st significant character.
             Input_line_pointer points after that character.  */
          if (is_name_beginner (c))
@@ -697,7 +763,7 @@ read_a_source_file (char *name)
                 S points to the beginning of the symbol.
                   [In case of pseudo-op, s->'.'.]
                 Input_line_pointer->'\0' where c was.  */
                 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 (TC_START_LABEL (c, s, input_line_pointer))
                {
                  if (flag_m68k_mri)
                    {
                {
                  if (flag_m68k_mri)
                    {
@@ -729,6 +795,14 @@ read_a_source_file (char *name)
                  /* Input_line_pointer->after ':'.  */
                  SKIP_WHITESPACE ();
                }
                  /* Input_line_pointer->after ':'.  */
                  SKIP_WHITESPACE ();
                }
+              else if ((c == '=' && input_line_pointer[1] == '=')
+                      || ((c == ' ' || c == '\t')
+                          && input_line_pointer[1] == '='
+                          && input_line_pointer[2] == '='))
+               {
+                 equals (s, -1);
+                 demand_empty_rest_of_line ();
+               }
               else if ((c == '='
                        || ((c == ' ' || c == '\t')
                             && input_line_pointer[1] == '='))
               else if ((c == '='
                        || ((c == ' ' || c == '\t')
                             && input_line_pointer[1] == '='))
@@ -761,8 +835,8 @@ read_a_source_file (char *name)
 #endif
                  if (NO_PSEUDO_DOT || flag_m68k_mri)
                    {
 #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;
@@ -816,9 +890,18 @@ read_a_source_file (char *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;
                        }
 
@@ -841,61 +924,17 @@ read_a_source_file (char *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, 0);
                      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, &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)
                        {
@@ -975,10 +1014,14 @@ read_a_source_file (char *name)
              unsigned int new_length;
              char *tmp_buf = 0;
 
              unsigned int new_length;
              char *tmp_buf = 0;
 
-             bump_line_counters ();
              s = input_line_pointer;
              if (strncmp (s, "APP\n", 4))
              s = input_line_pointer;
              if (strncmp (s, "APP\n", 4))
-               continue;       /* We ignore it */
+               {
+                 /* We ignore it.  */
+                 ignore_rest_of_line ();
+                 continue;
+               }
+             bump_line_counters ();
              s += 4;
 
              sb_new (&sbuf);
              s += 4;
 
              sb_new (&sbuf);
@@ -994,7 +1037,7 @@ read_a_source_file (char *name)
                     that goes with this #APP  There is one.  The specs
                     guarantee it...  */
                  tmp_len = buffer_limit - s;
                     that goes with this #APP  There is one.  The specs
                     guarantee it...  */
                  tmp_len = buffer_limit - s;
-                 tmp_buf = xmalloc (tmp_len + 1);
+                 tmp_buf = (char *) xmalloc (tmp_len + 1);
                  memcpy (tmp_buf, s, tmp_len);
                  do
                    {
                  memcpy (tmp_buf, s, tmp_len);
                  do
                    {
@@ -1010,7 +1053,7 @@ read_a_source_file (char *name)
                      else
                        num = buffer_limit - buffer;
 
                      else
                        num = buffer_limit - buffer;
 
-                     tmp_buf = xrealloc (tmp_buf, tmp_len + num);
+                     tmp_buf = (char *) xrealloc (tmp_buf, tmp_len + num);
                      memcpy (tmp_buf + tmp_len, buffer, num);
                      tmp_len += num;
                    }
                      memcpy (tmp_buf + tmp_len, buffer, num);
                      tmp_len += num;
                    }
@@ -1047,7 +1090,7 @@ read_a_source_file (char *name)
                      break;
                    }
 
                      break;
                    }
 
-                 new_buf = xrealloc (new_buf, new_length + 100);
+                 new_buf = (char *) xrealloc (new_buf, new_length + 100);
                  new_tmp = new_buf + new_length;
                  new_length += 100;
                }
                  new_tmp = new_buf + new_length;
                  new_length += 100;
                }
@@ -1077,16 +1120,13 @@ read_a_source_file (char *name)
            continue;
 #endif
          input_line_pointer--;
            continue;
 #endif
          input_line_pointer--;
-         /* Report unknown char as ignored.  */
+         /* Report unknown char as error.  */
          demand_empty_rest_of_line ();
        }
          demand_empty_rest_of_line ();
        }
-
-#ifdef md_after_pass_hook
-      md_after_pass_hook ();
-#endif
     }
 
  quit:
     }
 
  quit:
+  symbol_set_value_now (&dot_symbol);
 
 #ifdef md_cleanup
   md_cleanup ();
 
 #ifdef md_cleanup
   md_cleanup ();
@@ -1237,20 +1277,17 @@ do_align (int n, char *fill, int len, int max)
    (in bytes).  A negative ARG is the negative of the length of the
    fill pattern.  BYTES_P is non-zero if the alignment value should be
    interpreted as the byte boundary, rather than the power of 2.  */
    (in bytes).  A negative ARG is the negative of the length of the
    fill pattern.  BYTES_P is non-zero if the alignment value should be
    interpreted as the byte boundary, rather than the power of 2.  */
-
-#ifdef BFD_ASSEMBLER
-#define ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
-#else
-#define ALIGN_LIMIT 15
+#ifndef TC_ALIGN_LIMIT
+#define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
 #endif
 
 static void
 s_align (int arg, int bytes_p)
 {
 #endif
 
 static void
 s_align (int arg, int bytes_p)
 {
-  unsigned int align_limit = ALIGN_LIMIT;
+  unsigned int align_limit = TC_ALIGN_LIMIT;
   unsigned int align;
   char *stop = NULL;
   unsigned int align;
   char *stop = NULL;
-  char stopc;
+  char stopc = 0;
   offsetT fill = 0;
   int max;
   int fill_p;
   offsetT fill = 0;
   int max;
   int fill_p;
@@ -1394,7 +1431,7 @@ s_comm_internal (int param,
   offsetT temp, size;
   symbolS *symbolP = NULL;
   char *stop = NULL;
   offsetT temp, size;
   symbolS *symbolP = NULL;
   char *stop = NULL;
-  char stopc;
+  char stopc = 0;
   expressionS exp;
 
   if (flag_mri)
   expressionS exp;
 
   if (flag_mri)
@@ -1409,7 +1446,7 @@ s_comm_internal (int param,
   if (name == p)
     {
       as_bad (_("expected symbol name"));
   if (name == p)
     {
       as_bad (_("expected symbol name"));
-      discard_rest_of_line ();
+      ignore_rest_of_line ();
       goto out;
     }
 
       goto out;
     }
 
@@ -1422,9 +1459,7 @@ s_comm_internal (int param,
 
   temp = get_absolute_expr (&exp);
   size = temp;
 
   temp = get_absolute_expr (&exp);
   size = temp;
-#ifdef BFD_ASSEMBLER
   size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
   size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
-#endif
   if (exp.X_op == O_absent)
     {
       as_bad (_("missing size expression"));
   if (exp.X_op == O_absent)
     {
       as_bad (_("missing size expression"));
@@ -1440,13 +1475,22 @@ s_comm_internal (int param,
 
   *p = 0;
   symbolP = symbol_find_or_make (name);
 
   *p = 0;
   symbolP = symbol_find_or_make (name);
-  if (S_IS_DEFINED (symbolP) && !S_IS_COMMON (symbolP))
+  if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
+      && !S_IS_COMMON (symbolP))
     {
     {
-      symbolP = NULL;
-      as_bad (_("symbol `%s' is already defined"), name);
-      *p = c;
-      ignore_rest_of_line ();
-      goto out;
+      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);
     }
 
   size = S_GET_VALUE (symbolP);
@@ -1463,13 +1507,7 @@ s_comm_internal (int param,
     {
       S_SET_VALUE (symbolP, (valueT) size);
       S_SET_EXTERNAL (symbolP);
     {
       S_SET_VALUE (symbolP, (valueT) size);
       S_SET_EXTERNAL (symbolP);
-#ifdef OBJ_VMS
-      {
-       extern int flag_one;
-       if (size == 0 || !flag_one)
-         S_GET_OTHER (symbolP) = const_flag;
-      }
-#endif
+      S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
     }
 
   demand_empty_rest_of_line ();
     }
 
   demand_empty_rest_of_line ();
@@ -1498,7 +1536,7 @@ s_mri_common (int small ATTRIBUTE_UNUSED)
   symbolS *sym;
   offsetT align;
   char *stop = NULL;
   symbolS *sym;
   offsetT align;
   char *stop = NULL;
-  char stopc;
+  char stopc = 0;
 
   if (!flag_mri)
     {
 
   if (!flag_mri)
     {
@@ -1556,11 +1594,14 @@ s_mri_common (int small ATTRIBUTE_UNUSED)
     }
 
   S_SET_EXTERNAL (sym);
     }
 
   S_SET_EXTERNAL (sym);
+  S_SET_SEGMENT (sym, bfd_com_section_ptr);
   mri_common_symbol = sym;
 
 #ifdef S_SET_ALIGN
   if (align != 0)
     S_SET_ALIGN (sym, align);
   mri_common_symbol = sym;
 
 #ifdef S_SET_ALIGN
   if (align != 0)
     S_SET_ALIGN (sym, align);
+#else
+  (void) align;
 #endif
 
   if (line_label != NULL)
 #endif
 
   if (line_label != NULL)
@@ -1592,7 +1633,7 @@ void
 s_data (int ignore ATTRIBUTE_UNUSED)
 {
   segT section;
 s_data (int ignore ATTRIBUTE_UNUSED)
 {
   segT section;
-  register int temp;
+  int temp;
 
   temp = get_absolute_expression ();
   if (flag_readonly_data_in_text)
 
   temp = get_absolute_expression ();
   if (flag_readonly_data_in_text)
@@ -1605,9 +1646,6 @@ s_data (int ignore ATTRIBUTE_UNUSED)
 
   subseg_set (section, (subsegT) temp);
 
 
   subseg_set (section, (subsegT) temp);
 
-#ifdef OBJ_VMS
-  const_flag = 0;
-#endif
   demand_empty_rest_of_line ();
 }
 
   demand_empty_rest_of_line ();
 }
 
@@ -1634,17 +1672,14 @@ s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
 void
 s_app_file (int appfile)
 {
 void
 s_app_file (int appfile)
 {
-  register char *s;
+  char *s;
   int length;
 
   /* Some assemblers tolerate immediately following '"'.  */
   if ((s = demand_copy_string (&length)) != 0)
     {
   int length;
 
   /* Some assemblers tolerate immediately following '"'.  */
   if ((s = demand_copy_string (&length)) != 0)
     {
-      /* If this is a fake .appfile, a fake newline was inserted into
-        the buffer.  Passing -2 to new_logical_line tells it to
-        account for it.  */
       int may_omit
       int may_omit
-       = (!new_logical_line (s, appfile ? -2 : -1) && appfile);
+       = (!new_logical_line_flags (s, -1, 1) && appfile);
 
       /* In MRI mode, the preprocessor may have inserted an extraneous
         backquote.  */
 
       /* In MRI mode, the preprocessor may have inserted an extraneous
         backquote.  */
@@ -1659,32 +1694,123 @@ s_app_file (int appfile)
     }
 }
 
     }
 }
 
+static int
+get_linefile_number (int *flag)
+{
+  SKIP_WHITESPACE ();
+
+  if (*input_line_pointer < '0' || *input_line_pointer > '9')
+    return 0;
+
+  *flag = get_absolute_expression ();
+
+  return 1;
+}
+
 /* Handle the .appline pseudo-op.  This is automatically generated by
    do_scrub_chars when a preprocessor # line comment is seen.  This
    default definition may be overridden by the object or CPU specific
    pseudo-ops.  */
 
 void
 /* Handle the .appline pseudo-op.  This is automatically generated by
    do_scrub_chars when a preprocessor # line comment is seen.  This
    default definition may be overridden by the object or CPU specific
    pseudo-ops.  */
 
 void
-s_app_line (int ignore ATTRIBUTE_UNUSED)
+s_app_line (int appline)
 {
 {
+  char *file = NULL;
   int l;
 
   /* The given number is that of the next line.  */
   int l;
 
   /* The given number is that of the next line.  */
-  l = get_absolute_expression () - 1;
-  if (l < 0)
+  if (appline)
+    l = get_absolute_expression ();
+  else if (!get_linefile_number (&l))
+    {
+      ignore_rest_of_line ();
+      return;
+    }
+
+  l--;
+
+  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.  */
+       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
     {
     as_warn (_("line numbers must be positive; line number %d rejected"),
             l + 1);
   else
     {
-      new_logical_line ((char *) NULL, l);
+      int flags = 0;
+      int length = 0;
+
+      if (!appline)
+       {
+         SKIP_WHITESPACE ();
+
+         if (*input_line_pointer == '"')
+           file = demand_copy_string (&length);
+
+         if (file)
+           {
+             int this_flag;
+
+             while (get_linefile_number (&this_flag))
+               switch (this_flag)
+                 {
+                   /* From GCC's cpp documentation:
+                      1: start of a new file.
+                      2: returning to a file after having included
+                         another file.
+                      3: following text comes from a system header file.
+                      4: following text should be treated as extern "C".
+
+                      4 is nonsensical for the assembler; 3, we don't
+                      care about, so we ignore it just in case a
+                      system header file is included while
+                      preprocessing assembly.  So 1 and 2 are all we
+                      care about, and they are mutually incompatible.
+                      new_logical_line_flags() demands this.  */
+                 case 1:
+                 case 2:
+                   if (flags && flags != (1 << this_flag))
+                     as_warn (_("incompatible flag %i in line directive"),
+                              this_flag);
+                   else
+                     flags |= 1 << this_flag;
+                   break;
+
+                 case 3:
+                 case 4:
+                   /* We ignore these.  */
+                   break;
+
+                 default:
+                   as_warn (_("unsupported flag %i in line directive"),
+                            this_flag);
+                   break;
+                 }
+
+             if (!is_end_of_line[(unsigned char)*input_line_pointer])
+               file = 0;
+           }
+       }
+
+      if (appline || file)
+       {
+         new_logical_line_flags (file, l, flags);
 #ifdef LISTING
 #ifdef LISTING
-      if (listing)
-       listing_source_line (l);
+         if (listing)
+           listing_source_line (l);
 #endif
 #endif
+       }
     }
     }
-  demand_empty_rest_of_line ();
+  if (appline || file)
+    demand_empty_rest_of_line ();
+  else
+    ignore_rest_of_line ();
 }
 
 /* Handle the .end pseudo-op.  Actually, the real work is done in
 }
 
 /* Handle the .end pseudo-op.  Actually, the real work is done in
@@ -1735,7 +1861,7 @@ s_errwarn (int err)
        {
          as_bad (_("%s argument must be a string"),
                  err ? ".error" : ".warning");
        {
          as_bad (_("%s argument must be a string"),
                  err ? ".error" : ".warning");
-         discard_rest_of_line ();
+         ignore_rest_of_line ();
          return;
        }
 
          return;
        }
 
@@ -1758,7 +1884,7 @@ s_fail (int ignore ATTRIBUTE_UNUSED)
 {
   offsetT temp;
   char *stop = NULL;
 {
   offsetT temp;
   char *stop = NULL;
-  char stopc;
+  char stopc = 0;
 
   if (flag_mri)
     stop = mri_comment_field (&stopc);
 
   if (flag_mri)
     stop = mri_comment_field (&stopc);
@@ -1780,13 +1906,17 @@ s_fill (int ignore ATTRIBUTE_UNUSED)
 {
   expressionS rep_exp;
   long size = 1;
 {
   expressionS rep_exp;
   long size = 1;
-  register long fill = 0;
+  long fill = 0;
   char *p;
 
 #ifdef md_flush_pending_output
   md_flush_pending_output ();
 #endif
 
   char *p;
 
 #ifdef md_flush_pending_output
   md_flush_pending_output ();
 #endif
 
+#ifdef md_cons_align
+  md_cons_align (1);
+#endif
+
   get_known_segmented_expression (&rep_exp);
   if (*input_line_pointer == ',')
     {
   get_known_segmented_expression (&rep_exp);
   if (*input_line_pointer == ',')
     {
@@ -1880,7 +2010,7 @@ s_globl (int ignore ATTRIBUTE_UNUSED)
   int c;
   symbolS *symbolP;
   char *stop = NULL;
   int c;
   symbolS *symbolP;
   char *stop = NULL;
-  char stopc;
+  char stopc = 0;
 
   if (flag_mri)
     stop = mri_comment_field (&stopc);
 
   if (flag_mri)
     stop = mri_comment_field (&stopc);
@@ -1911,12 +2041,145 @@ s_globl (int ignore ATTRIBUTE_UNUSED)
     mri_comment_end (stop, stopc);
 }
 
     mri_comment_end (stop, stopc);
 }
 
+#ifdef OBJ_ELF
+#define skip_whitespace(str)  do { if (*(str) == ' ') ++(str); } while (0)
+
+static inline int
+skip_past_char (char ** str, char c)
+{
+  if (**str == c)
+    {
+      (*str)++;
+      return 0;
+    }
+  else
+    return -1;
+}
+#define skip_past_comma(str) skip_past_char (str, ',')
+
+/* Parse an attribute directive for VENDOR.
+   Returns the attribute number read, or zero on error.  */
+int
+s_vendor_attribute (int vendor)
+{
+  expressionS exp;
+  int type;
+  int tag;
+  unsigned int i = 0;
+  char *s = NULL;
+
+  /* Read the first number or name.  */
+  skip_whitespace (input_line_pointer);
+  s = input_line_pointer;
+  if (ISDIGIT (*input_line_pointer))
+    {
+      expression (& exp);
+      if (exp.X_op != O_constant)
+       goto bad;
+      tag = exp.X_add_number;
+    }
+  else
+    {
+      char *name;
+
+      /* A name may contain '_', but no other punctuation.  */
+      for (; ISALNUM (*input_line_pointer) || *input_line_pointer == '_';
+          ++input_line_pointer)
+       i++;
+      if (i == 0)
+       goto bad;
+
+      name = (char *) alloca (i + 1);
+      memcpy (name, s, i);
+      name[i] = '\0';
+
+#ifndef CONVERT_SYMBOLIC_ATTRIBUTE
+#define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1
+#endif
+
+      tag = CONVERT_SYMBOLIC_ATTRIBUTE (name);
+      if (tag == -1)
+       {
+         as_bad (_("Attribute name not recognised: %s"), name);
+         ignore_rest_of_line ();
+         return 0;
+       }
+    }
+
+  type = _bfd_elf_obj_attrs_arg_type (stdoutput, vendor, tag);
+
+  if (skip_past_comma (&input_line_pointer) == -1)
+    goto bad;
+  if (type & 1)
+    {
+      expression (& exp);
+      if (exp.X_op != O_constant)
+       {
+         as_bad (_("expected numeric constant"));
+         ignore_rest_of_line ();
+         return 0;
+       }
+      i = exp.X_add_number;
+    }
+  if ((type & 3) == 3
+      && skip_past_comma (&input_line_pointer) == -1)
+    {
+      as_bad (_("expected comma"));
+      ignore_rest_of_line ();
+      return 0;
+    }
+  if (type & 2)
+    {
+      int len;
+
+      skip_whitespace (input_line_pointer);
+      if (*input_line_pointer != '"')
+       goto bad_string;
+      s = demand_copy_C_string (&len);
+    }
+
+  switch (type & 3)
+    {
+    case 3:
+      bfd_elf_add_obj_attr_int_string (stdoutput, vendor, tag, i, s);
+      break;
+    case 2:
+      bfd_elf_add_obj_attr_string (stdoutput, vendor, tag, s);
+      break;
+    case 1:
+      bfd_elf_add_obj_attr_int (stdoutput, vendor, tag, i);
+      break;
+    default:
+      abort ();
+    }
+
+  demand_empty_rest_of_line ();
+  return tag;
+bad_string:
+  as_bad (_("bad string constant"));
+  ignore_rest_of_line ();
+  return 0;
+bad:
+  as_bad (_("expected <tag> , <value>"));
+  ignore_rest_of_line ();
+  return 0;
+}
+
+/* Parse a .gnu_attribute directive.  */
+
+static void
+s_gnu_attribute (int ignored ATTRIBUTE_UNUSED)
+{
+  s_vendor_attribute (OBJ_ATTR_GNU);
+}
+#endif /* OBJ_ELF */
+
 /* Handle the MRI IRP and IRPC pseudo-ops.  */
 
 void
 s_irp (int irpc)
 {
 /* Handle the MRI IRP and IRPC pseudo-ops.  */
 
 void
 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;
@@ -1925,12 +2188,13 @@ s_irp (int 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);
+  err = expand_irp (irpc, 0, &s, &out, get_non_macro_line_sb);
   if (err != NULL)
     as_bad_where (file, line, "%s", err);
 
   if (err != NULL)
     as_bad_where (file, line, "%s", err);
 
@@ -1979,7 +2243,6 @@ s_linkonce (int ignore ATTRIBUTE_UNUSED)
 #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;
 
@@ -2009,9 +2272,6 @@ s_linkonce (int ignore ATTRIBUTE_UNUSED)
       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 ();
@@ -2034,11 +2294,9 @@ bss_alloc (symbolS *symbolP, addressT size, int align)
        {
          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
@@ -2159,11 +2417,11 @@ s_lcomm_bytes (int needs_align)
 void
 s_lsym (int ignore ATTRIBUTE_UNUSED)
 {
 void
 s_lsym (int ignore ATTRIBUTE_UNUSED)
 {
-  register char *name;
-  register char c;
-  register char *p;
+  char *name;
+  char c;
+  char *p;
   expressionS exp;
   expressionS exp;
-  register symbolS *symbolP;
+  symbolS *symbolP;
 
   /* We permit ANY defined expression: BSD4.2 demands constants.  */
   name = input_line_pointer;
 
   /* We permit ANY defined expression: BSD4.2 demands constants.  */
   name = input_line_pointer;
@@ -2174,7 +2432,7 @@ s_lsym (int ignore ATTRIBUTE_UNUSED)
   if (name == p)
     {
       as_bad (_("expected symbol name"));
   if (name == p)
     {
       as_bad (_("expected symbol name"));
-      discard_rest_of_line ();
+      ignore_rest_of_line ();
       return;
     }
 
       return;
     }
 
@@ -2190,7 +2448,7 @@ s_lsym (int ignore ATTRIBUTE_UNUSED)
     }
 
   input_line_pointer++;
     }
 
   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)
@@ -2203,15 +2461,7 @@ s_lsym (int ignore ATTRIBUTE_UNUSED)
   *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.  */
@@ -2234,10 +2484,9 @@ s_lsym (int ignore ATTRIBUTE_UNUSED)
    or zero if there are no more lines.  */
 
 static int
    or zero if there are no more lines.  */
 
 static int
-get_line_sb (sb *line)
+get_line_sb (sb *line, int in_macro)
 {
 {
-  char quote1, quote2, inquote;
-  unsigned char c;
+  char *eol;
 
   if (input_line_pointer[-1] == '\n')
     bump_line_counters ();
 
   if (input_line_pointer[-1] == '\n')
     bump_line_counters ();
@@ -2249,45 +2498,28 @@ get_line_sb (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
-
-  inquote = '\0';
-
-  while ((c = * input_line_pointer ++) != 0
-        && (!is_end_of_line[c]
-            || (inquote != '\0' && c != '\n')))
-    {
-      if (inquote == c)
-       inquote = '\0';
-      else if (inquote == '\0')
-       {
-         if (c == quote1)
-           inquote = quote1;
-         else if (c == quote2)
-           inquote = quote2;
-       }
-
-      sb_add_char (line, c);
-    }
+  eol = _find_end_of_line (input_line_pointer, flag_m68k_mri, 0, in_macro);
+  sb_add_buffer (line, input_line_pointer, eol - input_line_pointer);
+  input_line_pointer = eol;
 
   /* 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.   */
 
   /* 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 c;
+  return *input_line_pointer++;
+}
+
+static int
+get_non_macro_line_sb (sb *line)
+{
+  return get_line_sb (line, 0);
+}
+
+static int
+get_macro_line_sb (sb *line)
+{
+  return get_line_sb (line, 1);
 }
 
 /* Define a macro.  This is an interface to macro.c.  */
 }
 
 /* Define a macro.  This is an interface to macro.c.  */
@@ -2295,31 +2527,37 @@ get_line_sb (sb *line)
 void
 s_macro (int ignore ATTRIBUTE_UNUSED)
 {
 void
 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_macro_line_sb, file, line, &name);
+      sb_kill (&label);
+    }
+  else
+    err = define_macro (0, &s, NULL, get_macro_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);
        }
@@ -2329,7 +2567,9 @@ s_macro (int ignore ATTRIBUTE_UNUSED)
          || (!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);
     }
 
@@ -2342,8 +2582,13 @@ s_macro (int ignore ATTRIBUTE_UNUSED)
 void
 s_mexit (int ignore ATTRIBUTE_UNUSED)
 {
 void
 s_mexit (int ignore ATTRIBUTE_UNUSED)
 {
-  cond_exit_macro (macro_nest);
-  buffer_limit = input_scrub_next_buffer (&input_line_pointer);
+  if (macro_nest)
+    {
+      cond_exit_macro (macro_nest);
+      buffer_limit = input_scrub_next_buffer (&input_line_pointer);
+    }
+  else
+    as_warn (_("ignoring macro exit outside a macro definition."));
 }
 
 /* Switch in and out of MRI mode.  */
 }
 
 /* Switch in and out of MRI mode.  */
@@ -2351,10 +2596,15 @@ s_mexit (int ignore ATTRIBUTE_UNUSED)
 void
 s_mri (int ignore ATTRIBUTE_UNUSED)
 {
 void
 s_mri (int ignore ATTRIBUTE_UNUSED)
 {
-  int on, old_flag;
+  int on;
+#ifdef MRI_MODE_CHANGE
+  int old_flag;
+#endif
 
   on = get_absolute_expression ();
 
   on = get_absolute_expression ();
+#ifdef MRI_MODE_CHANGE
   old_flag = flag_mri;
   old_flag = flag_mri;
+#endif
   if (on != 0)
     {
       flag_mri = 1;
   if (on != 0)
     {
       flag_mri = 1;
@@ -2389,7 +2639,9 @@ s_mri (int ignore ATTRIBUTE_UNUSED)
 static void
 do_org (segT segment, expressionS *exp, int fill)
 {
 static void
 do_org (segT segment, expressionS *exp, int fill)
 {
-  if (segment != now_seg && segment != absolute_section)
+  if (segment != now_seg
+      && segment != absolute_section
+      && segment != expr_section)
     as_bad (_("invalid segment \"%s\""), segment_name (segment));
 
   if (now_seg == absolute_section)
     as_bad (_("invalid segment \"%s\""), segment_name (segment));
 
   if (now_seg == absolute_section)
@@ -2424,9 +2676,9 @@ do_org (segT segment, expressionS *exp, int fill)
 void
 s_org (int ignore ATTRIBUTE_UNUSED)
 {
 void
 s_org (int ignore ATTRIBUTE_UNUSED)
 {
-  register segT segment;
+  segT segment;
   expressionS exp;
   expressionS exp;
-  register long temp_fill;
+  long temp_fill;
 
 #ifdef md_flush_pending_output
   md_flush_pending_output ();
 
 #ifdef md_flush_pending_output
   md_flush_pending_output ();
@@ -2473,8 +2725,7 @@ s_org (int ignore ATTRIBUTE_UNUSED)
    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
 s_mri_sect (char *type ATTRIBUTE_UNUSED)
 
 void
 s_mri_sect (char *type ATTRIBUTE_UNUSED)
@@ -2528,7 +2779,6 @@ s_mri_sect (char *type ATTRIBUTE_UNUSED)
        as_bad (_("unrecognized section type"));
       ++input_line_pointer;
 
        as_bad (_("unrecognized section type"));
       ++input_line_pointer;
 
-#ifdef BFD_ASSEMBLER
       {
        flagword flags;
 
       {
        flagword flags;
 
@@ -2547,7 +2797,6 @@ s_mri_sect (char *type ATTRIBUTE_UNUSED)
                       bfd_errmsg (bfd_get_error ()));
          }
       }
                       bfd_errmsg (bfd_get_error ()));
          }
       }
-#endif
     }
 
   /* Ignore the HP type.  */
     }
 
   /* Ignore the HP type.  */
@@ -2686,7 +2935,7 @@ s_purgem (int ignore ATTRIBUTE_UNUSED)
 static void
 s_bad_end (int endr)
 {
 static void
 s_bad_end (int endr)
 {
-  as_warn (_(".end%c encountered without preceeding %s"),
+  as_warn (_(".end%c encountered without preceding %s"),
           endr ? 'r' : 'm',
           endr ? ".rept, .irp, or .irpc" : ".macro");
   demand_empty_rest_of_line ();
           endr ? 'r' : 'm',
           endr ? ".rept, .irp, or .irpc" : ".macro");
   demand_empty_rest_of_line ();
@@ -2714,7 +2963,7 @@ do_repeat (int count, const char *start, const char *end)
   sb many;
 
   sb_new (&one);
   sb many;
 
   sb_new (&one);
-  if (!buffer_and_nest (start, end, &one, get_line_sb))
+  if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
     {
       as_bad (_("%s without %s"), start, end);
       return;
     {
       as_bad (_("%s without %s"), start, end);
       return;
@@ -2731,6 +2980,57 @@ do_repeat (int count, const char *start, const char *end)
   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
 }
 
   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
 }
 
+/* Like do_repeat except that any text matching EXPANDER in the
+   block is replaced by the itteration count.  */
+
+void
+do_repeat_with_expander (int count,
+                        const char * start,
+                        const char * end,
+                        const char * expander)
+{
+  sb one;
+  sb many;
+
+  sb_new (&one);
+  if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
+    {
+      as_bad (_("%s without %s"), start, end);
+      return;
+    }
+
+  sb_new (&many);
+
+  if (expander != NULL && strstr (one.ptr, expander) != NULL)
+    {
+      while (count -- > 0)
+       {
+         int len;
+         char * sub;
+         sb processed;
+
+         sb_new (& processed);
+         sb_add_sb (& processed, & one);
+         sub = strstr (processed.ptr, expander);
+         len = sprintf (sub, "%d", count);
+         gas_assert (len < 8);
+         strcpy (sub + len, sub + 8);
+         processed.len -= (8 - len);
+         sb_add_sb (& many, & processed);
+         sb_kill (& processed);
+       }
+    }
+  else
+    while (count-- > 0)
+      sb_add_sb (&many, &one);
+
+  sb_kill (&one);
+
+  input_scrub_include_sb (&many, input_line_pointer, 1);
+  sb_kill (&many);
+  buffer_limit = input_scrub_next_buffer (&input_line_pointer);
+}
+
 /* Skip to end of current repeat loop; EXTRA indicates how many additional
    input buffers to skip.  Assumes that conditionals preceding the loop end
    are properly nested.
 /* Skip to end of current repeat loop; EXTRA indicates how many additional
    input buffers to skip.  Assumes that conditionals preceding the loop end
    are properly nested.
@@ -2747,51 +3047,15 @@ end_repeat (int extra)
     buffer_limit = input_scrub_next_buffer (&input_line_pointer);
 }
 
     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 (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;
-
-  if (name == end_name)
-    {
-      as_bad (_("expected symbol name"));
-      discard_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;
+  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);
@@ -2799,13 +3063,13 @@ s_set (int 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
@@ -2813,33 +3077,86 @@ s_set (int equiv)
       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
     }
 
     }
 
-  symbol_table_insert (symbolP);
+  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);
+    }
+
+  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' is 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 ();
 }
 
   demand_empty_rest_of_line ();
 }
 
@@ -2850,13 +3167,17 @@ s_space (int mult)
   expressionS val;
   char *p = 0;
   char *stop = NULL;
   expressionS val;
   char *p = 0;
   char *stop = NULL;
-  char stopc;
+  char stopc = 0;
   int bytes;
 
 #ifdef md_flush_pending_output
   md_flush_pending_output ();
 #endif
 
   int bytes;
 
 #ifdef md_flush_pending_output
   md_flush_pending_output ();
 #endif
 
+#ifdef md_cons_align
+  md_cons_align (1);
+#endif
+
   if (flag_mri)
     stop = mri_comment_field (&stopc);
 
   if (flag_mri)
     stop = mri_comment_field (&stopc);
 
@@ -2872,12 +3193,12 @@ s_space (int mult)
        }
       else if (mri_common_symbol != NULL)
        {
        }
       else if (mri_common_symbol != NULL)
        {
-         valueT val;
+         valueT mri_val;
 
 
-         val = S_GET_VALUE (mri_common_symbol);
-         if ((val & 1) != 0)
+         mri_val = S_GET_VALUE (mri_common_symbol);
+         if ((mri_val & 1) != 0)
            {
            {
-             S_SET_VALUE (mri_common_symbol, val + 1);
+             S_SET_VALUE (mri_common_symbol, mri_val + 1);
              if (line_label != NULL)
                {
                  expressionS *symexp;
              if (line_label != NULL)
                {
                  expressionS *symexp;
@@ -2921,6 +3242,7 @@ s_space (int 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)
        as_bad (_("unsupported variable size or fill value"));
       else
       if (exp.X_op != O_constant)
        as_bad (_("unsupported variable size or fill value"));
       else
@@ -2936,9 +3258,12 @@ s_space (int mult)
     }
   else
     {
     }
   else
     {
+      if (now_seg == absolute_section || mri_common_symbol != NULL)
+       resolve_expression (&exp);
+
       if (exp.X_op == O_constant)
        {
       if (exp.X_op == O_constant)
        {
-         long repeat;
+         offsetT repeat;
 
          repeat = exp.X_add_number;
          if (mult)
 
          repeat = exp.X_add_number;
          if (mult)
@@ -3022,7 +3347,11 @@ s_float_space (int float_type)
   int flen;
   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
   char *stop = NULL;
   int flen;
   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
   char *stop = NULL;
-  char stopc;
+  char stopc = 0;
+
+#ifdef md_cons_align
+  md_cons_align (1);
+#endif
 
   if (flag_mri)
     stop = mri_comment_field (&stopc);
 
   if (flag_mri)
     stop = mri_comment_field (&stopc);
@@ -3068,7 +3397,7 @@ s_float_space (int float_type)
 
       err = md_atof (float_type, temp, &flen);
       know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
 
       err = md_atof (float_type, temp, &flen);
       know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
-      know (flen > 0);
+      know (err != NULL || flen > 0);
       if (err)
        {
          as_bad (_("bad floating literal: %s"), err);
       if (err)
        {
          as_bad (_("bad floating literal: %s"), err);
@@ -3099,11 +3428,17 @@ void
 s_struct (int ignore ATTRIBUTE_UNUSED)
 {
   char *stop = NULL;
 s_struct (int ignore ATTRIBUTE_UNUSED)
 {
   char *stop = NULL;
-  char stopc;
+  char stopc = 0;
 
   if (flag_mri)
     stop = mri_comment_field (&stopc);
   abs_section_offset = get_absolute_expression ();
 
   if (flag_mri)
     stop = mri_comment_field (&stopc);
   abs_section_offset = get_absolute_expression ();
+#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
+  /* The ELF backend needs to know that we are changing sections, so
+     that .previous works correctly. */
+  if (IS_ELF)
+    obj_elf_section_change_hook ();
+#endif
   subseg_set (absolute_section, 0);
   demand_empty_rest_of_line ();
   if (flag_mri)
   subseg_set (absolute_section, 0);
   demand_empty_rest_of_line ();
   if (flag_mri)
@@ -3113,14 +3448,143 @@ s_struct (int ignore ATTRIBUTE_UNUSED)
 void
 s_text (int ignore ATTRIBUTE_UNUSED)
 {
 void
 s_text (int ignore ATTRIBUTE_UNUSED)
 {
-  register int temp;
+  int temp;
 
   temp = get_absolute_expression ();
   subseg_set (text_section, (subsegT) temp);
   demand_empty_rest_of_line ();
 
   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
+    {
+      symbolS *symp = symbolP2;
+
+      while (S_IS_WEAKREFR (symp) && symp != symbolP)
+       {
+         expressionS *expP = symbol_get_value_expression (symp);
+
+         gas_assert (expP->X_op == O_symbol
+                 && expP->X_add_number == 0);
+         symp = expP->X_add_symbol;
+       }
+      if (symp == symbolP)
+       {
+         char *loop;
+
+         loop = concat (S_GET_NAME (symbolP),
+                        " => ", S_GET_NAME (symbolP2), (const char *) NULL);
+
+         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),
+                            (const char *) NULL);
+             free (old_loop);
+           }
+
+         as_bad (_("%s: would close weakref loop: %s"),
+                 S_GET_NAME (symbolP), loop);
+
+         free (loop);
+
+         *end_name = delim;
+         ignore_rest_of_line ();
+         return;
+       }
+
+      /* 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; */
+    }
+
+  *end_name = delim;
+
+  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);
+
+  demand_empty_rest_of_line ();
 }
 \f
 
 }
 \f
 
@@ -3164,17 +3628,14 @@ ignore_rest_of_line (void)
   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
 }
 
   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
 }
 
-void
-discard_rest_of_line (void)
-{
-  while (input_line_pointer < buffer_limit
-        && !is_end_of_line[(unsigned char) *input_line_pointer])
-    input_line_pointer++;
-
-  input_line_pointer++;
+/* Sets frag for given symbol to zero_address_frag, except when the
+   symbol frag is already set to a dummy listing frag.  */
 
 
-  /* Return pointing just after end-of-line.  */
-  know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
+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.
@@ -3188,16 +3649,14 @@ void
 pseudo_set (symbolS *symbolP)
 {
   expressionS exp;
 pseudo_set (symbolS *symbolP)
 {
   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)
     as_bad (_("illegal expression"));
 
   if (exp.X_op == O_illegal)
     as_bad (_("illegal expression"));
@@ -3211,6 +3670,7 @@ pseudo_set (symbolS *symbolP)
        as_bad (_("floating point number invalid"));
     }
   else if (exp.X_op == O_subtract
        as_bad (_("floating point number invalid"));
     }
   else if (exp.X_op == O_subtract
+          && !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)))
@@ -3220,6 +3680,12 @@ pseudo_set (symbolS *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:
@@ -3229,51 +3695,62 @@ pseudo_set (symbolS *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:
       break;
 
     case O_register:
+#ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
+      if (S_IS_EXTERNAL (symbolP))
+       {
+         as_bad ("can't equate global symbol `%s' with register name",
+                 S_GET_NAME (symbolP));
+         return;
+       }
+#endif
       S_SET_SEGMENT (symbolP, reg_section);
       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
       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);
+      symbol_get_value_expression (symbolP)->X_op = O_register;
       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 ("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);
+      copy_symbol_attributes (symbolP, exp.X_add_symbol);
+      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;
     }
 }
       break;
     }
 }
@@ -3336,13 +3813,13 @@ do_parse_cons_expression (expressionS *exp,
    Clobbers input_line_pointer and checks end-of-line.  */
 
 static void
    Clobbers input_line_pointer and checks end-of-line.  */
 
 static void
-cons_worker (register int nbytes,      /* 1=.byte, 2=.word, 4=.long.  */
+cons_worker (int nbytes,       /* 1=.byte, 2=.word, 4=.long.  */
             int rva)
 {
   int c;
   expressionS exp;
   char *stop = NULL;
             int rva)
 {
   int c;
   expressionS exp;
   char *stop = NULL;
-  char stopc;
+  char stopc = 0;
 
 #ifdef md_flush_pending_output
   md_flush_pending_output ();
 
 #ifdef md_flush_pending_output
   md_flush_pending_output ();
@@ -3376,7 +3853,15 @@ cons_worker (register int nbytes,        /* 1=.byte, 2=.word, 4=.long.  */
        parse_mri_cons (&exp, (unsigned int) nbytes);
       else
 #endif
        parse_mri_cons (&exp, (unsigned int) nbytes);
       else
 #endif
-       TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
+        {
+         if (*input_line_pointer == '"')
+           {
+             as_bad (_("unexpected `\"' in expression"));
+             ignore_rest_of_line ();
+             return;
+           }
+         TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
+       }
 
       if (rva)
        {
 
       if (rva)
        {
@@ -3416,6 +3901,113 @@ s_rva (int size)
   cons_worker (size, 1);
 }
 
   cons_worker (size, 1);
 }
 
+/* .reloc offset, reloc_name, symbol+addend.  */
+
+void
+s_reloc (int ignore ATTRIBUTE_UNUSED)
+{
+  char *stop = NULL;
+  char stopc = 0;
+  expressionS exp;
+  char *r_name;
+  int c;
+  struct reloc_list *reloc;
+
+  reloc = (struct reloc_list *) xmalloc (sizeof (*reloc));
+
+  if (flag_mri)
+    stop = mri_comment_field (&stopc);
+
+  expression (&exp);
+  switch (exp.X_op)
+    {
+    case O_illegal:
+    case O_absent:
+    case O_big:
+    case O_register:
+      as_bad (_("missing or bad offset expression"));
+      goto err_out;
+    case O_constant:
+      exp.X_add_symbol = section_symbol (now_seg);
+      exp.X_op = O_symbol;
+      /* Fall thru */
+    case O_symbol:
+      if (exp.X_add_number == 0)
+       {
+         reloc->u.a.offset_sym = exp.X_add_symbol;
+         break;
+       }
+      /* Fall thru */
+    default:
+      reloc->u.a.offset_sym = make_expr_symbol (&exp);
+      break;
+    }
+
+  SKIP_WHITESPACE ();
+  if (*input_line_pointer != ',')
+    {
+      as_bad (_("missing reloc type"));
+      goto err_out;
+    }
+
+  ++input_line_pointer;
+  SKIP_WHITESPACE ();
+  r_name = input_line_pointer;
+  c = get_symbol_end ();
+  reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name);
+  *input_line_pointer = c;
+  if (reloc->u.a.howto == NULL)
+    {
+      as_bad (_("unrecognized reloc type"));
+      goto err_out;
+    }
+
+  exp.X_op = O_absent;
+  SKIP_WHITESPACE ();
+  if (*input_line_pointer == ',')
+    {
+      ++input_line_pointer;
+      expression (&exp);
+    }
+  switch (exp.X_op)
+    {
+    case O_illegal:
+    case O_big:
+    case O_register:
+      as_bad (_("bad reloc expression"));
+    err_out:
+      ignore_rest_of_line ();
+      free (reloc);
+      if (flag_mri)
+       mri_comment_end (stop, stopc);
+      return;
+    case O_absent:
+      reloc->u.a.sym = NULL;
+      reloc->u.a.addend = 0;
+      break;
+    case O_constant:
+      reloc->u.a.sym = NULL;
+      reloc->u.a.addend = exp.X_add_number;
+      break;
+    case O_symbol:
+      reloc->u.a.sym = exp.X_add_symbol;
+      reloc->u.a.addend = exp.X_add_number;
+      break;
+    default:
+      reloc->u.a.sym = make_expr_symbol (&exp);
+      reloc->u.a.addend = 0;
+      break;
+    }
+
+  as_where (&reloc->file, &reloc->line);
+  reloc->next = reloc_list;
+  reloc_list = reloc;
+
+  demand_empty_rest_of_line ();
+  if (flag_mri)
+    mri_comment_end (stop, stopc);
+}
+
 /* Put the contents of expression EXP into the object file using
    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
 
 /* Put the contents of expression EXP into the object file using
    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
 
@@ -3423,13 +4015,16 @@ void
 emit_expr (expressionS *exp, unsigned int nbytes)
 {
   operatorT op;
 emit_expr (expressionS *exp, unsigned int nbytes)
 {
   operatorT op;
-  register char *p;
+  char *p;
   valueT extra_digit = 0;
 
   /* Don't do anything if we are going to make another pass.  */
   if (need_pass_2)
     return;
 
   valueT extra_digit = 0;
 
   /* Don't do anything if we are going to make another pass.  */
   if (need_pass_2)
     return;
 
+  /* Grow the current frag now so that dot_value does not get invalidated
+     if the frag were to fill up in the frag_more() call below.  */
+  frag_grow (nbytes);
   dot_value = frag_now_fix ();
 
 #ifndef NO_LISTING
   dot_value = frag_now_fix ();
 
 #ifndef NO_LISTING
@@ -3597,11 +4192,11 @@ emit_expr (expressionS *exp, unsigned int nbytes)
 
   if (op == O_constant)
     {
 
   if (op == O_constant)
     {
-      register valueT get;
-      register valueT use;
-      register valueT mask;
+      valueT get;
+      valueT use;
+      valueT mask;
       valueT hibit;
       valueT hibit;
-      register valueT unmask;
+      valueT unmask;
 
       /* JF << of >= number of bits in the object is undefined.  In
         particular SPARC (Sun 4) has problems.  */
 
       /* JF << of >= number of bits in the object is undefined.  In
         particular SPARC (Sun 4) has problems.  */
@@ -3633,8 +4228,18 @@ emit_expr (expressionS *exp, unsigned int 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.  */
+#if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
+#ifndef __MSVCRT__
+         as_warn (_("value 0x%llx truncated to 0x%llx"),
+                  (unsigned long long) get, (unsigned long long) use);
+#else
+         as_warn (_("value 0x%I64x truncated to 0x%I64x"),
+                  (unsigned long long) get, (unsigned long long) use);
+#endif
+#else
          as_warn (_("value 0x%lx truncated to 0x%lx"),
                   (unsigned long) get, (unsigned long) use);
          as_warn (_("value 0x%lx truncated to 0x%lx"),
                   (unsigned long) get, (unsigned long) use);
+#endif
        }
       /* Put bytes in right order.  */
       md_number_to_chars (p, use, (int) nbytes);
        }
       /* Put bytes in right order.  */
       md_number_to_chars (p, use, (int) nbytes);
@@ -3644,15 +4249,32 @@ emit_expr (expressionS *exp, unsigned int nbytes)
       unsigned int size;
       LITTLENUM_TYPE *nums;
 
       unsigned int size;
       LITTLENUM_TYPE *nums;
 
-      know (nbytes % CHARS_PER_LITTLENUM == 0);
-
       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);
+         int i = nbytes / CHARS_PER_LITTLENUM;
+         if (i != 0)
+           {
+             LITTLENUM_TYPE sign = 0;
+             if ((generic_bignum[--i]
+                  & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) != 0)
+               sign = ~(LITTLENUM_TYPE) 0;
+             while (++i < exp->X_add_number)
+               if (generic_bignum[i] != sign)
+                 break;
+           }
+         if (i < exp->X_add_number)
+           as_warn (_("bignum truncated to %d bytes"), nbytes);
          size = nbytes;
        }
 
          size = nbytes;
        }
 
+      if (nbytes == 1)
+       {
+         md_number_to_chars (p, (valueT) generic_bignum[0], 1);
+         return;
+       }
+      know (nbytes % CHARS_PER_LITTLENUM == 0);
+
       if (target_big_endian)
        {
          while (nbytes > size)
       if (target_big_endian)
        {
          while (nbytes > size)
@@ -3692,67 +4314,48 @@ emit_expr (expressionS *exp, unsigned int nbytes)
        }
     }
   else
        }
     }
   else
-    {
-      memset (p, 0, nbytes);
+    emit_expr_fix (exp, nbytes, frag_now, p);
+}
+
+void
+emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p)
+{
+  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.  */
+  /* Generate a fixS to record the symbol value.  */
 
 
-#ifdef BFD_ASSEMBLER
 #ifdef TC_CONS_FIX_NEW
 #ifdef TC_CONS_FIX_NEW
-      TC_CONS_FIX_NEW (frag_now, p - frag_now->fr_literal, nbytes, exp);
+  TC_CONS_FIX_NEW (frag, p - frag->fr_literal, nbytes, exp);
 #else
 #else
-      {
-       bfd_reloc_code_real_type r;
+  {
+    bfd_reloc_code_real_type r;
 
 
-       switch (nbytes)
-         {
-         case 1:
-           r = BFD_RELOC_8;
-           break;
-         case 2:
-           r = BFD_RELOC_16;
-           break;
-         case 4:
-           r = BFD_RELOC_32;
-           break;
-         case 8:
-           r = BFD_RELOC_64;
-           break;
-         default:
-           as_bad (_("unsupported BFD relocation size %u"), nbytes);
-           r = BFD_RELOC_32;
-           break;
-         }
-       fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp,
-                    0, r);
+    switch (nbytes)
+      {
+      case 1:
+       r = BFD_RELOC_8;
+       break;
+      case 2:
+       r = BFD_RELOC_16;
+       break;
+      case 3:
+       r = BFD_RELOC_24;
+       break;
+      case 4:
+       r = BFD_RELOC_32;
+       break;
+      case 8:
+       r = BFD_RELOC_64;
+       break;
+      default:
+       as_bad (_("unsupported BFD relocation size %u"), nbytes);
+       r = BFD_RELOC_32;
+       break;
       }
       }
+    fix_new_exp (frag, p - frag->fr_literal, (int) nbytes, exp,
+                0, r);
+  }
 #endif
 #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
 #ifdef BITFIELD_CONS_EXPRESSIONS
 }
 \f
 #ifdef BITFIELD_CONS_EXPRESSIONS
@@ -3965,7 +4568,7 @@ parse_repeat_cons (exp, nbytes)
      unsigned int nbytes;
 {
   expressionS count;
      unsigned int nbytes;
 {
   expressionS count;
-  register int i;
+  int i;
 
   expression (exp);
 
 
   expression (exp);
 
@@ -4100,11 +4703,11 @@ hex_float (int float_type, char *bytes)
 
 void
 float_cons (/* Clobbers input_line-pointer, checks end-of-line.  */
 
 void
 float_cons (/* Clobbers input_line-pointer, checks end-of-line.  */
-           register int float_type     /* 'f':.ffloat ... 'F':.float ...  */)
+           int float_type      /* 'f':.ffloat ... 'F':.float ...  */)
 {
 {
-  register char *p;
+  char *p;
   int length;                  /* Number of chars in an object.  */
   int length;                  /* Number of chars in an object.  */
-  register char *err;          /* Error from scanning floating literal.  */
+  char *err;           /* Error from scanning floating literal.  */
   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
 
   if (is_it_end_of_statement ())
   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
 
   if (is_it_end_of_statement ())
@@ -4117,6 +4720,10 @@ float_cons (/* Clobbers input_line-pointer, checks end-of-line.  */
   md_flush_pending_output ();
 #endif
 
   md_flush_pending_output ();
 #endif
 
+#ifdef md_cons_align
+  md_cons_align (1);
+#endif
+
   do
     {
       /* input_line_pointer->1st char of a flonum (we hope!).  */
   do
     {
       /* input_line_pointer->1st char of a flonum (we hope!).  */
@@ -4146,7 +4753,7 @@ float_cons (/* Clobbers input_line-pointer, checks end-of-line.  */
        {
          err = md_atof (float_type, temp, &length);
          know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
        {
          err = md_atof (float_type, temp, &length);
          know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
-         know (length > 0);
+         know (err != NULL || length > 0);
          if (err)
            {
              as_bad (_("bad floating literal: %s"), err);
          if (err)
            {
              as_bad (_("bad floating literal: %s"), err);
@@ -4197,8 +4804,8 @@ float_cons (/* Clobbers input_line-pointer, checks end-of-line.  */
 static inline int
 sizeof_sleb128 (offsetT value)
 {
 static inline int
 sizeof_sleb128 (offsetT value)
 {
-  register int size = 0;
-  register unsigned byte;
+  int size = 0;
+  unsigned byte;
 
   do
     {
 
   do
     {
@@ -4218,12 +4825,10 @@ sizeof_sleb128 (offsetT value)
 static inline int
 sizeof_uleb128 (valueT value)
 {
 static inline int
 sizeof_uleb128 (valueT value)
 {
-  register int size = 0;
-  register unsigned byte;
+  int size = 0;
 
   do
     {
 
   do
     {
-      byte = (value & 0x7f);
       value >>= 7;
       size += 1;
     }
       value >>= 7;
       size += 1;
     }
@@ -4246,8 +4851,8 @@ sizeof_leb128 (valueT value, int sign)
 static inline int
 output_sleb128 (char *p, offsetT value)
 {
 static inline int
 output_sleb128 (char *p, offsetT value)
 {
-  register char *orig = p;
-  register int more;
+  char *orig = p;
+  int more;
 
   do
     {
 
   do
     {
@@ -4409,7 +5014,7 @@ output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int 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
+static void
 emit_leb128_expr (expressionS *exp, int sign)
 {
   operatorT op = exp->X_op;
 emit_leb128_expr (expressionS *exp, int sign)
 {
   operatorT op = exp->X_op;
@@ -4509,22 +5114,64 @@ s_leb128 (int sign)
   demand_empty_rest_of_line ();
 }
 \f
   demand_empty_rest_of_line ();
 }
 \f
-/* We read 0 or more ',' separated, double-quoted strings.
+static void
+stringer_append_char (int c, int bitsize)
+{
+  if (!target_big_endian)
+    FRAG_APPEND_1_CHAR (c);
+
+  switch (bitsize)
+    {
+    case 64:
+      FRAG_APPEND_1_CHAR (0);
+      FRAG_APPEND_1_CHAR (0);
+      FRAG_APPEND_1_CHAR (0);
+      FRAG_APPEND_1_CHAR (0);
+      /* Fall through.  */
+    case 32:
+      FRAG_APPEND_1_CHAR (0);
+      FRAG_APPEND_1_CHAR (0);
+      /* Fall through.  */
+    case 16:
+      FRAG_APPEND_1_CHAR (0);
+      /* Fall through.  */
+    case 8:
+      break;
+    default:
+      /* Called with invalid bitsize argument.  */
+      abort ();
+      break;
+    }
+  if (target_big_endian)
+    FRAG_APPEND_1_CHAR (c);
+}
+
+/* Worker to do .ascii etc statements.
+   Reads 0 or more ',' separated, double-quoted strings.
    Caller should have checked need_pass_2 is FALSE because we don't
    Caller should have checked need_pass_2 is FALSE because we don't
-   check it.  */
+   check it.
+   Checks for end-of-line.
+   BITS_APPENDZERO says how many bits are in a target char.
+   The bottom bit is set if a NUL char should be appended to the strings.  */
 
 void
 
 void
-stringer (/* Worker to do .ascii etc statements.  */
-         /* Checks end-of-line.  */
-         register int append_zero      /* 0: don't append '\0', else 1.  */)
+stringer (int bits_appendzero)
 {
 {
-  register unsigned int c;
+  const int bitsize = bits_appendzero & ~7;
+  const int append_zero = bits_appendzero & 1;
+  unsigned int c;
+#if !defined(NO_LISTING) && defined (OBJ_ELF)
   char *start;
   char *start;
+#endif
 
 #ifdef md_flush_pending_output
   md_flush_pending_output ();
 #endif
 
 
 #ifdef md_flush_pending_output
   md_flush_pending_output ();
 #endif
 
+#ifdef md_cons_align
+  md_cons_align (1);
+#endif
+
   /* The following awkward logic is to parse ZERO or more strings,
      comma separated. Recall a string expression includes spaces
      before the opening '\"' and spaces after the closing '\"'.
   /* The following awkward logic is to parse ZERO or more strings,
      comma separated. Recall a string expression includes spaces
      before the opening '\"' and spaces after the closing '\"'.
@@ -4555,19 +5202,19 @@ stringer (/* Worker to do .ascii etc statements.  */
        {
        case '\"':
          ++input_line_pointer; /*->1st char of string.  */
        {
        case '\"':
          ++input_line_pointer; /*->1st char of string.  */
+#if !defined(NO_LISTING) && defined (OBJ_ELF)
          start = input_line_pointer;
          start = input_line_pointer;
+#endif
+
          while (is_a_char (c = next_char_of_string ()))
          while (is_a_char (c = next_char_of_string ()))
-           {
-             FRAG_APPEND_1_CHAR (c);
-           }
+           stringer_append_char (c, bitsize);
+
          if (append_zero)
          if (append_zero)
-           {
-             FRAG_APPEND_1_CHAR (0);
-           }
+           stringer_append_char (0, bitsize);
+
          know (input_line_pointer[-1] == '\"');
 
          know (input_line_pointer[-1] == '\"');
 
-#ifndef NO_LISTING
-#ifdef OBJ_ELF
+#if !defined(NO_LISTING) && defined (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
          /* 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
@@ -4583,18 +5230,16 @@ stringer (/* Worker to do .ascii etc statements.  */
              listing_source_file (start);
              input_line_pointer[-1] = c;
            }
              listing_source_file (start);
              input_line_pointer[-1] = c;
            }
-#endif
 #endif
 
          break;
        case '<':
          input_line_pointer++;
          c = get_single_number ();
 #endif
 
          break;
        case '<':
          input_line_pointer++;
          c = get_single_number ();
-         FRAG_APPEND_1_CHAR (c);
+         stringer_append_char (c, bitsize);
          if (*input_line_pointer != '>')
          if (*input_line_pointer != '>')
-           {
-             as_bad (_("expected <nn>"));
-           }
+           as_bad (_("expected <nn>"));
+
          input_line_pointer++;
          break;
        case ',':
          input_line_pointer++;
          break;
        case ',':
@@ -4606,7 +5251,7 @@ stringer (/* Worker to do .ascii etc statements.  */
     }
 
   demand_empty_rest_of_line ();
     }
 
   demand_empty_rest_of_line ();
-}                              /* stringer() */
+}
 \f
 /* FIXME-SOMEDAY: I had trouble here on characters with the
     high bits set.  We'll probably also have trouble with
 \f
 /* FIXME-SOMEDAY: I had trouble here on characters with the
     high bits set.  We'll probably also have trouble with
@@ -4616,7 +5261,7 @@ stringer (/* Worker to do .ascii etc statements.  */
 unsigned int
 next_char_of_string (void)
 {
 unsigned int
 next_char_of_string (void)
 {
-  register unsigned int c;
+  unsigned int c;
 
   c = *input_line_pointer++ & CHAR_MASK;
   switch (c)
 
   c = *input_line_pointer++ & CHAR_MASK;
   switch (c)
@@ -4736,9 +5381,9 @@ next_char_of_string (void)
 }
 \f
 static segT
 }
 \f
 static segT
-get_segmented_expression (register expressionS *expP)
+get_segmented_expression (expressionS *expP)
 {
 {
-  register segT retval;
+  segT retval;
 
   retval = expression (expP);
   if (expP->X_op == O_illegal
 
   retval = expression (expP);
   if (expP->X_op == O_illegal
@@ -4754,11 +5399,11 @@ get_segmented_expression (register expressionS *expP)
 }
 
 static segT
 }
 
 static segT
-get_known_segmented_expression (register expressionS *expP)
+get_known_segmented_expression (expressionS *expP)
 {
 {
-  register segT retval;
+  segT retval = get_segmented_expression (expP);
 
 
-  if ((retval = get_segmented_expression (expP)) == undefined_section)
+  if (retval == undefined_section)
     {
       /* There is no easy way to extract the undefined symbol from the
         expression.  */
     {
       /* There is no easy way to extract the undefined symbol from the
         expression.  */
@@ -4772,29 +5417,7 @@ get_known_segmented_expression (register expressionS *expP)
       expP->X_op = O_constant;
       expP->X_add_number = 0;
     }
       expP->X_op = O_constant;
       expP->X_add_number = 0;
     }
-  know (retval == absolute_section || SEG_NORMAL (retval));
-  return (retval);
-}
-
-offsetT
-get_absolute_expr (expressionS *exp)
-{
-  expression (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);
+  return retval;
 }
 
 char                           /* Return terminator.  */
 }
 
 char                           /* Return terminator.  */
@@ -4811,11 +5434,11 @@ get_absolute_expression_and_terminator (long *val_pointer /* Return value of exp
 char *
 demand_copy_C_string (int *len_pointer)
 {
 char *
 demand_copy_C_string (int *len_pointer)
 {
-  register char *s;
+  char *s;
 
   if ((s = demand_copy_string (len_pointer)) != 0)
     {
 
   if ((s = demand_copy_string (len_pointer)) != 0)
     {
-      register int len;
+      int len;
 
       for (len = *len_pointer; len > 0; len--)
        {
 
       for (len = *len_pointer; len > 0; len--)
        {
@@ -4838,8 +5461,8 @@ demand_copy_C_string (int *len_pointer)
 char *
 demand_copy_string (int *lenP)
 {
 char *
 demand_copy_string (int *lenP)
 {
-  register unsigned int c;
-  register int len;
+  unsigned int c;
+  int len;
   char *retval;
 
   len = 0;
   char *retval;
 
   len = 0;
@@ -4856,7 +5479,7 @@ demand_copy_string (int *lenP)
       /* JF this next line is so demand_copy_C_string will return a
         null terminated string.  */
       obstack_1grow (&notes, '\0');
       /* JF this next line is so demand_copy_C_string will return a
         null terminated string.  */
       obstack_1grow (&notes, '\0');
-      retval = obstack_finish (&notes);
+      retval = (char *) obstack_finish (&notes);
     }
   else
     {
     }
   else
     {
@@ -4884,13 +5507,14 @@ is_it_end_of_statement (void)
 void
 equals (char *sym_name, int reassign)
 {
 void
 equals (char *sym_name, int reassign)
 {
-  register symbolS *symbolP;   /* Symbol we are working with.  */
   char *stop = NULL;
   char *stop = NULL;
-  char stopc;
+  char stopc = 0;
 
   input_line_pointer++;
   if (*input_line_pointer == '=')
     input_line_pointer++;
 
   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++;
@@ -4898,44 +5522,10 @@ equals (char *sym_name, int 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')
-    {
-      /* Turn '. = mumble' into a .org mumble.  */
-      register segT segment;
-      expressionS exp;
-
-      segment = get_known_segmented_expression (&exp);
-      if (!need_pass_2)
-       do_org (segment, &exp, 0);
-    }
-  else
-    {
-#ifdef OBJ_COFF
-      int local;
-
-      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' is already defined"), S_GET_NAME (symbolP));
-
-#ifdef OBJ_COFF
-      /* "set" symbols are local unless otherwise specified.  */
-      if (local)
-       SF_SET_LOCAL (symbolP);
-#endif /* OBJ_COFF */
-
-      pseudo_set (symbolP);
-    }
+  assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);
 
   if (flag_mri)
     {
 
   if (flag_mri)
     {
-      /* Check garbage after the expression.  */
       demand_empty_rest_of_line ();
       mri_comment_end (stop, stopc);
     }
       demand_empty_rest_of_line ();
       mri_comment_end (stop, stopc);
     }
@@ -4959,6 +5549,10 @@ s_incbin (int x ATTRIBUTE_UNUSED)
   md_flush_pending_output ();
 #endif
 
   md_flush_pending_output ();
 #endif
 
+#ifdef md_cons_align
+  md_cons_align (1);
+#endif
+
   SKIP_WHITESPACE ();
   filename = demand_copy_string (& len);
   if (filename == NULL)
   SKIP_WHITESPACE ();
   filename = demand_copy_string (& len);
   if (filename == NULL)
@@ -4994,7 +5588,7 @@ s_incbin (int x ATTRIBUTE_UNUSED)
     {
       int i;
 
     {
       int i;
 
-      path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
+      path = (char *) xmalloc ((unsigned long) len + include_dir_maxlen + 5);
 
       for (i = 0; i < include_dir_count; i++)
        {
 
       for (i = 0; i < include_dir_count; i++)
        {
@@ -5064,7 +5658,7 @@ s_include (int arg ATTRIBUTE_UNUSED)
 {
   char *filename;
   int i;
 {
   char *filename;
   int i;
-  FILE *try;
+  FILE *try_file;
   char *path;
 
   if (!flag_m68k_mri)
   char *path;
 
   if (!flag_m68k_mri)
@@ -5091,22 +5685,23 @@ s_include (int arg ATTRIBUTE_UNUSED)
        }
 
       obstack_1grow (&notes, '\0');
        }
 
       obstack_1grow (&notes, '\0');
-      filename = obstack_finish (&notes);
+      filename = (char *) obstack_finish (&notes);
       while (!is_end_of_line[(unsigned char) *input_line_pointer])
        ++input_line_pointer;
     }
 
   demand_empty_rest_of_line ();
       while (!is_end_of_line[(unsigned char) *input_line_pointer])
        ++input_line_pointer;
     }
 
   demand_empty_rest_of_line ();
-  path = xmalloc ((unsigned long) i + include_dir_maxlen + 5 /* slop */ );
+  path = (char *) xmalloc ((unsigned long) i
+                           + include_dir_maxlen + 5 /* slop */ );
 
   for (i = 0; i < include_dir_count; i++)
     {
       strcpy (path, include_dirs[i]);
       strcat (path, "/");
       strcat (path, filename);
 
   for (i = 0; i < include_dir_count; i++)
     {
       strcpy (path, include_dirs[i]);
       strcat (path, "/");
       strcat (path, filename);
-      if (0 != (try = fopen (path, FOPEN_RT)))
+      if (0 != (try_file = fopen (path, FOPEN_RT)))
        {
        {
-         fclose (try);
+         fclose (try_file);
          goto gotit;
        }
     }
          goto gotit;
        }
     }
@@ -5192,7 +5787,7 @@ s_func (int 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
+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
 do_s_func (int end_p, const char *default_prefix)
 {
   /* Record the current function so that we can issue an error message for
@@ -5235,17 +5830,20 @@ do_s_func (int end_p, const char *default_prefix)
       if (*input_line_pointer != ',')
        {
          if (default_prefix)
       if (*input_line_pointer != ',')
        {
          if (default_prefix)
-           asprintf (&label, "%s%s", default_prefix, name);
+           {
+             if (asprintf (&label, "%s%s", default_prefix, name) == -1)
+               as_fatal ("%s", xstrerror (errno));
+           }
          else
            {
          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)
-               asprintf (&label, "%c%s", leading_char, name);
+               {
+                 if (asprintf (&label, "%c%s", leading_char, name) == -1)
+                   as_fatal ("%s", xstrerror (errno));
+               }
              else
                label = name;
            }
              else
                label = name;
            }
@@ -5273,11 +5871,7 @@ do_s_func (int end_p, const char *default_prefix)
 void
 s_ignore (int arg ATTRIBUTE_UNUSED)
 {
 void
 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
@@ -5315,3 +5909,59 @@ 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,
+                  int in_macro)
+{
+  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
+        /* PR 6926:  When we are parsing the body of a macro the sequence
+           \@ is special - it refers to the invocation count.  If the @
+           character happens to be registered as a line-separator character
+           by the target, then the is_end_of_line[] test above will have
+           returned true, but we need to ignore the line separating
+           semantics in this particular case.  */
+        || (in_macro && inescape && *s == '@')
+       )
+    {
+      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, 0);
+}
This page took 0.078755 seconds and 4 git commands to generate.