Help stupid cvs fixing basic conflicts.

1 files changed, 546 insertions, 343 deletions

diff --git a/gnu/usr.bin/binutils/gas/write.c b/gnu/usr.bin/binutils/gas/write.c
index 211573f2c3d..e386ece343b 100644
--- a/gnu/usr.bin/binutils/gas/write.c
+++ b/gnu/usr.bin/binutils/gas/write.c
@@ -1,5 +1,5 @@
 /* write.c - emit .o file
-   Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 1996
+   Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 96, 97, 98, 1999
    Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.
@@ -15,8 +15,9 @@
    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.  */
+   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.  */
 
 /* This thing should be set up to do byteordering correctly.  But... */
 
@@ -111,6 +112,26 @@ static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
 #endif
 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
+#if defined (BFD_ASSEMBLER) || ! defined (BFD)
+static fragS *chain_frchains_together_1 PARAMS ((segT, struct frchain *));
+#endif
+#ifdef BFD_ASSEMBLER
+static void chain_frchains_together PARAMS ((bfd *, segT, PTR));
+static void cvt_frag_to_fill PARAMS ((segT, fragS *));
+static void relax_and_size_seg PARAMS ((bfd *, asection *, PTR));
+static void adjust_reloc_syms PARAMS ((bfd *, asection *, PTR));
+static void write_relocs PARAMS ((bfd *, asection *, PTR));
+static void write_contents PARAMS ((bfd *, asection *, PTR));
+static void set_symtab PARAMS ((void));
+#endif
+#if defined (BFD_ASSEMBLER) || (! defined (BFD) && ! defined (OBJ_AOUT))
+static void merge_data_into_text PARAMS ((void));
+#endif
+#if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
+static void cvt_frag_to_fill PARAMS ((object_headers *, segT, fragS *));
+static void remove_subsegs PARAMS ((frchainS *, int, fragS **, fragS **));
+static void relax_and_size_all_segments PARAMS ((void));
+#endif
 
 /*
  *			fix_new()
@@ -145,7 +166,7 @@ fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
   /* We've made fx_size a narrow field; check that it's wide enough.  */
   if (fixP->fx_size != size)
     {
-      as_bad ("field fx_size too small to hold %d", size);
+      as_bad (_("field fx_size too small to hold %d"), size);
       abort ();
     }
   fixP->fx_addsy = add_symbol;
@@ -162,6 +183,13 @@ fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
   fixP->fx_addnumber = 0;
   fixP->fx_tcbit = 0;
   fixP->fx_done = 0;
+  fixP->fx_no_overflow = 0;
+  fixP->fx_signed = 0;
+
+#ifdef USING_CGEN
+  fixP->fx_cgen.insn = NULL;
+  fixP->fx_cgen.opinfo = 0;
+#endif
 
 #ifdef TC_FIX_TYPE
   TC_INIT_FIX_DATA(fixP);
@@ -257,7 +285,6 @@ fix_new_exp (frag, where, size, exp, pcrel, r_type)
       /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
 	 the difference expression cannot immediately be reduced.  */
       {
-	extern symbolS *make_expr_symbol ();
 	symbolS *stmp = make_expr_symbol (exp);
 	exp->X_op = O_symbol;
 	exp->X_op_symbol = 0;
@@ -276,7 +303,7 @@ fix_new_exp (frag, where, size, exp, pcrel, r_type)
 #if defined(TC_RVA_RELOC)
       r_type = TC_RVA_RELOC;
 #else
-      as_fatal("rva not supported");
+      as_fatal(_("rva not supported"));
 #endif
 #endif
       break;
@@ -341,7 +368,7 @@ record_alignment (seg, align)
   if (seg == absolute_section)
     return;
 #ifdef BFD_ASSEMBLER
-  if (align > bfd_get_section_alignment (stdoutput, seg))
+  if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg))
     bfd_set_section_alignment (stdoutput, seg, align);
 #else
   if (align > section_alignment[(int) seg])
@@ -355,7 +382,7 @@ record_alignment (seg, align)
 
 static void
 renumber_sections (abfd, sec, countparg)
-     bfd *abfd;
+     bfd *abfd ATTRIBUTE_UNUSED;
      asection *sec;
      PTR countparg;
 {
@@ -406,9 +433,9 @@ chain_frchains_together_1 (section, frchp)
 
 static void
 chain_frchains_together (abfd, section, xxx)
-     bfd *abfd;			/* unused */
+     bfd *abfd ATTRIBUTE_UNUSED;
      segT section;
-     PTR xxx;			/* unused */
+     PTR xxx ATTRIBUTE_UNUSED;
 {
   segment_info_type *info;
 
@@ -428,7 +455,7 @@ chain_frchains_together (abfd, section, xxx)
 
 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
 
-void
+static void
 remove_subsegs (head, seg, root, last)
      frchainS *head;
      int seg;
@@ -471,8 +498,9 @@ cvt_frag_to_fill (headersP, sec, fragP)
 			  - fragP->fr_fix) / fragP->fr_var;
       if (fragP->fr_offset < 0)
 	{
-	  as_bad ("attempt to .org/.space backwards? (%ld)",
-		  (long) fragP->fr_offset);
+	  as_bad_where (fragP->fr_file, fragP->fr_line,
+			_("attempt to .org/.space backwards? (%ld)"),
+			(long) fragP->fr_offset);
 	}
       fragP->fr_type = rs_fill;
       break;
@@ -480,6 +508,26 @@ cvt_frag_to_fill (headersP, sec, fragP)
     case rs_fill:
       break;
 
+    case rs_leb128:
+      {
+	valueT value = S_GET_VALUE (fragP->fr_symbol);
+	int size;
+
+	size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
+			      fragP->fr_subtype);
+
+	fragP->fr_fix += size;
+	fragP->fr_type = rs_fill;
+	fragP->fr_var = 0;
+	fragP->fr_offset = 0;
+	fragP->fr_symbol = NULL;
+      }
+      break;
+
+    case rs_cfa:
+      eh_frame_convert_frag (fragP);
+      break;
+
     case rs_machine_dependent:
 #ifdef BFD_ASSEMBLER
       md_convert_frag (stdoutput, sec, fragP);
@@ -487,7 +535,9 @@ cvt_frag_to_fill (headersP, sec, fragP)
       md_convert_frag (headersP, sec, fragP);
 #endif
 
