* coff-h8300.c: Include libiberty.h.

	(h8300_reloc16_extra_cases): Check the hash table creator before
	referencing h8300 specific fields.  Stash the hash table pointer
	in a local var.  Comment typo fixes.
	(h8300_bfd_link_add_symbols): Likewise.

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index ae1ef6e4ff3eaf0b337d2eb6d107bad131501618..eca3b3b8a72594023a489be5857eb41563a739ea 100644 (file)
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,5 +1,11 @@
 2002-12-19  Alan Modra  <amodra@bigpond.net.au>
 
+       * coff-h8300.c: Include libiberty.h.
+       (h8300_reloc16_extra_cases): Check the hash table creator before
+       referencing h8300 specific fields.  Stash the hash table pointer
+       in a local var.  Comment typo fixes.
+       (h8300_bfd_link_add_symbols): Likewise.
+
        * bfd/reloc.c (struct reloc_howto_struct): Revise src_mask and
        dst_mask comments.
        * bfd-in2.h: Regenerate.

diff --git a/bfd/coff-h8300.c b/bfd/coff-h8300.c
index d571e189827d6261ad97372ea0513d4e6bede460..5429076814338647605805faa11bef051261e824 100644 (file)
--- a/bfd/coff-h8300.c
+++ b/bfd/coff-h8300.c
@@ -28,6 +28,7 @@
 #include "coff/h8300.h"
 #include "coff/internal.h"
 #include "libcoff.h"
+#include "libiberty.h"
 
 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (1)
 
@@ -65,7 +66,7 @@ funcvec_hash_newfunc
 static bfd_boolean
 funcvec_hash_table_init
   PARAMS ((struct funcvec_hash_table *, bfd *,
-           struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
+          struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
                                       struct bfd_hash_table *,
                                       const char *)));
 
@@ -137,8 +138,8 @@ funcvec_hash_newfunc (entry, gen_table, string)
      subclass.  */
   if (ret == NULL)
     ret = ((struct funcvec_hash_entry *)
-           bfd_hash_allocate (gen_table,
-                              sizeof (struct funcvec_hash_entry)));
+          bfd_hash_allocate (gen_table,
+                             sizeof (struct funcvec_hash_entry)));
   if (ret == NULL)
     return NULL;
 
@@ -516,16 +517,16 @@ h8300_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
             Only perform this optimisation for jumps (code 0x5a) not
             subroutine calls, as otherwise it could transform:
 
-                            mov.w   r0,r0
-                            beq     .L1
-                            jsr     @_bar
-                     .L1:   rts
-                     _bar:  rts
+                            mov.w   r0,r0
+                            beq     .L1
+                            jsr     @_bar
+                     .L1:   rts
+                     _bar:  rts
             into:
-                            mov.w   r0,r0
-                            bne     _bar
-                            rts
-                     _bar:  rts
+                            mov.w   r0,r0
+                            bne     _bar
+                            rts
+                     _bar:  rts
 
             which changes the call (jsr) into a branch (bne).  */
          if (code == 0x5a
@@ -564,7 +565,7 @@ h8300_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
        pc-relative branch.  */
     case R_PCRWORD:
       /* Get the address of the target of this branch, add one to the value
-         because the addend field in PCrel jumps is off by -1.  */
+        because the addend field in PCrel jumps is off by -1.  */
       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section) + 1;
 
       /* Get the address of the next instruction if we were to relax.  */
@@ -649,7 +650,7 @@ h8300_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 
       /* If this address is in 0x0000..0x7fff inclusive or
-         0xff8000..0xffffff inclusive, then it can be relaxed.  */
+        0xff8000..0xffffff inclusive, then it can be relaxed.  */
       if (value <= 0x7fff || value >= 0xff8000)
        {
          /* Change the reloc type.  */
@@ -1091,7 +1092,25 @@ h8300_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
        const char *name;
        struct funcvec_hash_table *ftab;
        struct funcvec_hash_entry *h;
-       asection *vectors_sec = h8300_coff_hash_table (link_info)->vectors_sec;
+       struct h8300_coff_link_hash_table *htab;
+       asection *vectors_sec;
+
+       if (link_info->hash->creator != abfd->xvec)
+         {
+           (*_bfd_error_handler)
+             (_("cannot handle R_MEM_INDIRECT reloc when using %s output"),
+              link_info->hash->creator->name);
+
+           /* What else can we do?  This function doesn't allow return
+              of an error, and we don't want to call abort as that
+              indicates an internal error.  */
+#ifndef EXIT_FAILURE
+#define EXIT_FAILURE 1
+#endif
+           xexit (EXIT_FAILURE);
+         }
+       htab = h8300_coff_hash_table (link_info);
+       vectors_sec = htab->vectors_sec;
 
        /* First see if this is a reloc against the absolute symbol
           or against a symbol with a nonnegative value <= 0xff.  */
@@ -1140,12 +1159,12 @@ h8300_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
            name = new_name;
          }
 
