Merge GDB 7.5.1

bfd/elf32-m68hc1x.c

 /* Motorola 68HC11/HC12-specific support for 32-bit ELF
    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
-   2009, 2010, 2011  Free Software Foundation, Inc.
+   2009, 2010, 2011, 2012 Free Software Foundation, Inc.
    Contributed by Stephane Carrez (stcarrez@nerim.fr)
 
    This file is part of BFD, the Binary File Descriptor library.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
    MA 02110-1301, USA.  */
 
+#include "sysdep.h"
 #include "alloca-conf.h"
-#include "sysdep.h"
 #include "bfd.h"
 #include "bfdlink.h"
 #include "libbfd.h"
 #include "elf-bfd.h"
 #include "elf32-m68hc1x.h"
 #include "elf/m68hc11.h"
 #include "opcode/m68hc11.h"
 
 
 #define m68hc12_stub_hash_lookup(table, string, create, copy) \
   ((struct elf32_m68hc11_stub_hash_entry *) \
    bfd_hash_lookup ((table), (string), (create), (copy)))
 
 static struct elf32_m68hc11_stub_hash_entry* m68hc12_add_stub
   (const char *stub_name,
    asection *section,
    struct m68hc11_elf_link_hash_table *htab);
 
 static struct bfd_hash_entry *stub_hash_newfunc
   (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
 
 static void m68hc11_elf_set_symbol (bfd* abfd, struct bfd_link_info *info,
                                     const char* name, bfd_vma value,
                                     asection* sec);
 
 static bfd_boolean m68hc11_elf_export_one_stub
   (struct bfd_hash_entry *gen_entry, void *in_arg);
 
-static void scan_sections_for_abi (bfd*, asection*, PTR);
+static void scan_sections_for_abi (bfd*, asection*, void *);
 
 struct m68hc11_scan_param
 {
    struct m68hc11_page_info* pinfo;
    bfd_boolean use_memory_banks;
 };
 
 
 /* Create a 68HC11/68HC12 ELF linker hash table.  */
 
@@ skipping 143 matching lines @@
                                             BSF_GLOBAL,
                                             bfd_und_section_ptr,
                                             (bfd_vma) 0, (const char*) NULL,
                                             FALSE, FALSE, &entry);
         }
 
     }
   return TRUE;
 }
 
+/* Merge non-visibility st_other attributes, STO_M68HC12_FAR and
+   STO_M68HC12_INTERRUPT.  */
+
+void
+elf32_m68hc11_merge_symbol_attribute (struct elf_link_hash_entry *h,
+                                      const Elf_Internal_Sym *isym,
+                                      bfd_boolean definition,
+                                      bfd_boolean dynamic ATTRIBUTE_UNUSED)
+{
+  if (definition)
+    h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
+                | ELF_ST_VISIBILITY (h->other));
+}
+
 /* External entry points for sizing and building linker stubs.  */
 
 /* Set up various things so that we can make a list of input sections
    for each output section included in the link.  Returns -1 on error,
    0 when no stubs will be needed, and 1 on success.  */
 
 int
 elf32_m68hc11_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
 {
   bfd *input_bfd;
@@ skipping 701 matching lines @@
       Elf_Internal_Sym *sym;
       asection *sec;
       bfd_vma relocation = 0;
       bfd_reloc_status_type r = bfd_reloc_undefined;
       bfd_vma phys_page;
       bfd_vma phys_addr;
       bfd_vma insn_addr;
       bfd_vma insn_page;
       bfd_boolean is_far = FALSE;
       struct elf_link_hash_entry *h;
+      bfd_vma val;
 
       r_symndx = ELF32_R_SYM (rel->r_info);
       r_type = ELF32_R_TYPE (rel->r_info);
 
       if (r_type == R_M68HC11_GNU_VTENTRY
           || r_type == R_M68HC11_GNU_VTINHERIT )
         continue;
 
       (*ebd->elf_info_to_howto_rel) (input_bfd, &arel, rel);
       howto = arel.howto;
@@ skipping 15 matching lines @@
           bfd_boolean unresolved_reloc, warned;
 
           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
                                    r_symndx, symtab_hdr, sym_hashes,
                                    h, sec, relocation, unresolved_reloc,
                                    warned);
 
           is_far = (h && (h->other & STO_M68HC12_FAR));
         }
 
-      if (sec != NULL && elf_discarded_section (sec))
+      if (sec != NULL && discarded_section (sec))
         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