-      assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
+      assert (fragP->fr_next == NULL
+	      || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
+		  == fragP->fr_fix));
 
       /*
        * After md_convert_frag, we make the frag into a ".space 0".
@@ -529,7 +579,7 @@ static void
 relax_and_size_seg (abfd, sec, xxx)
      bfd *abfd;
      asection *sec;
-     PTR xxx;
+     PTR xxx ATTRIBUTE_UNUSED;
 {
   flagword flags;
   fragS *fragp;
@@ -595,7 +645,7 @@ relax_and_size_seg (abfd, sec, xxx)
 #ifdef DEBUG2
 static void
 dump_section_relocs (abfd, sec, stream_)
-     bfd *abfd;
+     bfd *abfd ATTRIBUTE_UNUSED;
      asection *sec;
      char *stream_;
 {
@@ -610,22 +660,16 @@ dump_section_relocs (abfd, sec, stream_)
   while (fixp)
     {
       symbolS *s = fixp->fx_addsy;
-      if (s)
+
+      fprintf (stream, "  %08lx: type %d ", (unsigned long) fixp,
+	       (int) fixp->fx_r_type);
+      if (s == NULL)
+	fprintf (stream, "no sym\n");
+      else
 	{
-	  fprintf (stream, "  %08x: %s(%s", fixp, S_GET_NAME (s),
-		   s->bsym->section->name);
-	  if (s->bsym->flags & BSF_SECTION_SYM)
-	    {
-	      fprintf (stream, " section sym");
-	      if (S_GET_VALUE (s))
-		fprintf (stream, "+%x", S_GET_VALUE (s));
-	    }
-	  else
-	    fprintf (stream, "+%x", S_GET_VALUE (s));
-	  fprintf (stream, ")+%x\n", fixp->fx_offset);
+	  print_symbol_value_1 (stream, s);
+	  fprintf (stream, "\n");
 	}
-      else
-	fprintf (stream, "  %08x: type %d no sym\n", fixp, fixp->fx_r_type);
       fixp = fixp->fx_next;
     }
 }
@@ -639,9 +683,9 @@ dump_section_relocs (abfd, sec, stream_)
 
 static void
 adjust_reloc_syms (abfd, sec, xxx)
-     bfd *abfd;
+     bfd *abfd ATTRIBUTE_UNUSED;
      asection *sec;
-     PTR xxx;
+     PTR xxx ATTRIBUTE_UNUSED;
 {
   segment_info_type *seginfo = seg_info (sec);
   fixS *fixp;
@@ -659,32 +703,54 @@ adjust_reloc_syms (abfd, sec, xxx)
 	symbolS *sym;
 	asection *symsec;
 
-      reduce_fixup:
-
 #ifdef DEBUG5
 	fprintf (stderr, "\n\nadjusting fixup:\n");
 	print_fixup (fixp);
 #endif
 
 	sym = fixp->fx_addsy;
-	symsec = sym->bsym->section;
 
-	if (sym != NULL && sym->sy_mri_common)
+	/* All symbols should have already been resolved at this
+	   point.  It is possible to see unresolved expression
+	   symbols, though, since they are not in the regular symbol
+	   table.  */
+	if (sym != NULL)
+	  resolve_symbol_value (sym, 1);
+	
+	if (fixp->fx_subsy != NULL)
+	  resolve_symbol_value (fixp->fx_subsy, 1);
+
+	/* If this symbol is equated to an undefined symbol, convert
+           the fixup to being against that symbol.  */
+	if (sym != NULL && symbol_equated_p (sym)
+	    && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
+	  {
+	    fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
+	    sym = symbol_get_value_expression (sym)->X_add_symbol;
+	    fixp->fx_addsy = sym;
+	  }
+
+	if (sym != NULL && symbol_mri_common_p (sym))
 	  {
 	    /* These symbols are handled specially in fixup_segment.  */
 	    goto done;
 	  }
 
+	symsec = S_GET_SEGMENT (sym);
+
+	if (symsec == NULL)
+	  abort ();
+	
 	if (bfd_is_abs_section (symsec))
 	  {
 	    /* The fixup_segment routine will not use this symbol in a
                relocation unless TC_FORCE_RELOCATION returns 1.  */
 	    if (TC_FORCE_RELOCATION (fixp))
 	      {
-		fixp->fx_addsy->sy_used_in_reloc = 1;
+		symbol_mark_used_in_reloc (fixp->fx_addsy);
 #ifdef UNDEFINED_DIFFERENCE_OK
 		if (fixp->fx_subsy != NULL)
-		  fixp->fx_subsy->sy_used_in_reloc = 1;
+		  symbol_mark_used_in_reloc (fixp->fx_subsy);
 #endif
 	      }
 	    goto done;
@@ -698,31 +764,77 @@ adjust_reloc_syms (abfd, sec, xxx)
 	if (bfd_is_und_section (symsec)
 	    || bfd_is_com_section (symsec))
 	  {
-	    fixp->fx_addsy->sy_used_in_reloc = 1;
+	    symbol_mark_used_in_reloc (fixp->fx_addsy);
 #ifdef UNDEFINED_DIFFERENCE_OK
 	    /* We have the difference of an undefined symbol and some
 	       other symbol.  Make sure to mark the other symbol as used
 	       in a relocation so that it will always be output.  */
 	    if (fixp->fx_subsy)
-	      fixp->fx_subsy->sy_used_in_reloc = 1;
+	      symbol_mark_used_in_reloc (fixp->fx_subsy);
 #endif
 	    goto done;
 	  }
 
+	/* Don't try to reduce relocs which refer to non-local symbols
+           in .linkonce sections.  It can lead to confusion when a
+           debugging section refers to a .linkonce section.  I hope
+           this will always be correct.  */
+	if (symsec != sec && ! S_IS_LOCAL (sym))
+	  {
+	    boolean linkonce;
+
+	    linkonce = false;
+#ifdef BFD_ASSEMBLER
+	    if ((bfd_get_section_flags (stdoutput, symsec) & SEC_LINK_ONCE)
+		!= 0)
+	      linkonce = true;
+#endif
+#ifdef OBJ_ELF
+	    /* The GNU toolchain uses an extension for ELF: a section
+               beginning with the magic string .gnu.linkonce is a
+               linkonce section.  */
+	    if (strncmp (segment_name (symsec), ".gnu.linkonce",
+			 sizeof ".gnu.linkonce" - 1) == 0)
+	      linkonce = true;
+#endif
+
+	    if (linkonce)
+	      {
+		symbol_mark_used_in_reloc (fixp->fx_addsy);
+#ifdef UNDEFINED_DIFFERENCE_OK
+		if (fixp->fx_subsy != NULL)
+		  symbol_mark_used_in_reloc (fixp->fx_subsy);
+#endif
+		goto done;
+	      }
+	  }
+
 	/* Since we're reducing to section symbols, don't attempt to reduce
 	   anything that's already using one.  */
-	if (sym->bsym->flags & BSF_SECTION_SYM)
+	if (symbol_section_p (sym))
+	  {
+	    symbol_mark_used_in_reloc (fixp->fx_addsy);
+	    goto done;
+	  }
+
+#ifdef BFD_ASSEMBLER
+	/* We can never adjust a reloc against a weak symbol.  If we
+           did, and the weak symbol was overridden by a real symbol
+           somewhere else, then our relocation would be pointing at
+           the wrong area of memory.  */
+	if (S_IS_WEAK (sym))
 	  {
-	    fixp->fx_addsy->sy_used_in_reloc = 1;
+	    symbol_mark_used_in_reloc (fixp->fx_addsy);
 	    goto done;
 	  }
+#endif
 
 	/* Is there some other reason we can't adjust this one?  (E.g.,
 	   call/bal links in i960-bout symbols.)  */
 #ifdef obj_fix_adjustable
 	if (! obj_fix_adjustable (fixp))
 	  {
-	    fixp->fx_addsy->sy_used_in_reloc = 1;
+	    symbol_mark_used_in_reloc (fixp->fx_addsy);
 	    goto done;
 	  }
 #endif
@@ -733,32 +845,11 @@ adjust_reloc_syms (abfd, sec, xxx)
 #ifdef tc_fix_adjustable
 	if (! tc_fix_adjustable (fixp))
 	  {
-	    fixp->fx_addsy->sy_used_in_reloc = 1;
+	    symbol_mark_used_in_reloc (fixp->fx_addsy);
 	    goto done;
 	  }
 #endif
 
-	/* For PIC support: We may get expressions like
-	   "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
-	   necessarily have had a fixed difference initially.  But now
-	   it should be a known constant, so we can reduce it.  Since
-	   we can't easily handle a symbol value that looks like
-	   someUndefinedSymbol+const, though, we convert the fixup to
-	   access the undefined symbol directly, and discard the
-	   intermediate symbol.  */
-	if (S_GET_SEGMENT (sym) == expr_section
-	    && sym->sy_value.X_op == O_add
-	    && (resolve_symbol_value (sym->sy_value.X_add_symbol),
-		S_GET_SEGMENT (sym->sy_value.X_add_symbol) == undefined_section)
-	    && (resolve_symbol_value (sym->sy_value.X_op_symbol),
-		S_GET_SEGMENT (sym->sy_value.X_op_symbol) == absolute_section))
-	  {
-	    fixp->fx_offset += S_GET_VALUE (sym->sy_value.X_op_symbol);
-	    fixp->fx_offset += sym->sy_value.X_add_number;
-	    fixp->fx_addsy = sym->sy_value.X_add_symbol;
-	    goto reduce_fixup;
-	  }
-
 	/* If the section symbol isn't going to be output, the relocs
 	   at least should still work.  If not, figure out what to do
 	   when we run into that case.
@@ -768,7 +859,11 @@ adjust_reloc_syms (abfd, sec, xxx)
 	   the section when it calls resolve_symbol_value. */
 	fixp->fx_offset += S_GET_VALUE (sym);
 	fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
-	fixp->fx_addsy->sy_used_in_reloc = 1;
+	symbol_mark_used_in_reloc (fixp->fx_addsy);
+#ifdef DEBUG5
+	fprintf (stderr, "\nadjusted fixup:\n");
+	print_fixup (fixp);
+#endif
 
       done:
 	;
@@ -793,7 +888,7 @@ static void
 write_relocs (abfd, sec, xxx)
      bfd *abfd;
      asection *sec;
-     PTR xxx;
+     PTR xxx ATTRIBUTE_UNUSED;
 {
   segment_info_type *seginfo = seg_info (sec);
   int i;
@@ -815,8 +910,7 @@ write_relocs (abfd, sec, xxx)
 
 #ifndef RELOC_EXPANSION_POSSIBLE
   /* Set up reloc information as well.  */
-  relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
-					     n * sizeof (arelent *));
+  relocs = (arelent **) xmalloc (n * sizeof (arelent *));
   memset ((char*)relocs, 0, n * sizeof (arelent*));
 
   i = 0;
@@ -836,9 +930,19 @@ write_relocs (abfd, sec, xxx)
          symbol, then use generate the reloc against the latter symbol
          rather than the former.  */
       sym = fixp->fx_addsy;
-      while (sym->sy_value.X_op == O_symbol
+      while (symbol_equated_p (sym)
 	     && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
-	sym = sym->sy_value.X_add_symbol;
+	{
+	  symbolS *n;
+
+	  /* We must avoid looping, as that can occur with a badly
+	     written program.  */
+	  n = symbol_get_value_expression (sym)->X_add_symbol;
+	  if (n == sym)
+	    break;
+	  fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
+	  sym = n;
+	}
       fixp->fx_addsy = sym;
 
       reloc = tc_gen_reloc (sec, fixp);
@@ -864,19 +968,21 @@ write_relocs (abfd, sec, xxx)
 	case bfd_reloc_ok:
 	  break;
 	case bfd_reloc_overflow:
-	  as_bad_where (fixp->fx_file, fixp->fx_line, "relocation overflow");
+	  as_bad_where (fixp->fx_file, fixp->fx_line, _("relocation overflow"));
+	  break;
+	case bfd_reloc_outofrange:
+	  as_bad_where (fixp->fx_file, fixp->fx_line, _("relocation out of range"));
 	  break;
 	default:
-	  as_fatal ("%s:%u: bad return from bfd_perform_relocation",
-		    fixp->fx_file, fixp->fx_line);
+	  as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
+		    fixp->fx_file, fixp->fx_line, s);
 	}
       relocs[i++] = reloc;
     }
 #else
   n = n * MAX_RELOC_EXPANSION;
   /* Set up reloc information as well.  */
-  relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
-					     n * sizeof (arelent *));
+  relocs = (arelent **) xmalloc (n * sizeof (arelent *));
 
   i = 0;
   for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
