Changeset 609 for branches/GNU/src/binutils/gas/write.c

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/gas/write.c (modified) (71 diffs, 1 prop)

branches/GNU/src/binutils/gas/write.c

@@ -1 +1 @@
 /* write.c - emit .o file
    Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
-   1998, 1999, 2000, 2001
+   1998, 1999, 2000, 2001, 2002, 2003
    Free Software Foundation, Inc.
 
@@ -29 +29 @@
 #include "dwarf2dbg.h"
 
-/* This looks like a good idea.  Let's try turning it on always, for now.  */
-#undef  BFD_FAST_SECTION_FILL
-#define BFD_FAST_SECTION_FILL
-
 #ifndef TC_ADJUST_RELOC_COUNT
-#define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
+#define TC_ADJUST_RELOC_COUNT(FIX, COUNT)
 #endif
 
 #ifndef TC_FORCE_RELOCATION
-#define TC_FORCE_RELOCATION(FIXP) 0
-#endif
-
-#ifndef TC_FORCE_RELOCATION_SECTION
-#define TC_FORCE_RELOCATION_SECTION(FIXP,SEG) TC_FORCE_RELOCATION(FIXP)
+#define TC_FORCE_RELOCATION(FIX)                \
+  (generic_force_reloc (FIX))
+#endif
+
+#ifndef TC_FORCE_RELOCATION_ABS
+#define TC_FORCE_RELOCATION_ABS(FIX)            \
+  (TC_FORCE_RELOCATION (FIX))
+#endif
+
+#ifndef TC_FORCE_RELOCATION_LOCAL
+#define TC_FORCE_RELOCATION_LOCAL(FIX)          \
+  (!(FIX)->fx_pcrel                             \
+   || (FIX)->fx_plt                             \
+   || TC_FORCE_RELOCATION (FIX))
+#endif
+
+#ifndef TC_FORCE_RELOCATION_SUB_SAME
+#define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG)  \
+  (! SEG_NORMAL (SEG))
+#endif
+
+#ifndef TC_FORCE_RELOCATION_SUB_ABS
+#define TC_FORCE_RELOCATION_SUB_ABS(FIX)        0
+#endif
+
+#ifndef TC_FORCE_RELOCATION_SUB_LOCAL
+#ifdef DIFF_EXPR_OK
+#define TC_FORCE_RELOCATION_SUB_LOCAL(FIX)      0
+#else
+#define TC_FORCE_RELOCATION_SUB_LOCAL(FIX)      1
+#endif
+#endif
+
+#ifndef TC_VALIDATE_FIX_SUB
+#ifdef UNDEFINED_DIFFERENCE_OK
+/* The PA needs this for PIC code generation.  */
+#define TC_VALIDATE_FIX_SUB(FIX) 1
+#else
+#ifdef BFD_ASSEMBLER
+#define TC_VALIDATE_FIX_SUB(FIX)                \
+  ((FIX)->fx_r_type == BFD_RELOC_GPREL32        \
+   || (FIX)->fx_r_type == BFD_RELOC_GPREL16)
+#else
+#define TC_VALIDATE_FIX_SUB(FIX) 0
+#endif
+#endif
 #endif
 
@@ -49 +86 @@
 #endif
 
-#ifndef TC_FIX_ADJUSTABLE
-#define TC_FIX_ADJUSTABLE(fix) 1
+#ifndef MD_APPLY_SYM_VALUE
+#define MD_APPLY_SYM_VALUE(FIX) 1
+#endif
+
+#ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
+#define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
 #endif
 
 #ifndef MD_PCREL_FROM_SECTION
-#define MD_PCREL_FROM_SECTION(FIXP, SEC) md_pcrel_from(FIXP)
+#define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
 #endif
 
 #ifndef WORKING_DOT_WORD
-extern CONST int md_short_jump_size;
-extern CONST int md_long_jump_size;
-#endif
+extern const int md_short_jump_size;
+extern const int md_long_jump_size;
+#endif
+
+/* Used to control final evaluation of expressions.  */
+int finalize_syms = 0;
 
 int symbol_table_frozen;
+
+symbolS *abs_section_sym;
+
+/* Remember the value of dot when parsing expressions.  */
+addressT dot_value;
+
 void print_fixup PARAMS ((fixS *));
 
@@ -103 +153 @@
 
 #ifdef BFD_ASSEMBLER
+#define RELOC_ENUM enum bfd_reloc_code_real
+#else
+#define RELOC_ENUM int
+#endif
+
 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
                                        symbolS *add, symbolS *sub,
                                        offsetT offset, int pcrel,
-                                       bfd_reloc_code_real_type r_type));
-#else
-static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
-                                       symbolS *add, symbolS *sub,
-                                       offsetT offset, int pcrel,
-                                       int r_type));
-#endif
+                                       RELOC_ENUM r_type));
 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
-static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
+static long fixup_segment PARAMS ((fixS *, segT));
 #endif
 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
@@ -123 +172 @@
 static void chain_frchains_together PARAMS ((bfd *, segT, PTR));
 static void cvt_frag_to_fill PARAMS ((segT, fragS *));
-static void relax_seg PARAMS ((bfd *, asection *, PTR));
-static void size_seg PARAMS ((bfd *, asection *, PTR));
 static void adjust_reloc_syms PARAMS ((bfd *, asection *, PTR));
+static void fix_segment PARAMS ((bfd *, asection *, PTR));
 static void write_relocs PARAMS ((bfd *, asection *, PTR));
 static void write_contents PARAMS ((bfd *, asection *, PTR));
@@ -137 +185 @@
 static void remove_subsegs PARAMS ((frchainS *, int, fragS **, fragS **));
 static void relax_and_size_all_segments PARAMS ((void));
-#endif
-#if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
-static void set_segment_vma PARAMS ((bfd *, asection *, PTR));
 #endif
 
@@ -154 +199 @@
      offsetT offset;            /* X_add_number.  */
      int pcrel;                 /* TRUE if PC-relative relocation.  */