-       ftab = h8300_coff_hash_table (link_info)->funcvec_hash_table;
+       ftab = htab->funcvec_hash_table;
        h = funcvec_hash_lookup (ftab, name, FALSE, FALSE);
 
        /* This shouldn't ever happen.  If it does that means we've got
           data corruption of some kind.  Aborting seems like a reasonable
-          think to do here.  */
+          thing to do here.  */
        if (h == NULL || vectors_sec == NULL)
          abort ();
 
@@ -1214,24 +1233,30 @@ h8300_bfd_link_add_symbols (abfd, info)
   asection *sec;
   struct funcvec_hash_table *funcvec_hash_table;
   bfd_size_type amt;
+  struct h8300_coff_link_hash_table *htab;
+
+  /* Add the symbols using the generic code.  */
+  _bfd_generic_link_add_symbols (abfd, info);
+
+  if (info->hash->creator != abfd->xvec)
+    return TRUE;
+
+  htab = h8300_coff_hash_table (info);
 
   /* If we haven't created a vectors section, do so now.  */
-  if (!h8300_coff_hash_table (info)->vectors_sec)
+  if (!htab->vectors_sec)
     {
       flagword flags;
 
       /* Make sure the appropriate flags are set, including SEC_IN_MEMORY.  */
       flags = (SEC_ALLOC | SEC_LOAD
               | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_READONLY);
-      h8300_coff_hash_table (info)->vectors_sec = bfd_make_section (abfd,
-                                                                   ".vectors");
+      htab->vectors_sec = bfd_make_section (abfd, ".vectors");
 
       /* If the section wasn't created, or we couldn't set the flags,
-        quit quickly now, rather than dieing a painful death later.  */
-      if (! h8300_coff_hash_table (info)->vectors_sec
-         || ! bfd_set_section_flags (abfd,
-                                     h8300_coff_hash_table(info)->vectors_sec,
-                                     flags))
+        quit quickly now, rather than dying a painful death later.  */
+      if (!htab->vectors_sec
+         || !bfd_set_section_flags (abfd, htab->vectors_sec, flags))
        return FALSE;
 
       /* Also create the vector hash table.  */
@@ -1250,14 +1275,11 @@ h8300_bfd_link_add_symbols (abfd, info)
        }
 
       /* Store away a pointer to the funcvec hash table.  */
-      h8300_coff_hash_table (info)->funcvec_hash_table = funcvec_hash_table;
+      htab->funcvec_hash_table = funcvec_hash_table;
     }
 
   /* Load up the function vector hash table.  */
-  funcvec_hash_table = h8300_coff_hash_table (info)->funcvec_hash_table;
-
-  /* Add the symbols using the generic code.  */
-  _bfd_generic_link_add_symbols (abfd, info);
+  funcvec_hash_table = htab->funcvec_hash_table;
 
   /* Now scan the relocs for all the sections in this bfd; create
      additional space in the .vectors section as needed.  */
@@ -1322,7 +1344,7 @@ h8300_bfd_link_add_symbols (abfd, info)
                }
 
              /* Look this symbol up in the function vector hash table.  */
-             ftab = h8300_coff_hash_table (info)->funcvec_hash_table;
+             ftab = htab->funcvec_hash_table;
              h = funcvec_hash_lookup (ftab, name, FALSE, FALSE);
 
              /* If this symbol isn't already in the hash table, add
@@ -1339,10 +1361,10 @@ h8300_bfd_link_add_symbols (abfd, info)
                  /* Bump the size of the vectors section.  Each vector
                     takes 2 bytes on the h8300 and 4 bytes on the h8300h.  */
                  if (bfd_get_mach (abfd) == bfd_mach_h8300)
-                   h8300_coff_hash_table (info)->vectors_sec->_raw_size += 2;
+                   htab->vectors_sec->_raw_size += 2;
                  else if (bfd_get_mach (abfd) == bfd_mach_h8300h
                           || bfd_get_mach (abfd) == bfd_mach_h8300s)
-                   h8300_coff_hash_table (info)->vectors_sec->_raw_size += 4;
+                   htab->vectors_sec->_raw_size += 4;
                }
            }
        }
@@ -1353,7 +1375,7 @@ h8300_bfd_link_add_symbols (abfd, info)
 
   /* Now actually allocate some space for the function vector.  It's
      wasteful to do this more than once, but this is easier.  */
-  sec = h8300_coff_hash_table (info)->vectors_sec;
+  sec = htab->vectors_sec;
   if (sec->_raw_size != 0)
     {
       /* Free the old contents.  */