* elf32-m32r.c (m32r_elf_create_dynamic_sections): Fix pointer

	aliasing warning.  Remove trailing whitespace throughout file.

1 files changed, 145 insertions, 144 deletions

diff --git a/bfd/elf32-m32r.c b/bfd/elf32-m32r.c
index 3edf4a9..3f5fbca 100644
--- a/bfd/elf32-m32r.c
+++ b/bfd/elf32-m32r.c
@@ -1,5 +1,5 @@
 /* M32R-specific support for 32-bit ELF.
-   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
    Free Software Foundation, Inc.
 
    This file is part of BFD, the Binary File Descriptor library.
@@ -93,11 +93,11 @@ static bfd_boolean m32r_elf_create_dynamic_sections
 
 static bfd_boolean m32r_elf_finish_dynamic_sections
   PARAMS ((bfd *, struct bfd_link_info *));
-                                                                                
+
 static bfd_boolean m32r_elf_finish_dynamic_symbol
   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
            Elf_Internal_Sym *));
-                                                                                
+
 static bfd_boolean allocate_dynrelocs
   PARAMS ((struct elf_link_hash_entry *, PTR));
 static bfd_boolean readonly_dynrelocs
@@ -122,39 +122,39 @@ static bfd_boolean m32r_elf_fake_sections
 /* Use RELA. But use REL to link old objects for backwords compatibility. */
 
 /* Functions for the M32R ELF linker.  */
-                                                                                
+
 /* The name of the dynamic interpreter.  This is put in the .interp
    section.  */
-                                                                                
+
 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
-                                                                                
+
 /* The nop opcode we use.  */
-                                                                                
+
 #define M32R_NOP 0x7000f000
-                                                                                
+
 #define PLT_EMPTY   0x10101010  /* RIE  -> RIE */
-                                                                                
+
 /* The size in bytes of an entry in the procedure linkage table.  */
 
 #define PLT_ENTRY_SIZE 20
 #define PLT_HEADER_SIZE 20
-                                                                                
+
 /* The first one entries in a procedure linkage table are reserved,
    and the initial contents are unimportant (we zero them out).
    Subsequent entries look like this. */
-                                                                                
+
 #define PLT0_ENTRY_WORD0  0xd6c00000    /* seth r6, #high(.got+4)          */
 #define PLT0_ENTRY_WORD1  0x86e60000    /* or3  r6, r6, #low(.got)+4)      */
 #define PLT0_ENTRY_WORD2  0x24e626c6    /* ld   r4, @r6+    -> ld r6, @r6  */
 #define PLT0_ENTRY_WORD3  0x1fc6f000    /* jmp  r6          || pnop        */
 #define PLT0_ENTRY_WORD4  PLT_EMPTY     /* RIE             -> RIE          */
-                                                                                
+
 #define PLT0_PIC_ENTRY_WORD0  0xa4cc0004 /* ld   r4, @(4,r12)              */
 #define PLT0_PIC_ENTRY_WORD1  0xa6cc0008 /* ld   r6, @(8,r12)              */
 #define PLT0_PIC_ENTRY_WORD2  0x1fc6f000 /* jmp  r6         || nop         */
 #define PLT0_PIC_ENTRY_WORD3  PLT_EMPTY  /* RIE             -> RIE         */
 #define PLT0_PIC_ENTRY_WORD4  PLT_EMPTY  /* RIE             -> RIE         */
-                                                                                
+
 #define PLT_ENTRY_WORD0  0xe6000000 /* ld24 r6, .name_in_GOT                */
 #define PLT_ENTRY_WORD1  0x06acf000 /* add  r6, r12          || nop         */
 #define PLT_ENTRY_WORD0b 0xd6c00000 /* seth r6, #high(.name_in_GOT)         */
@@ -1248,7 +1248,7 @@ static const struct m32r_reloc_map m32r_reloc_map[] =
   { BFD_RELOC_M32R_SDA16, R_M32R_SDA16_RELA },
   { BFD_RELOC_VTABLE_INHERIT, R_M32R_RELA_GNU_VTINHERIT },
   { BFD_RELOC_VTABLE_ENTRY, R_M32R_RELA_GNU_VTENTRY },