-#ifdef BFD_ASSEMBLER
-     bfd_reloc_code_real_type r_type; /* Relocation type.  */
-#else
-     int r_type;                /* Relocation type.  */
-#endif
+     RELOC_ENUM r_type ATTRIBUTE_UNUSED; /* Relocation type.  */
 {
   fixS *fixP;
@@ -178 +219 @@
   fixP->fx_subsy = sub_symbol;
   fixP->fx_offset = offset;
+  fixP->fx_dot_value = dot_value;
   fixP->fx_pcrel = pcrel;
   fixP->fx_plt = 0;
@@ -249 +291 @@
      offsetT offset;            /* X_add_number.  */
      int pcrel;                 /* TRUE if PC-relative relocation.  */
-#ifdef BFD_ASSEMBLER
-     bfd_reloc_code_real_type r_type; /* Relocation type.  */
-#else
-     int r_type;                /* Relocation type.  */
-#endif
+     RELOC_ENUM r_type;         /* Relocation type.  */
 {
   return fix_new_internal (frag, where, size, add_symbol,
@@ -270 +308 @@
      expressionS *exp;          /* Expression.  */
      int pcrel;                 /* TRUE if PC-relative relocation.  */
-#ifdef BFD_ASSEMBLER
-     bfd_reloc_code_real_type r_type; /* Relocation type.  */
-#else
-     int r_type;                /* Relocation type.  */
-#endif
+     RELOC_ENUM r_type;         /* Relocation type.  */
 {
   symbolS *add = NULL;
@@ -339 +373 @@
 
   return fix_new_internal (frag, where, size, add, sub, off, pcrel, r_type);
+}
+
+/* Generic function to determine whether a fixup requires a relocation.  */
+int
+generic_force_reloc (fix)
+     fixS *fix;
+{
+#ifdef BFD_ASSEMBLER
+  if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
+      || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
+    return 1;
+#endif
+  return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
 }
 
@@ -523 +570 @@
                         _("attempt to .org/.space backwards? (%ld)"),
                         (long) fragP->fr_offset);
+          fragP->fr_offset = 0;
         }
       fragP->fr_type = rs_fill;
@@ -599 +647 @@
 
 #ifdef BFD_ASSEMBLER
+static void relax_seg PARAMS ((bfd *, asection *, PTR));
 static void
-relax_seg (abfd, sec, do_code)
-     bfd *abfd;
+relax_seg (abfd, sec, xxx)
+     bfd *abfd ATTRIBUTE_UNUSED;
      asection *sec;
-     PTR do_code;
-{
-  flagword flags = bfd_get_section_flags (abfd, sec);
+     PTR xxx;
+{
   segment_info_type *seginfo = seg_info (sec);
 
-  if (!(flags & SEC_CODE) == !do_code
-      && seginfo && seginfo->frchainP)
-    relax_segment (seginfo->frchainP->frch_root, sec);
-}
-
+  if (seginfo && seginfo->frchainP
+      && relax_segment (seginfo->frchainP->frch_root, sec))
+    {
+      int *result = (int *) xxx;
+      *result = 1;
+    }
+}
+
+static void size_seg PARAMS ((bfd *, asection *, PTR));
 static void
 size_seg (abfd, sec, xxx)
@@ -653 +705 @@
     flags &= ~SEC_RELOC;
   x = bfd_set_section_flags (abfd, sec, flags);
-  assert (x == true);
+  assert (x);
 
   newsize = md_section_align (sec, size);
   x = bfd_set_section_size (abfd, sec, newsize);
-  assert (x == true);
+  assert (x);
 
   /* If the size had to be rounded up, add some padding in the last
@@ -669 +721 @@
         fragp = fragp->fr_next;
       last->fr_address = size;
-      fragp->fr_offset += newsize - size;
+      if ((newsize - size) % fragp->fr_var == 0)
+        fragp->fr_offset += (newsize - size) / fragp->fr_var;
+      else
+        /* If we hit this abort, it's likely due to subsegs_finish not
+           providing sufficient alignment on the last frag, and the
+           machine dependent code using alignment frags with fr_var
+           greater than 1.  */
+        abort ();
     }
 
@@ -719 +778 @@
 #endif
 
+/* This pass over fixups decides whether symbols can be replaced with
+   section symbols.  */
+
 static void
 adjust_reloc_syms (abfd, sec, xxx)
@@ -753 +815 @@
            symbols, though, since they are not in the regular symbol
            table.  */
-        if (sym != NULL)
-          resolve_symbol_value (sym, 1);
+        resolve_symbol_value (sym);
 
         if (fixp->fx_subsy != NULL)
-          resolve_symbol_value (fixp->fx_subsy, 1);
+          resolve_symbol_value (fixp->fx_subsy);
 
         /* 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)))
+        if (symbol_equated_reloc_p (sym))
           {
             fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
@@ -769 +829 @@
           }
 
-        if (sym != NULL && symbol_mri_common_p (sym))
+        if (symbol_mri_common_p (sym))
           {
             /* These symbols are handled specially in fixup_segment.  */
-            goto done;
+            continue;
           }
 
+        /* If the symbol is undefined, common, weak, or global (ELF
+           shared libs), we can't replace it with the section symbol.  */
+        if (S_FORCE_RELOC (fixp->fx_addsy, 1))
+          continue;
+
+        /* Is there some other (target cpu dependent) reason we can't adjust
+           this one?  (E.g. relocations involving function addresses on
+           the PA.  */
+#ifdef tc_fix_adjustable
+        if (! tc_fix_adjustable (fixp))
+          continue;
+#endif
+
+        /* Since we're reducing to section symbols, don't attempt to reduce
+           anything that's already using one.  */
+        if (symbol_section_p (sym))
+          continue;
+
         symsec = S_GET_SEGMENT (sym);
-
         if (symsec == NULL)
           abort ();
@@ -782 +859 @@
         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))
-              {
-                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;
-          }
-
-        /* If it's one of these sections, assume the symbol is
-           definitely going to be output.  The code in
-           md_estimate_size_before_relax in tc-mips.c uses this test
-           as well, so if you change this code you should look at that
-           code.  */
-        if (bfd_is_und_section (symsec)
-            || bfd_is_com_section (symsec))
-          {
-            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)
-              symbol_mark_used_in_reloc (fixp->fx_subsy);
-#endif
-            goto done;
+            /* The fixup_segment routine normally will not use this
+               symbol in a relocation.  */
+            continue;
           }
 
