Don't update target_dcache if it is not initialized

[deliverable/binutils-gdb.git] / bfd / elf32-xtensa.c

diff --git a/bfd/elf32-xtensa.c b/bfd/elf32-xtensa.c
index 6cd396a6bcbbc160aad42c4ef59111426d7593f7..75ccefef0251cbe796e2b0f84a20344a9a2d37b1 100644 (file)
--- a/bfd/elf32-xtensa.c
+++ b/bfd/elf32-xtensa.c
@@ -1,5 +1,5 @@
 /* Xtensa-specific support for 32-bit ELF.
 /* Xtensa-specific support for 32-bit ELF.

-   Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+   Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012

    Free Software Foundation, Inc.
 
    This file is part of BFD, the Binary File Descriptor library.
    Free Software Foundation, Inc.
 
    This file is part of BFD, the Binary File Descriptor library.


@@ -655,7 +655,7 @@ elf_xtensa_link_hash_table_create (bfd *abfd)
   struct elf_xtensa_link_hash_table *ret;
   bfd_size_type amt = sizeof (struct elf_xtensa_link_hash_table);
 
   struct elf_xtensa_link_hash_table *ret;
   bfd_size_type amt = sizeof (struct elf_xtensa_link_hash_table);
 

-  ret = bfd_malloc (amt);
+  ret = bfd_zmalloc (amt);

   if (ret == NULL)
     return NULL;
 
   if (ret == NULL)
     return NULL;
 


@@ -668,16 +668,6 @@ elf_xtensa_link_hash_table_create (bfd *abfd)
       return NULL;
     }
 
       return NULL;
     }
 

-  ret->sgot = NULL;
-  ret->sgotplt = NULL;
-  ret->srelgot = NULL;
-  ret->splt = NULL;
-  ret->srelplt = NULL;
-  ret->sgotloc = NULL;
-  ret->spltlittbl = NULL;
-
-  ret->plt_reloc_count = 0;
-

   /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
      for it later.  */
   tlsbase = elf_link_hash_lookup (&ret->elf, "_TLS_MODULE_BASE_",
   /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
      for it later.  */
   tlsbase = elf_link_hash_lookup (&ret->elf, "_TLS_MODULE_BASE_",


@@ -752,7 +742,7 @@ property_table_compare (const void *ap, const void *bp)
              != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
        return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
                - GET_XTENSA_PROP_ALIGNMENT (b->flags));
              != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
        return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
                - GET_XTENSA_PROP_ALIGNMENT (b->flags));