-                                                                                
+
   { BFD_RELOC_M32R_GOT24, R_M32R_GOT24 },
   { BFD_RELOC_M32R_26_PLTREL, R_M32R_26_PLTREL },
   { BFD_RELOC_M32R_COPY, R_M32R_COPY },
@@ -1596,7 +1596,7 @@ m32r_elf_link_hash_newfunc (entry, table, string)
 {
   struct elf_m32r_link_hash_entry *ret =
     (struct elf_m32r_link_hash_entry *) entry;
-    
+
   /* Allocate the structure if it has not already been allocated by a
      subclass.  */
   if (ret == (struct elf_m32r_link_hash_entry *) NULL)
@@ -1605,7 +1605,7 @@ m32r_elf_link_hash_newfunc (entry, table, string)
                               sizeof (struct elf_m32r_link_hash_entry)));
   if (ret == (struct elf_m32r_link_hash_entry *) NULL)
     return (struct bfd_hash_entry *) ret;
-   
+
   /* Call the allocation method of the superclass.  */
   ret = ((struct elf_m32r_link_hash_entry *)
          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
@@ -1613,13 +1613,13 @@ m32r_elf_link_hash_newfunc (entry, table, string)
   if (ret != (struct elf_m32r_link_hash_entry *) NULL)
     {
       struct elf_m32r_link_hash_entry *eh;
-  
+
       eh = (struct elf_m32r_link_hash_entry *) ret;
       eh->dyn_relocs = NULL;
 //      eh->gotplt_refcount = 0;
       /* eh->pcrel_relocs_copied = NULL; FIXME */
     }
-                                                                                                 
+
   return (struct bfd_hash_entry *) ret;
 }
 
@@ -1632,18 +1632,18 @@ m32r_elf_link_hash_table_create (abfd)
 {
   struct elf_m32r_link_hash_table *ret;
   bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table);
-                                                                                                 
+
   ret = (struct elf_m32r_link_hash_table *) bfd_malloc (amt);
   if (ret == (struct elf_m32r_link_hash_table *) NULL)
     return NULL;
-              
+
   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
                                        m32r_elf_link_hash_newfunc))
     {
       free (ret);
       return NULL;
     }
-               
+
   ret->sgot = NULL;
   ret->sgotplt = NULL;
   ret->srelgot = NULL;
@@ -1652,7 +1652,7 @@ m32r_elf_link_hash_table_create (abfd)
   ret->sdynbss = NULL;
   ret->srelbss = NULL;
   ret->sym_sec.abfd = NULL;
-                
+
   return &ret->root.root;
 }
 
@@ -1730,13 +1730,14 @@ m32r_elf_create_dynamic_sections (abfd, info)
     {
       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
          .plt section.  */
-      struct elf_link_hash_entry *h = NULL;
+      struct bfd_link_hash_entry *bh = NULL;
+      struct elf_link_hash_entry *h;
       if (! (_bfd_generic_link_add_one_symbol
              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
               (bfd_vma) 0, (const char *) NULL, FALSE,
-              get_elf_backend_data (abfd)->collect,
-              (struct bfd_link_hash_entry **) &h)))
+              get_elf_backend_data (abfd)->collect, &bh)))
         return FALSE;
+      h = (struct elf_link_hash_entry *) bh;
       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
       h->type = STT_OBJECT;
 
@@ -1827,33 +1828,33 @@ m32r_elf_create_dynamic_sections (abfd, info)
 static void m32r_elf_copy_indirect_symbol (const struct elf_backend_data *,
                                            struct elf_link_hash_entry *,
                                            struct elf_link_hash_entry *);
