bfd/elf32-sh64.c

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