@@ -897,9 +1003,9 @@ write_relocs (abfd, sec, xxx)
          symbol, then use generate the reloc against the latter symbol
          rather than the former.  */
       sym = fixp->fx_addsy;
-      while (sym->sy_value.X_op == O_symbol
+      while (symbol_equated_p (sym)
 	     && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
-	sym = sym->sy_value.X_add_symbol;
+	sym = symbol_get_value_expression (sym)->X_add_symbol;
       fixp->fx_addsy = sym;
 
       reloc = tc_gen_reloc (sec, fixp);
@@ -912,7 +1018,8 @@ write_relocs (abfd, sec, xxx)
       data = fixp->fx_frag->fr_literal + fixp->fx_where;
       if (fixp->fx_where + fixp->fx_size
 	  > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
-	abort ();
+	as_bad_where (fixp->fx_file, fixp->fx_line,
+		      _("internal error: fixup not contained within frag"));
       for (j = 0; reloc[j]; j++)
         {
 	  s = bfd_install_relocation (stdoutput, reloc[j],
@@ -925,10 +1032,10 @@ write_relocs (abfd, sec, xxx)
 	      break;
 	    case bfd_reloc_overflow:
 	      as_bad_where (fixp->fx_file, fixp->fx_line,
-			    "relocation overflow");
+			    _("relocation overflow"));
 	      break;
 	    default:
-	      as_fatal ("%s:%u: bad return from bfd_perform_relocation",
+	      as_fatal (_("%s:%u: bad return from bfd_install_relocation"),
 			fixp->fx_file, fixp->fx_line);
 	    }
         }
@@ -961,6 +1068,10 @@ write_relocs (abfd, sec, xxx)
 			   (bfd_get_section_flags (abfd, sec)
 			    & (flagword) ~SEC_RELOC));
 
+#ifdef SET_SECTION_RELOCS
+  SET_SECTION_RELOCS (sec, relocs, n);
+#endif
+
 #ifdef DEBUG3
   {
     int i;
@@ -980,9 +1091,9 @@ write_relocs (abfd, sec, xxx)
 
 static void
 write_contents (abfd, sec, xxx)
-     bfd *abfd;
+     bfd *abfd ATTRIBUTE_UNUSED;
      asection *sec;
-     PTR xxx;
+     PTR xxx ATTRIBUTE_UNUSED;
 {
   segment_info_type *seginfo = seg_info (sec);
   unsigned long offset = 0;
@@ -1011,7 +1122,7 @@ write_contents (abfd, sec, xxx)
 	  if (x == false)
 	    {
 	      bfd_perror (stdoutput->filename);
-	      as_perror ("FATAL: Can't write %s", stdoutput->filename);
+	      as_perror (_("FATAL: Can't write %s"), stdoutput->filename);
 	      exit (EXIT_FAILURE);
 	    }
 	  offset += f->fr_fix;
@@ -1035,7 +1146,7 @@ write_contents (abfd, sec, xxx)
 		  if (x == false)
 		    {
 		      bfd_perror (stdoutput->filename);
-		      as_perror ("FATAL: Can't write %s", stdoutput->filename);
+		      as_perror (_("FATAL: Can't write %s"), stdoutput->filename);
 		      exit (EXIT_FAILURE);
 		    }
 		  offset += fill_size;
@@ -1066,7 +1177,7 @@ write_contents (abfd, sec, xxx)
 						buf, (file_ptr) offset,
 						(bfd_size_type) n_per_buf * fill_size);
 		  if (x != true)
-		    as_fatal ("Cannot write to output file.");
+		    as_fatal (_("Cannot write to output file."));
 		  offset += n_per_buf * fill_size;
 		}
 	    }
@@ -1225,8 +1336,8 @@ set_symtab ()
       symp = symbol_rootP;
       for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
 	{
-	  asympp[i] = symp->bsym;
-	  symp->written = 1;
+	  asympp[i] = symbol_get_bfdsym (symp);
+	  symbol_mark_written (symp);
 	}
     }
   else