-                                                                                
+
 static void
 m32r_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
                                struct elf_link_hash_entry *dir,
                                struct elf_link_hash_entry *ind)
 {
   struct elf_m32r_link_hash_entry *edir, *eind;
-                                                                                
+
   edir = (struct elf_m32r_link_hash_entry *) dir;
   eind = (struct elf_m32r_link_hash_entry *) ind;
-                                                                                
+
   if (eind->dyn_relocs != NULL)
     {
       if (edir->dyn_relocs != NULL)
         {
           struct elf_m32r_dyn_relocs **pp;
           struct elf_m32r_dyn_relocs *p;
-                                                                                
+
           if (ind->root.type == bfd_link_hash_indirect)
             abort ();
-                                                                                
+
           /* Add reloc counts against the weak sym to the strong sym
              list.  Merge any entries against the same section.  */
           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
             {
               struct elf_m32r_dyn_relocs *q;
-                                                                                
+
               for (q = edir->dyn_relocs; q != NULL; q = q->next)
                 if (q->sec == p->sec)
                   {
@@ -1867,11 +1868,11 @@ m32r_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
             }
           *pp = edir->dyn_relocs;
         }
-                                                                                
+
       edir->dyn_relocs = eind->dyn_relocs;
       eind->dyn_relocs = NULL;
     }
-                                                                                
+
 //  if (ind->root.type == bfd_link_hash_indirect
 //      && dir->got.refcount <= 0)
 //    {
@@ -1887,7 +1888,7 @@ m32r_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
    dynamic object, but we're not including those sections.  We have to
    change the definition to something the rest of the link can
    understand.  */
- 
+
 static bfd_boolean
 m32r_elf_adjust_dynamic_symbol (info, h)
      struct bfd_link_info *info;
@@ -1903,9 +1904,9 @@ m32r_elf_adjust_dynamic_symbol (info, h)
 #ifdef DEBUG_PIC
 printf("m32r_elf_adjust_dynamic_symbol()\n");
 #endif
- 
+
   dynobj = elf_hash_table (info)->dynobj;
- 
+
   /* Make sure we know what is going on here.  */
   BFD_ASSERT (dynobj != NULL
               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
@@ -1917,7 +1918,7 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
                       && (h->elf_link_hash_flags
                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
 
- 
+
   /* If this is a function, put it in the procedure linkage table.  We
      will fill in the contents of the procedure linkage table later,
      when we know the address of the .got section.  */
@@ -1943,7 +1944,7 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
     }
   else
     h->plt.offset = (bfd_vma) -1;
- 
+
   /* If this is a weak symbol, and there is a real definition, the
      processor independent code will have arranged for us to see the
      real definition first, and we can just use the same value.  */
@@ -1955,17 +1956,17 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
       h->root.u.def.value = h->weakdef->root.u.def.value;
       return TRUE;
     }
- 
+
   /* This is a reference to a symbol defined by a dynamic object which
      is not a function.  */
- 
+
   /* If we are creating a shared library, we must presume that the
      only references to the symbol are via the global offset table.
      For such cases we need not do anything here; the relocations will
      be handled correctly by relocate_section.  */
   if (info->shared)
     return TRUE;
- 
+
   /* If there are no references to this symbol that do not use the
      GOT, we don't need to generate a copy reloc.  */
   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
@@ -2004,11 +2005,11 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
      determine the address it must put in the global offset table, so
      both the dynamic object and the regular object will refer to the
      same memory location for the variable.  */
- 
+
   htab = m32r_elf_hash_table (info);
   s = htab->sdynbss;
   BFD_ASSERT (s != NULL);
- 
+
   /* We must generate a R_M32R_COPY reloc to tell the dynamic linker
      to copy the initial value out of the dynamic object and into the
      runtime process image.  We need to remember the offset into the
@@ -2016,19 +2017,19 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
     {
       asection *srel;
- 
+
       srel = htab->srelbss;
       BFD_ASSERT (srel != NULL);
       srel->_raw_size += sizeof (Elf32_External_Rela);
       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
     }
- 
+
   /* We need to figure out the alignment required for this symbol.  I
      have no idea how ELF linkers handle this.  */
   power_of_two = bfd_log2 (h->size);
   if (power_of_two > 3)
     power_of_two = 3;
- 
+
   /* Apply the required alignment.  */
   s->_raw_size = BFD_ALIGN (s->_raw_size,
                             (bfd_size_type) (1 << power_of_two));
@@ -2037,14 +2038,14 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
         return FALSE;
     }
- 
+
   /* Define the symbol as being at this point in the section.  */
   h->root.u.def.section = s;
   h->root.u.def.value = s->_raw_size;
- 
+
   /* Increment the section size to make room for the symbol.  */
   s->_raw_size += h->size;
- 
+
   return TRUE;
 }
 