@@ -820 +870 @@
         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;
-              }
+            if ((symsec->flags & SEC_LINK_ONCE) != 0
+                || (IS_ELF
+                    /* The GNU toolchain uses an extension for ELF: a
+                       section beginning with the magic string
+                       .gnu.linkonce is a linkonce section.  */
+                    && strncmp (segment_name (symsec), ".gnu.linkonce",
+                                sizeof ".gnu.linkonce" - 1) == 0))
+              continue;
           }
 
-        /* Since we're reducing to section symbols, don't attempt to reduce
-           anything that's already using one.  */
-        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))
-          {
-            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))
-          {
-            symbol_mark_used_in_reloc (fixp->fx_addsy);
-            goto done;
-          }
-#endif
-
-        /* Is there some other (target cpu dependent) reason we can't adjust
-           this one?  (E.g. relocations involving function addresses on
-           the PA.  */
-#ifdef tc_fix_adjustable
-        if (! tc_fix_adjustable (fixp))
-          {
-            symbol_mark_used_in_reloc (fixp->fx_addsy);
-            goto done;
-          }
-#endif
-
-        /* 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.
-
-           We refetch the segment when calling section_symbol, rather
+        /* Never adjust a reloc against local symbol in a merge section
+           with non-zero addend.  */
+        if ((symsec->flags & SEC_MERGE) != 0
+            && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL))
+          continue;
+
+        /* Never adjust a reloc against TLS local symbol.  */
+        if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
+          continue;
+
+        /* We refetch the segment when calling section_symbol, rather
            than using symsec, because S_GET_VALUE may wind up changing
            the section when it calls resolve_symbol_value.  */
         fixp->fx_offset += S_GET_VALUE (sym);
         fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
-        symbol_mark_used_in_reloc (fixp->fx_addsy);
 #ifdef DEBUG5
         fprintf (stderr, "\nadjusted fixup:\n");
         print_fixup (fixp);
 #endif
-
-      done:
-        ;
       }
-#if 1 /* def RELOC_REQUIRES_SYMBOL  */
-    else
-      {
-        /* There was no symbol required by this relocation.  However,
-           BFD doesn't really handle relocations without symbols well.
-           (At least, the COFF support doesn't.)  So for now we fake up
-           a local symbol in the absolute section.  */
-
-        fixp->fx_addsy = section_symbol (absolute_section);
-#if 0
-        fixp->fx_addsy->sy_used_in_reloc = 1;
-#endif
-      }
-#endif
 
   dump_section_relocs (abfd, sec, stderr);
+}
+
+static void
+fix_segment (abfd, sec, xxx)
+     bfd *abfd ATTRIBUTE_UNUSED;
+     asection *sec;
+     PTR xxx ATTRIBUTE_UNUSED;
+{
+  segment_info_type *seginfo = seg_info (sec);
+
+  fixup_segment (seginfo->fix_root, sec);
 }
 
@@ -943 +933 @@
     return;
 
-  fixup_segment (seginfo->fix_root, sec);
-
   n = 0;
   for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
@@ -968 +956 @@
 
       /* If this is an undefined symbol which was equated to another
-         symbol, then use generate the reloc against the latter symbol
+         symbol, then generate the reloc against the latter symbol
          rather than the former.  */
       sym = fixp->fx_addsy;