@@ -1237,10 +1348,53 @@ set_symtab ()
 }
 #endif
 
+/* Finish the subsegments.  After every sub-segment, we fake an
+   ".align ...".  This conforms to BSD4.2 brane-damage.  We then fake
+   ".fill 0" because that is the kind of frag that requires least
+   thought.  ".align" frags like to have a following frag since that
+   makes calculating their intended length trivial.  */
+
+#ifndef SUB_SEGMENT_ALIGN
+#ifdef BFD_ASSEMBLER
+#define SUB_SEGMENT_ALIGN(SEG) (0)
+#else
+#define SUB_SEGMENT_ALIGN(SEG) (2)
+#endif
+#endif
+
+void
+subsegs_finish ()
+{
+  struct frchain *frchainP;
+
+  for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
+    {
+      subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
+
+      /* This now gets called even if we had errors.  In that case,
+         any alignment is meaningless, and, moreover, will look weird
+         if we are generating a listing.  */
+      frag_align (had_errors () ? 0 : SUB_SEGMENT_ALIGN (now_seg),
+		  subseg_text_p (now_seg) ? NOP_OPCODE : 0,
+		  0);
+
+      /* frag_align will have left a new frag.
+	 Use this last frag for an empty ".fill".
+
+	 For this segment ...
+	 Create a last frag. Do not leave a "being filled in frag".  */
+
+      frag_wane (frag_now);
+      frag_now->fr_fix = 0;
+      know (frag_now->fr_next == NULL);
+    }
+}
+
+/* Write the object file.  */
+
 void
 write_object_file ()
 {
-  struct frchain *frchainP;	/* Track along all frchains. */
 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
   fragS *fragP;			/* Track along all frags. */
 #endif
@@ -1255,14 +1409,14 @@ write_object_file ()
     if (flag_always_generate_output)
       {
 	if (n_warns || n_errs)
-	  as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
+	  as_warn (_("%d error%s, %d warning%s, generating bad object file.\n"),
 		   n_errs, n_errs == 1 ? "" : "s",
 		   n_warns, n_warns == 1 ? "" : "s");
       }
     else
       {
 	if (n_errs)
-	  as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
+	  as_fatal (_("%d error%s, %d warning%s, no object file generated.\n"),
 		    n_errs, n_errs == 1 ? "" : "s",
 		    n_warns, n_warns == 1 ? "" : "s");
       }
@@ -1275,34 +1429,6 @@ write_object_file ()
   vms_check_for_main ();
 #endif /* OBJ_VMS */
 
-  /* After every sub-segment, we fake an ".align ...". This conforms to
-     BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
-     frag that requires least thought. ".align" frags like to have a
-     following frag since that makes calculating their intended length
-     trivial.
-
-     @@ Is this really necessary??  */
-#ifndef SUB_SEGMENT_ALIGN
-#ifdef BFD_ASSEMBLER
-#define SUB_SEGMENT_ALIGN(SEG) (0)
-#else
-#define SUB_SEGMENT_ALIGN(SEG) (2)
-#endif
-#endif
-  for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
-    {
-      subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
-      frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
-      /* frag_align will have left a new frag.
-	 Use this last frag for an empty ".fill".
-
-	 For this segment ...
-	 Create a last frag. Do not leave a "being filled in frag".  */
-      frag_wane (frag_now);
-      frag_now->fr_fix = 0;
-      know (frag_now->fr_next == NULL);
-    }
-
   /* From now on, we don't care about sub-segments.  Build one frag chain
      for each segment. Linked thru fr_next.  */
 
@@ -1396,6 +1522,13 @@ write_object_file ()
 
   for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
     {
+      /* At this point we have linked all the frags into a single
+         chain.  However, cvt_frag_to_fill may call md_convert_frag
+         which may call fix_new.  We need to ensure that fix_new adds
+         the fixup to the right section.  */
+      if (fragP == data_frag_root)
+	subseg_change (SEG_DATA, 0);
+
       cvt_frag_to_fill (&headers, SEG_TEXT, fragP);
 
       /* Some assert macros don't work with # directives mixed in.  */
@@ -1422,6 +1555,7 @@ write_object_file ()
 	{
 	  expressionS exp;
 
+	  subseg_change (lie->seg, lie->subseg);
 	  exp.X_op = O_subtract;
 	  exp.X_add_symbol = lie->add;
 	  exp.X_op_symbol = lie->sub;
@@ -1466,6 +1600,7 @@ write_object_file ()
 	addressT from_addr, to_addr;
 	int n, m;
 
+	subseg_change (lie->seg, lie->subseg);
 	fragP = lie->dispfrag;
 
 	/* Find out how many broken_words go here.  */
@@ -1492,7 +1627,7 @@ write_object_file ()
 	    /* This is the offset from ??? to table_ptr+0 */
 	    to_addr = table_addr - S_GET_VALUE (lie->sub);
 #ifdef BFD_ASSEMBLER
-	    to_addr -= lie->sub->sy_frag->fr_address;
+	    to_addr -= symbol_get_frag (lie->sub)->fr_address;
 #endif
 	    md_number_to_chars (lie->word_goes_here, to_addr, 2);
 	    for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
@@ -1506,7 +1641,7 @@ write_object_file ()
 	    from_addr = table_addr;
 	    to_addr = S_GET_VALUE (lie->add) + lie->addnum;
 #ifdef BFD_ASSEMBLER
-	    to_addr += lie->add->sy_frag->fr_address;
+	    to_addr += symbol_get_frag (lie->add)->fr_address;
 #endif
 	    md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
 	    table_ptr += md_long_jump_size;
@@ -1639,9 +1774,9 @@ write_object_file ()
       symbolS *symp;
 
       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
-	if (!symp->sy_resolved)
-	  resolve_symbol_value (symp);
+	resolve_symbol_value (symp, 1);
     }
+  resolve_local_symbol_values ();
 
   PROGRESS (1);
 
@@ -1664,10 +1799,10 @@ write_object_file ()
 	  int punt = 0;
 	  const char *name;
 
-	  if (symp->sy_mri_common)
+	  if (symbol_mri_common_p (symp))
 	    {
 	      if (S_IS_EXTERNAL (symp))
-		as_bad ("%s: global symbols not supported in common sections",
+		as_bad (_("%s: global symbols not supported in common sections"),
 			S_GET_NAME (symp));
 	      symbol_remove (symp, &symbol_rootP, &symbol_lastP);
 	      continue;
@@ -1680,29 +1815,17 @@ write_object_file ()
 	      /* They only differ if `name' is a fb or dollar local
 		 label name.  */
 	      if (name2 != name && ! S_IS_DEFINED (symp))
-		as_bad ("local label %s is not defined", name2);
+		as_bad (_("local label %s is not defined"), name2);
 	    }
 
 	  /* Do it again, because adjust_reloc_syms might introduce
 	     more symbols.  They'll probably only be section symbols,
 	     but they'll still need to have the values computed.  */
-	  if (! symp->sy_resolved)
-	    {
-	      if (symp->sy_value.X_op == O_constant)
-		{
-		  /* This is the normal case; skip the call.  */
-		  S_SET_VALUE (symp,
-			       (S_GET_VALUE (symp)
-				+ symp->sy_frag->fr_address));
-		  symp->sy_resolved = 1;
-		}
-	      else
-		resolve_symbol_value (symp);
-	    }
+	  resolve_symbol_value (symp, 1);
 
 	  /* Skip symbols which were equated to undefined or common
              symbols.  */
-	  if (symp->sy_value.X_op == O_symbol
+	  if (symbol_equated_p (symp)
 	      && (! S_IS_DEFINED (symp) || S_IS_COMMON (symp)))
 	    {
 	      symbol_remove (symp, &symbol_rootP, &symbol_lastP);
@@ -1718,15 +1841,15 @@ write_object_file ()
 	  printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
 		  S_GET_NAME (symp), symp,
 		  S_GET_VALUE (symp),
-		  symp->bsym->flags,
-		  segment_name (symp->bsym->section));
+		  symbol_get_bfdsym (symp)->flags,
+		  segment_name (S_GET_SEGMENT (symp)));
 #endif
 
 #ifdef obj_frob_symbol
 	  obj_frob_symbol (symp, punt);
 #endif
 #ifdef tc_frob_symbol
-	  if (! punt || symp->sy_used_in_reloc)
+	  if (! punt || symbol_used_in_reloc_p (symp))
 	    tc_frob_symbol (symp, punt);
 #endif
 
@@ -1736,13 +1859,13 @@ write_object_file ()
 	     and symbols that the frob_symbol macros told us to punt,
 	     but we keep such symbols if they are used in relocs.  */
 	  if ((! EMIT_SECTION_SYMBOLS
-	       && (symp->bsym->flags & BSF_SECTION_SYM) != 0)
+	       && symbol_section_p (symp))
 	      /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
 		 opposites.  Sometimes the former checks flags and the
 		 latter examines the name...  */
 	      || (!S_IS_EXTERN (symp)
 		  && (S_IS_LOCAL (symp) || punt)
-		  && ! symp->sy_used_in_reloc))
+		  && ! symbol_used_in_reloc_p (symp)))
 	    {
 	      symbol_remove (symp, &symbol_rootP, &symbol_lastP);
 	      /* After symbol_remove, symbol_next(symp) still returns
@@ -1753,16 +1876,16 @@ write_object_file ()
 	    }
 
 	  /* Make sure we really got a value for the symbol.  */
-	  if (! symp->sy_resolved)
+	  if (! symbol_resolved_p (symp))
 	    {
-	      as_bad ("can't resolve value for symbol \"%s\"",
+	      as_bad (_("can't resolve value for symbol \"%s\""),
 		      S_GET_NAME (symp));
-	      symp->sy_resolved = 1;
+	      symbol_mark_resolved (symp);
 	    }
 
 	  /* Set the value into the BFD symbol.  Up til now the value
 	     has only been kept in the gas symbolS struct.  */
-	  symp->bsym->value = S_GET_VALUE (symp);
+	  symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
 	}
     }
 