@@ -2061,7 +2062,7 @@ printf("m32r_elf_adjust_dynamic_symbol()\n");
 
 /* Allocate space in .plt, .got and associated reloc sections for
    dynamic relocs.  */
-                  
+
 static bfd_boolean
 allocate_dynrelocs (h, inf)
      struct elf_link_hash_entry *h;
@@ -2071,19 +2072,19 @@ allocate_dynrelocs (h, inf)
   struct elf_m32r_link_hash_table *htab;
   struct elf_m32r_link_hash_entry *eh;
   struct elf_m32r_dyn_relocs *p;
-                 
+
   if (h->root.type == bfd_link_hash_indirect)
     return TRUE;
-                
+
   if (h->root.type == bfd_link_hash_warning)
     /* When warning symbols are created, they **replace** the "real"
        entry in the hash table, thus we never get to see the real
        symbol in a hash traversal.  So look at it now.  */
     h = (struct elf_link_hash_entry *) h->root.u.i.link;
-               
+
   info = (struct bfd_link_info *) inf;
   htab = m32r_elf_hash_table (info);
-              
+
   eh = (struct elf_m32r_link_hash_entry *) h;
 //  if ((h->got.refcount > 0
 //      || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
@@ -2095,7 +2096,7 @@ allocate_dynrelocs (h, inf)
 //      if (h->plt.refcount >= eh->gotplt_refcount)
 //        h->plt.refcount -= eh->gotplt_refcount;
 //    }
-             
+
   if (htab->root.dynamic_sections_created
       && h->plt.refcount > 0)
     {
@@ -2107,18 +2108,18 @@ allocate_dynrelocs (h, inf)
           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
             return FALSE;
         }
-            
+
       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
         {
           asection *s = htab->splt;
-           
+
           /* If this is the first .plt entry, make room for the special
              first entry.  */
           if (s->_raw_size == 0)
             s->_raw_size += PLT_ENTRY_SIZE;
-          
+
           h->plt.offset = s->_raw_size;
-         
+
           /* If this symbol is not defined in a regular file, and we are
              not generating a shared library, then set the symbol to this
              location in the .plt.  This is required to make function
@@ -2130,14 +2131,14 @@ allocate_dynrelocs (h, inf)
               h->root.u.def.section = s;
               h->root.u.def.value = h->plt.offset;
             }
-        
+
           /* Make room for this entry.  */
           s->_raw_size += PLT_ENTRY_SIZE;
-       
+
           /* We also need to make an entry in the .got.plt section, which
              will be placed in the .got section by the linker script.  */
           htab->sgotplt->_raw_size += 4;
-      
+
           /* We also need to make an entry in the .rel.plt section.  */
           htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
         }
@@ -2152,12 +2153,12 @@ allocate_dynrelocs (h, inf)
       h->plt.offset = (bfd_vma) -1;
       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
     }
-     
+
   if (h->got.refcount > 0)
     {
       asection *s;
       bfd_boolean dyn;
-    
+
       /* Make sure this symbol is output as a dynamic symbol.
          Undefined weak syms won't yet be marked as dynamic.  */
       if (h->dynindx == -1
@@ -2166,7 +2167,7 @@ allocate_dynrelocs (h, inf)
           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
             return FALSE;
         }
-   
+
       s = htab->sgot;
 
       h->got.offset = s->_raw_size;
@@ -2177,10 +2178,10 @@ allocate_dynrelocs (h, inf)
     }
   else
     h->got.offset = (bfd_vma) -1;
-  
+
   if (eh->dyn_relocs == NULL)
     return TRUE;