-      
+

       if ((a->flags & XTENSA_PROP_UNREACHABLE)
          != (b->flags & XTENSA_PROP_UNREACHABLE))
        return ((b->flags & XTENSA_PROP_UNREACHABLE)
       if ((a->flags & XTENSA_PROP_UNREACHABLE)
          != (b->flags & XTENSA_PROP_UNREACHABLE))
        return ((b->flags & XTENSA_PROP_UNREACHABLE)


@@ -814,7 +804,7 @@ xtensa_read_table_entries (bfd *abfd,
   if (table_section)
     table_size = table_section->size;
 
   if (table_section)
     table_size = table_section->size;
 

-  if (table_size == 0) 
+  if (table_size == 0)

     {
       *table_p = NULL;
       return 0;
     {
       *table_p = NULL;
       return 0;


@@ -849,7 +839,7 @@ xtensa_read_table_entries (bfd *abfd,
   section_limit = bfd_get_section_limit (abfd, section);
   rel_end = internal_relocs + table_section->reloc_count;
 
   section_limit = bfd_get_section_limit (abfd, section);
   rel_end = internal_relocs + table_section->reloc_count;
 

-  for (off = 0; off < table_size; off += table_entry_size) 
+  for (off = 0; off < table_size; off += table_entry_size)

     {
       bfd_vma address = bfd_get_32 (abfd, table_data + off);
 
     {
       bfd_vma address = bfd_get_32 (abfd, table_data + off);
 


@@ -1017,6 +1007,10 @@ elf_xtensa_check_relocs (bfd *abfd,
          while (h->root.type == bfd_link_hash_indirect
                 || h->root.type == bfd_link_hash_warning)
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
          while (h->root.type == bfd_link_hash_indirect
                 || h->root.type == bfd_link_hash_warning)
            h = (struct elf_link_hash_entry *) h->root.u.i.link;

+
+         /* PR15323, ref flags aren't set for references in the same
+            object.  */
+         h->root.non_ir_ref = 1;

        }
       eh = elf_xtensa_hash_entry (h);
 
        }
       eh = elf_xtensa_hash_entry (h);
 


@@ -1414,11 +1408,11 @@ elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
   /* First do all the standard stuff.  */
   if (! _bfd_elf_create_dynamic_sections (dynobj, info))
     return FALSE;
   /* First do all the standard stuff.  */
   if (! _bfd_elf_create_dynamic_sections (dynobj, info))
     return FALSE;

-  htab->splt = bfd_get_section_by_name (dynobj, ".plt");
-  htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
-  htab->sgot = bfd_get_section_by_name (dynobj, ".got");
-  htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
-  htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+  htab->splt = bfd_get_linker_section (dynobj, ".plt");
+  htab->srelplt = bfd_get_linker_section (dynobj, ".rela.plt");
+  htab->sgot = bfd_get_linker_section (dynobj, ".got");
+  htab->sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
+  htab->srelgot = bfd_get_linker_section (dynobj, ".rela.got");

 
   /* Create any extra PLT sections in case check_relocs has already
      been called on all the non-dynamic input files.  */
 
   /* Create any extra PLT sections in case check_relocs has already
      been called on all the non-dynamic input files.  */


@@ -1435,14 +1429,15 @@ elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
     return FALSE;
 
   /* Create ".got.loc" (literal tables for use by dynamic linker).  */
     return FALSE;
 
   /* Create ".got.loc" (literal tables for use by dynamic linker).  */

-  htab->sgotloc = bfd_make_section_with_flags (dynobj, ".got.loc", flags);
+  htab->sgotloc = bfd_make_section_anyway_with_flags (dynobj, ".got.loc",
+                                                     flags);

   if (htab->sgotloc == NULL
       || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2))
     return FALSE;
 
   /* Create ".xt.lit.plt" (literal table for ".got.plt*").  */
   if (htab->sgotloc == NULL
       || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2))
     return FALSE;
 
   /* Create ".xt.lit.plt" (literal table for ".got.plt*").  */

-  htab->spltlittbl = bfd_make_section_with_flags (dynobj, ".xt.lit.plt",
-                                                 noalloc_flags);
+  htab->spltlittbl = bfd_make_section_anyway_with_flags (dynobj, ".xt.lit.plt",
+                                                        noalloc_flags);

   if (htab->spltlittbl == NULL
       || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2))
     return FALSE;
   if (htab->spltlittbl == NULL
       || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2))
     return FALSE;


@@ -1474,14 +1469,14 @@ add_extra_plt_sections (struct bfd_link_info *info, int count)
 
       sname = (char *) bfd_malloc (10);
       sprintf (sname, ".plt.%u", chunk);
 
       sname = (char *) bfd_malloc (10);
       sprintf (sname, ".plt.%u", chunk);

-      s = bfd_make_section_with_flags (dynobj, sname, flags | SEC_CODE);
+      s = bfd_make_section_anyway_with_flags (dynobj, sname, flags | SEC_CODE);

       if (s == NULL
          || ! bfd_set_section_alignment (dynobj, s, 2))
        return FALSE;
 
       sname = (char *) bfd_malloc (14);
       sprintf (sname, ".got.plt.%u", chunk);
       if (s == NULL
          || ! bfd_set_section_alignment (dynobj, s, 2))
        return FALSE;
 
       sname = (char *) bfd_malloc (14);
       sprintf (sname, ".got.plt.%u", chunk);

-      s = bfd_make_section_with_flags (dynobj, sname, flags);
+      s = bfd_make_section_anyway_with_flags (dynobj, sname, flags);

       if (s == NULL
          || ! bfd_set_section_alignment (dynobj, s, 2))
        return FALSE;
       if (s == NULL
          || ! bfd_set_section_alignment (dynobj, s, 2))
        return FALSE;


@@ -1531,9 +1526,6 @@ elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry *h, void *arg)
   if (h->root.type == bfd_link_hash_indirect)
     return TRUE;
 
   if (h->root.type == bfd_link_hash_indirect)
     return TRUE;
 

-  if (h->root.type == bfd_link_hash_warning)
-    h = (struct elf_link_hash_entry *) h->root.u.i.link;
-

   info = (struct bfd_link_info *) arg;
   htab = elf_xtensa_hash_table (info);
   if (htab == NULL)
   info = (struct bfd_link_info *) arg;
   htab = elf_xtensa_hash_table (info);
   if (htab == NULL)


@@ -1639,7 +1631,7 @@ elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
       /* Set the contents of the .interp section to the interpreter.  */
       if (info->executable)
        {
       /* Set the contents of the .interp section to the interpreter.  */
       if (info->executable)
        {

-         s = bfd_get_section_by_name (dynobj, ".interp");
+         s = bfd_get_linker_section (dynobj, ".interp");

          if (s == NULL)
            abort ();
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
          if (s == NULL)
            abort ();
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;


@@ -1715,7 +1707,7 @@ elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
            continue;
          for (s = abfd->sections; s != NULL; s = s->next)
            {
            continue;
          for (s = abfd->sections; s != NULL; s = s->next)
            {

-             if (! elf_discarded_section (s)
+             if (! discarded_section (s)

                  && xtensa_is_littable_section (s)
                  && s != spltlittbl)
                sgotloc->size += s->size;
                  && xtensa_is_littable_section (s)
                  && s != spltlittbl)
                sgotloc->size += s->size;


@@ -1971,7 +1963,7 @@ elf_xtensa_do_reloc (reloc_howto_type *howto,
          if (is_windowed_call_opcode (opcode))
            {
              if ((self_address >> CALL_SEGMENT_BITS)
          if (is_windowed_call_opcode (opcode))
            {
              if ((self_address >> CALL_SEGMENT_BITS)

-                 != (relocation >> CALL_SEGMENT_BITS)) 
+                 != (relocation >> CALL_SEGMENT_BITS))

                {
                  *error_message = "windowed longcall crosses 1GB boundary; "
                    "return may fail";
                {
                  *error_message = "windowed longcall crosses 1GB boundary; "
                    "return may fail";


@@ -2144,7 +2136,7 @@ elf_xtensa_do_reloc (reloc_howto_type *howto,
       && is_windowed_call_opcode (opcode))
     {
       if ((self_address >> CALL_SEGMENT_BITS)
       && is_windowed_call_opcode (opcode))
     {
       if ((self_address >> CALL_SEGMENT_BITS)

-         != (relocation >> CALL_SEGMENT_BITS)) 
+         != (relocation >> CALL_SEGMENT_BITS))

        {
          *error_message =
            "windowed call crosses 1GB boundary; return may fail";
        {
          *error_message =
            "windowed call crosses 1GB boundary; return may fail";


@@ -2172,8 +2164,8 @@ vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
 
   VA_OPEN (ap, arglen);
   VA_FIXEDARG (ap, const char *, origmsg);
 
   VA_OPEN (ap, arglen);
   VA_FIXEDARG (ap, const char *, origmsg);

-  
-  is_append = (origmsg == message);  
+
+  is_append = (origmsg == message);

 
   orig_len = strlen (origmsg);
   len = orig_len + strlen (fmt) + arglen + 20;
 
   orig_len = strlen (origmsg);
   len = orig_len + strlen (fmt) + arglen + 20;


@@ -2646,10 +2638,12 @@ elf_xtensa_relocate_section (bfd *output_bfd,
        }
       else
        {
        }
       else
        {

+         bfd_boolean ignored;
+

          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
                                   r_symndx, symtab_hdr, sym_hashes,
                                   h, sec, relocation,
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
                                   r_symndx, symtab_hdr, sym_hashes,
                                   h, sec, relocation,

-                                  unresolved_reloc, warned);
+                                  unresolved_reloc, warned, ignored);

 
          if (relocation == 0
              && !unresolved_reloc
 
          if (relocation == 0
              && !unresolved_reloc


@@ -2659,16 +2653,9 @@ elf_xtensa_relocate_section (bfd *output_bfd,
          sym_type = h->type;
        }
 
          sym_type = h->type;
        }
 

-      if (sec != NULL && elf_discarded_section (sec))
-       {
-         /* For relocs against symbols from removed linkonce sections,
-            or sections discarded by a linker script, we just want the
-            section contents zeroed.  Avoid any special processing.  */
-         _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
-         rel->r_info = 0;
-         rel->r_addend = 0;
-         continue;
-       }
+      if (sec != NULL && discarded_section (sec))
+       RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
+                                        rel, 1, relend, howto, 0, contents);

 
       if (info->relocatable)
        {
 
       if (info->relocatable)
        {


@@ -3068,7 +3055,9 @@ elf_xtensa_relocate_section (bfd *output_bfd,
         not process them.  */
       if (unresolved_reloc
          && !((input_section->flags & SEC_DEBUGGING) != 0
         not process them.  */
       if (unresolved_reloc
          && !((input_section->flags & SEC_DEBUGGING) != 0

-              && h->def_dynamic))
+              && h->def_dynamic)
+         && _bfd_elf_section_offset (output_bfd, info, input_section,
+                                     rel->r_offset) != (bfd_vma) -1)

        {
          (*_bfd_error_handler)
            (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
        {
          (*_bfd_error_handler)
            (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),


@@ -3142,7 +3131,7 @@ elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
     }
 
   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
     }
 
   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */

-  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
+  if (h == elf_hash_table (info)->hdynamic

       || h == elf_hash_table (info)->hgot)
     sym->st_shndx = SHN_ABS;
 
       || h == elf_hash_table (info)->hgot)
     sym->st_shndx = SHN_ABS;
 


@@ -3283,7 +3272,7 @@ elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
     return FALSE;
 
   dynobj = elf_hash_table (info)->dynobj;
     return FALSE;
 
   dynobj = elf_hash_table (info)->dynobj;

-  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+  sdyn = bfd_get_linker_section (dynobj, ".dynamic");

   BFD_ASSERT (sdyn != NULL);
 
   /* Set the first entry in the global offset table to the address of
   BFD_ASSERT (sdyn != NULL);
 
   /* Set the first entry in the global offset table to the address of


@@ -3473,7 +3462,7 @@ elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
   unsigned out_mach, in_mach;
   flagword out_flag, in_flag;
 
   unsigned out_mach, in_mach;
   flagword out_flag, in_flag;
 

-  /* Check if we have the same endianess.  */
+  /* Check if we have the same endianness.  */

   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
     return FALSE;
 
   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
     return FALSE;
 


@@ -3509,10 +3498,10 @@ elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
       return TRUE;
     }
 
       return TRUE;
     }
 

-  if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN)) 
+  if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))

     elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
 
     elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
 

-  if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT)) 
+  if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))

     elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
 
   return TRUE;
     elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
 
   return TRUE;


@@ -3602,7 +3591,9 @@ elf_xtensa_final_write_processing (bfd *abfd,
 
 
 static enum elf_reloc_type_class
 
 
 static enum elf_reloc_type_class

-elf_xtensa_reloc_type_class (const Elf_Internal_Rela *rela)
+elf_xtensa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
+                            const asection *rel_sec ATTRIBUTE_UNUSED,
+                            const Elf_Internal_Rela *rela)

 {
   switch ((int) ELF32_R_TYPE (rela->r_info))
     {
 {
   switch ((int) ELF32_R_TYPE (rela->r_info))
     {


@@ -3799,10 +3790,10 @@ elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
      based on the size.  Just assume this is GNU/Linux.  */
 
   /* pr_cursig */
      based on the size.  Just assume this is GNU/Linux.  */
 
   /* pr_cursig */

-  elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
+  elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);

 
   /* pr_pid */
 
   /* pr_pid */

-  elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
+  elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);

 
   /* pr_reg */
   offset = 72;
 
   /* pr_reg */
   offset = 72;


@@ -3823,9 +3814,9 @@ elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
        return FALSE;
 
       case 128:                /* GNU/Linux elf_prpsinfo */
        return FALSE;
 
       case 128:                /* GNU/Linux elf_prpsinfo */

-       elf_tdata (abfd)->core_program
+       elf_tdata (abfd)->core->program

         = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
         = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);

-       elf_tdata (abfd)->core_command
+       elf_tdata (abfd)->core->command

         = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
     }
 
         = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
     }
 


@@ -3834,7 +3825,7 @@ elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
      implementations, so strip it off if it exists.  */
 
   {
      implementations, so strip it off if it exists.  */
 
   {

-    char *command = elf_tdata (abfd)->core_command;
+    char *command = elf_tdata (abfd)->core->command;

     int n = strlen (command);
 
     if (0 < n && command[n - 1] == ' ')
     int n = strlen (command);
 
     if (0 < n && command[n - 1] == ' ')


@@ -4103,7 +4094,7 @@ get_asm_simplify_size (bfd_byte *contents,
     return 0;
 
   size += insnlen;
     return 0;
 
   size += insnlen;

-  
+

   insnlen = insn_decode_len (contents, content_len, offset + size);
   if (insnlen == 0)
     return 0;
   insnlen = insn_decode_len (contents, content_len, offset + size);
   if (insnlen == 0)
     return 0;


@@ -4142,7 +4133,7 @@ is_operand_relocation (int r_type)
   return FALSE;
 }
 
   return FALSE;
 }
 

-      
+

 #define MIN_INSN_LENGTH 2
 
 /* Return 0 if it fails to decode.  */
 #define MIN_INSN_LENGTH 2
 
 /* Return 0 if it fails to decode.  */


@@ -4243,7 +4234,7 @@ check_loop_aligned (bfd_byte *contents,
       BFD_ASSERT (FALSE);
       return FALSE;
     }
       BFD_ASSERT (FALSE);
       return FALSE;
     }

-  
+

   loop_len = insn_decode_len (contents, content_length, offset);
   insn_len = insn_decode_len (contents, content_length, offset + loop_len);
   if (loop_len == 0 || insn_len == 0)
   loop_len = insn_decode_len (contents, content_length, offset);
   insn_len = insn_decode_len (contents, content_length, offset + loop_len);
   if (loop_len == 0 || insn_len == 0)


@@ -4635,7 +4626,7 @@ can_widen_instruction (xtensa_insnbuf slotbuf,
   return 0;
 }
 
   return 0;
 }
 

-                      
+

 /* Attempt to widen an instruction.  If the widening is valid, perform
    the action in-place directly into the contents and return TRUE.  Otherwise,
    the return value is FALSE and the contents are not modified.  */
 /* Attempt to widen an instruction.  If the widening is valid, perform
    the action in-place directly into the contents and return TRUE.  Otherwise,
    the return value is FALSE and the contents are not modified.  */


@@ -4730,12 +4721,12 @@ elf_xtensa_do_asm_simplify (bfd_byte *contents,
       *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
       return bfd_reloc_other;
     }
       *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
       return bfd_reloc_other;
     }

-  
+

   /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset.  */
   core_format = xtensa_format_lookup (isa, "x24");
   opcode = xtensa_opcode_lookup (isa, "or");
   xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
   /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset.  */
   core_format = xtensa_format_lookup (isa, "x24");
   opcode = xtensa_opcode_lookup (isa, "or");
   xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);

-  for (opn = 0; opn < 3; opn++) 
+  for (opn = 0; opn < 3; opn++)

     {
       uint32 regno = 1;
       xtensa_operand_encode (isa, opcode, opn, &regno);
     {
       uint32 regno = 1;
       xtensa_operand_encode (isa, opcode, opn, &regno);


@@ -4803,7 +4794,7 @@ swap_callx_for_call_opcode (xtensa_opcode opcode)
 #define CONST16_TARGET_REG_OPERAND 0
 #define CALLN_SOURCE_OPERAND 0
 
 #define CONST16_TARGET_REG_OPERAND 0
 #define CALLN_SOURCE_OPERAND 0
 

-static xtensa_opcode 
+static xtensa_opcode

 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
 {
   static xtensa_insnbuf insnbuf = NULL;
 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
 {
   static xtensa_insnbuf insnbuf = NULL;


@@ -4879,7 +4870,7 @@ get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
       || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
     return XTENSA_UNDEFINED;
   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
       || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
     return XTENSA_UNDEFINED;
   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);

-  if (opcode == XTENSA_UNDEFINED 
+  if (opcode == XTENSA_UNDEFINED

       || !is_indirect_call_opcode (opcode))
     return XTENSA_UNDEFINED;
 
       || !is_indirect_call_opcode (opcode))
     return XTENSA_UNDEFINED;
 


@@ -4910,7 +4901,7 @@ get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
    For efficiency, an r_reloc also contains a "target_offset" field to
    cache the target-section-relative offset value that is represented by
    the relocation.
    For efficiency, an r_reloc also contains a "target_offset" field to
    cache the target-section-relative offset value that is represented by
    the relocation.

-   
+

    The r_reloc also contains a virtual offset that allows multiple
    inserted literals to be placed at the same "address" with
    different offsets.  */
    The r_reloc also contains a virtual offset that allows multiple
    inserted literals to be placed at the same "address" with
    different offsets.  */


@@ -5037,7 +5028,7 @@ print_r_reloc (FILE *fp, const r_reloc *r_rel)
       fprintf (fp, " + ");
       fprintf_vma (fp, r_rel->virtual_offset);
     }
       fprintf (fp, " + ");
       fprintf_vma (fp, r_rel->virtual_offset);
     }

-    
+

   fprintf (fp, ")");
 }
 
   fprintf (fp, ")");
 }
 


@@ -5157,7 +5148,7 @@ typedef struct value_map_hash_table_struct value_map_hash_table;
 
 struct literal_value_struct
 {
 
 struct literal_value_struct
 {

-  r_reloc r_rel; 
+  r_reloc r_rel;

   unsigned long value;
   bfd_boolean is_abs_literal;
 };
   unsigned long value;
   bfd_boolean is_abs_literal;
 };


@@ -5198,7 +5189,7 @@ literal_value_equal (const literal_value *src1,
 {
   struct elf_link_hash_entry *h1, *h2;
 
 {
   struct elf_link_hash_entry *h1, *h2;
 

-  if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel)) 
+  if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))

     return FALSE;
 
   if (r_reloc_is_const (&src1->r_rel))
     return FALSE;
 
   if (r_reloc_is_const (&src1->r_rel))