@@ -1819,14 +1942,15 @@ write_object_file ()
  * these frag addresses may not be the same as final object-file addresses.
  */
 
-#ifndef md_relax_frag
 #ifdef TC_GENERIC_RELAX_TABLE
 
+static int is_dnrange PARAMS ((fragS *, fragS *));
+
 /* Subroutines of relax_segment.  */
 static int
 is_dnrange (f1, f2)
-     struct frag *f1;
-     struct frag *f2;
+     fragS *f1;
+     fragS *f2;
 {
   for (; f1; f1 = f1->fr_next)
     if (f1->fr_next == f2)
@@ -1834,8 +1958,109 @@ is_dnrange (f1, f2)
   return 0;
 }
 
+/* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE.  */
+
+long
+relax_frag (fragP, stretch)
+     fragS *fragP;
+     long stretch;
+{
+  const relax_typeS *this_type;
+  const relax_typeS *start_type;
+  relax_substateT next_state;
+  relax_substateT this_state;
+  long aim, target, growth;
+  symbolS *symbolP = fragP->fr_symbol;
+  long offset = fragP->fr_offset;
+  /* Recompute was_address by undoing "+= stretch" done by relax_segment.  */
+  unsigned long was_address = fragP->fr_address - stretch;
+  unsigned long address = fragP->fr_address;
+  const relax_typeS *table = TC_GENERIC_RELAX_TABLE;
+
+  this_state = fragP->fr_subtype;
+  start_type = this_type = table + this_state;
+  target = offset;
+
+  if (symbolP)
+    {
+#ifndef DIFF_EXPR_OK
+#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
+      know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
+	    || (S_GET_SEGMENT (symbolP) == SEG_DATA)
+	    || (S_GET_SEGMENT (symbolP) == SEG_BSS)
+	    || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
+#endif
+      know (symbolP->sy_frag);
+#endif
+      know (!(S_GET_SEGMENT (symbolP) == absolute_section)
+	    || symbolP->sy_frag == &zero_address_frag);
+      target +=	S_GET_VALUE (symbolP) + symbol_get_frag (symbolP)->fr_address;
+
+      /* If frag has yet to be reached on this pass,
+	 assume it will move by STRETCH just as we did.
+	 If this is not so, it will be because some frag
+	 between grows, and that will force another pass.
+
+	 Beware zero-length frags.
+
+	 There should be a faster way to do this.  */
+
+      if (symbol_get_frag (symbolP)->fr_address >= was_address
+	  && is_dnrange (fragP, symbol_get_frag (symbolP)))
+	{
+	  target += stretch;
+	}
+    }
+
+  aim = target - address - fragP->fr_fix;
+#ifdef TC_PCREL_ADJUST
+  /* Currently only the ns32k family needs this */
+  aim += TC_PCREL_ADJUST(fragP);
+/*#else*/
+  /* This machine doesn't want to use pcrel_adjust.
+     In that case, pcrel_adjust should be zero.  */
+/*  assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);*/
+#endif
+#ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
+  md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
+#endif
+
+  if (aim < 0)
+    {
+      /* Look backwards. */
+      for (next_state = this_type->rlx_more; next_state;)
+	if (aim >= this_type->rlx_backward)
+	  next_state = 0;
+	else
+	  {
+	    /* Grow to next state. */
+	    this_state = next_state;
+	    this_type = table + this_state;
+	    next_state = this_type->rlx_more;
+	  }
+    }
+  else
+    {
+      /* Look forwards. */
+      for (next_state = this_type->rlx_more; next_state;)
+	if (aim <= this_type->rlx_forward)
+	  next_state = 0;
+	else
+	  {
+	    /* Grow to next state. */
+	    this_state = next_state;
+	    this_type = table + this_state;
+	    next_state = this_type->rlx_more;
+	  }
+    }
+
+  growth = this_type->rlx_length - start_type->rlx_length;
+  if (growth != 0)
+    fragP->fr_subtype = this_state;
+  return growth;
+}
+
 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
