bfd/elf32-sh64.c

   1 /* SuperH SH64-specific support for 32-bit ELF
   2    Copyright 2000, 2001, 2002, 2003, 2004, 2005
   3    Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  20
  21 #define SH64_ELF
  22
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "elf-bfd.h"
  26 #include "../opcodes/sh64-opc.h"
  27 #include "elf32-sh64.h"
  28
  29 /* Add a suffix for datalabel indirection symbols.  It must not match any
  30    other symbols; user symbols with or without version or other
  31    decoration.  It must only be used internally and not emitted by any
  32    means.  */
  33 #define DATALABEL_SUFFIX " DL"
  34
  35 /* Used to hold data for function called through bfd_map_over_sections.  */
  36 struct sh64_find_section_vma_data
  37  {
  38    asection *section;
  39    bfd_vma addr;
  40  };
  41
  42 static bfd_boolean sh64_elf_new_section_hook
  43   (bfd *, asection *);
  44 static bfd_boolean sh64_elf_copy_private_data
  45   (bfd *, bfd *);
  46 static bfd_boolean sh64_elf_merge_private_data
  47   (bfd *, bfd *);
  48 static bfd_boolean sh64_elf_fake_sections
  49   (bfd *, Elf_Internal_Shdr *, asection *);
  50 static bfd_boolean sh64_elf_set_private_flags
  51   (bfd *, flagword);
  52 static bfd_boolean sh64_elf_set_mach_from_flags
  53   (bfd *);
  54 static bfd_boolean shmedia_prepare_reloc
  55   (struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  56    const Elf_Internal_Rela *, bfd_vma *);
  57 static int sh64_elf_get_symbol_type
  58   (Elf_Internal_Sym *, int);
  59 static bfd_boolean sh64_elf_add_symbol_hook
  60   (bfd *, struct bfd_link_info *, Elf_Internal_Sym *, const char **,
  61    flagword *, asection **, bfd_vma *);
  62 static bfd_boolean sh64_elf_link_output_symbol_hook
  63   (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
  64    struct elf_link_hash_entry *);
  65 static bfd_boolean sh64_backend_section_from_shdr
  66   (bfd *, Elf_Internal_Shdr *, const char *, int);
  67 static void sh64_elf_final_write_processing
  68   (bfd *, bfd_boolean);
  69 static bfd_boolean sh64_bfd_elf_copy_private_section_data
  70   (bfd *, asection *, bfd *, asection *);
  71 static void sh64_find_section_for_address
  72   (bfd *, asection *, void *);
  73
  74 /* Let elf32-sh.c handle the "bfd_" definitions, so we only have to
  75    intrude with an #ifndef around the function definition.  */
  76 #define sh_elf_copy_private_data                sh64_elf_copy_private_data
  77 #define sh_elf_merge_private_data               sh64_elf_merge_private_data
  78 #define sh_elf_set_private_flags                sh64_elf_set_private_flags
  79 /* Typo in elf32-sh.c (and unlinear name).  */
  80 #define bfd_elf32_bfd_set_private_flags         sh64_elf_set_private_flags
  81 #define sh_elf_set_mach_from_flags              sh64_elf_set_mach_from_flags
  82
  83 #define elf_backend_sign_extend_vma             1
  84 #define elf_backend_fake_sections               sh64_elf_fake_sections
  85 #define elf_backend_get_symbol_type             sh64_elf_get_symbol_type
  86 #define elf_backend_add_symbol_hook             sh64_elf_add_symbol_hook
  87 #define elf_backend_link_output_symbol_hook \
  88         sh64_elf_link_output_symbol_hook
  89 #define elf_backend_merge_symbol_attribute      sh64_elf_merge_symbol_attribute
  90 #define elf_backend_final_write_processing      sh64_elf_final_write_processing
  91 #define elf_backend_section_from_shdr           sh64_backend_section_from_shdr
  92 #define elf_backend_get_sec_type_attr           sh64_elf_get_sec_type_attr
  93 #define elf_backend_section_flags               sh64_elf_section_flags
  94
  95 #define bfd_elf32_new_section_hook              sh64_elf_new_section_hook
  96
  97 /* For objcopy, we need to set up sh64_elf_section_data (asection *) from
  98    incoming section flags.  This is otherwise done in sh64elf.em when
  99    linking or tc-sh64.c when assembling.  */
 100 #define bfd_elf32_bfd_copy_private_section_data \
 101         sh64_bfd_elf_copy_private_section_data
 102
 103 /* This COFF-only function (only compiled with COFF support, making
 104    ELF-only chains problematic) returns TRUE early for SH4, so let's just
 105    define it TRUE here.  */
 106 #define _bfd_sh_align_load_span(a,b,c,d,e,f,g,h,i,j) TRUE
 107
 108 #define GOT_BIAS (-((long)-32768))
 109 #define INCLUDE_SHMEDIA
 110 #define SH_TARGET_ALREADY_DEFINED
 111 #include "elf32-sh.c"
 112
 113 /* Tack some extra info on struct bfd_elf_section_data.  */
 114
 115 static bfd_boolean
 116 sh64_elf_new_section_hook (bfd *abfd, asection *sec)
 117 {
 118   struct _sh64_elf_section_data *sdata;
 119   bfd_size_type amt = sizeof (*sdata);
 120
 121   sdata = (struct _sh64_elf_section_data *) bfd_zalloc (abfd, amt);
 122   if (sdata == NULL)
 123     return FALSE;
 124   sec->used_by_bfd = sdata;
 125
 126   return _bfd_elf_new_section_hook (abfd, sec);
 127 }
 128
 129 /* Set the SHF_SH5_ISA32 flag for ISA SHmedia code sections, and pass
 130    through SHT_SH5_CR_SORTED on a sorted .cranges section.  */
 131
 132 bfd_boolean
 133 sh64_elf_fake_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 134                         Elf_Internal_Shdr *elf_section_hdr,
 135                         asection *asect)
 136 {
 137   if (sh64_elf_section_data (asect)->sh64_info != NULL)
 138     elf_section_hdr->sh_flags
 139       |= sh64_elf_section_data (asect)->sh64_info->contents_flags;
 140
 141   /* If this section has the SEC_SORT_ENTRIES flag set, it is a sorted
 142      .cranges section passing through objcopy.  */
 143   if ((bfd_get_section_flags (output_bfd, asect) & SEC_SORT_ENTRIES) != 0
 144       && strcmp (bfd_get_section_name (output_bfd, asect),
 145                  SH64_CRANGES_SECTION_NAME) == 0)
 146     elf_section_hdr->sh_type = SHT_SH5_CR_SORTED;
 147
 148   return TRUE;
 149 }
 150
 151 static bfd_boolean
 152 sh64_elf_set_mach_from_flags (bfd *abfd)
 153 {
 154   flagword flags = elf_elfheader (abfd)->e_flags;
 155
 156   switch (flags & EF_SH_MACH_MASK)
 157     {
 158     case EF_SH5:
 159       /* These are fit to execute on SH5.  Just one but keep the switch
 160          construct to make additions easy.  */
 161       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh5);
 162       break;
 163
 164     default:
 165       bfd_set_error (bfd_error_wrong_format);
 166       return FALSE;
 167     }
 168
 169   return TRUE;
 170 }
 171
 172 static bfd_boolean
 173 sh64_elf_section_flags (flagword *flags,
 174                         const Elf_Internal_Shdr *hdr)
 175 {
 176   if (hdr->bfd_section == NULL)
 177     return FALSE;
 178
 179   if (strcmp (hdr->bfd_section->name, SH64_CRANGES_SECTION_NAME) == 0)
 180     *flags |= SEC_DEBUGGING;
 181
 182   return TRUE;
 183 }
 184
 185 static bfd_boolean
 186 sh64_elf_copy_private_data (bfd * ibfd, bfd * obfd)
 187 {
 188   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 189       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 190     return TRUE;
 191
 192   BFD_ASSERT (!elf_flags_init (obfd)
 193               || (elf_elfheader (obfd)->e_flags
 194                   == elf_elfheader (ibfd)->e_flags));
 195
 196   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
 197   return TRUE;
 198 }
 199
 200 static bfd_boolean
 201 sh64_elf_merge_private_data (bfd *ibfd, bfd *obfd)
 202 {
 203   flagword old_flags, new_flags;
 204
 205   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
 206     return FALSE;
 207
 208   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 209       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 210     return TRUE;
 211
 212   if (bfd_get_arch_size (ibfd) != bfd_get_arch_size (obfd))
 213     {
 214       const char *msg;
 215
 216       if (bfd_get_arch_size (ibfd) == 32
 217           && bfd_get_arch_size (obfd) == 64)
 218         msg = _("%s: compiled as 32-bit object and %s is 64-bit");
 219       else if (bfd_get_arch_size (ibfd) == 64
 220                && bfd_get_arch_size (obfd) == 32)
 221         msg = _("%s: compiled as 64-bit object and %s is 32-bit");
 222       else
 223         msg = _("%s: object size does not match that of target %s");
 224
 225       (*_bfd_error_handler) (msg, bfd_get_filename (ibfd),
 226                              bfd_get_filename (obfd));
 227       bfd_set_error (bfd_error_wrong_format);
 228       return FALSE;
 229     }
 230
 231   old_flags = elf_elfheader (obfd)->e_flags;
 232   new_flags = elf_elfheader (ibfd)->e_flags;
 233   if (! elf_flags_init (obfd))
 234     {
 235       /* This happens when ld starts out with a 'blank' output file.  */
 236       elf_flags_init (obfd) = TRUE;
 237       elf_elfheader (obfd)->e_flags = old_flags = new_flags;
 238     }
 239   /* We don't allow linking in non-SH64 code.  */
 240   else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
 241     {
 242       (*_bfd_error_handler)
 243         ("%s: uses non-SH64 instructions while previous modules use SH64 instructions",
 244          bfd_get_filename (ibfd));
 245       bfd_set_error (bfd_error_bad_value);
 246       return FALSE;
 247     }
 248
 249   /* I can't think of anything sane other than old_flags being EF_SH5 and
 250      that we need to preserve that.  */
 251   elf_elfheader (obfd)->e_flags = old_flags;
 252   return sh64_elf_set_mach_from_flags (obfd);
 253 }
 254
 255 /* Handle a SH64-specific section when reading an object file.  This
 256    is called when bfd_section_from_shdr finds a section with an unknown
 257    type.
 258
 259    We only recognize SHT_SH5_CR_SORTED, on the .cranges section.  */
 260
 261 bfd_boolean
 262 sh64_backend_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
 263                                 const char *name, int shindex)
 264 {
 265   flagword flags = 0;
 266
 267   /* We do like MIPS with a bit switch for recognized types, and returning
 268      FALSE for a recognized section type with an unexpected name.  Right
 269      now we only have one recognized type, but that might change.  */
 270   switch (hdr->sh_type)
 271     {
 272     case SHT_SH5_CR_SORTED:
 273       if (strcmp (name, SH64_CRANGES_SECTION_NAME) != 0)
 274         return FALSE;
 275
 276       /* We set the SEC_SORT_ENTRIES flag so it can be passed on to
 277          sh64_elf_fake_sections, keeping SHT_SH5_CR_SORTED if this object
 278          passes through objcopy.  Perhaps it is brittle; the flag can
 279          suddenly be used by other BFD parts, but it seems not really used
 280          anywhere at the moment.  */
 281       flags = SEC_DEBUGGING | SEC_SORT_ENTRIES;
 282       break;
 283
 284     default:
 285       return FALSE;
 286     }
 287
 288   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
 289     return FALSE;
 290
 291   if (flags
 292       && ! bfd_set_section_flags (abfd, hdr->bfd_section,
 293                                   bfd_get_section_flags (abfd,
 294                                                          hdr->bfd_section)
 295                                   | flags))
 296     return FALSE;
 297
 298   return TRUE;
 299 }
 300
 301 /* In contrast to sh64_backend_section_from_shdr, this is called for all
 302    sections, but only when copying sections, not when linking or
 303    assembling.  We need to set up the sh64_elf_section_data (asection *)
 304    structure for the SH64 ELF section flags to be copied correctly.  */
 305
 306 bfd_boolean
 307 sh64_bfd_elf_copy_private_section_data (bfd *ibfd, asection *isec,
 308                                         bfd *obfd, asection *osec)
 309 {
 310   struct sh64_section_data *sh64_sec_data;
 311
 312   if (ibfd->xvec->flavour != bfd_target_elf_flavour
 313       || obfd->xvec->flavour != bfd_target_elf_flavour)
 314     return TRUE;
 315
 316   if (! _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec))
 317     return FALSE;
 318
 319   sh64_sec_data = sh64_elf_section_data (isec)->sh64_info;
 320   if (sh64_sec_data == NULL)
 321     {
 322       sh64_sec_data = bfd_zmalloc (sizeof (struct sh64_section_data));
 323
 324       if (sh64_sec_data == NULL)
 325         return FALSE;
 326
 327       sh64_sec_data->contents_flags
 328         = (elf_section_data (isec)->this_hdr.sh_flags
 329            & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED));
 330
 331       sh64_elf_section_data (osec)->sh64_info = sh64_sec_data;
 332     }
 333
 334   return TRUE;
 335 }
 336
 337 /* Function to keep SH64 specific file flags.  */
 338
 339 static bfd_boolean
 340 sh64_elf_set_private_flags (bfd *abfd, flagword flags)
 341 {
 342   BFD_ASSERT (! elf_flags_init (abfd)
 343               || elf_elfheader (abfd)->e_flags == flags);
 344
 345   elf_elfheader (abfd)->e_flags = flags;
 346   elf_flags_init (abfd) = TRUE;
 347   return sh64_elf_set_mach_from_flags (abfd);
 348 }
 349
 350 /* Called when writing out an object file to decide the type of a symbol.  */
 351
 352 static int
 353 sh64_elf_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
 354 {
 355   if (ELF_ST_TYPE (elf_sym->st_info) == STT_DATALABEL)
 356     return STT_DATALABEL;
 357
 358   return type;
 359 }
 360
 361 /* Hook called by the linker routine which adds symbols from an object
 362    file.  We must make indirect symbols for undefined symbols marked with
 363    STT_DATALABEL, so relocations passing them will pick up that attribute
 364    and neutralize STO_SH5_ISA32 found on the symbol definition.
 365
 366    There is a problem, though: We want to fill in the hash-table entry for
 367    this symbol and signal to the caller that no further processing is
 368    needed.  But we don't have the index for this hash-table entry.  We
 369    rely here on that the current entry is the first hash-entry with NULL,
 370    which seems brittle.  Also, iterating over the hash-table to find that
 371    entry is a linear operation on the number of symbols in this input
 372    file, and this function should take constant time, so that's not good
 373    too.  Only comfort is that DataLabel references should only be found in
 374    hand-written assembly code and thus be rare.  FIXME: Talk maintainers
 375    into adding an option to elf_add_symbol_hook (preferably) for the index
 376    or the hash entry, alternatively adding the index to Elf_Internal_Sym
 377    (not so good).  */
 378
 379 static bfd_boolean
 380 sh64_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
 381                           Elf_Internal_Sym *sym, const char **namep,
 382                           flagword *flagsp ATTRIBUTE_UNUSED,
 383                           asection **secp, bfd_vma *valp)
 384 {
 385   /* We want to do this for relocatable as well as final linking.  */
 386   if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL
 387       && is_elf_hash_table (info->hash))
 388     {
 389       struct elf_link_hash_entry *h;
 390
 391       /* For relocatable links, we register the DataLabel sym in its own
 392          right, and tweak the name when it's output.  Otherwise, we make
 393          an indirect symbol of it.  */
 394       flagword flags
 395         = info->relocatable || info->emitrelocations
 396         ? BSF_GLOBAL : BSF_GLOBAL | BSF_INDIRECT;
 397
 398       char *dl_name
 399         = bfd_malloc (strlen (*namep) + sizeof (DATALABEL_SUFFIX));
 400       struct elf_link_hash_entry ** sym_hash = elf_sym_hashes (abfd);
 401
 402       BFD_ASSERT (sym_hash != NULL);
 403
 404       /* Allocation may fail.  */
 405       if (dl_name == NULL)
 406         return FALSE;
 407
 408       strcpy (dl_name, *namep);
 409       strcat (dl_name, DATALABEL_SUFFIX);
 410
 411       h = (struct elf_link_hash_entry *)
 412         bfd_link_hash_lookup (info->hash, dl_name, FALSE, FALSE, FALSE);
 413
 414       if (h == NULL)
 415         {
 416           /* No previous datalabel symbol.  Make one.  */
 417           struct bfd_link_hash_entry *bh = NULL;
 418           const struct elf_backend_data *bed = get_elf_backend_data (abfd);
 419
 420           if (! _bfd_generic_link_add_one_symbol (info, abfd, dl_name,
 421                                                   flags, *secp, *valp,
 422                                                   *namep, FALSE,
 423                                                   bed->collect, &bh))
 424             {
 425               free (dl_name);
 426               return FALSE;
 427             }
 428
 429           h = (struct elf_link_hash_entry *) bh;
 430           h->non_elf = 0;
 431           h->type = STT_DATALABEL;
 432         }
 433       else
 434         /* If a new symbol was created, it holds the allocated name.
 435            Otherwise, we don't need it anymore and should deallocate it.  */
 436         free (dl_name);
 437
 438       if (h->type != STT_DATALABEL
 439           || ((info->relocatable || info->emitrelocations)
 440               && h->root.type != bfd_link_hash_undefined)
 441           || (! info->relocatable && !info->emitrelocations
 442               && h->root.type != bfd_link_hash_indirect))
 443         {
 444           /* Make sure we don't get confused on invalid input.  */
 445           (*_bfd_error_handler)
 446             (_("%s: encountered datalabel symbol in input"),
 447              bfd_get_filename (abfd));
 448           bfd_set_error (bfd_error_bad_value);
 449           return FALSE;
 450         }
 451
 452       /* Now find the hash-table slot for this entry and fill it in.  */
 453       while (*sym_hash != NULL)
 454         sym_hash++;
 455       *sym_hash = h;
 456
 457       /* Signal to caller to skip this symbol - we've handled it.  */
 458       *namep = NULL;
 459     }
 460
 461   return TRUE;
 462 }
 463
 464 /* This hook function is called before the linker writes out a global
 465    symbol.  For relocatable links, DataLabel symbols will be present in
 466    linker output.  We cut off the special suffix on those symbols, so the
 467    right name appears in the output.
 468
 469    When linking and emitting relocations, there can appear global symbols
 470    that are not referenced by relocs, but rather only implicitly through
 471    DataLabel references, a relation that is not visible to the linker.
 472    Since no stripping of global symbols in done when doing such linking,
 473    we don't need to look up and make sure to emit the main symbol for each
 474    DataLabel symbol.  */
 475
 476 bfd_boolean
 477 sh64_elf_link_output_symbol_hook (struct bfd_link_info *info,
 478                                   const char *cname,
 479                                   Elf_Internal_Sym *sym,
 480                                   asection *input_sec ATTRIBUTE_UNUSED,
 481                                   struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
 482 {
 483   char *name = (char *) cname;
 484
 485   if (info->relocatable || info->emitrelocations)
 486     {
 487       if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL)
 488         name[strlen (name) - strlen (DATALABEL_SUFFIX)] = 0;
 489     }
 490
 491   return TRUE;
 492 }
 493
 494 /* Check a SH64-specific reloc and put the value to relocate to into
 495    RELOCATION, ready to pass to _bfd_final_link_relocate.  Return FALSE if
 496    bad value, TRUE if ok.  */
 497
 498 static bfd_boolean
 499 shmedia_prepare_reloc (struct bfd_link_info *info, bfd *abfd,
 500                        asection *input_section, bfd_byte *contents,
 501                        const Elf_Internal_Rela *rel, bfd_vma *relocation)
 502 {
 503   bfd_vma disp, dropped;
 504
 505   switch (ELF32_R_TYPE (rel->r_info))
 506     {
 507     case R_SH_PT_16:
 508       /* Check the lowest bit of the destination field.  If it is 1, we
 509          check the ISA type of the destination (i.e. the low bit of the
 510          "relocation" value, and emit an error if the instruction does not
 511          match).  If it is 0, we change a PTA to PTB.  There should never
 512          be a PTB that should change to a PTA; that indicates a toolchain
 513          error; a mismatch with GAS.  */
 514       {
 515         char *msg = NULL;
 516         bfd_vma insn = bfd_get_32 (abfd, contents + rel->r_offset);
 517
 518         if (insn & (1 << 10))
 519           {
 520             /* Check matching insn and ISA (address of target).  */
 521             if ((insn & SHMEDIA_PTB_BIT) != 0
 522                 && ((*relocation + rel->r_addend) & 1) != 0)
 523               msg = _("PTB mismatch: a SHmedia address (bit 0 == 1)");
 524             else if ((insn & SHMEDIA_PTB_BIT) == 0
 525                      && ((*relocation + rel->r_addend) & 1) == 0)
 526               msg = _("PTA mismatch: a SHcompact address (bit 0 == 0)");
 527
 528             if (msg != NULL
 529                 && ! ((*info->callbacks->reloc_dangerous)
 530                       (info, msg, abfd, input_section,
 531                        rel->r_offset)))
 532               return FALSE;
 533           }
 534         else
 535           {
 536             /* We shouldn't get here with a PTB insn and a R_SH_PT_16.  It
 537                means GAS output does not match expectations; a PTA or PTB
 538                expressed as such (or a PT found at assembly to be PTB)
 539                would match the test above, and PT expansion with an
 540                unknown destination (or when relaxing) will get us here.  */
 541             if ((insn & SHMEDIA_PTB_BIT) != 0)
 542               {
 543                 (*_bfd_error_handler)
 544                   (_("%s: GAS error: unexpected PTB insn with R_SH_PT_16"),
 545                    bfd_get_filename (input_section->owner));
 546                 return FALSE;
 547               }
 548
 549             /* Change the PTA to a PTB, if destination indicates so.  */
 550             if (((*relocation + rel->r_addend) & 1) == 0)
 551               bfd_put_32 (abfd, insn | SHMEDIA_PTB_BIT,
 552                           contents + rel->r_offset);
 553           }
 554       }
 555
 556     case R_SH_SHMEDIA_CODE:
 557     case R_SH_DIR5U:
 558     case R_SH_DIR6S:
 559     case R_SH_DIR6U:
 560     case R_SH_DIR10S:
 561     case R_SH_DIR10SW:
 562     case R_SH_DIR10SL:
 563     case R_SH_DIR10SQ:
 564     case R_SH_IMMS16:
 565     case R_SH_IMMU16:
 566     case R_SH_IMM_LOW16:
 567     case R_SH_IMM_LOW16_PCREL:
 568     case R_SH_IMM_MEDLOW16:
 569     case R_SH_IMM_MEDLOW16_PCREL:
 570     case R_SH_IMM_MEDHI16:
 571     case R_SH_IMM_MEDHI16_PCREL:
 572     case R_SH_IMM_HI16:
 573     case R_SH_IMM_HI16_PCREL:
 574     case R_SH_64:
 575     case R_SH_64_PCREL:
 576       break;
 577
 578     default:
 579       return FALSE;
 580     }
 581
 582   disp = (*relocation & 0xf);
 583   dropped = 0;
 584   switch (ELF32_R_TYPE (rel->r_info))
 585     {
 586     case R_SH_DIR10SW: dropped = disp & 1; break;
 587     case R_SH_DIR10SL: dropped = disp & 3; break;
 588     case R_SH_DIR10SQ: dropped = disp & 7; break;
 589     }
 590   if (dropped != 0)
 591     {
 592       (*_bfd_error_handler)
 593         (_("%B: error: unaligned relocation type %d at %08x reloc %p\n"),
 594          input_section->owner, ELF32_R_TYPE (rel->r_info),
 595          (unsigned) rel->r_offset, relocation);
 596       return FALSE;
 597     }
 598
 599   return TRUE;
 600 }
 601
 602 /* Helper function to locate the section holding a certain address.  This
 603    is called via bfd_map_over_sections.  */
 604
 605 static void
 606 sh64_find_section_for_address (bfd *abfd ATTRIBUTE_UNUSED,
 607                                asection *section, void *data)
 608 {
 609   bfd_vma vma;
 610   bfd_size_type size;
 611
 612   struct sh64_find_section_vma_data *fsec_datap
 613     = (struct sh64_find_section_vma_data *) data;
 614
 615   /* Return if already found.  */
 616   if (fsec_datap->section)
 617     return;
 618
 619   /* If this section isn't part of the addressable contents, skip it.  */
 620   if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
 621     return;
 622
 623   vma = bfd_get_section_vma (abfd, section);
 624   if (fsec_datap->addr < vma)
 625     return;
 626
 627   size = section->size;
 628   if (fsec_datap->addr >= vma + size)
 629     return;
 630
 631   fsec_datap->section = section;
 632 }
 633
 634 /* Make sure to write out the generated entries in the .cranges section
 635    when doing partial linking, and set bit 0 on the entry address if it
 636    points to SHmedia code and write sorted .cranges entries when writing
 637    executables (final linking and objcopy).  */
 638
 639 static void
 640 sh64_elf_final_write_processing (bfd *abfd,
 641                                  bfd_boolean linker ATTRIBUTE_UNUSED)
 642 {
 643   bfd_vma ld_generated_cranges_size;
 644   asection *cranges
 645     = bfd_get_section_by_name (abfd, SH64_CRANGES_SECTION_NAME);
 646
 647   /* If no new .cranges were added, the generic ELF linker parts will
 648      write it all out.  If not, we need to write them out when doing
 649      partial linking.  For a final link, we will sort them and write them
 650      all out further below.  */
 651   if (linker
 652       && cranges != NULL
 653       && elf_elfheader (abfd)->e_type != ET_EXEC
 654       && (ld_generated_cranges_size
 655           = sh64_elf_section_data (cranges)->sh64_info->cranges_growth) != 0)
 656     {
 657       bfd_vma incoming_cranges_size
 658         = cranges->size - ld_generated_cranges_size;
 659
 660       if (! bfd_set_section_contents (abfd, cranges,
 661                                       cranges->contents
 662                                       + incoming_cranges_size,
 663                                       cranges->output_offset
 664                                       + incoming_cranges_size,
 665                                       ld_generated_cranges_size))
 666         {
 667           bfd_set_error (bfd_error_file_truncated);
 668           (*_bfd_error_handler)
 669             (_("%s: could not write out added .cranges entries"),
 670              bfd_get_filename (abfd));
 671         }
 672     }
 673
 674   /* Only set entry address bit 0 and sort .cranges when linking to an
 675      executable; never with objcopy or strip.  */
 676   if (linker && elf_elfheader (abfd)->e_type == ET_EXEC)
 677     {
 678       struct sh64_find_section_vma_data fsec_data;
 679       sh64_elf_crange dummy;
 680
 681       /* For a final link, set the low bit of the entry address to
 682          reflect whether or not it is a SHmedia address.
 683          FIXME: Perhaps we shouldn't do this if the entry address was
 684          supplied numerically, but we currently lack the infrastructure to
 685          recognize that: The entry symbol, and info whether it is numeric
 686          or a symbol name is kept private in the linker.  */
 687       fsec_data.addr = elf_elfheader (abfd)->e_entry;
 688       fsec_data.section = NULL;
 689
 690       bfd_map_over_sections (abfd, sh64_find_section_for_address,
 691                              &fsec_data);
 692       if (fsec_data.section
 693           && (sh64_get_contents_type (fsec_data.section,
 694                                       elf_elfheader (abfd)->e_entry,
 695                                       &dummy) == CRT_SH5_ISA32))
 696         elf_elfheader (abfd)->e_entry |= 1;
 697
 698       /* If we have a .cranges section, sort the entries.  */
 699       if (cranges != NULL)
 700         {
 701           bfd_size_type cranges_size = cranges->size;
 702
 703           /* We know we always have these in memory at this time.  */
 704           BFD_ASSERT (cranges->contents != NULL);
 705
 706           /* The .cranges may already have been sorted in the process of
 707              finding out the ISA-type of the entry address.  If not, we do
 708              it here.  */
 709           if (elf_section_data (cranges)->this_hdr.sh_type
 710               != SHT_SH5_CR_SORTED)
 711             {
 712               qsort (cranges->contents, cranges_size / SH64_CRANGE_SIZE,
 713                      SH64_CRANGE_SIZE,
 714                      bfd_big_endian (cranges->owner)
 715                      ? _bfd_sh64_crange_qsort_cmpb
 716                      : _bfd_sh64_crange_qsort_cmpl);
 717               elf_section_data (cranges)->this_hdr.sh_type
 718                 = SHT_SH5_CR_SORTED;
 719             }
 720
 721           /* We need to write it out in whole as sorted.  */
 722           if (! bfd_set_section_contents (abfd, cranges,
 723                                           cranges->contents,
 724                                           cranges->output_offset,
 725                                           cranges_size))
 726             {
 727               bfd_set_error (bfd_error_file_truncated);
 728               (*_bfd_error_handler)
 729                 (_("%s: could not write out sorted .cranges entries"),
 730                  bfd_get_filename (abfd));
 731             }
 732         }
 733     }
 734 }
 735
 736 /* Merge non visibility st_other attribute when the symbol comes from
 737    a dynamic object.  */
 738 static void
 739 sh64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
 740                                  const Elf_Internal_Sym *isym,
 741                                  bfd_boolean definition,
 742                                  bfd_boolean dynamic)
 743 {
 744   if (isym->st_other != 0 && dynamic)
 745     {
 746       unsigned char other;
 747
 748       /* Take the balance of OTHER from the definition.  */
 749       other = (definition ? isym->st_other : h->other);
 750       other &= ~ ELF_ST_VISIBILITY (-1);
 751       h->other = other | ELF_ST_VISIBILITY (h->other);
 752     }
 753
 754   return;
 755 }
 756
 757 static struct bfd_elf_special_section const sh64_elf_special_sections[] =
 758 {
 759   { ".cranges", 8, 0, SHT_PROGBITS, 0 },
 760   { NULL,       0, 0, 0,            0 }
 761 };
 762
 763 static const struct bfd_elf_special_section *
 764 sh64_elf_get_sec_type_attr (bfd *abfd, asection *sec)
 765 {
 766   const struct bfd_elf_special_section const *ssect;
 767
 768   /* See if this is one of the special sections.  */
 769   if (sec->name == NULL)
 770     return NULL;
 771
 772   ssect = _bfd_elf_get_special_section (sec->name,
 773                                         sh64_elf_special_sections,
 774                                         sec->use_rela_p);
 775   if (ssect != NULL)
 776     return ssect;
 777
 778   return _bfd_elf_get_sec_type_attr (abfd, sec);
 779 }
 780
 781 #undef  TARGET_BIG_SYM
 782 #define TARGET_BIG_SYM          bfd_elf32_sh64_vec
 783 #undef  TARGET_BIG_NAME
 784 #define TARGET_BIG_NAME         "elf32-sh64"
 785 #undef  TARGET_LITTLE_SYM
 786 #define TARGET_LITTLE_SYM       bfd_elf32_sh64l_vec
 787 #undef  TARGET_LITTLE_NAME
 788 #define TARGET_LITTLE_NAME      "elf32-sh64l"
 789
 790 #include "elf32-target.h"
 791
 792 /* NetBSD support.  */
 793 #undef  TARGET_BIG_SYM
 794 #define TARGET_BIG_SYM          bfd_elf32_sh64nbsd_vec
 795 #undef  TARGET_BIG_NAME
 796 #define TARGET_BIG_NAME         "elf32-sh64-nbsd"
 797 #undef  TARGET_LITTLE_SYM
 798 #define TARGET_LITTLE_SYM       bfd_elf32_sh64lnbsd_vec
 799 #undef  TARGET_LITTLE_NAME
 800 #define TARGET_LITTLE_NAME      "elf32-sh64l-nbsd"
 801 #undef  ELF_MAXPAGESIZE
 802 #define ELF_MAXPAGESIZE         0x10000
 803 #undef  elf_symbol_leading_char
 804 #define elf_symbol_leading_char 0
 805 #undef  elf32_bed
 806 #define elf32_bed               elf32_sh64_nbsd_bed
 807
 808 #include "elf32-target.h"
 809
 810 /* Linux support.  */
 811 #undef  TARGET_BIG_SYM
 812 #define TARGET_BIG_SYM          bfd_elf32_sh64blin_vec
 813 #undef  TARGET_BIG_NAME
 814 #define TARGET_BIG_NAME         "elf32-sh64big-linux"
 815 #undef  TARGET_LITTLE_SYM
 816 #define TARGET_LITTLE_SYM       bfd_elf32_sh64lin_vec
 817 #undef  TARGET_LITTLE_NAME
 818 #define TARGET_LITTLE_NAME      "elf32-sh64-linux"
 819 #undef  elf32_bed
 820 #define elf32_bed               elf32_sh64_lin_bed
 821
 822 #include "elf32-target.h"
 823