- 
+
   /* In the shared -Bsymbolic case, discard space allocated for
      dynamic pc-relative relocs against symbols which turn out to be
      defined in regular objects.  For the normal shared case, discard
@@ -2210,7 +2211,7 @@ allocate_dynrelocs (h, inf)
       /* For the non-shared case, discard space for relocs against
          symbols which turn out to need copy relocs or are not
          dynamic.  */
-                                                                      
+
       if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
           && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
@@ -2226,29 +2227,29 @@ allocate_dynrelocs (h, inf)
               if (! bfd_elf32_link_record_dynamic_symbol (info, h))
                 return FALSE;
             }
-                                                                       
+
           /* If that succeeded, we know we'll be keeping all the
              relocs.  */
           if (h->dynindx != -1)
             goto keep;
         }
-                                                                        
+
       eh->dyn_relocs = NULL;
-                                                                         
+
     keep: ;
     }
-                                                                          
+
   /* Finally, allocate space.  */
   for (p = eh->dyn_relocs; p != NULL; p = p->next)
     {
       asection *sreloc = elf_section_data (p->sec)->sreloc;
       sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
     }
-                                                                           
+
   return TRUE;
 }
 /* Find any dynamic relocs that apply to read-only sections.  */
-                                                                            
+
 static bfd_boolean
 readonly_dynrelocs (h, inf)
      struct elf_link_hash_entry *h;
@@ -2279,7 +2280,7 @@ readonly_dynrelocs (h, inf)
 }
 
 /* Set the sizes of the dynamic sections.  */
- 
+
 static bfd_boolean
 m32r_elf_size_dynamic_sections (output_bfd, info)
      bfd *output_bfd ATTRIBUTE_UNUSED;
@@ -2541,7 +2542,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 
   dynobj = htab->root.dynobj;
   local_got_offsets = elf_local_got_offsets (input_bfd);
-                                                                                
+
   sgot = htab->sgot;
   splt = htab->splt;
   sreloc = NULL;
@@ -2681,7 +2682,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                          section symbol winds up in the output section.  */
                       if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
                         rel->r_addend += sec->output_offset + sym->st_value;
-                                                                                
+
                       continue;
                     }
                 }