-#endif /* ! defined (md_relax_frag) */
 
 /* Relax_align. Advance location counter to next address that has 'alignment'
    lowest order bits all 0s, return size of adjustment made.  */
@@ -1888,13 +2113,18 @@ relax_segment (segment_frag_root, segment)
 	case rs_align:
 	case rs_align_code:
 	  {
-	    int offset = relax_align (address, (int) fragP->fr_offset);
+	    addressT offset = relax_align (address, (int) fragP->fr_offset);
+
+	    if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
+	      offset = 0;
+
 	    if (offset % fragP->fr_var != 0)
 	      {
-		as_bad ("alignment padding (%d bytes) not a multiple of %ld",
-			offset, (long) fragP->fr_var);
+		as_bad (_("alignment padding (%lu bytes) not a multiple of %ld"),
+			(unsigned long) offset, (long) fragP->fr_var);
 		offset -= (offset % fragP->fr_var);
 	      }
+
 	    address += offset;
 	  }
 	  break;
@@ -1914,6 +2144,16 @@ relax_segment (segment_frag_root, segment)
 	  break;
 #endif
 
+	case rs_leb128:
+	  /* Initial guess is always 1; doing otherwise can result in 
+	     stable solutions that are larger than the minimum.  */
+	  address += fragP->fr_offset = 1;
+	  break;
+
+	case rs_cfa:
+	  address += eh_frame_estimate_size_before_relax (fragP);
+	  break;
+
 	default:
 	  BAD_CASE (fragP->fr_type);
 	  break;