-                                         rel, relend, howto, contents);
+                                         rel, 1, relend, howto, 0, contents);
 
       if (info->relocatable)
         {
           /* This is a relocatable link.  We don't have to change
              anything, unless the reloc is against a section symbol,
              in which case we have to adjust according to where the
              section symbol winds up in the output section.  */
           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
             rel->r_addend += sec->output_offset;
           continue;
@@ skipping 22 matching lines @@
                 + stub->stub_sec->output_offset;
               is_far = FALSE;
             }
         }
 
       /* Do the memory bank mapping.  */
       phys_addr = m68hc11_phys_addr (pinfo, relocation + rel->r_addend);
       phys_page = m68hc11_phys_page (pinfo, relocation + rel->r_addend);
       switch (r_type)
         {
+        case R_M68HC12_LO8XG:
+          /* This relocation is specific to XGATE IMM16 calls and will precede
+             a HI8. tc-m68hc11 only generates them in pairs.
+             Leave the relocation to the HI8XG step.  */
+          r = bfd_reloc_ok;
+          r_type = R_M68HC11_NONE;
+          break;
+
+        case R_M68HC12_HI8XG:
+          /* This relocation is specific to XGATE IMM16 calls and must follow
+             a LO8XG. Does not actually check that it was a LO8XG.
+             Adjusts high and low bytes.  */
+          relocation = phys_addr;
+          if ((elf_elfheader (input_bfd)->e_flags & E_M68HC11_XGATE_RAMOFFSET)
+              && (relocation >= 0x2000))
+            relocation += 0xc000; /* HARDCODED RAM offset for XGATE.  */
+
+          /* Fetch 16 bit value including low byte in previous insn.  */
+          val = (bfd_get_8 (input_bfd, (bfd_byte*) contents + rel->r_offset) << 8)
+            | bfd_get_8 (input_bfd, (bfd_byte*) contents + rel->r_offset - 2);
+
+          /* Add on value to preserve carry, then write zero to high byte.  */
+          relocation += val;
+
+          /* Write out top byte.  */
+          bfd_put_8 (input_bfd, (relocation >> 8) & 0xff,
+                     (bfd_byte*) contents + rel->r_offset);
+
+          /* Write out low byte to previous instruction.  */
+          bfd_put_8 (input_bfd, relocation & 0xff,
+                     (bfd_byte*) contents + rel->r_offset - 2);
+
+          /* Mark as relocation completed.  */
+          r = bfd_reloc_ok;
+          r_type = R_M68HC11_NONE;
+          break;
+
+        /* The HI8 and LO8 relocs are generated by %hi(expr) %lo(expr)
+           assembler directives. %hi does not support carry.  */
+        case R_M68HC11_HI8:
+        case R_M68HC11_LO8:
+          relocation = phys_addr;
+          break;
+
         case R_M68HC11_24:
           /* Reloc used by 68HC12 call instruction.  */
           bfd_put_16 (input_bfd, phys_addr,
                       (bfd_byte*) contents + rel->r_offset);
           bfd_put_8 (input_bfd, phys_page,
                      (bfd_byte*) contents + rel->r_offset + 2);
           r = bfd_reloc_ok;
           r_type = R_M68HC11_NONE;
           break;
 
@@ skipping 74 matching lines @@
               relocation = phys_addr;
               break;
             }
 
           /* If this is a banked address use the phys_addr so that
              we stay in the banked window.  */
           if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend))
             relocation = phys_addr;
           break;
         }
+
       if (r_type != R_M68HC11_NONE)
-        r = _bfd_final_link_relocate (howto, input_bfd, input_section,
+        {
+          if ((r_type == R_M68HC12_PCREL_9) || (r_type == R_M68HC12_PCREL_10))
+            r = _bfd_final_link_relocate (howto, input_bfd, input_section,
                                       contents, rel->r_offset,
-                                      relocation, rel->r_addend);
+                                      relocation - 2, rel->r_addend);
+          else
+            r = _bfd_final_link_relocate (howto, input_bfd, input_section,
+                                          contents, rel->r_offset,
+                                          relocation, rel->r_addend);
+        }
 
       if (r != bfd_reloc_ok)
         {
           const char * msg = (const char *) 0;
 
           switch (r)
             {
             case bfd_reloc_overflow:
               if (!((*info->callbacks->reloc_overflow)
                     (info, NULL, name, howto->name, (bfd_vma) 0,
@@ skipping 167 matching lines @@
     fprintf (file, _("32-bit double, "));
 
   if (strcmp (bfd_get_target (abfd), "elf32-m68hc11") == 0)
     fprintf (file, _("cpu=HC11]"));
   else if (elf_elfheader (abfd)->e_flags & EF_M68HCS12_MACH)
     fprintf (file, _("cpu=HCS12]"));
   else
     fprintf (file, _("cpu=HC12]"));    
 
   if (elf_elfheader (abfd)->e_flags & E_M68HC12_BANKS)