@@ -2744,7 +2745,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                               || r_type == R_M32R_26_PCREL_RELA)
                           && ((input_section->flags & SEC_ALLOC) != 0
                               /* DWARF will emit R_M32R_16(24,32) relocations
-                                 in its sections against symbols defined 
+                                 in its sections against symbols defined
                                  externally in shared libraries.  We can't do
                                  anything with them here.  */
                               || ((input_section->flags & SEC_DEBUGGING) != 0
@@ -2781,7 +2782,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 		  if (! ((*info->callbacks->undefined_symbol)
 			 (info, h->root.root.string, input_bfd,
 			  input_section, offset,
-                          (!info->shared 
+                          (!info->shared
                            || ELF_ST_VISIBILITY (h->other)))))
 		    return FALSE;
 		  relocation = 0;
@@ -2806,7 +2807,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 
             case R_M32R_GOTPC_HI_ULO:
             case R_M32R_GOTPC_HI_SLO:
-            case R_M32R_GOTPC_LO: 
+            case R_M32R_GOTPC_LO:
               {
                 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
                    bl .+4
@@ -2821,7 +2822,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                 relocation -= (input_section->output_section->vma
                                + input_section->output_offset
                                + rel->r_offset);
-                if ((r_type == R_M32R_GOTPC_HI_SLO) 
+                if ((r_type == R_M32R_GOTPC_HI_SLO)
                      && ((relocation + rel->r_addend) & 0x8000))
                   rel->r_addend += 0x10000;
 
@@ -2829,18 +2830,18 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
               }
             case R_M32R_GOT16_HI_ULO:
             case R_M32R_GOT16_HI_SLO:
-            case R_M32R_GOT16_LO: 
+            case R_M32R_GOT16_LO:
               /* Fall through.  */
             case R_M32R_GOT24:
               /* Relocation is to the entry for this symbol in the global
                  offset table.  */
               BFD_ASSERT (sgot != NULL);
- 
+
               if (h != NULL)
                 {
                   bfd_boolean dyn;
                   bfd_vma off;
- 
+
                   off = h->got.offset;
                   BFD_ASSERT (off != (bfd_vma) -1);
 
@@ -2860,7 +2861,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                          offset must always be a multiple of 4, we use the
                          least significant bit to record whether we have
                          initialized it already.
- 
+
                          When doing a dynamic link, we create a .rela.got
                          relocation entry to initialize the value.  This
                          is done in the finish_dynamic_symbol routine.  */
@@ -2873,19 +2874,19 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                           h->got.offset |= 1;
                         }
                     }
- 
+
                   relocation = sgot->output_offset + off;
                 }
               else
                 {
                   bfd_vma off;
                   bfd_byte *loc;
- 
+
                   BFD_ASSERT (local_got_offsets != NULL
                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
- 
+
                   off = local_got_offsets[r_symndx];
- 
+
                   /* The offset must always be a multiple of 4.  We use
                      the least significant bit to record whether we have
                      already processed this entry.  */
@@ -2894,17 +2895,17 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                   else
                     {
                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
- 
+
                       if (info->shared)
                         {
                           asection *srelgot;
                           Elf_Internal_Rela outrel;
- 
+
                           /* We need to generate a R_M32R_RELATIVE reloc
                              for the dynamic linker.  */
                           srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
                           BFD_ASSERT (srelgot != NULL);
- 
+
                           outrel.r_offset = (sgot->output_section->vma
                                              + sgot->output_offset
                                              + off);
@@ -2915,10 +2916,10 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                           bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
                           ++srelgot->reloc_count;
                         }
- 
+
                       local_got_offsets[r_symndx] |= 1;
                     }
- 
+
                   relocation = sgot->output_offset + off;
                 }
               if ((r_type == R_M32R_GOT16_HI_SLO)
@@ -2926,11 +2927,11 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                 rel->r_addend += 0x10000;
 
               break;
- 
+
             case R_M32R_26_PLTREL:
               /* Relocation is to the entry for this symbol in the
                  procedure linkage table.  */
- 
+
               /* The native assembler will generate a 26_PLTREL reloc
                  for a local symbol if you assemble a call from one
                  section to another when using -K pic. */
@@ -2950,12 +2951,12 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                      using -Bsymbolic.  */
                   break;
                 }
- 
+
               relocation = (splt->output_section->vma
                             + splt->output_offset
                             + h->plt.offset);
               break;
- 
+
             case R_M32R_HI16_SLO_RELA:
               {
                  if ((relocation + rel->r_addend) & 0x8000)
@@ -2986,34 +2987,34 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                   Elf_Internal_Rela outrel;
                   bfd_boolean skip, relocate;
                   bfd_byte *loc;
- 
+
                   /* When generating a shared object, these relocations
                      are copied into the output file to be resolved at run
                      time.  */
- 
+
                   if (sreloc == NULL)
                     {
                       const char *name;
- 
+
                       name = (bfd_elf_string_from_elf_section
                               (input_bfd,
                                elf_elfheader (input_bfd)->e_shstrndx,
                                elf_section_data (input_section)->rel_hdr.sh_name));
                       if (name == NULL)
                         return FALSE;
- 
+
                       BFD_ASSERT (strncmp (name, ".rela", 5) == 0
                                   && strcmp (bfd_get_section_name (input_bfd,
                                                                    input_section),
                                              name + 5) == 0);
- 
+
                       sreloc = bfd_get_section_by_name (dynobj, name);
                       BFD_ASSERT (sreloc != NULL);
                     }
- 
+
                   skip = FALSE;
                   relocate = FALSE;
- 
+
                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
                                                              info,
                                                              input_section,
@@ -3024,7 +3025,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                     skip = TRUE, relocate = TRUE;
                   outrel.r_offset += (input_section->output_section->vma
                                       + input_section->output_offset);
- 
+
                   if (skip)
                     memset (&outrel, 0, sizeof outrel);
                   else if (r_type == R_M32R_18_PCREL_RELA
@@ -3068,7 +3069,7 @@ m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                     continue;
                 }
               break;
- 
+
 	    case (int) R_M32R_10_PCREL :
 	      r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
 					      contents, offset,
@@ -3238,11 +3239,11 @@ m32r_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
   struct elf_m32r_link_hash_table *htab;
   bfd *dynobj;
   bfd_byte *loc;
- 
+
 #ifdef DEBUG_PIC
 printf("m32r_elf_finish_dynamic_symbol()\n");
 #endif
-  
+
   htab = m32r_elf_hash_table (info);
   dynobj = htab->root.dynobj;
 
@@ -3255,12 +3256,12 @@ printf("m32r_elf_finish_dynamic_symbol()\n");
       bfd_vma plt_index;
       bfd_vma got_offset;
       Elf_Internal_Rela rela;
- 
+
       /* This symbol has an entry in the procedure linkage table.  Set
          it up.  */
- 
+
       BFD_ASSERT (h->dynindx != -1);
- 
+
       splt = htab->splt;
       sgot = htab->sgotplt;
       srela = htab->srelplt;
@@ -3321,7 +3322,7 @@ printf("m32r_elf_finish_dynamic_symbol()\n");
                + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
               splt->contents + h->plt.offset + 16);
         }
- 
+
       /* Fill in the entry in the global offset table.  */
       bfd_put_32 (output_bfd,
                   (splt->output_section->vma
@@ -3339,7 +3340,7 @@ printf("m32r_elf_finish_dynamic_symbol()\n");
       loc = srela->contents;
       loc += plt_index * sizeof(Elf32_External_Rela);
       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
- 
+
       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
         {
           /* Mark the symbol as undefined, rather than as defined in
@@ -3353,18 +3354,18 @@ printf("m32r_elf_finish_dynamic_symbol()\n");
       asection *sgot;
       asection *srela;
       Elf_Internal_Rela rela;
- 
+
       /* This symbol has an entry in the global offset table.  Set it
          up.  */
- 
+
       sgot = htab->sgot;
       srela = htab->srelgot;
       BFD_ASSERT (sgot != NULL && srela != NULL);
- 
+
       rela.r_offset = (sgot->output_section->vma
                        + sgot->output_offset
                        + (h->got.offset &~ 1));
- 
+
       /* If this is a -Bsymbolic link, and the symbol is defined
          locally, we just want to emit a RELATIVE reloc.  Likewise if
          the symbol was forced to be local because of a version file.
@@ -3388,28 +3389,28 @@ printf("m32r_elf_finish_dynamic_symbol()\n");
           rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT);
           rela.r_addend = 0;
         }
- 
+
       loc = srela->contents;
       loc += srela->reloc_count * sizeof(Elf32_External_Rela);
       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
       ++srela->reloc_count;
     }
- 
+
   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
     {
       asection *s;
       Elf_Internal_Rela rela;
- 
+
       /* This symbols needs a copy reloc.  Set it up.  */
- 
+
       BFD_ASSERT (h->dynindx != -1
                   && (h->root.type == bfd_link_hash_defined
                       || h->root.type == bfd_link_hash_defweak));
- 
+
       s = bfd_get_section_by_name (h->root.u.def.section->owner,
                                    ".rela.bss");
       BFD_ASSERT (s != NULL);
- 
+
       rela.r_offset = (h->root.u.def.value
                        + h->root.u.def.section->output_section->vma
                        + h->root.u.def.section->output_offset);
@@ -3420,18 +3421,18 @@ printf("m32r_elf_finish_dynamic_symbol()\n");
       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
       ++s->reloc_count;
     }
- 
+
   /* Mark some specially defined symbols as absolute.  */
   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
     sym->st_shndx = SHN_ABS;
- 
+
   return TRUE;
 }
 
 
 /* Finish up the dynamic sections.  */
- 
+
 static bfd_boolean
 m32r_elf_finish_dynamic_sections (output_bfd, info)
      bfd *output_bfd;
@@ -3445,20 +3446,20 @@ m32r_elf_finish_dynamic_sections (output_bfd, info)
 #ifdef DEBUG_PIC
 printf("m32r_elf_finish_dynamic_sections()\n");
 #endif
- 
+
   htab = m32r_elf_hash_table (info);
   dynobj = htab->root.dynobj;
 
   sgot = htab->sgotplt;
   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
- 
+
   if (htab->root.dynamic_sections_created)
     {
       asection *splt;
       Elf32_External_Dyn *dyncon, *dynconend;
- 
+
       BFD_ASSERT (sgot != NULL && sdyn != NULL);
- 
+
       dyncon = (Elf32_External_Dyn *) sdyn->contents;
       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
 
@@ -3467,9 +3468,9 @@ printf("m32r_elf_finish_dynamic_sections()\n");
           Elf_Internal_Dyn dyn;
           const char *name;
           asection *s;
- 
+
           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
- 
+
           switch (dyn.d_tag)
             {
             default:
@@ -3477,7 +3478,7 @@ printf("m32r_elf_finish_dynamic_sections()\n");
 
             case DT_PLTGOT:
               name = ".got";
-              s = htab->sgot->output_section; 
+              s = htab->sgot->output_section;
               goto get_vma;
             case DT_JMPREL:
               name = ".rela.plt";
@@ -3520,7 +3521,7 @@ printf("m32r_elf_finish_dynamic_sections()\n");
               break;
             }
         }
- 
+
       /* Fill in the first entry in the procedure linkage table.  */
       splt = htab->splt;
       if (splt && splt->_raw_size > 0)
@@ -3541,7 +3542,7 @@ printf("m32r_elf_finish_dynamic_sections()\n");
               bfd_put_32 (output_bfd,
 			  PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
 			  splt->contents);
-              bfd_put_32 (output_bfd, 
+              bfd_put_32 (output_bfd,
 			  PLT0_ENTRY_WORD1 | (addr & 0xffff),
 			  splt->contents + 4);
               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
@@ -3568,7 +3569,7 @@ printf("m32r_elf_finish_dynamic_sections()\n");
 
       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
     }
- 
+
   return TRUE;
 }
 
@@ -4473,7 +4474,7 @@ m32r_elf_check_relocs (abfd, info, sec, relocs)
         {
 	case R_M32R_GOT16_HI_ULO:
 	case R_M32R_GOT16_HI_SLO:
-	case R_M32R_GOT16_LO: 
+	case R_M32R_GOT16_LO:
         case R_M32R_GOT24:
 
           if (h != NULL)
@@ -4507,7 +4508,7 @@ m32r_elf_check_relocs (abfd, info, sec, relocs)
              because this might be a case of linking PIC code without
              linking in any dynamic objects, in which case we don't
              need to generate a procedure linkage table after all.  */
- 
+
 	  /* If this is a local symbol, we resolve it directly without
 	     creating a procedure linkage table entry.  */
           if (h == NULL)
@@ -4583,23 +4584,23 @@ m32r_elf_check_relocs (abfd, info, sec, relocs)
               if (sreloc == NULL)
                 {
                   const char *name;
- 
+
                   name = (bfd_elf_string_from_elf_section
                           (abfd,
                            elf_elfheader (abfd)->e_shstrndx,
                            elf_section_data (sec)->rel_hdr.sh_name));
                   if (name == NULL)
                     return FALSE;
- 
+
                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
                               && strcmp (bfd_get_section_name (abfd, sec),
                                          name + 5) == 0);
- 
+
                   sreloc = bfd_get_section_by_name (dynobj, name);
                   if (sreloc == NULL)
                     {
                       flagword flags;
- 
+
                       sreloc = bfd_make_section (dynobj, name);
                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
@@ -4612,7 +4613,7 @@ m32r_elf_check_relocs (abfd, info, sec, relocs)
                     }
                   elf_section_data (sec)->sreloc = sreloc;
                 }
- 
+
               /* If this is a global symbol, we count the number of
                  relocations we need for this symbol.  */
               if (h != NULL)