-      while (symbol_equated_p (sym)
-             && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
+      while (symbol_equated_reloc_p (sym))
         {
           symbolS *n;
@@ -1009 +996 @@
           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"));
+          as_bad_where (fixp->fx_file, fixp->fx_line,
+                        _("relocation out of range"));
           break;
         default:
@@ -1029 +1018 @@
     {
       arelent **reloc;
-      char *data;
       bfd_reloc_status_type s;
       symbolS *sym;
@@ -1044 +1032 @@
          rather than the former.  */
       sym = fixp->fx_addsy;
-      while (symbol_equated_p (sym)
-             && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
-        sym = symbol_get_value_expression (sym)->X_add_symbol;
+      while (symbol_equated_reloc_p (sym))
+        {
+          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;
 
@@ -1056 +1053 @@
           assert (i <= n);
         }
-      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)
@@ -1075 +1071 @@
                             _("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_install_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);
             }
         }
@@ -1160 +1160 @@
                                         f->fr_literal, (file_ptr) offset,
                                         (bfd_size_type) f->fr_fix);
-          if (x == false)
+          if (!x)
             {
               bfd_perror (stdoutput->filename);
@@ -1184 +1184 @@
                                                 (file_ptr) offset,
                                                 (bfd_size_type) fill_size);
-                  if (x == false)
+                  if (!x)
                     {
                       bfd_perror (stdoutput->filename);
@@ -1218 +1218 @@
                     (stdoutput, sec, buf, (file_ptr) offset,
                      (bfd_size_type) n_per_buf * fill_size);
-                  if (x != true)
-                    as_fatal (_("Cannot write to output file."));
+                  if (!x)
+                    as_fatal (_("cannot write to output file"));
                   offset += n_per_buf * fill_size;
                 }
@@ -1352 +1352 @@
   asymbol **asympp;
   symbolS *symp;
-  boolean result;
-  extern PTR bfd_alloc PARAMS ((bfd *, size_t));
+  bfd_boolean result;
+  extern PTR bfd_alloc PARAMS ((bfd *, bfd_size_type));
 
   /* Count symbols.  We can't rely on a count made by the loop in
@@ -1365 +1365 @@
     {
       int i;
-
-      asympp = (asymbol **) bfd_alloc (stdoutput,
-                                       nsyms * sizeof (asymbol *));
+      bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
+
+      asympp = (asymbol **) bfd_alloc (stdoutput, amt);
       symp = symbol_rootP;
       for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
@@ -1378 +1378 @@
     asympp = 0;
   result = bfd_set_symtab (stdoutput, asympp, nsyms);
-  assert (result == true);
+  assert (result);
   symbol_table_frozen = 1;
 }
 #endif
-
-#if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
-static void
-set_segment_vma (abfd, sec, xxx)
-     bfd *abfd;
-     asection *sec;
-     PTR xxx ATTRIBUTE_UNUSED;
-{
-  static bfd_vma addr = 0;
-
-  bfd_set_section_vma (abfd, sec, addr);
-  addr += bfd_section_size (abfd, sec);
-}
-#endif /* BFD_ASSEMBLER && OBJ_COFF && !TE_PE  */
 
 /* Finish the subsegments.  After every sub-segment, we fake an
@@ -1404 +1390 @@
 
 #ifndef SUB_SEGMENT_ALIGN
+#ifdef HANDLE_ALIGN
+/* The last subsegment gets an aligment corresponding to the alignment
+   of the section.  This allows proper nop-filling at the end of
+   code-bearing sections.  */
+#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN)                                 \
+  (!(FRCHAIN)->frch_next || (FRCHAIN)->frch_next->frch_seg != (SEG)     \
+   ? get_recorded_alignment (SEG) : 0)
+#else
 #ifdef BFD_ASSEMBLER
-#define SUB_SEGMENT_ALIGN(SEG) (0)
+#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
 #else
-#define SUB_SEGMENT_ALIGN(SEG) (2)
+#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 2
+#endif
 #endif
 #endif
@@ -1418 +1413 @@
   for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
     {
-      int alignment;
+      int alignment = 0;
 
       subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
@@ -1425 +1420 @@
          any alignment is meaningless, and, moreover, will look weird
          if we are generating a listing.  */
-      alignment = had_errors () ? 0 : SUB_SEGMENT_ALIGN (now_seg);
-
-      /* The last subsegment gets an aligment corresponding to the
-         alignment of the section.  This allows proper nop-filling
-         at the end of code-bearing sections.  */
-      if (!frchainP->frch_next || frchainP->frch_next->frch_seg != now_seg)
-        alignment = get_recorded_alignment (now_seg);
+      if (!had_errors ())
+        {
+          alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
+#ifdef BFD_ASSEMBLER
+          if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
+              && now_seg->entsize)
+            {
+              unsigned int entsize = now_seg->entsize;
+              int entalign = 0;
+
+              while ((entsize & 1) == 0)
+                {
+                  ++entalign;
+                  entsize >>= 1;
+                }
+              if (entalign > alignment)
+                alignment = entalign;
+            }
+#endif
+        }
 
       if (subseg_text_p (now_seg))
@@ -1468 +1476 @@
       {
         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_errs, n_errs == 1 ? "" : "s",
                    n_warns, n_warns == 1 ? "" : "s");
@@ -1475 +1483 @@
       {
         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_errs, n_errs == 1 ? "" : "s",
                     n_warns, n_warns == 1 ? "" : "s");
@@ -1494 +1502 @@
   /* Remove the sections created by gas for its own purposes.  */
   {
-    asection **seclist, *sec;
+    asection **seclist;
     int i;
 
     seclist = &stdoutput->sections;
-    while (seclist && *seclist)
+    while (*seclist)
       {
-        sec = *seclist;
-        while (sec == reg_section || sec == expr_section)
+        if (*seclist == reg_section || *seclist == expr_section)
           {
-            sec = sec->next;
-            *seclist = sec;
+            bfd_section_list_remove (stdoutput, seclist);
             stdoutput->section_count--;
-            if (!sec)
-              break;
           }
-        if (*seclist)
+        else
           seclist = &(*seclist)->next;
       }
@@ -1534 +1538 @@
 
 #ifdef BFD_ASSEMBLER
-  bfd_map_over_sections (stdoutput, relax_seg, (char *) 1);
-  bfd_map_over_sections (stdoutput, relax_seg, (char *) 0);
+  while (1)
+    {
+      int changed;
+
+#ifndef WORKING_DOT_WORD
+      /* We need to reset the markers in the broken word list and
+         associated frags between calls to relax_segment (via
+         relax_seg).  Since the broken word list is global, we do it
+         once per round, rather than locally in relax_segment for each
+         segment.  */
+      struct broken_word *brokp;
+
+      for (brokp = broken_words;
+           brokp != (struct broken_word *) NULL;
+           brokp = brokp->next_broken_word)
+        {
+          brokp->added = 0;
+
+          if (brokp->dispfrag != (fragS *) NULL
+              && brokp->dispfrag->fr_type == rs_broken_word)
+            brokp->dispfrag->fr_subtype = 0;
+        }
+#endif
+
+      changed = 0;
+      bfd_map_over_sections (stdoutput, relax_seg, &changed);
+      if (!changed)
+        break;
+    }
+
+  /* Note - Most ports will use the default value of
+     TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1.  This will force
+     local symbols to be resolved, removing their frag information.
+     Some ports however, will not have finished relaxing all of
+     their frags and will still need the local symbol frag
+     information.  These ports can set
+     TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0.  */
+  finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
+
   bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
 #else
@@ -1541 +1582 @@
 #endif /* BFD_ASSEMBLER  */
 
-#if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
-  /* Now that the segments have their final sizes, run through the
-     sections and set their vma and lma. !BFD gas sets them, and BFD gas
-     should too. Currently, only DJGPP uses this code, but other
-     COFF targets may need to execute this too.  */
-  bfd_map_over_sections (stdoutput, set_segment_vma, (char *) 0);
+  /* Relaxation has completed.  Freeze all syms.  */
+  finalize_syms = 1;
+
+#ifdef md_post_relax_hook
+  md_post_relax_hook;
 #endif
 
@@ -1600 +1640 @@
             || fragP->fr_next == data_frag_root
 #endif
-            || ((fragP->fr_next->fr_address - fragP->fr_address)
+            || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
                 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
         abort ();
@@ -1695 +1735 @@
             /* This is the offset from ??? to table_ptr+0.  */
             to_addr = table_addr - S_GET_VALUE (lie->sub);
-#ifdef BFD_ASSEMBLER
-            to_addr -= symbol_get_frag (lie->sub)->fr_address;
-#endif
 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
             TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie);
@@ -1714 +1751 @@
             from_addr = table_addr;
             to_addr = S_GET_VALUE (lie->add) + lie->addnum;
-#ifdef BFD_ASSEMBLER
-            to_addr += symbol_get_frag (lie->add)->fr_address;
-#endif
             md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
                                  lie->add);
@@ -1834 +1868 @@
 
 #ifdef BFD_HEADERS
-    bfd_seek (stdoutput, 0, 0);
-    bfd_write (the_object_file, 1, object_file_size, stdoutput);
+    bfd_seek (stdoutput, (file_ptr) 0, 0);
+    bfd_bwrite (the_object_file, (bfd_size_type) object_file_size, stdoutput);
 #else
 
@@ -1859 +1893 @@
 
       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
-        resolve_symbol_value (symp, 1);
+        resolve_symbol_value (symp);
     }
   resolve_local_symbol_values ();