@@ -1937,11 +2177,9 @@ relax_segment (segment_frag_root, segment)
 	for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
 	  {
 	    long growth = 0;
-	    unsigned long was_address;
-	    long offset;
+	    addressT was_address;
+	    offsetT offset;
 	    symbolS *symbolP;
-	    long target;
-	    long after;
 
 	    was_address = fragP->fr_address;
 	    address = fragP->fr_address += stretch;
@@ -1977,10 +2215,10 @@ relax_segment (segment_frag_root, segment)
 		      if (lie->added)
 			continue;
 
-		      offset = (lie->add->sy_frag->fr_address
+		      offset = (symbol_get_frag (lie->add)->fr_address
 				+ S_GET_VALUE (lie->add)
 				+ lie->addnum
-				- (lie->sub->sy_frag->fr_address
+				- (symbol_get_frag (lie->sub)->fr_address
 				   + S_GET_VALUE (lie->sub)));
 		      if (offset <= -32768 || offset >= 32767)
 			{
@@ -1988,7 +2226,7 @@ relax_segment (segment_frag_root, segment)
 			    {
 			      char buf[50];
 			      sprint_value (buf, (addressT) lie->addnum);
-			      as_warn (".word %s-%s+%s didn't fit",
+			      as_warn (_(".word %s-%s+%s didn't fit"),
 				       S_GET_NAME (lie->add),
 				       S_GET_NAME (lie->sub),
 				       buf);
@@ -2002,8 +2240,10 @@ relax_segment (segment_frag_root, segment)
 			  for (untruth = lie->next_broken_word;
 			       untruth && untruth->dispfrag == lie->dispfrag;
 			       untruth = untruth->next_broken_word)
-			    if ((untruth->add->sy_frag == lie->add->sy_frag)
-				&& S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
+			    if ((symbol_get_frag (untruth->add)
+				 == symbol_get_frag (lie->add))
+				&& (S_GET_VALUE (untruth->add)
+				    == S_GET_VALUE (lie->add)))
 			      {
 				untruth->added = 2;
 				untruth->use_jump = lie;
@@ -2017,57 +2257,83 @@ relax_segment (segment_frag_root, segment)
 #endif
 	      case rs_align:
 	      case rs_align_code:
-		growth = (relax_align ((relax_addressT) (address
-							 + fragP->fr_fix),
-				       (int) offset)
-			  - relax_align ((relax_addressT) (was_address
-							   + fragP->fr_fix),
-					 (int) offset));
+		{
+		  addressT oldoff, newoff;
+
+		  oldoff = relax_align (was_address + fragP->fr_fix,
+					(int) offset);
+		  newoff = relax_align (address + fragP->fr_fix,
+					(int) offset);
+
+		  if (fragP->fr_subtype != 0)
+		    {
+		      if (oldoff > fragP->fr_subtype)
+			oldoff = 0;
+		      if (newoff > fragP->fr_subtype)
+			newoff = 0;
+		    }
+
+		  growth = newoff - oldoff;
+		}
 		break;
 
 	      case rs_org:
-		target = offset;
+		{
+		  long target = offset;
+		  long after;
 
-		if (symbolP)
-		  {
+		  if (symbolP)
+		    {
 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
-		    know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
-			  || (S_GET_SEGMENT (symbolP) == SEG_DATA)
-			  || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
-			  || S_GET_SEGMENT (symbolP) == SEG_BSS);
-		    know (symbolP->sy_frag);
-		    know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
-			  || (symbolP->sy_frag == &zero_address_frag));
-#endif
-		    target += S_GET_VALUE (symbolP)
-		      + symbolP->sy_frag->fr_address;
-		  }		/* if we have a symbol */
-
-		know (fragP->fr_next);
-		after = fragP->fr_next->fr_address;
-		growth = target - after;
-		if (growth < 0)
-		  {
-		    /* Growth may be negative, but variable part of frag
-		       cannot have fewer than 0 chars.  That is, we can't
-		       .org backwards. */
-		    as_bad ("attempt to .org backwards ignored");
-		    growth = 0;
-		  }
+		      know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
+			    || (S_GET_SEGMENT (symbolP) == SEG_DATA)
+			    || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
+			    || S_GET_SEGMENT (symbolP) == SEG_BSS);
+		      know (symbolP->sy_frag);
+		      know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
+			    || (symbolP->sy_frag == &zero_address_frag));
+#endif
+		      target += (S_GET_VALUE (symbolP)
+				 + symbol_get_frag (symbolP)->fr_address);
+		    }		/* if we have a symbol */
 
-		growth -= stretch;	/* This is an absolute growth factor */
-		break;
+		  know (fragP->fr_next);
+		  after = fragP->fr_next->fr_address;
+		  growth = target - after;
+		  if (growth < 0)
+		    {
+		      /* Growth may be negative, but variable part of frag
+			 cannot have fewer than 0 chars.  That is, we can't
+			 .org backwards. */
+		      as_bad_where (fragP->fr_file, fragP->fr_line,
+				    _("attempt to .org backwards ignored"));
+
+		      /* We've issued an error message.  Change the
+                         frag to avoid cascading errors.  */
+		      fragP->fr_type = rs_align;
+		      fragP->fr_subtype = 0;
+		      fragP->fr_offset = 0;
+		      fragP->fr_fix = after - address;
+		      growth = stretch;
+		    }
+
+		  growth -= stretch;	/* This is an absolute growth factor */
+		  break;
+		}
 
 	      case rs_space:
 		if (symbolP)
 		  {
 		    growth = S_GET_VALUE (symbolP);
-		    if (symbolP->sy_frag != &zero_address_frag)
-		      as_bad (".space specifies non-absolute value");
+		    if (symbol_get_frag (symbolP) != &zero_address_frag
+			|| S_IS_COMMON (symbolP)
+			|| ! S_IS_DEFINED (symbolP))
+		      as_bad_where (fragP->fr_file, fragP->fr_line,
+				    _(".space specifies non-absolute value"));
 		    fragP->fr_symbol = 0;
 		    if (growth < 0)
 		      {
-			as_warn (".space or .fill with negative value, ignored");
+			as_warn (_(".space or .fill with negative value, ignored"));
 			growth = 0;
 		      }
 		  }
@@ -2081,100 +2347,26 @@ relax_segment (segment_frag_root, segment)
 #else
 #ifdef TC_GENERIC_RELAX_TABLE
 		/* The default way to relax a frag is to look through
-		   md_relax_table.  */
-		{
-		  const relax_typeS *this_type;
-		  const relax_typeS *start_type;
-		  relax_substateT next_state;
-		  relax_substateT this_state;
-		  long aim;
-		  const relax_typeS *table = TC_GENERIC_RELAX_TABLE;
-
-		  this_state = fragP->fr_subtype;
-		  start_type = this_type = table + this_state;
-		  target = offset;
-
-		  if (symbolP)
-		    {
-#ifndef DIFF_EXPR_OK
-#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
-		      know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
-			    || (S_GET_SEGMENT (symbolP) == SEG_DATA)
-			    || (S_GET_SEGMENT (symbolP) == SEG_BSS)
-			    || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
-#endif
-		      know (symbolP->sy_frag);
-#endif
-		      know (!(S_GET_SEGMENT (symbolP) == absolute_section)
-			    || symbolP->sy_frag == &zero_address_frag);
-		      target +=
-			S_GET_VALUE (symbolP)
-			+ symbolP->sy_frag->fr_address;
-
-		      /* If frag has yet to be reached on this pass,
-			 assume it will move by STRETCH just as we did.
-			 If this is not so, it will be because some frag
-			 between grows, and that will force another pass.
-
-			 Beware zero-length frags.
-
-			 There should be a faster way to do this.  */
-
-		      if (symbolP->sy_frag->fr_address >= was_address
-			  && is_dnrange (fragP, symbolP->sy_frag))
-			{
-			  target += stretch;
-			}
-		    }
-
-		  aim = target - address - fragP->fr_fix;
-#ifdef TC_PCREL_ADJUST
-		  /* Currently only the ns32k family needs this */
-		  aim += TC_PCREL_ADJUST(fragP);
-#else
-		  /* This machine doesn't want to use pcrel_adjust.
-		     In that case, pcrel_adjust should be zero.  */
-		  assert (fragP->fr_pcrel_adjust == 0);
+		   TC_GENERIC_RELAX_TABLE.  */
+		growth = relax_frag (fragP, stretch);
+#endif /* TC_GENERIC_RELAX_TABLE */
 #endif
+		break;
 
-		  if (aim < 0)
-		    {
-		      /* Look backwards. */
-		      for (next_state = this_type->rlx_more; next_state;)
-			if (aim >= this_type->rlx_backward)
-			  next_state = 0;
-			else
-			  {
-			    /* Grow to next state. */
-			    this_state = next_state;
-			    this_type = table + this_state;
-			    next_state = this_type->rlx_more;
-			  }
-		    }
-		  else
-		    {
-#ifdef M68K_AIM_KLUDGE
-		      M68K_AIM_KLUDGE (aim, this_state, this_type);
-#endif
-		      /* Look forwards. */
-		      for (next_state = this_type->rlx_more; next_state;)
-			if (aim <= this_type->rlx_forward)
-			  next_state = 0;
-			else
-			  {
-			    /* Grow to next state. */
-			    this_state = next_state;
-			    this_type = table + this_state;
-			    next_state = this_type->rlx_more;
-			  }
-		    }
+	      case rs_leb128:
+		{
+		  valueT value;
+		  int size;
 
-		  growth = this_type->rlx_length - start_type->rlx_length;
-		  if (growth != 0)
-		    fragP->fr_subtype = this_state;
+		  value = resolve_symbol_value (fragP->fr_symbol, 0);
+		  size = sizeof_leb128 (value, fragP->fr_subtype);
+		  growth = size - fragP->fr_offset;
+		  fragP->fr_offset = size;
 		}
-#endif /* TC_GENERIC_RELAX_TABLE */
-#endif
+		break;
+
+	      case rs_cfa:
+		growth = eh_frame_relax_frag (fragP);
 		break;
 
 	      default:
@@ -2251,11 +2443,13 @@ fixup_segment (fixP, this_segment_type)
 
   for (; fixP; fixP = fixP->fx_next)
     {
+
 #ifdef DEBUG5
       fprintf (stderr, "\nprocessing fixup:\n");
       print_fixup (fixP);
 #endif
 
+
       fragP = fixP->fx_frag;
       know (fragP);
       where = fixP->fx_where;
@@ -2271,12 +2465,13 @@ fixup_segment (fixP, this_segment_type)
       plt = fixP->fx_plt;
 
       if (add_symbolP != NULL
-	  && add_symbolP->sy_mri_common)
+	  && symbol_mri_common_p (add_symbolP))
 	{
 	  know (add_symbolP->sy_value.X_op == O_symbol);
 	  add_number += S_GET_VALUE (add_symbolP);
 	  fixP->fx_offset = add_number;
-	  add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
+	  add_symbolP = fixP->fx_addsy =
+	    symbol_get_value_expression (add_symbolP)->X_add_symbol;
 	}
 
       if (add_symbolP)
@@ -2284,7 +2479,7 @@ fixup_segment (fixP, this_segment_type)
 
       if (sub_symbolP)
 	{
-	  resolve_symbol_value (sub_symbolP);
+	  resolve_symbol_value (sub_symbolP, 1);
 	  if (add_symbolP == NULL || add_symbol_segment == absolute_section)
 	    {
 	      if (add_symbolP != NULL)
@@ -2309,7 +2504,7 @@ fixup_segment (fixP, this_segment_type)
 	      else
 	      bad_sub_reloc:
 		as_bad_where (fixP->fx_file, fixP->fx_line,
-			      "Negative of non-absolute symbol %s",
+			      _("Negative of non-absolute symbol %s"),
 			      S_GET_NAME (sub_symbolP));
 	    }
 	  else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
@@ -2323,7 +2518,7 @@ fixup_segment (fixP, this_segment_type)
 		 as the target of a call instruction.  */
 	      if (fixP->fx_tcbit)
 		as_bad_where (fixP->fx_file, fixP->fx_line,
-			      "callj to difference of 2 symbols");
+			      _("callj to difference of 2 symbols"));
 #endif /* TC_I960 */
 	      add_number += S_GET_VALUE (add_symbolP) -
 		S_GET_VALUE (sub_symbolP);
@@ -2389,9 +2584,12 @@ fixup_segment (fixP, this_segment_type)
 		  char buf[50];
 		  sprint_value (buf, fragP->fr_address + where);
 		  as_bad_where (fixP->fx_file, fixP->fx_line,
-				"Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
+				_("Subtraction of two symbols in different sections \"%s\" {%s section} - \"%s\" {%s section} at file address %s."),
+				S_GET_NAME (add_symbolP),
+				segment_name (S_GET_SEGMENT (add_symbolP)),
+				S_GET_NAME (sub_symbolP),
 				segment_name (S_GET_SEGMENT (sub_symbolP)),
-				S_GET_NAME (sub_symbolP), buf);
+				buf);
 		}
 	    }
 	}
@@ -2430,7 +2628,8 @@ fixup_segment (fixP, this_segment_type)
 	    }
 	  else
 	    {
-	      if (add_symbol_segment == absolute_section)
+	      if (add_symbol_segment == absolute_section
+		  && ! pcrel)
 		{
 #ifdef TC_I960
 		  /* See comment about reloc_callj() above.  */
@@ -2463,7 +2662,7 @@ fixup_segment (fixP, this_segment_type)
 		       * relocation.
 		       */
 		      as_bad_where (fixP->fx_file, fixP->fx_line,
-				    "can't use COBR format with external label");
+				    _("can't use COBR format with external label"));
 		      fixP->fx_addsy = NULL;
 		      fixP->fx_done = 1;
 		      continue;
@@ -2481,11 +2680,17 @@ fixup_segment (fixP, this_segment_type)
 	      else
 		{
 		  seg_reloc_count++;
+#if !(defined (TC_V850) && defined (OBJ_ELF))
 #if !(defined (TC_M68K) && defined (OBJ_ELF))
-#if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
+#if !(defined (TC_ARM)  && defined (OBJ_ELF))
+#if !(defined (TC_I960) && defined (OBJ_ELF))
+#if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF)) || defined (TE_PE)
 		  add_number += S_GET_VALUE (add_symbolP);
 #endif
 #endif
+#endif
+#endif
+#endif
 		}
 	    }
 	}