@@ -5210,13 +5201,13 @@ literal_value_equal (const literal_value *src1,
 
   if (src1->r_rel.target_offset != src2->r_rel.target_offset)
     return FALSE;
 
   if (src1->r_rel.target_offset != src2->r_rel.target_offset)
     return FALSE;

-   
+

   if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
     return FALSE;
 
   if (src1->value != src2->value)
     return FALSE;
   if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
     return FALSE;
 
   if (src1->value != src2->value)
     return FALSE;

-  
+

   /* Now check for the same section (if defined) or the same elf_hash
      (if undefined or weak).  */
   h1 = r_reloc_get_hash_entry (&src1->r_rel);
   /* Now check for the same section (if defined) or the same elf_hash
      (if undefined or weak).  */
   h1 = r_reloc_get_hash_entry (&src1->r_rel);


@@ -5258,7 +5249,7 @@ value_map_hash_table_init (void)
   values->count = 0;
   values->buckets = (value_map **)
     bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
   values->count = 0;
   values->buckets = (value_map **)
     bfd_zmalloc (sizeof (value_map *) * values->bucket_count);

-  if (values->buckets == NULL) 
+  if (values->buckets == NULL)

     {
       free (values);
       return NULL;
     {
       free (values);
       return NULL;


@@ -5297,7 +5288,7 @@ literal_value_hash (const literal_value *src)
       hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
       hash_val += hash_bfd_vma (src->r_rel.target_offset);
       hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
       hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
       hash_val += hash_bfd_vma (src->r_rel.target_offset);
       hash_val += hash_bfd_vma (src->r_rel.virtual_offset);

-  
+

       /* Now check for the same section and the same elf_hash.  */
       if (r_reloc_is_defined (&src->r_rel))
        sec_or_hash = r_reloc_get_section (&src->r_rel);
       /* Now check for the same section and the same elf_hash.  */
       if (r_reloc_is_defined (&src->r_rel))
        sec_or_hash = r_reloc_get_section (&src->r_rel);


@@ -5363,7 +5354,7 @@ add_value_map (value_map_hash_table *map,
   *bucket_p = val_e;
   map->count++;
   /* FIXME: Consider resizing the hash table if we get too many entries.  */
   *bucket_p = val_e;
   map->count++;
   /* FIXME: Consider resizing the hash table if we get too many entries.  */

-  
+

   return val_e;
 }
 
   return val_e;
 }
 


@@ -5503,7 +5494,7 @@ adjust_fill_action (text_action *ta, int fill_diff)
    "unreachable_space" bytes can be freely contracted.  Note that a
    negative removed value is a fill.  */
 
    "unreachable_space" bytes can be freely contracted.  Note that a
    negative removed value is a fill.  */
 

-static void 
+static void

 text_action_add (text_action_list *l,
                 text_action_t action,
                 asection *sec,
 text_action_add (text_action_list *l,
                 text_action_t action,
                 asection *sec,


@@ -5524,8 +5515,8 @@ text_action_add (text_action_list *l,
   for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
     {
       text_action *t = *m_p;
   for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
     {
       text_action *t = *m_p;

-      
-      if (action == ta_fill) 
+
+      if (action == ta_fill)

        {
          /* When the action is another fill at the same address,
             just increase the size.  */
        {
          /* When the action is another fill at the same address,
             just increase the size.  */


@@ -5622,7 +5613,7 @@ removed_by_actions (text_action **p_start_action,
 }
 
 
 }
 
 

-static bfd_vma 
+static bfd_vma

 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
 {
   text_action *r = action_list->head;
 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
 {
   text_action *r = action_list->head;


@@ -5760,9 +5751,9 @@ add_removed_literal (removed_literal_list *removed_list,
   else
     new_r->to.abfd = NULL;
   new_r->next = NULL;
   else
     new_r->to.abfd = NULL;
   new_r->next = NULL;

-  
+

   r = removed_list->head;
   r = removed_list->head;

-  if (r == NULL) 
+  if (r == NULL)

     {
       removed_list->head = new_r;
       removed_list->tail = new_r;
     {
       removed_list->head = new_r;
       removed_list->tail = new_r;


@@ -5775,7 +5766,7 @@ add_removed_literal (removed_literal_list *removed_list,
     }
   else
     {
     }
   else
     {

-      while (r->from.target_offset < from->target_offset && r->next) 
+      while (r->from.target_offset < from->target_offset && r->next)

        {
          r = r->next;
        }
        {
          r = r->next;
        }


@@ -5853,7 +5844,7 @@ struct xtensa_relax_info_struct
      reallocated, the newly allocated relocations will be referenced
      here along with the actual size allocated.  The relocation
      count will always be found in the section structure.  */
      reallocated, the newly allocated relocations will be referenced
      here along with the actual size allocated.  The relocation
      count will always be found in the section structure.  */

-  Elf_Internal_Rela *allocated_relocs; 
+  Elf_Internal_Rela *allocated_relocs;

   unsigned relocs_count;
   unsigned allocated_relocs_count;
 };
   unsigned relocs_count;
   unsigned allocated_relocs_count;
 };


@@ -5919,7 +5910,7 @@ init_xtensa_relax_info (asection *sec)
   relax_info->fix_array = NULL;
   relax_info->fix_array_count = 0;
 
   relax_info->fix_array = NULL;
   relax_info->fix_array_count = 0;
 

-  relax_info->allocated_relocs = NULL; 
+  relax_info->allocated_relocs = NULL;

   relax_info->relocs_count = 0;
   relax_info->allocated_relocs_count = 0;
 }
   relax_info->relocs_count = 0;
   relax_info->allocated_relocs_count = 0;
 }


@@ -5939,11 +5930,11 @@ struct reloc_bfd_fix_struct
   asection *src_sec;
   bfd_vma src_offset;
   unsigned src_type;                   /* Relocation type.  */
   asection *src_sec;
   bfd_vma src_offset;
   unsigned src_type;                   /* Relocation type.  */

-  
+

   asection *target_sec;
   bfd_vma target_offset;
   bfd_boolean translated;
   asection *target_sec;
   bfd_vma target_offset;
   bfd_boolean translated;

-  
+

   reloc_bfd_fix *next;
 };
 
   reloc_bfd_fix *next;
 };
 


@@ -6074,7 +6065,7 @@ init_section_cache (section_cache_t *sec_cache)
 
 
 static void
 
 
 static void

-clear_section_cache (section_cache_t *sec_cache)
+free_section_cache (section_cache_t *sec_cache)

 {
   if (sec_cache->sec)
     {
 {
   if (sec_cache->sec)
     {


@@ -6082,7 +6073,6 @@ clear_section_cache (section_cache_t *sec_cache)
       release_internal_relocs (sec_cache->sec, sec_cache->relocs);
       if (sec_cache->ptbl)
        free (sec_cache->ptbl);
       release_internal_relocs (sec_cache->sec, sec_cache->relocs);
       if (sec_cache->ptbl)
        free (sec_cache->ptbl);

-      memset (sec_cache, 0, sizeof (sec_cache));

     }
 }
 
     }
 }
 


@@ -6123,8 +6113,8 @@ section_cache_section (section_cache_t *sec_cache,
     goto err;
 
   /* Fill in the new section cache.  */
     goto err;
 
   /* Fill in the new section cache.  */

-  clear_section_cache (sec_cache);
-  memset (sec_cache, 0, sizeof (sec_cache));
+  free_section_cache (sec_cache);
+  init_section_cache (sec_cache);

 
   sec_cache->sec = sec;
   sec_cache->contents = contents;
 
   sec_cache->sec = sec;
   sec_cache->contents = contents;


@@ -6555,7 +6545,7 @@ retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
 
   sec_size = bfd_get_section_limit (abfd, sec);
   contents = elf_section_data (sec)->this_hdr.contents;
 
   sec_size = bfd_get_section_limit (abfd, sec);
   contents = elf_section_data (sec)->this_hdr.contents;

-  
+

   if (contents == NULL && sec_size != 0)
     {
       if (!bfd_malloc_and_get_section (abfd, sec, &contents))
   if (contents == NULL && sec_size != 0)
     {
       if (!bfd_malloc_and_get_section (abfd, sec, &contents))


@@ -6564,7 +6554,7 @@ retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
            free (contents);
          return NULL;
        }
            free (contents);
          return NULL;
        }

-      if (keep_memory) 
+      if (keep_memory)

        elf_section_data (sec)->this_hdr.contents = contents;
     }
   return contents;
        elf_section_data (sec)->this_hdr.contents = contents;
     }
   return contents;


@@ -6639,12 +6629,12 @@ static bfd_boolean compute_removed_literals
   (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
 static Elf_Internal_Rela *get_irel_at_offset
   (asection *, Elf_Internal_Rela *, bfd_vma);
   (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
 static Elf_Internal_Rela *get_irel_at_offset
   (asection *, Elf_Internal_Rela *, bfd_vma);

-static bfd_boolean is_removable_literal 
+static bfd_boolean is_removable_literal

   (const source_reloc *, int, const source_reloc *, int, asection *,
    property_table_entry *, int);
 static bfd_boolean remove_dead_literal
   (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
   (const source_reloc *, int, const source_reloc *, int, asection *,
    property_table_entry *, int);
 static bfd_boolean remove_dead_literal
   (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,

-   Elf_Internal_Rela *, source_reloc *, property_table_entry *, int); 
+   Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);

 static bfd_boolean identify_literal_placement
   (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
    value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
 static bfd_boolean identify_literal_placement
   (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
    value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,


@@ -6674,7 +6664,7 @@ static bfd_boolean relax_property_section
 static bfd_boolean relax_section_symbols (bfd *, asection *);
 
 
 static bfd_boolean relax_section_symbols (bfd *, asection *);
 
 

-static bfd_boolean 
+static bfd_boolean

 elf_xtensa_relax_section (bfd *abfd,
                          asection *sec,
                          struct bfd_link_info *link_info,
 elf_xtensa_relax_section (bfd *abfd,
                          asection *sec,
                          struct bfd_link_info *link_info,


@@ -6837,7 +6827,7 @@ find_relaxable_sections (bfd *abfd,
 
   internal_relocs = retrieve_internal_relocs (abfd, sec,
                                              link_info->keep_memory);
 
   internal_relocs = retrieve_internal_relocs (abfd, sec,
                                              link_info->keep_memory);

-  if (internal_relocs == NULL) 
+  if (internal_relocs == NULL)

     return ok;
 
   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
     return ok;
 
   contents = retrieve_contents (abfd, sec, link_info->keep_memory);


@@ -6848,7 +6838,7 @@ find_relaxable_sections (bfd *abfd,
     }
 
   source_relax_info = get_xtensa_relax_info (sec);
     }
 
   source_relax_info = get_xtensa_relax_info (sec);

-  for (i = 0; i < sec->reloc_count; i++) 
+  for (i = 0; i < sec->reloc_count; i++)

     {
       Elf_Internal_Rela *irel = &internal_relocs[i];
       r_reloc r_rel;
     {
       Elf_Internal_Rela *irel = &internal_relocs[i];
       r_reloc r_rel;


@@ -6928,9 +6918,9 @@ collect_source_relocs (bfd *abfd,
   unsigned i;
   bfd_size_type sec_size;
 
   unsigned i;
   bfd_size_type sec_size;
 

-  internal_relocs = retrieve_internal_relocs (abfd, sec, 
+  internal_relocs = retrieve_internal_relocs (abfd, sec,

                                              link_info->keep_memory);
                                              link_info->keep_memory);

-  if (internal_relocs == NULL) 
+  if (internal_relocs == NULL)

     return ok;
 
   sec_size = bfd_get_section_limit (abfd, sec);
     return ok;
 
   sec_size = bfd_get_section_limit (abfd, sec);


@@ -6942,7 +6932,7 @@ collect_source_relocs (bfd *abfd,
     }
 
   /* Record relocations against relaxable literal sections.  */
     }
 
   /* Record relocations against relaxable literal sections.  */

-  for (i = 0; i < sec->reloc_count; i++) 
+  for (i = 0; i < sec->reloc_count; i++)

     {
       Elf_Internal_Rela *irel = &internal_relocs[i];
       r_reloc r_rel;
     {
       Elf_Internal_Rela *irel = &internal_relocs[i];
       r_reloc r_rel;


@@ -7000,7 +6990,7 @@ collect_source_relocs (bfd *abfd,
      relocations associated with ASM_EXPANDs because they were just
      added in the preceding loop over the relocations.  */
 
      relocations associated with ASM_EXPANDs because they were just
      added in the preceding loop over the relocations.  */
 

-  for (i = 0; i < sec->reloc_count; i++) 
+  for (i = 0; i < sec->reloc_count; i++)

     {
       Elf_Internal_Rela *irel = &internal_relocs[i];
       bfd_boolean is_reachable;
     {
       Elf_Internal_Rela *irel = &internal_relocs[i];
       bfd_boolean is_reachable;


@@ -7039,7 +7029,7 @@ collect_source_relocs (bfd *abfd,
                 the l32r_irel.  Note: The src_relocs array is not yet
                 sorted, but it wouldn't matter anyway because we're
                 searching by source offset instead of target offset.  */
                 the l32r_irel.  Note: The src_relocs array is not yet
                 sorted, but it wouldn't matter anyway because we're
                 searching by source offset instead of target offset.  */

-             s_reloc = find_source_reloc (target_relax_info->src_relocs, 
+             s_reloc = find_source_reloc (target_relax_info->src_relocs,

                                           target_relax_info->src_next,
                                           sec, l32r_irel);
              BFD_ASSERT (s_reloc);
                                           target_relax_info->src_next,
                                           sec, l32r_irel);
              BFD_ASSERT (s_reloc);


@@ -7098,7 +7088,7 @@ is_resolvable_asm_expansion (bfd *abfd,
   if (contents == NULL)
     return FALSE;
 
   if (contents == NULL)
     return FALSE;
 

-  if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND) 
+  if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)

     return FALSE;
 
   sec_size = bfd_get_section_limit (abfd, sec);
     return FALSE;
 
   sec_size = bfd_get_section_limit (abfd, sec);


@@ -7107,7 +7097,7 @@ is_resolvable_asm_expansion (bfd *abfd,
   /* Optimization of longcalls that use CONST16 is not yet implemented.  */
   if (!uses_l32r)
     return FALSE;
   /* Optimization of longcalls that use CONST16 is not yet implemented.  */
   if (!uses_l32r)
     return FALSE;

-  
+

   direct_call_opcode = swap_callx_for_call_opcode (opcode);
   if (direct_call_opcode == XTENSA_UNDEFINED)
     return FALSE;
   direct_call_opcode = swap_callx_for_call_opcode (opcode);
   if (direct_call_opcode == XTENSA_UNDEFINED)
     return FALSE;


@@ -7126,7 +7116,7 @@ is_resolvable_asm_expansion (bfd *abfd,
      shouldn't crash regardless.  */
   if (!target_sec->output_section)
     return FALSE;
      shouldn't crash regardless.  */
   if (!target_sec->output_section)
     return FALSE;

-      
+

   /* For relocatable sections, we can only simplify when the output
      section of the target is the same as the output section of the
      source.  */
   /* For relocatable sections, we can only simplify when the output
      section of the target is the same as the output section of the
      source.  */


@@ -7139,7 +7129,7 @@ is_resolvable_asm_expansion (bfd *abfd,
                  + sec->output_offset + irel->r_offset + 3);
   dest_address = (target_sec->output_section->vma
                  + target_sec->output_offset + target_offset);
                  + sec->output_offset + irel->r_offset + 3);
   dest_address = (target_sec->output_section->vma
                  + target_sec->output_offset + target_offset);

-      
+

   *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
                                      self_address, dest_address);
 
   *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
                                      self_address, dest_address);
 


@@ -7160,7 +7150,7 @@ find_associated_l32r_irel (bfd *abfd,
 {
   unsigned i;
 
 {
   unsigned i;
 

-  for (i = 0; i < sec->reloc_count; i++) 
+  for (i = 0; i < sec->reloc_count; i++)

     {
       Elf_Internal_Rela *irel = &internal_relocs[i];
 
     {
       Elf_Internal_Rela *irel = &internal_relocs[i];
 


@@ -7377,7 +7367,7 @@ prev_instr_is_a_loop (bfd_byte *contents,
     return FALSE;
   prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
   return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
     return FALSE;
   prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
   return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);

-} 
+}

 
 
 /* Find all of the possible actions for an extended basic block.  */
 
 
 /* Find all of the possible actions for an extended basic block.  */


@@ -7427,7 +7417,7 @@ compute_ebb_proposed_actions (ebb_constraint *ebb_table)
 
          insn_len = insn_decode_len (ebb->contents, ebb->content_length,
                                      offset);
 
          insn_len = insn_decode_len (ebb->contents, ebb->content_length,
                                      offset);

-         if (insn_len == 0) 
+         if (insn_len == 0)

            goto decode_error;
 
          if (check_branch_target_aligned_address (offset, insn_len))
            goto decode_error;
 
          if (check_branch_target_aligned_address (offset, insn_len))


@@ -7456,7 +7446,7 @@ compute_ebb_proposed_actions (ebb_constraint *ebb_table)
            {
              bfd_size_type simplify_size;
 
            {
              bfd_size_type simplify_size;
 

-             simplify_size = get_asm_simplify_size (ebb->contents, 
+             simplify_size = get_asm_simplify_size (ebb->contents,

                                                     ebb->content_length,
                                                     irel->r_offset);
              if (simplify_size == 0)
                                                     ebb->content_length,
                                                     irel->r_offset);
              if (simplify_size == 0)


@@ -7464,7 +7454,7 @@ compute_ebb_proposed_actions (ebb_constraint *ebb_table)
 
              ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
                                  ta_convert_longcall, offset, 0, TRUE);
 
              ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
                                  ta_convert_longcall, offset, 0, TRUE);

-             
+

              offset += simplify_size;
              continue;
            }
              offset += simplify_size;
              continue;
            }


@@ -7811,7 +7801,7 @@ struct xlate_map
 };
 
 
 };
 
 

-static int 
+static int

 xlate_compare (const void *a_v, const void *b_v)
 {
   const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
 xlate_compare (const void *a_v, const void *b_v)
 {
   const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;


@@ -7841,7 +7831,7 @@ xlate_offset_with_removed_text (const xlate_map_t *map,
   r = bsearch (&offset, map->entry, map->entry_count,
               sizeof (xlate_map_entry_t), &xlate_compare);
   e = (xlate_map_entry_t *) r;
   r = bsearch (&offset, map->entry, map->entry_count,
               sizeof (xlate_map_entry_t), &xlate_compare);
   e = (xlate_map_entry_t *) r;

-  
+

   BFD_ASSERT (e != NULL);
   if (e == NULL)
     return offset;
   BFD_ASSERT (e != NULL);
   if (e == NULL)
     return offset;


@@ -7866,7 +7856,7 @@ build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
     return NULL;
 
   num_actions = action_list_count (action_list);
     return NULL;
 
   num_actions = action_list_count (action_list);

-  map->entry = (xlate_map_entry_t *) 
+  map->entry = (xlate_map_entry_t *)

     bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
   if (map->entry == NULL)
     {
     bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
   if (map->entry == NULL)
     {


@@ -7874,7 +7864,7 @@ build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
       return NULL;
     }
   map->entry_count = 0;
       return NULL;
     }
   map->entry_count = 0;

-  
+

   removed = 0;
   current_entry = &map->entry[0];
 
   removed = 0;
   current_entry = &map->entry[0];
 


@@ -7929,7 +7919,7 @@ build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
 
 /* Free an offset translation map.  */
 
 
 /* Free an offset translation map.  */
 

-static void 
+static void

 free_xlate_map (xlate_map_t *map)
 {
   if (map && map->entry)
 free_xlate_map (xlate_map_t *map)
 {
   if (map && map->entry)


@@ -8161,7 +8151,7 @@ compute_fill_extra_space (property_table_entry *entry)
    add an entry to the per-section list of removed literals.  The
    actual changes are deferred until the next pass.  */
 
    add an entry to the per-section list of removed literals.  The
    actual changes are deferred until the next pass.  */
 

-static bfd_boolean 
+static bfd_boolean

 compute_removed_literals (bfd *abfd,
                          asection *sec,
                          struct bfd_link_info *link_info,
 compute_removed_literals (bfd *abfd,
                          asection *sec,
                          struct bfd_link_info *link_info,


@@ -8188,7 +8178,7 @@ compute_removed_literals (bfd *abfd,
   if (!relax_info->is_relaxable_literal_section)
     return ok;
 
   if (!relax_info->is_relaxable_literal_section)
     return ok;
 

-  internal_relocs = retrieve_internal_relocs (abfd, sec, 
+  internal_relocs = retrieve_internal_relocs (abfd, sec,

                                              link_info->keep_memory);
 
   sec_size = bfd_get_section_limit (abfd, sec);
                                              link_info->keep_memory);
 
   sec_size = bfd_get_section_limit (abfd, sec);


@@ -8240,14 +8230,14 @@ compute_removed_literals (bfd *abfd,
        continue;
       prev_i = i;
 
        continue;
       prev_i = i;
 

-      if (last_loc_is_prev && 
+      if (last_loc_is_prev &&

          last_target_offset + 4 != rel->r_rel.target_offset)
        last_loc_is_prev = FALSE;
 
       /* Check if the relocation was from an L32R that is being removed
         because a CALLX was converted to a direct CALL, and check if
         there are no other relocations to the literal.  */
          last_target_offset + 4 != rel->r_rel.target_offset)
        last_loc_is_prev = FALSE;
 
       /* Check if the relocation was from an L32R that is being removed
         because a CALLX was converted to a direct CALL, and check if
         there are no other relocations to the literal.  */

-      if (is_removable_literal (rel, i, src_relocs, relax_info->src_count, 
+      if (is_removable_literal (rel, i, src_relocs, relax_info->src_count,

                                sec, prop_table, ptblsize))
        {
          if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
                                sec, prop_table, ptblsize))
        {
          if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,


@@ -8261,8 +8251,8 @@ compute_removed_literals (bfd *abfd,
        }
 
       if (!identify_literal_placement (abfd, sec, contents, link_info,
        }
 
       if (!identify_literal_placement (abfd, sec, contents, link_info,

-                                      values, 
-                                      &last_loc_is_prev, irel, 
+                                      values,
+                                      &last_loc_is_prev, irel,

                                       relax_info->src_count - i, rel,
                                       prop_table, ptblsize,
                                       &target_sec_cache, rel->is_abs_literal))
                                       relax_info->src_count - i, rel,
                                       prop_table, ptblsize,
                                       &target_sec_cache, rel->is_abs_literal))


@@ -8279,8 +8269,9 @@ compute_removed_literals (bfd *abfd,
 #endif /* DEBUG */
 
 error_return:
 #endif /* DEBUG */
 
 error_return:

-  if (prop_table) free (prop_table);
-  clear_section_cache (&target_sec_cache);
+  if (prop_table)
+    free (prop_table);
+  free_section_cache (&target_sec_cache);

 
   release_contents (sec, contents);
   release_internal_relocs (sec, internal_relocs);
 
   release_contents (sec, contents);
   release_internal_relocs (sec, internal_relocs);


@@ -8298,7 +8289,7 @@ get_irel_at_offset (asection *sec,
   unsigned r_type;
   Elf_Internal_Rela key;
 
   unsigned r_type;
   Elf_Internal_Rela key;
 

-  if (!internal_relocs) 
+  if (!internal_relocs)

     return NULL;
 
   key.r_offset = offset;
     return NULL;
 
   key.r_offset = offset;


@@ -8342,8 +8333,8 @@ is_removable_literal (const source_reloc *rel,
 
   if (!rel->is_null)
     return FALSE;
 
   if (!rel->is_null)
     return FALSE;

-  
-  entry = elf_xtensa_find_property_entry (prop_table, ptblsize, 
+
+  entry = elf_xtensa_find_property_entry (prop_table, ptblsize,

                                          sec->vma + rel->r_rel.target_offset);
   if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
     return FALSE;
                                          sec->vma + rel->r_rel.target_offset);
   if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
     return FALSE;


@@ -8364,7 +8355,7 @@ is_removable_literal (const source_reloc *rel,
 }
 
 
 }
 
 

-bfd_boolean 
+bfd_boolean

 remove_dead_literal (bfd *abfd,
                     asection *sec,
                     struct bfd_link_info *link_info,
 remove_dead_literal (bfd *abfd,
                     asection *sec,
                     struct bfd_link_info *link_info,


@@ -8391,7 +8382,7 @@ remove_dead_literal (bfd *abfd,
                   ta_remove_literal, sec, rel->r_rel.target_offset, 4);
 
   /* If the section is 4-byte aligned, do not add fill.  */
                   ta_remove_literal, sec, rel->r_rel.target_offset, 4);
 
   /* If the section is 4-byte aligned, do not add fill.  */

-  if (sec->alignment_power > 2) 
+  if (sec->alignment_power > 2)

     {
       int fill_extra_space;
       bfd_vma entry_sec_offset;
     {
       int fill_extra_space;
       bfd_vma entry_sec_offset;


@@ -8435,7 +8426,7 @@ remove_dead_literal (bfd *abfd,
 }
 
 
 }
 
 

-bfd_boolean 
+bfd_boolean

 identify_literal_placement (bfd *abfd,
                            asection *sec,
                            bfd_byte *contents,
 identify_literal_placement (bfd *abfd,
                            asection *sec,
                            bfd_byte *contents,


@@ -8505,7 +8496,7 @@ identify_literal_placement (bfd *abfd,
   /* For relocatable links, do not try to move literals.  To do it
      correctly might increase the number of relocations in an input
      section making the default relocatable linking fail.  */
   /* For relocatable links, do not try to move literals.  To do it
      correctly might increase the number of relocations in an input
      section making the default relocatable linking fail.  */

-  if (!link_info->relocatable && !literal_placed 
+  if (!link_info->relocatable && !literal_placed

       && values->has_last_loc && !(*last_loc_is_prev_p))
     {
       asection *target_sec = r_reloc_get_section (&values->last_loc);
       && values->has_last_loc && !(*last_loc_is_prev_p))
     {
       asection *target_sec = r_reloc_get_section (&values->last_loc);


@@ -8518,7 +8509,7 @@ identify_literal_placement (bfd *abfd,
          /* There is a last loc that was in the same output section.  */
          if (relocations_reach (rel, remaining_src_rels, &try_loc)
              && move_shared_literal (sec, link_info, rel,
          /* There is a last loc that was in the same output section.  */
          if (relocations_reach (rel, remaining_src_rels, &try_loc)
              && move_shared_literal (sec, link_info, rel,

-                                     prop_table, ptblsize, 
+                                     prop_table, ptblsize,

                                      &try_loc, &val, target_sec_cache))
            {
              values->last_loc.virtual_offset += 4;
                                      &try_loc, &val, target_sec_cache))
            {
              values->last_loc.virtual_offset += 4;


@@ -8618,7 +8609,7 @@ relocations_reach (source_reloc *reloc,
 /* Move a literal to another literal location because it is
    the same as the other literal value.  */
 
 /* Move a literal to another literal location because it is
    the same as the other literal value.  */
 

-static bfd_boolean 
+static bfd_boolean

 coalesce_shared_literal (asection *sec,
                         source_reloc *rel,
                         property_table_entry *prop_table,
 coalesce_shared_literal (asection *sec,
                         source_reloc *rel,
                         property_table_entry *prop_table,


@@ -8647,7 +8638,7 @@ coalesce_shared_literal (asection *sec,
                   ta_remove_literal, sec, rel->r_rel.target_offset, 4);
 
   /* If the section is 4-byte aligned, do not add fill.  */
                   ta_remove_literal, sec, rel->r_rel.target_offset, 4);
 
   /* If the section is 4-byte aligned, do not add fill.  */

-  if (sec->alignment_power > 2) 
+  if (sec->alignment_power > 2)

     {
       int fill_extra_space;
       bfd_vma entry_sec_offset;
     {
       int fill_extra_space;
       bfd_vma entry_sec_offset;


@@ -8683,7 +8674,7 @@ coalesce_shared_literal (asection *sec,
    total amount of space used because of alignments so we need to do
    this carefully.  Also, it may make a branch go out of range.  */
 
    total amount of space used because of alignments so we need to do
    this carefully.  Also, it may make a branch go out of range.  */
 

-static bfd_boolean 
+static bfd_boolean

 move_shared_literal (asection *sec,
                     struct bfd_link_info *link_info,
                     source_reloc *rel,
 move_shared_literal (asection *sec,
                     struct bfd_link_info *link_info,
                     source_reloc *rel,


@@ -8726,7 +8717,7 @@ move_shared_literal (asection *sec,
     return FALSE;
 
   target_entry = elf_xtensa_find_property_entry
     return FALSE;
 
   target_entry = elf_xtensa_find_property_entry

-    (target_sec_cache->ptbl, target_sec_cache->pte_count, 
+    (target_sec_cache->ptbl, target_sec_cache->pte_count,

      target_sec->vma + target_loc->target_offset);
 
   if (!target_entry)
      target_sec->vma + target_loc->target_offset);
 
   if (!target_entry)


@@ -8737,7 +8728,7 @@ move_shared_literal (asection *sec,
 
   init_ebb_constraint (&ebb_table);
   ebb = &ebb_table.ebb;
 
   init_ebb_constraint (&ebb_table);
   ebb = &ebb_table.ebb;

-  init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents, 
+  init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,

            target_sec_cache->content_length,
            target_sec_cache->ptbl, target_sec_cache->pte_count,
            target_sec_cache->relocs, target_sec_cache->reloc_count);
            target_sec_cache->content_length,
            target_sec_cache->ptbl, target_sec_cache->pte_count,
            target_sec_cache->relocs, target_sec_cache->reloc_count);


@@ -8749,24 +8740,24 @@ move_shared_literal (asection *sec,
                      -4 - (1 << target_sec->alignment_power), TRUE);
 
   /* Check all of the PC-relative relocations to make sure they still fit.  */
                      -4 - (1 << target_sec->alignment_power), TRUE);
 
   /* Check all of the PC-relative relocations to make sure they still fit.  */

-  relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec, 
+  relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,

                                             target_sec_cache->contents,
                                             target_sec_cache->relocs,
                                             &ebb_table, NULL);
 
                                             target_sec_cache->contents,
                                             target_sec_cache->relocs,
                                             &ebb_table, NULL);
 

-  if (!relocs_fit) 
+  if (!relocs_fit)

     return FALSE;
 
   text_action_add_literal (&target_relax_info->action_list,
                           ta_add_literal, target_loc, lit_value, -4);
 
     return FALSE;
 
   text_action_add_literal (&target_relax_info->action_list,
                           ta_add_literal, target_loc, lit_value, -4);
 

-  if (target_sec->alignment_power > 2 && target_entry != src_entry) 
+  if (target_sec->alignment_power > 2 && target_entry != src_entry)

     {
       /* May need to add or remove some fill to maintain alignment.  */
       int fill_extra_space;
       bfd_vma entry_sec_offset;
 
     {
       /* May need to add or remove some fill to maintain alignment.  */
       int fill_extra_space;
       bfd_vma entry_sec_offset;
 

-      entry_sec_offset = 
+      entry_sec_offset =

        target_entry->address - target_sec->vma + target_entry->size;
 
       /* If the literal range is at the end of the section,
        target_entry->address - target_sec->vma + target_entry->size;
 
       /* If the literal range is at the end of the section,


@@ -8799,7 +8790,7 @@ move_shared_literal (asection *sec,
                   ta_remove_literal, sec, rel->r_rel.target_offset, 4);
 
   /* If the section is 4-byte aligned, do not add fill.  */
                   ta_remove_literal, sec, rel->r_rel.target_offset, 4);
 
   /* If the section is 4-byte aligned, do not add fill.  */

-  if (sec->alignment_power > 2 && target_entry != src_entry) 
+  if (sec->alignment_power > 2 && target_entry != src_entry)

     {
       int fill_extra_space;
       bfd_vma entry_sec_offset;
     {
       int fill_extra_space;
       bfd_vma entry_sec_offset;


@@ -8863,7 +8854,7 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
       return relax_property_section (abfd, sec, link_info);
     }
 
       return relax_property_section (abfd, sec, link_info);
     }
 

-  internal_relocs = retrieve_internal_relocs (abfd, sec, 
+  internal_relocs = retrieve_internal_relocs (abfd, sec,

                                              link_info->keep_memory);
   if (!internal_relocs && !relax_info->action_list.head)
     return TRUE;
                                              link_info->keep_memory);
   if (!internal_relocs && !relax_info->action_list.head)
     return TRUE;


@@ -8970,9 +8961,9 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
             that here and adjust things accordingly.  */
          if (! elf_xtensa_ignore_discarded_relocs (sec)
              && elf_xtensa_action_discarded (sec) == PRETEND
             that here and adjust things accordingly.  */
          if (! elf_xtensa_ignore_discarded_relocs (sec)
              && elf_xtensa_action_discarded (sec) == PRETEND

-             && sec->sec_info_type != ELF_INFO_TYPE_STABS
+             && sec->sec_info_type != SEC_INFO_TYPE_STABS

              && target_sec != NULL
              && target_sec != NULL

-             && elf_discarded_section (target_sec))
+             && discarded_section (target_sec))

            {
              /* It would be natural to call _bfd_elf_check_kept_section
                 here, but it's not exported from elflink.c.  It's also a
            {
              /* It would be natural to call _bfd_elf_check_kept_section
                 here, but it's not exported from elflink.c.  It's also a


@@ -9193,7 +9184,7 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
                      dup_dot += copy_size;
                    }
                  virtual_action = TRUE;
                      dup_dot += copy_size;
                    }
                  virtual_action = TRUE;

-               } 
+               }

              else
                BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
            }
              else
                BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
            }


@@ -9264,7 +9255,7 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
                                 relax_info, &internal_relocs, &action->value))
                goto error_return;
 
                                 relax_info, &internal_relocs, &action->value))
                goto error_return;
 

-             if (virtual_action) 
+             if (virtual_action)

                orig_dot_vo += copy_size;
 
              orig_dot += orig_insn_size;
                orig_dot_vo += copy_size;
 
              orig_dot += orig_insn_size;


@@ -9329,7 +9320,7 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
 }
 
 
 }
 
 

-static bfd_boolean 
+static bfd_boolean

 translate_section_fixes (asection *sec)
 {
   xtensa_relax_info *relax_info;
 translate_section_fixes (asection *sec)
 {
   xtensa_relax_info *relax_info;


@@ -9350,7 +9341,7 @@ translate_section_fixes (asection *sec)
 /* Translate a fix given the mapping in the relax info for the target
    section.  If it has already been translated, no work is required.  */
 
 /* Translate a fix given the mapping in the relax info for the target
    section.  If it has already been translated, no work is required.  */
 

-static bfd_boolean 
+static bfd_boolean

 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
 {
   reloc_bfd_fix new_fix;
 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
 {
   reloc_bfd_fix new_fix;


@@ -9396,7 +9387,7 @@ translate_reloc_bfd_fix (reloc_bfd_fix *fix)
                                      target_offset);
     }
 
                                      target_offset);
     }
 

-  if (removed) 
+  if (removed)

     {
       asection *new_sec;
 
     {
       asection *new_sec;
 


@@ -9406,11 +9397,11 @@ translate_reloc_bfd_fix (reloc_bfd_fix *fix)
 
       /* This was moved to some other address (possibly another section).  */
       new_sec = r_reloc_get_section (&removed->to);
 
       /* This was moved to some other address (possibly another section).  */
       new_sec = r_reloc_get_section (&removed->to);

-      if (new_sec != sec) 
+      if (new_sec != sec)

        {
          sec = new_sec;
          relax_info = get_xtensa_relax_info (sec);
        {
          sec = new_sec;
          relax_info = get_xtensa_relax_info (sec);

-         if (!relax_info || 
+         if (!relax_info ||

              (!relax_info->is_relaxable_literal_section
               && !relax_info->is_relaxable_asm_section))
            {
              (!relax_info->is_relaxable_literal_section
               && !relax_info->is_relaxable_asm_section))
            {


@@ -9699,7 +9690,7 @@ move_literal (bfd *abfd,
          BFD_ASSERT (relax_info->allocated_relocs == NULL
                      || sec->reloc_count == relax_info->relocs_count);
 
          BFD_ASSERT (relax_info->allocated_relocs == NULL
                      || sec->reloc_count == relax_info->relocs_count);
 

-         if (relax_info->allocated_relocs_count == 0) 
+         if (relax_info->allocated_relocs_count == 0)

            new_relocs_count = (sec->reloc_count + 2) * 2;
          else
            new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
            new_relocs_count = (sec->reloc_count + 2) * 2;
          else
            new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;


@@ -9719,7 +9710,7 @@ move_literal (bfd *abfd,
          if (insert_at != sec->reloc_count)
            memcpy (new_relocs + insert_at + 1,
                    (*internal_relocs_p) + insert_at,
          if (insert_at != sec->reloc_count)
            memcpy (new_relocs + insert_at + 1,
                    (*internal_relocs_p) + insert_at,

-                   (sec->reloc_count - insert_at) 
+                   (sec->reloc_count - insert_at)

                    * sizeof (Elf_Internal_Rela));
 
          if (*internal_relocs_p != relax_info->allocated_relocs)
                    * sizeof (Elf_Internal_Rela));
 
          if (*internal_relocs_p != relax_info->allocated_relocs)


@@ -9778,7 +9769,7 @@ relax_property_section (bfd *abfd,
   bfd_size_type entry_size;
 
   sec_size = bfd_get_section_limit (abfd, sec);
   bfd_size_type entry_size;
 
   sec_size = bfd_get_section_limit (abfd, sec);

-  internal_relocs = retrieve_internal_relocs (abfd, sec, 
+  internal_relocs = retrieve_internal_relocs (abfd, sec,

                                              link_info->keep_memory);
   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
   if (contents == NULL && sec_size != 0)
                                              link_info->keep_memory);
   contents = retrieve_contents (abfd, sec, link_info->keep_memory);
   if (contents == NULL && sec_size != 0)


@@ -10003,7 +9994,7 @@ relax_property_section (bfd *abfd,
          actual_offset = offset - removed_bytes;
          size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
 
          actual_offset = offset - removed_bytes;
          size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
 

-         if (is_full_prop_section) 
+         if (is_full_prop_section)

            flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
          else
            flags = predef_flags;
            flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
          else
            flags = predef_flags;


@@ -10031,7 +10022,7 @@ relax_property_section (bfd *abfd,
                  bfd_vma new_address =
                    (offset_rel->r_addend
                     + bfd_get_32 (abfd, &contents[actual_offset]));
                  bfd_vma new_address =
                    (offset_rel->r_addend
                     + bfd_get_32 (abfd, &contents[actual_offset]));

-                 if (is_full_prop_section) 
+                 if (is_full_prop_section)

                    old_flags = bfd_get_32
                      (abfd, &contents[last_irel->r_offset + 8]);
                  else
                    old_flags = bfd_get_32
                      (abfd, &contents[last_irel->r_offset + 8]);
                  else


@@ -10283,7 +10274,7 @@ elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
 
   dynobj = elf_hash_table (info)->dynobj;
   sprintf (plt_name, ".plt.%u", chunk);
 
   dynobj = elf_hash_table (info)->dynobj;
   sprintf (plt_name, ".plt.%u", chunk);

-  return bfd_get_section_by_name (dynobj, plt_name);
+  return bfd_get_linker_section (dynobj, plt_name);

 }
 
 
 }
 
 


@@ -10304,7 +10295,7 @@ elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
 
   dynobj = elf_hash_table (info)->dynobj;
   sprintf (got_name, ".got.plt.%u", chunk);
 
   dynobj = elf_hash_table (info)->dynobj;
   sprintf (got_name, ".got.plt.%u", chunk);

-  return bfd_get_section_by_name (dynobj, got_name);
+  return bfd_get_linker_section (dynobj, got_name);

 }
 
 
 }
 
 


@@ -10447,7 +10438,7 @@ pcrel_reloc_fits (xtensa_opcode opc,
 }
 
 
 }
 
 

-static bfd_boolean 
+static bfd_boolean

 xtensa_is_property_section (asection *sec)
 {
   if (xtensa_is_insntable_section (sec)
 xtensa_is_property_section (asection *sec)
 {
   if (xtensa_is_insntable_section (sec)


@@ -10459,7 +10450,7 @@ xtensa_is_property_section (asection *sec)
 }
 
 
 }
 
 

-static bfd_boolean 
+static bfd_boolean

 xtensa_is_insntable_section (asection *sec)
 {
   if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
 xtensa_is_insntable_section (asection *sec)
 {
   if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)


@@ -10470,7 +10461,7 @@ xtensa_is_insntable_section (asection *sec)
 }
 
 
 }
 
 

-static bfd_boolean 
+static bfd_boolean

 xtensa_is_littable_section (asection *sec)
 {
   if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
 xtensa_is_littable_section (asection *sec)
 {
   if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)


@@ -10481,7 +10472,7 @@ xtensa_is_littable_section (asection *sec)
 }
 
 
 }
 
 

-static bfd_boolean 
+static bfd_boolean

 xtensa_is_proptable_section (asection *sec)
 {
   if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
 xtensa_is_proptable_section (asection *sec)
 {
   if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)


@@ -10534,7 +10525,7 @@ match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
 {
   const char *gname = inf;
   const char *group_name = elf_group_name (sec);
 {
   const char *gname = inf;
   const char *group_name = elf_group_name (sec);

-  
+

   return (group_name == gname
          || (group_name != NULL
              && gname != NULL
   return (group_name == gname
          || (group_name != NULL
              && gname != NULL


@@ -10566,9 +10557,9 @@ xtensa_property_section_name (asection *sec, const char *base_name)
     {
       char *linkonce_kind = 0;
 
     {
       char *linkonce_kind = 0;
 

-      if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0) 
+      if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)

        linkonce_kind = "x.";
        linkonce_kind = "x.";

-      else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0) 
+      else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)

        linkonce_kind = "p.";
       else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
        linkonce_kind = "prop.";
        linkonce_kind = "p.";
       else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
        linkonce_kind = "prop.";


@@ -10683,7 +10674,7 @@ xtensa_callback_required_dependence (bfd *abfd,
 
       /* Find the corresponding ".got.plt*" section.  */
       if (sec->name[4] == '\0')
 
       /* Find the corresponding ".got.plt*" section.  */
       if (sec->name[4] == '\0')

-       sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
+       sgotplt = bfd_get_linker_section (sec->owner, ".got.plt");

       else
        {
          char got_name[14];
       else
        {
          char got_name[14];


@@ -10693,7 +10684,7 @@ xtensa_callback_required_dependence (bfd *abfd,
          chunk = strtol (&sec->name[5], NULL, 10);
 
          sprintf (got_name, ".got.plt.%u", chunk);
          chunk = strtol (&sec->name[5], NULL, 10);
 
          sprintf (got_name, ".got.plt.%u", chunk);

-         sgotplt = bfd_get_section_by_name (sec->owner, got_name);
+         sgotplt = bfd_get_linker_section (sec->owner, got_name);

        }
       BFD_ASSERT (sgotplt);
 
        }
       BFD_ASSERT (sgotplt);
 


@@ -10708,7 +10699,7 @@ xtensa_callback_required_dependence (bfd *abfd,
   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
     return ok;
 
   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
     return ok;
 

-  internal_relocs = retrieve_internal_relocs (abfd, sec, 
+  internal_relocs = retrieve_internal_relocs (abfd, sec,

                                              link_info->keep_memory);
   if (internal_relocs == NULL
       || sec->reloc_count == 0)
                                              link_info->keep_memory);
   if (internal_relocs == NULL
       || sec->reloc_count == 0)