@@ -1873 +1907 @@
 
   bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
+
+#ifdef tc_frob_file_before_fix
+  tc_frob_file_before_fix ();
+#endif
+#ifdef obj_frob_file_before_fix
+  obj_frob_file_before_fix ();
+#endif
+
+  bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
 
   /* Set up symbol table, and write it out.  */
@@ -1901 +1944 @@
                  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);
             }
 
@@ -1907 +1950 @@
              more symbols.  They'll probably only be section symbols,
              but they'll still need to have the values computed.  */
-          resolve_symbol_value (symp, 1);
+          resolve_symbol_value (symp);
 
           /* Skip symbols which were equated to undefined or common
              symbols.  */
-          if (symbol_equated_p (symp)
-              && (! S_IS_DEFINED (symp) || S_IS_COMMON (symp)))
+          if (symbol_equated_reloc_p (symp))
             {
               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
@@ -1944 +1986 @@
              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
-               && symbol_section_p (symp))
+          if (symp == abs_section_sym
+              || (! EMIT_SECTION_SYMBOLS
+                  && 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)
+                  && (punt || S_IS_LOCAL (symp))
                   && ! symbol_used_in_reloc_p (symp)))
             {
@@ -1964 +2007 @@
           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));
               symbol_mark_resolved (symp);
@@ -2058 +2101 @@
       know (sym_frag != NULL);
 #endif
-      know (!(S_GET_SEGMENT (symbolP) == absolute_section)
+      know (S_GET_SEGMENT (symbolP) != absolute_section
             || sym_frag == &zero_address_frag);
-      target += S_GET_VALUE (symbolP) + sym_frag->fr_address;
+      target += S_GET_VALUE (symbolP);
 
       /* If frag has yet to be reached on this pass,
@@ -2158 +2201 @@
    addresses.  */
 
-void
+int
 relax_segment (segment_frag_root, segment)
      struct frag *segment_frag_root;
@@ -2165 +2208 @@
   register struct frag *fragP;
   register relax_addressT address;
+  int ret;
+
 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
   know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
@@ -2197 +2242 @@
             if (offset % fragP->fr_var != 0)
               {
-                as_bad (_("alignment padding (%lu bytes) not a multiple of %ld"),
-                        (unsigned long) offset, (long) fragP->fr_var);
+                as_bad_where (fragP->fr_file, fragP->fr_line,
+                              _("alignment padding (%lu bytes) not a multiple of %ld"),
+                              (unsigned long) offset, (long) fragP->fr_var);
                 offset -= (offset % fragP->fr_var);
               }
@@ -2212 +2258 @@
 
         case rs_machine_dependent:
+          /* If fr_symbol is an expression, this call to
+             resolve_symbol_value sets up the correct segment, which will
+             likely be needed in md_estimate_size_before_relax.  */
+          if (fragP->fr_symbol)
+            resolve_symbol_value (fragP->fr_symbol);
+
           address += md_estimate_size_before_relax (fragP, segment);
           break;
@@ -2298 +2350 @@
                         continue;
 
-                      offset = (symbol_get_frag (lie->add)->fr_address
-                                + S_GET_VALUE (lie->add)
+                      offset = (S_GET_VALUE (lie->add)
                                 + lie->addnum
-                                - (symbol_get_frag (lie->sub)->fr_address
-                                   + S_GET_VALUE (lie->sub)));
+                                - S_GET_VALUE (lie->sub));
                       if (offset <= -32768 || offset >= 32767)
                         {
@@ -2309 +2359 @@
                               char buf[50];
                               sprint_value (buf, (addressT) lie->addnum);
-                              as_warn (_(".word %s-%s+%s didn't fit"),
-                                       S_GET_NAME (lie->add),
-                                       S_GET_NAME (lie->sub),
-                                       buf);
+                              as_warn_where (fragP->fr_file, fragP->fr_line,
+                                             _(".word %s-%s+%s didn't fit"),
+                                             S_GET_NAME (lie->add),
+                                             S_GET_NAME (lie->sub),
+                                             buf);
                             }
                           lie->added = 1;
@@ -2377 +2428 @@
                             || (symbolP->sy_frag == &zero_address_frag));
 #endif
-                      target += (S_GET_VALUE (symbolP)
-                                 + symbol_get_frag (symbolP)->fr_address);
-                    }           /* if we have a symbol  */
+                      /* Convert from an actual address to an octet offset
+                         into the section.  Here it is assumed that the
+                         section's VMA is zero, and can omit subtracting it
+                         from the symbol's value to get the address offset.  */
+                      know (S_GET_SECTION (symbolP)->vma == 0);
+                      target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
+                    }
 
                   know (fragP->fr_next);
@@ -2390 +2445 @@
                          .org backwards.  */
                       as_bad_where (fragP->fr_file, fragP->fr_line,
-                                    _("attempt to .org backwards ignored"));
+                                    _("attempt to .org backwards"));
 
                       /* We've issued an error message.  Change the
@@ -2407 +2462 @@
 
               case rs_space:
+                growth = 0;
                 if (symbolP)
                   {
-                    growth = S_GET_VALUE (symbolP);
-                    if (symbol_get_frag (symbolP) != &zero_address_frag
+                    offsetT amount;
+
+                    amount = S_GET_VALUE (symbolP);
+                    if (S_GET_SEGMENT (symbolP) != absolute_section
                         || 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"));
-                        growth = 0;
+                        as_bad_where (fragP->fr_file, fragP->fr_line,
+                                      _(".space specifies non-absolute value"));
+                        /* Prevent repeat of this error message.  */
+                        fragP->fr_symbol = 0;
                       }