@@ -2500,27 +2705,42 @@ fixup_segment (fixP, this_segment_type)
 #else
 	      fixP->fx_addsy = section_symbol (absolute_section);
 #endif
-	      fixP->fx_addsy->sy_used_in_reloc = 1;
+	      symbol_mark_used_in_reloc (fixP->fx_addsy);
 	      ++seg_reloc_count;
 	    }
 	}
 
+      if (!fixP->fx_done)
+	{
+#ifdef MD_APPLY_FIX3
+	  md_apply_fix3 (fixP, &add_number, this_segment_type);
+#else
+#ifdef BFD_ASSEMBLER
+	  md_apply_fix (fixP, &add_number);
+#else
+	  md_apply_fix (fixP, add_number);
+#endif
+#endif
+
+#ifndef TC_HANDLES_FX_DONE
+	  /* If the tc-* files haven't been converted, assume it's handling
+	     it the old way, where a null fx_addsy means that the fix has
+	     been applied completely, and no further work is needed.  */
+	  if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
+	    fixP->fx_done = 1;
+#endif
+	}
+
       if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && size > 0)
 	{
-	  valueT mask = 0;
-	  if (size < sizeof (mask))
+	  if ((size_t) size < sizeof (valueT))
 	    {
-	      /* set all bits to one */
-	      mask--;
-	      /* Technically, combining these produces an undefined result
-		 if size is sizeof (valueT), though I think these two
-		 half-way operations should both be defined.  And the
-		 compiler should be able to combine them if it's valid on
-		 the host architecture.  */
-	      mask <<= size * 4;
-	      mask <<= size * 4;
-	      if ((add_number & mask) != 0
-		  && (add_number & mask) != mask)
+	      valueT mask;
+
+	      mask = 0;
+	      mask--;		/* set all bits to one */
+	      mask <<= size * 8 - (fixP->fx_signed ? 1 : 0);
+	      if ((add_number & mask) != 0 && (add_number & mask) != mask)
 		{
 		  char buf[50], buf2[50];
 		  sprint_value (buf, fragP->fr_address + where);
@@ -2529,7 +2749,7 @@ fixup_segment (fixP, this_segment_type)
 		  else
 		    sprintf (buf2, "%ld", (long) add_number);
 		  as_bad_where (fixP->fx_file, fixP->fx_line,
-				"Value of %s too large for field of %d bytes at %s",
+				_("Value of %s too large for field of %d bytes at %s"),
 				buf2, size, buf);
 		} /* generic error checking */
 	    }
@@ -2541,34 +2761,15 @@ fixup_segment (fixP, this_segment_type)
 	      && size == 2
 	      && add_number > 0x7fff)
 	    as_bad_where (fixP->fx_file, fixP->fx_line,
-			  "Signed .word overflow; switch may be too large; %ld at 0x%lx",
+			  _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
 			  (long) add_number,
 			  (unsigned long) (fragP->fr_address + where));
 #endif
 	}			/* not a bit fix */
 
-      if (!fixP->fx_done)
-	{
-#ifdef MD_APPLY_FIX3
-	  md_apply_fix3 (fixP, &add_number, this_segment_type);
-#else
-#ifdef BFD_ASSEMBLER
-	  md_apply_fix (fixP, &add_number);
-#else
-	  md_apply_fix (fixP, add_number);
-#endif
-#endif
-
-#ifndef TC_HANDLES_FX_DONE
-	  /* If the tc-* files haven't been converted, assume it's handling
-	     it the old way, where a null fx_addsy means that the fix has
-	     been applied completely, and no further work is needed.  */
-	  if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
-	    fixP->fx_done = 1;
-#endif
-	}
 #ifdef TC_VALIDATE_FIX
-    skip: ;
+    skip:  ATTRIBUTE_UNUSED_LABEL
+      ;
 #endif
 #ifdef DEBUG5
       fprintf (stderr, "result:\n");
@@ -2588,7 +2789,7 @@ number_to_chars_bigendian (buf, val, n)
      valueT val;
      int n;
 {
-  if (n > sizeof (val)|| n <= 0)
+  if ((size_t) n > sizeof (val) || n <= 0)
     abort ();
   while (n--)
     {
@@ -2603,7 +2804,7 @@ number_to_chars_littleendian (buf, val, n)
      valueT val;
      int n;
 {
-  if (n > sizeof (val) || n <= 0)
+  if ((size_t) n > sizeof (val) || n <= 0)
     abort ();
   while (n--)
     {
@@ -2616,12 +2817,11 @@ void
 write_print_statistics (file)
      FILE *file;
 {
-  fprintf (stderr, "fixups: %d\n", n_fixups);
+  fprintf (file, "fixups: %d\n", n_fixups);
 }
 
 /* for debugging */
 extern int indent_level;
-extern void print_symbol_value_1 ();
 
 void
 print_fixup (fixp)
@@ -2669,6 +2869,9 @@ print_fixup (fixp)
       fprintf (stderr, ">");
     }
   fprintf (stderr, "\n");
+#ifdef TC_FIX_DATA_PRINT
+  TC_FIX_DATA_PRINT (stderr, fixp);
+#endif
 }
 
 /* end of write.c */