+                    else if (amount < 0)
+                      {
+                        as_warn_where (fragP->fr_file, fragP->fr_line,
+                                       _(".space or .fill with negative value, ignored"));
+                        fragP->fr_symbol = 0;
+                      }
+                    else
+                      growth = (was_address + fragP->fr_fix + amount
+                                - fragP->fr_next->fr_address);
                   }
-                else
-                  growth = 0;
                 break;
 
@@ -2443 +2506 @@
                   int size;
 
-                  value = resolve_symbol_value (fragP->fr_symbol, 0);
+                  value = resolve_symbol_value (fragP->fr_symbol);
                   size = sizeof_leb128 (value, fragP->fr_subtype);
                   growth = size - fragP->fr_offset;
@@ -2472 +2535 @@
   }                             /* do_relax  */
 
-  /* We now have valid fr_address'es for each frag.  */
-
-  /* All fr_address's are correct, relative to their own segment.
-     We have made all the fixS we will ever make.  */
+  ret = 0;
+  for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
+    if (fragP->last_fr_address != fragP->fr_address)
+      {
+        fragP->last_fr_address = fragP->fr_address;
+        ret = 1;
+      }
+  return ret;
 }
 
 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
-
-#ifndef TC_RELOC_RTSYM_LOC_FIXUP
-#define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
-#endif
 
 /* fixup_segment()
@@ -2489 +2552 @@
    handled now.  (These consist of fixS where we have since discovered
    the value of a symbol, or the address of the frag involved.)
-   For each one, call md_apply_fix to put the fix into the frag data.
+   For each one, call md_apply_fix3 to put the fix into the frag data.
 
    Result is a count of how many relocation structs will be needed to
@@ -2496 +2559 @@
 
 static long
-fixup_segment (fixP, this_segment_type)
-     register fixS *fixP;
-     segT this_segment_type;    /* N_TYPE bits for segment.  */
+fixup_segment (fixP, this_segment)
+     fixS *fixP;
+     segT this_segment;
 {
   long seg_reloc_count = 0;
-  symbolS *add_symbolP;
-  symbolS *sub_symbolP;
   valueT add_number;
-  int size;
-  char *place;
-  long where;
-  int pcrel, plt;
   fragS *fragP;
   segT add_symbol_segment = absolute_section;
 
+  if (fixP != NULL && abs_section_sym == NULL)
+    {
+#ifndef BFD_ASSEMBLER
+      abs_section_sym = &abs_symbol;
+#else
+      abs_section_sym = section_symbol (absolute_section);
+#endif
+    }
+
   /* If the linker is doing the relaxing, we must not do any fixups.
 
-     Well, strictly speaking that's not true -- we could do any that are
-     PC-relative and don't cross regions that could change size.  And for the
-     i960 (the only machine for which we've got a relaxing linker right now),
-     we might be able to turn callx/callj into bal anyways in cases where we
-     know the maximum displacement.  */
-  if (linkrelax && TC_LINKRELAX_FIXUP (this_segment_type))
+     Well, strictly speaking that's not true -- we could do any that
+     are PC-relative and don't cross regions that could change size.
+     And for the i960 we might be able to turn callx/callj into bal
+     anyways in cases where we know the maximum displacement.  */
+  if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
     {
       for (; fixP; fixP = fixP->fx_next)
-        seg_reloc_count++;
+        if (!fixP->fx_done)
+          {
+            if (fixP->fx_addsy == NULL)
+              {
+                /* There was no symbol required by this relocation.
+                   However, BFD doesn't really handle relocations
+                   without symbols well. So fake up a local symbol in
+                   the absolute section.  */
+                fixP->fx_addsy = abs_section_sym;
+              }
+            symbol_mark_used_in_reloc (fixP->fx_addsy);
+            if (fixP->fx_subsy != NULL)
+              symbol_mark_used_in_reloc (fixP->fx_subsy);
+            seg_reloc_count++;
+          }
       TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
       return seg_reloc_count;
@@ -2535 +2614 @@
       fragP = fixP->fx_frag;
       know (fragP);
-      where = fixP->fx_where;
-      place = fragP->fr_literal + where;
-      size = fixP->fx_size;
-      add_symbolP = fixP->fx_addsy;
 #ifdef TC_VALIDATE_FIX
-      TC_VALIDATE_FIX (fixP, this_segment_type, skip);
-#endif
-      sub_symbolP = fixP->fx_subsy;
+      TC_VALIDATE_FIX (fixP, this_segment, skip);
+#endif
       add_number = fixP->fx_offset;
-      pcrel = fixP->fx_pcrel;
-      plt = fixP->fx_plt;
-
-      if (add_symbolP != NULL
-          && symbol_mri_common_p (add_symbolP))
+
+      if (fixP->fx_addsy != NULL
+          && symbol_mri_common_p (fixP->fx_addsy))
         {
-          know (add_symbolP->sy_value.X_op == O_symbol);
-          add_number += S_GET_VALUE (add_symbolP);
+          know (fixP->fx_addsy->sy_value.X_op == O_symbol);
+          add_number += S_GET_VALUE (fixP->fx_addsy);
           fixP->fx_offset = add_number;
-          add_symbolP = fixP->fx_addsy =
-            symbol_get_value_expression (add_symbolP)->X_add_symbol;
+          fixP->fx_addsy
+            = symbol_get_value_expression (fixP->fx_addsy)->X_add_symbol;
         }
 
-      if (add_symbolP)
-        add_symbol_segment = S_GET_SEGMENT (add_symbolP);
-
-      if (sub_symbolP)
+      if (fixP->fx_addsy != NULL)
+        add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
+
+      if (fixP->fx_subsy != NULL)
         {
-          resolve_symbol_value (sub_symbolP, 1);
-          if (add_symbolP == NULL || add_symbol_segment == absolute_section)
+          segT sub_symbol_segment;
+          resolve_symbol_value (fixP->fx_subsy);
+          sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
+          if (fixP->fx_addsy != NULL
+              && sub_symbol_segment == add_symbol_segment
+              && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
             {
-              if (add_symbolP != NULL)
-                {
-                  add_number += S_GET_VALUE (add_symbolP);
-                  add_symbolP = NULL;
-                  fixP->fx_addsy = NULL;
-                }
-
-              /* It's just -sym.  */
-              if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
-                {
-                  add_number -= S_GET_VALUE (sub_symbolP);
-                  fixP->fx_subsy = NULL;
-                }
-              else if (pcrel
-                       && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
-                {
-                  /* Should try converting to a constant.  */
-                  goto bad_sub_reloc;
-                }
-              else
-              bad_sub_reloc:
-                as_bad_where (fixP->fx_file, fixP->fx_line,
-                              _("Negative of non-absolute symbol %s"),
-                              S_GET_NAME (sub_symbolP));
+              add_number += S_GET_VALUE (fixP->fx_addsy);
+              add_number -= S_GET_VALUE (fixP->fx_subsy);
+              fixP->fx_offset = add_number;
+              /* If the back-end code has selected a pc-relative
+                 reloc, adjust the value to be pc-relative.  */
+              if (1
+#ifdef TC_M68K
+                  /* See the comment below about 68k weirdness.  */
+                  && 0
+#endif
+                  && fixP->fx_pcrel)
+                add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment); 
+              fixP->fx_addsy = NULL;
+              fixP->fx_subsy = NULL;
+              fixP->fx_pcrel = 0;
             }
-          else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
-                   && SEG_NORMAL (add_symbol_segment))
+          else if (sub_symbol_segment == absolute_section
+                   && !TC_FORCE_RELOCATION_SUB_ABS (fixP))
             {
-              /* Difference of 2 symbols from same segment.
-                 Can't make difference of 2 undefineds: 'value' means
-                 something different for N_UNDF.  */
-#ifdef TC_I960
-              /* Makes no sense to use the difference of 2 arbitrary symbols
-                 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"));
-#endif /* TC_I960  */
-              add_number += S_GET_VALUE (add_symbolP) -
-                S_GET_VALUE (sub_symbolP);
-
-              add_symbolP = NULL;
-              pcrel = 0;        /* No further pcrel processing.  */
-
-              /* Let the target machine make the final determination
-                 as to whether or not a relocation will be needed to
-                 handle this fixup.  */
-              if (!TC_FORCE_RELOCATION_SECTION (fixP, this_segment_type))
-                {
-                  fixP->fx_pcrel = 0;
-                  fixP->fx_addsy = NULL;
-                  fixP->fx_subsy = NULL;
-                }
+              add_number -= S_GET_VALUE (fixP->fx_subsy);
+              fixP->fx_offset = add_number;
+              fixP->fx_subsy = NULL;
             }
-          else
+          else if (sub_symbol_segment == this_segment
+                   && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP))
             {
-              /* Different segments in subtraction.  */
-              know (!(S_IS_EXTERNAL (sub_symbolP)
-                      && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
-
-              if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
-                add_number -= S_GET_VALUE (sub_symbolP);
-
-#ifdef DIFF_EXPR_OK
-              else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
-#if 0
-                       /* Do this even if it's already described as
-                          pc-relative.  For example, on the m68k, an
-                          operand of "pc@(foo-.-2)" should address
-                          "foo" in a pc-relative mode.  */
-                       && pcrel
-#endif
-                       )
-                {
-                  /* Make it pc-relative.  */
-                  add_number += (MD_PCREL_FROM_SECTION (fixP, this_segment_type)
-                                 - S_GET_VALUE (sub_symbolP));
-                  pcrel = 1;
-                  fixP->fx_pcrel = 1;
-                  sub_symbolP = 0;
-                  fixP->fx_subsy = 0;
-                }
-#endif
-#ifdef UNDEFINED_DIFFERENCE_OK
-              /* The PA needs this for PIC code generation.  We basically
-                 don't want to do anything if we have the difference of two
-                 symbols at this point.  */
-              else if (1)
-                {
-                  /* Leave it alone.  */
-                }
-#endif
-#ifdef BFD_ASSEMBLER
-              else if (fixP->fx_r_type == BFD_RELOC_GPREL32
-                       || fixP->fx_r_type == BFD_RELOC_GPREL16)
-                {
-                  /* Leave it alone.  */
-                }
-#endif
-              else
-                {
-                  char buf[50];
-                  sprint_value (buf, fragP->fr_address + where);
-                  as_bad_where (fixP->fx_file, fixP->fx_line,
-                                _("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)),
-                                buf);
-                }
+              add_number -= S_GET_VALUE (fixP->fx_subsy);
+              fixP->fx_offset = (add_number + fixP->fx_dot_value
+                                 + fixP->fx_frag->fr_address);
+
+              /* Make it pc-relative.  If the back-end code has not
+                 selected a pc-relative reloc, cancel the adjustment
+                 we do later on all pc-relative relocs.  */
+              if (0
+#ifdef TC_M68K
+                  /* Do this for m68k even if it's already described
+                     as pc-relative.  On the m68k, an operand of
+                     "pc@(foo-.-2)" should address "foo" in a
+                     pc-relative mode.  */
+                  || 1
+#endif
+                  || !fixP->fx_pcrel)
+                add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
+              fixP->fx_subsy = NULL;
+              fixP->fx_pcrel = 1;
+            }
+          else if (!TC_VALIDATE_FIX_SUB (fixP))
+            {
+              as_bad_where (fixP->fx_file, fixP->fx_line,
+                            _("can't resolve `%s' {%s section} - `%s' {%s section}"),
+                            fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
+                            segment_name (add_symbol_segment),
+                            S_GET_NAME (fixP->fx_subsy),
+                            segment_name (sub_symbol_segment));
             }
         }
 
-      if (add_symbolP)
+      if (fixP->fx_addsy)
         {
-          if (add_symbol_segment == this_segment_type && pcrel && !plt
-              && TC_RELOC_RTSYM_LOC_FIXUP (fixP))
+          if (add_symbol_segment == this_segment
+              && !TC_FORCE_RELOCATION_LOCAL (fixP))
             {
               /* This fixup was made when the symbol's segment was
                  SEG_UNKNOWN, but it is now in the local segment.
                  So we know how to do the address without relocation.  */
-#ifdef TC_I960
-              /* reloc_callj() may replace a 'call' with a 'calls' or a
-                 'bal', in which cases it modifies *fixP as appropriate.
-                 In the case of a 'calls', no further work is required,
-                 and *fixP has been set up to make the rest of the code
-                 below a no-op.  */
-              reloc_callj (fixP);
-#endif /* TC_I960  */
-
-              add_number += S_GET_VALUE (add_symbolP);
-              add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
-              /* Lie.  Don't want further pcrel processing.  */
-              pcrel = 0;
-
-              /* Let the target machine make the final determination
-                 as to whether or not a relocation will be needed to
-                 handle this fixup.  */
-              if (!TC_FORCE_RELOCATION (fixP))
-                {
-                  fixP->fx_pcrel = 0;
-                  fixP->fx_addsy = NULL;
-                }
+              add_number += S_GET_VALUE (fixP->fx_addsy);
+              fixP->fx_offset = add_number;
+              if (fixP->fx_pcrel)
+                add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
+              fixP->fx_addsy = NULL;
+              fixP->fx_pcrel = 0;
             }
-          else
+          else if (add_symbol_segment == absolute_section
+                   && !TC_FORCE_RELOCATION_ABS (fixP))
             {
-              if (add_symbol_segment == absolute_section
-                  && ! pcrel)
-                {
-#ifdef TC_I960
-                  /* See comment about reloc_callj() above.  */
-                  reloc_callj (fixP);
-#endif /* TC_I960  */
-                  add_number += S_GET_VALUE (add_symbolP);
-
-                  /* Let the target machine make the final determination
-                     as to whether or not a relocation will be needed to
-                     handle this fixup.  */
-
-                  if (!TC_FORCE_RELOCATION (fixP))
-                    {
-                      fixP->fx_addsy = NULL;
-                      add_symbolP = NULL;
-                    }
-                }
-              else if (add_symbol_segment == undefined_section
+              add_number += S_GET_VALUE (fixP->fx_addsy);
+              fixP->fx_offset = add_number;
+              fixP->fx_addsy = NULL;
+            }
+          else if (add_symbol_segment != undefined_section
 #ifdef BFD_ASSEMBLER
-                       || bfd_is_com_section (add_symbol_segment)
-#endif
-                       )
-                {
-#ifdef TC_I960
-                  if ((int) fixP->fx_bit_fixP == 13)
-                    {
-                      /* This is a COBR instruction.  They have only a
-                         13-bit displacement and are only to be used
-                         for local branches: flag as error, don't generate
-                         relocation.  */
-                      as_bad_where (fixP->fx_file, fixP->fx_line,
-                                    _("can't use COBR format with external label"));
-                      fixP->fx_addsy = NULL;
-                      fixP->fx_done = 1;
-                      continue;
-                    }           /* COBR.  */
-#endif /* TC_I960  */
-
-#ifdef OBJ_COFF
-#ifdef TE_I386AIX
-                  if (S_IS_COMMON (add_symbolP))
-                    add_number += S_GET_VALUE (add_symbolP);
-#endif /* TE_I386AIX  */
-#endif /* OBJ_COFF  */
-                  ++seg_reloc_count;
-                }
-              else
-                {
-                  seg_reloc_count++;
-                  if (TC_FIX_ADJUSTABLE (fixP))
-                    add_number += S_GET_VALUE (add_symbolP);
-                }
+                   && ! bfd_is_com_section (add_symbol_segment)
+#endif
+                   && MD_APPLY_SYM_VALUE (fixP))
+            add_number += S_GET_VALUE (fixP->fx_addsy);
+        }
+
+      if (fixP->fx_pcrel)
+        {
+          add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
+          if (!fixP->fx_done && fixP->fx_addsy == NULL)
+            {
+              /* There was no symbol required by this relocation.
+                 However, BFD doesn't really handle relocations
+                 without symbols well. So fake up a local symbol in
+                 the absolute section.  */
+              fixP->fx_addsy = abs_section_sym;
             }
         }
 
-      if (pcrel)
-        {
-          add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
-          if (add_symbolP == 0)
-            {
-#ifndef BFD_ASSEMBLER
-              fixP->fx_addsy = &abs_symbol;
-#else
-              fixP->fx_addsy = section_symbol (absolute_section);
-#endif
-              symbol_mark_used_in_reloc (fixP->fx_addsy);
-              ++seg_reloc_count;
-            }
-        }
+      if (!fixP->fx_done)
+        md_apply_fix3 (fixP, &add_number, this_segment);
 
       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
+          ++seg_reloc_count;
+          if (fixP->fx_addsy == NULL)
+            fixP->fx_addsy = abs_section_sym;
+          symbol_mark_used_in_reloc (fixP->fx_addsy);
+          if (fixP->fx_subsy != NULL)
+            symbol_mark_used_in_reloc (fixP->fx_subsy);
         }
 
-      if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && size > 0)
+      if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
         {
-          if ((size_t) size < sizeof (valueT))
+          if (fixP->fx_size < sizeof (valueT))
             {
               valueT mask;
@@ -2813 +2762 @@
               mask = 0;
               mask--;           /* Set all bits to one.  */
-              mask <<= size * 8 - (fixP->fx_signed ? 1 : 0);
+              mask <<= fixP->fx_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);
+                  sprint_value (buf, fragP->fr_address + fixP->fx_where);
                   if (add_number > 1000)
                     sprint_value (buf2, add_number);
@@ -2823 +2772 @@
                     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"),
-                                buf2, size, buf);
+                                _("value of %s too large for field of %d bytes at %s"),
+                                buf2, fixP->fx_size, buf);
                 } /* Generic error checking.  */
             }
@@ -2832 +2781 @@
              catch over-large switches generated by gcc on the 68k.  */
           if (!flag_signed_overflow_ok
-              && size == 2
+              && fixP->fx_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));
+                          (long) (fragP->fr_address + fixP->fx_where));
 #endif
         }                       /* Not a bit fix.  */
@@ -2863 +2812 @@
      int n;
 {
-  if ((size_t) n > sizeof (val) || n <= 0)
+  if (n <= 0)
     abort ();
   while (n--)
@@ -2878 +2827 @@
      int n;
 {
-  if ((size_t) n > sizeof (val) || n <= 0)
+  if (n <= 0)
     abort ();
   while (n--)