Automatic date update in version.in
[external/binutils.git] / bfd / elf32-sh.c
1 /* Renesas / SuperH SH specific support for 32-bit ELF
2    Copyright (C) 1996-2018 Free Software Foundation, Inc.
3    Contributed by Ian Lance Taylor, Cygnus Support.
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 3 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,
20    MA 02110-1301, USA.  */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "bfdlink.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "elf-vxworks.h"
28 #include "elf/sh.h"
29 #include "dwarf2.h"
30 #include "libiberty.h"
31 #include "../opcodes/sh-opc.h"
32
33 static bfd_reloc_status_type sh_elf_reloc
34   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
35 static bfd_reloc_status_type sh_elf_ignore_reloc
36   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
37 static bfd_boolean sh_elf_relax_delete_bytes
38   (bfd *, asection *, bfd_vma, int);
39 static bfd_boolean sh_elf_align_loads
40   (bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_boolean *);
41 static bfd_boolean sh_elf_swap_insns
42   (bfd *, asection *, void *, bfd_byte *, bfd_vma);
43 static int sh_elf_optimized_tls_reloc
44   (struct bfd_link_info *, int, int);
45 static bfd_vma dtpoff_base
46   (struct bfd_link_info *);
47 static bfd_vma tpoff
48   (struct bfd_link_info *, bfd_vma);
49
50 /* The name of the dynamic interpreter.  This is put in the .interp
51    section.  */
52
53 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
54
55 /* FDPIC binaries have a default 128K stack.  */
56 #define DEFAULT_STACK_SIZE 0x20000
57
58 #define MINUS_ONE ((bfd_vma) 0 - 1)
59
60 /* Decide whether a reference to a symbol can be resolved locally or
61    not.  If the symbol is protected, we want the local address, but
62    its function descriptor must be assigned by the dynamic linker.  */
63 #define SYMBOL_FUNCDESC_LOCAL(INFO, H) \
64   (SYMBOL_REFERENCES_LOCAL (INFO, H) \
65    || ! elf_hash_table (INFO)->dynamic_sections_created)
66 \f
67 #define SH_PARTIAL32 TRUE
68 #define SH_SRC_MASK32 0xffffffff
69 #define SH_ELF_RELOC sh_elf_reloc
70 static reloc_howto_type sh_elf_howto_table[] =
71 {
72 #include "elf32-sh-relocs.h"
73 };
74
75 #define SH_PARTIAL32 FALSE
76 #define SH_SRC_MASK32 0
77 #define SH_ELF_RELOC bfd_elf_generic_reloc
78 static reloc_howto_type sh_vxworks_howto_table[] =
79 {
80 #include "elf32-sh-relocs.h"
81 };
82 \f
83 /* Return true if OUTPUT_BFD is a VxWorks object.  */
84
85 static bfd_boolean
86 vxworks_object_p (bfd *abfd ATTRIBUTE_UNUSED)
87 {
88 #if !defined SH_TARGET_ALREADY_DEFINED
89   extern const bfd_target sh_elf32_vxworks_le_vec;
90   extern const bfd_target sh_elf32_vxworks_vec;
91
92   return (abfd->xvec == &sh_elf32_vxworks_le_vec
93           || abfd->xvec == &sh_elf32_vxworks_vec);
94 #else
95   return FALSE;
96 #endif
97 }
98
99 /* Return true if OUTPUT_BFD is an FDPIC object.  */
100
101 static bfd_boolean
102 fdpic_object_p (bfd *abfd ATTRIBUTE_UNUSED)
103 {
104 #if !defined SH_TARGET_ALREADY_DEFINED
105   extern const bfd_target sh_elf32_fdpic_le_vec;
106   extern const bfd_target sh_elf32_fdpic_be_vec;
107
108   return (abfd->xvec == &sh_elf32_fdpic_le_vec
109           || abfd->xvec == &sh_elf32_fdpic_be_vec);
110 #else
111   return FALSE;
112 #endif
113 }
114
115 /* Return the howto table for ABFD.  */
116
117 static reloc_howto_type *
118 get_howto_table (bfd *abfd)
119 {
120   if (vxworks_object_p (abfd))
121     return sh_vxworks_howto_table;
122   return sh_elf_howto_table;
123 }
124
125 static bfd_reloc_status_type
126 sh_elf_reloc_loop (int r_type ATTRIBUTE_UNUSED, bfd *input_bfd,
127                    asection *input_section, bfd_byte *contents,
128                    bfd_vma addr, asection *symbol_section,
129                    bfd_vma start, bfd_vma end)
130 {
131   static bfd_vma last_addr;
132   static asection *last_symbol_section;
133   bfd_byte *start_ptr, *ptr, *last_ptr;
134   int diff, cum_diff;
135   bfd_signed_vma x;
136   int insn;
137
138   /* Sanity check the address.  */
139   if (addr > bfd_get_section_limit (input_bfd, input_section))
140     return bfd_reloc_outofrange;
141
142   /* We require the start and end relocations to be processed consecutively -
143      although we allow then to be processed forwards or backwards.  */
144   if (! last_addr)
145     {
146       last_addr = addr;
147       last_symbol_section = symbol_section;
148       return bfd_reloc_ok;
149     }
150   if (last_addr != addr)
151     abort ();
152   last_addr = 0;
153
154   if (! symbol_section || last_symbol_section != symbol_section || end < start)
155     return bfd_reloc_outofrange;
156
157   /* Get the symbol_section contents.  */
158   if (symbol_section != input_section)
159     {
160       if (elf_section_data (symbol_section)->this_hdr.contents != NULL)
161         contents = elf_section_data (symbol_section)->this_hdr.contents;
162       else
163         {
164           if (!bfd_malloc_and_get_section (input_bfd, symbol_section,
165                                            &contents))
166             {
167               if (contents != NULL)
168                 free (contents);
169               return bfd_reloc_outofrange;
170             }
171         }
172     }
173 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
174   start_ptr = contents + start;
175   for (cum_diff = -6, ptr = contents + end; cum_diff < 0 && ptr > start_ptr;)
176     {
177       for (last_ptr = ptr, ptr -= 4; ptr >= start_ptr && IS_PPI (ptr);)
178         ptr -= 2;
179       ptr += 2;
180       diff = (last_ptr - ptr) >> 1;
181       cum_diff += diff & 1;
182       cum_diff += diff;
183     }
184   /* Calculate the start / end values to load into rs / re minus four -
185      so that will cancel out the four we would otherwise have to add to
186      addr to get the value to subtract in order to get relative addressing.  */
187   if (cum_diff >= 0)
188     {
189       start -= 4;
190       end = (ptr + cum_diff * 2) - contents;
191     }
192   else
193     {
194       bfd_vma start0 = start - 4;
195
196       while (start0 && IS_PPI (contents + start0))
197         start0 -= 2;
198       start0 = start - 2 - ((start - start0) & 2);
199       start = start0 - cum_diff - 2;
200       end = start0;
201     }
202
203   if (contents != NULL
204       && elf_section_data (symbol_section)->this_hdr.contents != contents)
205     free (contents);
206
207   insn = bfd_get_16 (input_bfd, contents + addr);
208
209   x = (insn & 0x200 ? end : start) - addr;
210   if (input_section != symbol_section)
211     x += ((symbol_section->output_section->vma + symbol_section->output_offset)
212           - (input_section->output_section->vma
213              + input_section->output_offset));
214   x >>= 1;
215   if (x < -128 || x > 127)
216     return bfd_reloc_overflow;
217
218   x = (insn & ~0xff) | (x & 0xff);
219   bfd_put_16 (input_bfd, (bfd_vma) x, contents + addr);
220
221   return bfd_reloc_ok;
222 }
223
224 /* This function is used for normal relocs.  This used to be like the COFF
225    function, and is almost certainly incorrect for other ELF targets.  */
226
227 static bfd_reloc_status_type
228 sh_elf_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol_in,
229               void *data, asection *input_section, bfd *output_bfd,
230               char **error_message ATTRIBUTE_UNUSED)
231 {
232   unsigned long insn;
233   bfd_vma sym_value;
234   enum elf_sh_reloc_type r_type;
235   bfd_vma addr = reloc_entry->address;
236   bfd_byte *hit_data = addr + (bfd_byte *) data;
237
238   r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
239
240   if (output_bfd != NULL)
241     {
242       /* Partial linking--do nothing.  */
243       reloc_entry->address += input_section->output_offset;
244       return bfd_reloc_ok;
245     }
246
247   /* Almost all relocs have to do with relaxing.  If any work must be
248      done for them, it has been done in sh_relax_section.  */
249   if (r_type == R_SH_IND12W && (symbol_in->flags & BSF_LOCAL) != 0)
250     return bfd_reloc_ok;
251
252   if (symbol_in != NULL
253       && bfd_is_und_section (symbol_in->section))
254     return bfd_reloc_undefined;
255
256   /* PR 17512: file: 9891ca98.  */
257   if (addr * bfd_octets_per_byte (abfd) + bfd_get_reloc_size (reloc_entry->howto)
258       > bfd_get_section_limit_octets (abfd, input_section))
259     return bfd_reloc_outofrange;
260
261   if (bfd_is_com_section (symbol_in->section))
262     sym_value = 0;
263   else
264     sym_value = (symbol_in->value +
265                  symbol_in->section->output_section->vma +
266                  symbol_in->section->output_offset);
267
268   switch (r_type)
269     {
270     case R_SH_DIR32:
271       insn = bfd_get_32 (abfd, hit_data);
272       insn += sym_value + reloc_entry->addend;
273       bfd_put_32 (abfd, (bfd_vma) insn, hit_data);
274       break;
275     case R_SH_IND12W:
276       insn = bfd_get_16 (abfd, hit_data);
277       sym_value += reloc_entry->addend;
278       sym_value -= (input_section->output_section->vma
279                     + input_section->output_offset
280                     + addr
281                     + 4);
282       sym_value += (insn & 0xfff) << 1;
283       if (insn & 0x800)
284         sym_value -= 0x1000;
285       insn = (insn & 0xf000) | (sym_value & 0xfff);
286       bfd_put_16 (abfd, (bfd_vma) insn, hit_data);
287       if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
288         return bfd_reloc_overflow;
289       break;
290     default:
291       abort ();
292       break;
293     }
294
295   return bfd_reloc_ok;
296 }
297
298 /* This function is used for relocs which are only used for relaxing,
299    which the linker should otherwise ignore.  */
300
301 static bfd_reloc_status_type
302 sh_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
303                      asymbol *symbol ATTRIBUTE_UNUSED,
304                      void *data ATTRIBUTE_UNUSED, asection *input_section,
305                      bfd *output_bfd,
306                      char **error_message ATTRIBUTE_UNUSED)
307 {
308   if (output_bfd != NULL)
309     reloc_entry->address += input_section->output_offset;
310   return bfd_reloc_ok;
311 }
312
313 /* This structure is used to map BFD reloc codes to SH ELF relocs.  */
314
315 struct elf_reloc_map
316 {
317   bfd_reloc_code_real_type bfd_reloc_val;
318   unsigned char elf_reloc_val;
319 };
320
321 /* An array mapping BFD reloc codes to SH ELF relocs.  */
322
323 static const struct elf_reloc_map sh_reloc_map[] =
324 {
325   { BFD_RELOC_NONE, R_SH_NONE },
326   { BFD_RELOC_32, R_SH_DIR32 },
327   { BFD_RELOC_16, R_SH_DIR16 },
328   { BFD_RELOC_8, R_SH_DIR8 },
329   { BFD_RELOC_CTOR, R_SH_DIR32 },
330   { BFD_RELOC_32_PCREL, R_SH_REL32 },
331   { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
332   { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
333   { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
334   { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
335   { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
336   { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
337   { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
338   { BFD_RELOC_SH_USES, R_SH_USES },
339   { BFD_RELOC_SH_COUNT, R_SH_COUNT },
340   { BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
341   { BFD_RELOC_SH_CODE, R_SH_CODE },
342   { BFD_RELOC_SH_DATA, R_SH_DATA },
343   { BFD_RELOC_SH_LABEL, R_SH_LABEL },
344   { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
345   { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
346   { BFD_RELOC_SH_LOOP_START, R_SH_LOOP_START },
347   { BFD_RELOC_SH_LOOP_END, R_SH_LOOP_END },
348   { BFD_RELOC_SH_TLS_GD_32, R_SH_TLS_GD_32 },
349   { BFD_RELOC_SH_TLS_LD_32, R_SH_TLS_LD_32 },
350   { BFD_RELOC_SH_TLS_LDO_32, R_SH_TLS_LDO_32 },
351   { BFD_RELOC_SH_TLS_IE_32, R_SH_TLS_IE_32 },
352   { BFD_RELOC_SH_TLS_LE_32, R_SH_TLS_LE_32 },
353   { BFD_RELOC_SH_TLS_DTPMOD32, R_SH_TLS_DTPMOD32 },
354   { BFD_RELOC_SH_TLS_DTPOFF32, R_SH_TLS_DTPOFF32 },
355   { BFD_RELOC_SH_TLS_TPOFF32, R_SH_TLS_TPOFF32 },
356   { BFD_RELOC_32_GOT_PCREL, R_SH_GOT32 },
357   { BFD_RELOC_32_PLT_PCREL, R_SH_PLT32 },
358   { BFD_RELOC_SH_COPY, R_SH_COPY },
359   { BFD_RELOC_SH_GLOB_DAT, R_SH_GLOB_DAT },
360   { BFD_RELOC_SH_JMP_SLOT, R_SH_JMP_SLOT },
361   { BFD_RELOC_SH_RELATIVE, R_SH_RELATIVE },
362   { BFD_RELOC_32_GOTOFF, R_SH_GOTOFF },
363   { BFD_RELOC_SH_GOTPC, R_SH_GOTPC },
364   { BFD_RELOC_SH_GOTPLT32, R_SH_GOTPLT32 },
365   { BFD_RELOC_SH_GOT20, R_SH_GOT20 },
366   { BFD_RELOC_SH_GOTOFF20, R_SH_GOTOFF20 },
367   { BFD_RELOC_SH_GOTFUNCDESC, R_SH_GOTFUNCDESC },
368   { BFD_RELOC_SH_GOTFUNCDESC20, R_SH_GOTFUNCDESC20 },
369   { BFD_RELOC_SH_GOTOFFFUNCDESC, R_SH_GOTOFFFUNCDESC },
370   { BFD_RELOC_SH_GOTOFFFUNCDESC20, R_SH_GOTOFFFUNCDESC20 },
371   { BFD_RELOC_SH_FUNCDESC, R_SH_FUNCDESC },
372 };
373
374 /* Given a BFD reloc code, return the howto structure for the
375    corresponding SH ELF reloc.  */
376
377 static reloc_howto_type *
378 sh_elf_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
379 {
380   unsigned int i;
381
382   for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
383     {
384       if (sh_reloc_map[i].bfd_reloc_val == code)
385         return get_howto_table (abfd) + (int) sh_reloc_map[i].elf_reloc_val;
386     }
387
388   return NULL;
389 }
390
391 static reloc_howto_type *
392 sh_elf_reloc_name_lookup (bfd *abfd, const char *r_name)
393 {
394   unsigned int i;
395
396   if (vxworks_object_p (abfd))
397     {
398       for (i = 0;
399            i < (sizeof (sh_vxworks_howto_table)
400                 / sizeof (sh_vxworks_howto_table[0]));
401            i++)
402         if (sh_vxworks_howto_table[i].name != NULL
403             && strcasecmp (sh_vxworks_howto_table[i].name, r_name) == 0)
404           return &sh_vxworks_howto_table[i];
405     }
406   else
407     {
408       for (i = 0;
409            i < (sizeof (sh_elf_howto_table)
410                 / sizeof (sh_elf_howto_table[0]));
411            i++)
412         if (sh_elf_howto_table[i].name != NULL
413             && strcasecmp (sh_elf_howto_table[i].name, r_name) == 0)
414           return &sh_elf_howto_table[i];
415     }
416
417   return NULL;
418 }
419
420 /* Given an ELF reloc, fill in the howto field of a relent.  */
421
422 static bfd_boolean
423 sh_elf_info_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
424 {
425   unsigned int r;
426
427   r = ELF32_R_TYPE (dst->r_info);
428
429   if (r >= R_SH_max
430       || (r >= R_SH_FIRST_INVALID_RELOC   && r <= R_SH_LAST_INVALID_RELOC)
431       || (r >= R_SH_FIRST_INVALID_RELOC_2 && r <= R_SH_LAST_INVALID_RELOC_2)
432       || (r >= R_SH_FIRST_INVALID_RELOC_3 && r <= R_SH_LAST_INVALID_RELOC_3)
433       || (r >= R_SH_FIRST_INVALID_RELOC_4 && r <= R_SH_LAST_INVALID_RELOC_4)
434       || (r >= R_SH_FIRST_INVALID_RELOC_5 && r <= R_SH_LAST_INVALID_RELOC_5)
435       || (r >= R_SH_FIRST_INVALID_RELOC_6 && r <= R_SH_LAST_INVALID_RELOC_6))
436     {
437       /* xgettext:c-format */
438       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
439                           abfd, r);
440       bfd_set_error (bfd_error_bad_value);
441       return FALSE;
442     }
443
444   cache_ptr->howto = get_howto_table (abfd) + r;
445   return TRUE;
446 }
447 \f
448 /* This function handles relaxing for SH ELF.  See the corresponding
449    function in coff-sh.c for a description of what this does.  FIXME:
450    There is a lot of duplication here between this code and the COFF
451    specific code.  The format of relocs and symbols is wound deeply
452    into this code, but it would still be better if the duplication
453    could be eliminated somehow.  Note in particular that although both
454    functions use symbols like R_SH_CODE, those symbols have different
455    values; in coff-sh.c they come from include/coff/sh.h, whereas here
456    they come from enum elf_sh_reloc_type in include/elf/sh.h.  */
457
458 static bfd_boolean
459 sh_elf_relax_section (bfd *abfd, asection *sec,
460                       struct bfd_link_info *link_info, bfd_boolean *again)
461 {
462   Elf_Internal_Shdr *symtab_hdr;
463   Elf_Internal_Rela *internal_relocs;
464   bfd_boolean have_code;
465   Elf_Internal_Rela *irel, *irelend;
466   bfd_byte *contents = NULL;
467   Elf_Internal_Sym *isymbuf = NULL;
468
469   *again = FALSE;
470
471   if (bfd_link_relocatable (link_info)
472       || (sec->flags & SEC_RELOC) == 0
473       || sec->reloc_count == 0)
474     return TRUE;
475
476   symtab_hdr = &elf_symtab_hdr (abfd);
477
478   internal_relocs = (_bfd_elf_link_read_relocs
479                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
480                       link_info->keep_memory));
481   if (internal_relocs == NULL)
482     goto error_return;
483
484   have_code = FALSE;
485
486   irelend = internal_relocs + sec->reloc_count;
487   for (irel = internal_relocs; irel < irelend; irel++)
488     {
489       bfd_vma laddr, paddr, symval;
490       unsigned short insn;
491       Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
492       bfd_signed_vma foff;
493
494       if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
495         have_code = TRUE;
496
497       if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
498         continue;
499
500       /* Get the section contents.  */
501       if (contents == NULL)
502         {
503           if (elf_section_data (sec)->this_hdr.contents != NULL)
504             contents = elf_section_data (sec)->this_hdr.contents;
505           else
506             {
507               if (!bfd_malloc_and_get_section (abfd, sec, &contents))
508                 goto error_return;
509             }
510         }
511
512       /* The r_addend field of the R_SH_USES reloc will point us to
513          the register load.  The 4 is because the r_addend field is
514          computed as though it were a jump offset, which are based
515          from 4 bytes after the jump instruction.  */
516       laddr = irel->r_offset + 4 + irel->r_addend;
517       if (laddr >= sec->size)
518         {
519           /* xgettext:c-format */
520           _bfd_error_handler
521             (_("%pB: %#" PRIx64 ": warning: bad R_SH_USES offset"),
522              abfd, (uint64_t) irel->r_offset);
523           continue;
524         }
525       insn = bfd_get_16 (abfd, contents + laddr);
526
527       /* If the instruction is not mov.l NN,rN, we don't know what to
528          do.  */
529       if ((insn & 0xf000) != 0xd000)
530         {
531           _bfd_error_handler
532             /* xgettext:c-format */
533             (_("%pB: %#" PRIx64 ": warning: "
534                "R_SH_USES points to unrecognized insn 0x%x"),
535              abfd, (uint64_t) irel->r_offset, insn);
536           continue;
537         }
538
539       /* Get the address from which the register is being loaded.  The
540          displacement in the mov.l instruction is quadrupled.  It is a
541          displacement from four bytes after the movl instruction, but,
542          before adding in the PC address, two least significant bits
543          of the PC are cleared.  We assume that the section is aligned
544          on a four byte boundary.  */
545       paddr = insn & 0xff;
546       paddr *= 4;
547       paddr += (laddr + 4) &~ (bfd_vma) 3;
548       if (paddr >= sec->size)
549         {
550           _bfd_error_handler
551             /* xgettext:c-format */
552             (_("%pB: %#" PRIx64 ": warning: bad R_SH_USES load offset"),
553              abfd, (uint64_t) irel->r_offset);
554           continue;
555         }
556
557       /* Get the reloc for the address from which the register is
558          being loaded.  This reloc will tell us which function is
559          actually being called.  */
560       for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
561         if (irelfn->r_offset == paddr
562             && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
563           break;
564       if (irelfn >= irelend)
565         {
566           _bfd_error_handler
567             /* xgettext:c-format */
568             (_("%pB: %#" PRIx64 ": warning: could not find expected reloc"),
569              abfd, (uint64_t) paddr);
570           continue;
571         }
572
573       /* Read this BFD's symbols if we haven't done so already.  */
574       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
575         {
576           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
577           if (isymbuf == NULL)
578             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
579                                             symtab_hdr->sh_info, 0,
580                                             NULL, NULL, NULL);
581           if (isymbuf == NULL)
582             goto error_return;
583         }
584
585       /* Get the value of the symbol referred to by the reloc.  */
586       if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
587         {
588           /* A local symbol.  */
589           Elf_Internal_Sym *isym;
590
591           isym = isymbuf + ELF32_R_SYM (irelfn->r_info);
592           if (isym->st_shndx
593               != (unsigned int) _bfd_elf_section_from_bfd_section (abfd, sec))
594             {
595               _bfd_error_handler
596                 /* xgettext:c-format */
597                 (_("%pB: %#" PRIx64 ": warning: symbol in unexpected section"),
598                  abfd, (uint64_t) paddr);
599               continue;
600             }
601
602           symval = (isym->st_value
603                     + sec->output_section->vma
604                     + sec->output_offset);
605         }
606       else
607         {
608           unsigned long indx;
609           struct elf_link_hash_entry *h;
610
611           indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
612           h = elf_sym_hashes (abfd)[indx];
613           BFD_ASSERT (h != NULL);
614           if (h->root.type != bfd_link_hash_defined
615               && h->root.type != bfd_link_hash_defweak)
616             {
617               /* This appears to be a reference to an undefined
618                  symbol.  Just ignore it--it will be caught by the
619                  regular reloc processing.  */
620               continue;
621             }
622
623           symval = (h->root.u.def.value
624                     + h->root.u.def.section->output_section->vma
625                     + h->root.u.def.section->output_offset);
626         }
627
628       if (get_howto_table (abfd)[R_SH_DIR32].partial_inplace)
629         symval += bfd_get_32 (abfd, contents + paddr);
630       else
631         symval += irelfn->r_addend;
632
633       /* See if this function call can be shortened.  */
634       foff = (symval
635               - (irel->r_offset
636                  + sec->output_section->vma
637                  + sec->output_offset
638                  + 4));
639       /* A branch to an address beyond ours might be increased by an
640          .align that doesn't move when bytes behind us are deleted.
641          So, we add some slop in this calculation to allow for
642          that.  */
643       if (foff < -0x1000 || foff >= 0x1000 - 8)
644         {
645           /* After all that work, we can't shorten this function call.  */
646           continue;
647         }
648
649       /* Shorten the function call.  */
650
651       /* For simplicity of coding, we are going to modify the section
652          contents, the section relocs, and the BFD symbol table.  We
653          must tell the rest of the code not to free up this
654          information.  It would be possible to instead create a table
655          of changes which have to be made, as is done in coff-mips.c;
656          that would be more work, but would require less memory when
657          the linker is run.  */
658
659       elf_section_data (sec)->relocs = internal_relocs;
660       elf_section_data (sec)->this_hdr.contents = contents;
661       symtab_hdr->contents = (unsigned char *) isymbuf;
662
663       /* Replace the jmp/jsr with a bra/bsr.  */
664
665       /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
666          replace the jmp/jsr with a bra/bsr.  */
667       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
668       /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
669          here, but that only checks if the symbol is an external symbol,
670          not if the symbol is in a different section.  Besides, we need
671          a consistent meaning for the relocation, so we just assume here that
672          the value of the symbol is not available.  */
673
674       /* We can't fully resolve this yet, because the external
675          symbol value may be changed by future relaxing.  We let
676          the final link phase handle it.  */
677       if (bfd_get_16 (abfd, contents + irel->r_offset) & 0x0020)
678         bfd_put_16 (abfd, (bfd_vma) 0xa000, contents + irel->r_offset);
679       else
680         bfd_put_16 (abfd, (bfd_vma) 0xb000, contents + irel->r_offset);
681
682       irel->r_addend = -4;
683
684       /* When we calculated the symbol "value" we had an offset in the
685          DIR32's word in memory (we read and add it above).  However,
686          the jsr we create does NOT have this offset encoded, so we
687          have to add it to the addend to preserve it.  */
688       irel->r_addend += bfd_get_32 (abfd, contents + paddr);
689
690       /* See if there is another R_SH_USES reloc referring to the same
691          register load.  */
692       for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
693         if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
694             && laddr == irelscan->r_offset + 4 + irelscan->r_addend)
695           break;
696       if (irelscan < irelend)
697         {
698           /* Some other function call depends upon this register load,
699              and we have not yet converted that function call.
700              Indeed, we may never be able to convert it.  There is
701              nothing else we can do at this point.  */
702           continue;
703         }
704
705       /* Look for a R_SH_COUNT reloc on the location where the
706          function address is stored.  Do this before deleting any
707          bytes, to avoid confusion about the address.  */
708       for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
709         if (irelcount->r_offset == paddr
710             && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
711           break;
712
713       /* Delete the register load.  */
714       if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
715         goto error_return;
716
717       /* That will change things, so, just in case it permits some
718          other function call to come within range, we should relax
719          again.  Note that this is not required, and it may be slow.  */
720       *again = TRUE;
721
722       /* Now check whether we got a COUNT reloc.  */
723       if (irelcount >= irelend)
724         {
725           _bfd_error_handler
726             /* xgettext:c-format */
727             (_("%pB: %#" PRIx64 ": warning: "
728                "could not find expected COUNT reloc"),
729              abfd, (uint64_t) paddr);
730           continue;
731         }
732
733       /* The number of uses is stored in the r_addend field.  We've
734          just deleted one.  */
735       if (irelcount->r_addend == 0)
736         {
737           /* xgettext:c-format */
738           _bfd_error_handler (_("%pB: %#" PRIx64 ": warning: bad count"),
739                               abfd, (uint64_t) paddr);
740           continue;
741         }
742
743       --irelcount->r_addend;
744
745       /* If there are no more uses, we can delete the address.  Reload
746          the address from irelfn, in case it was changed by the
747          previous call to sh_elf_relax_delete_bytes.  */
748       if (irelcount->r_addend == 0)
749         {
750           if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
751             goto error_return;
752         }
753
754       /* We've done all we can with that function call.  */
755     }
756
757   /* Look for load and store instructions that we can align on four
758      byte boundaries.  */
759   if ((elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK) != EF_SH4
760       && have_code)
761     {
762       bfd_boolean swapped;
763
764       /* Get the section contents.  */
765       if (contents == NULL)
766         {
767           if (elf_section_data (sec)->this_hdr.contents != NULL)
768             contents = elf_section_data (sec)->this_hdr.contents;
769           else
770             {
771               if (!bfd_malloc_and_get_section (abfd, sec, &contents))
772                 goto error_return;
773             }
774         }
775
776       if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
777                                 &swapped))
778         goto error_return;
779
780       if (swapped)
781         {
782           elf_section_data (sec)->relocs = internal_relocs;
783           elf_section_data (sec)->this_hdr.contents = contents;
784           symtab_hdr->contents = (unsigned char *) isymbuf;
785         }
786     }
787
788   if (isymbuf != NULL
789       && symtab_hdr->contents != (unsigned char *) isymbuf)
790     {
791       if (! link_info->keep_memory)
792         free (isymbuf);
793       else
794         {
795           /* Cache the symbols for elf_link_input_bfd.  */
796           symtab_hdr->contents = (unsigned char *) isymbuf;
797         }
798     }
799
800   if (contents != NULL
801       && elf_section_data (sec)->this_hdr.contents != contents)
802     {
803       if (! link_info->keep_memory)
804         free (contents);
805       else
806         {
807           /* Cache the section contents for elf_link_input_bfd.  */
808           elf_section_data (sec)->this_hdr.contents = contents;
809         }
810     }
811
812   if (internal_relocs != NULL
813       && elf_section_data (sec)->relocs != internal_relocs)
814     free (internal_relocs);
815
816   return TRUE;
817
818  error_return:
819   if (isymbuf != NULL
820       && symtab_hdr->contents != (unsigned char *) isymbuf)
821     free (isymbuf);
822   if (contents != NULL
823       && elf_section_data (sec)->this_hdr.contents != contents)
824     free (contents);
825   if (internal_relocs != NULL
826       && elf_section_data (sec)->relocs != internal_relocs)
827     free (internal_relocs);
828
829   return FALSE;
830 }
831
832 /* Delete some bytes from a section while relaxing.  FIXME: There is a
833    lot of duplication between this function and sh_relax_delete_bytes
834    in coff-sh.c.  */
835
836 static bfd_boolean
837 sh_elf_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr,
838                            int count)
839 {
840   Elf_Internal_Shdr *symtab_hdr;
841   unsigned int sec_shndx;
842   bfd_byte *contents;
843   Elf_Internal_Rela *irel, *irelend;
844   Elf_Internal_Rela *irelalign;
845   bfd_vma toaddr;
846   Elf_Internal_Sym *isymbuf, *isym, *isymend;
847   struct elf_link_hash_entry **sym_hashes;
848   struct elf_link_hash_entry **end_hashes;
849   unsigned int symcount;
850   asection *o;
851
852   symtab_hdr = &elf_symtab_hdr (abfd);
853   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
854
855   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
856
857   contents = elf_section_data (sec)->this_hdr.contents;
858
859   /* The deletion must stop at the next ALIGN reloc for an alignment
860      power larger than the number of bytes we are deleting.  */
861
862   irelalign = NULL;
863   toaddr = sec->size;
864
865   irel = elf_section_data (sec)->relocs;
866   irelend = irel + sec->reloc_count;
867   for (; irel < irelend; irel++)
868     {
869       if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
870           && irel->r_offset > addr
871           && count < (1 << irel->r_addend))
872         {
873           irelalign = irel;
874           toaddr = irel->r_offset;
875           break;
876         }
877     }
878
879   /* Actually delete the bytes.  */
880   memmove (contents + addr, contents + addr + count,
881            (size_t) (toaddr - addr - count));
882   if (irelalign == NULL)
883     sec->size -= count;
884   else
885     {
886       int i;
887
888 #define NOP_OPCODE (0x0009)
889
890       BFD_ASSERT ((count & 1) == 0);
891       for (i = 0; i < count; i += 2)
892         bfd_put_16 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
893     }
894
895   /* Adjust all the relocs.  */
896   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
897     {
898       bfd_vma nraddr, stop;
899       bfd_vma start = 0;
900       int insn = 0;
901       int off, adjust, oinsn;
902       bfd_signed_vma voff = 0;
903       bfd_boolean overflow;
904
905       /* Get the new reloc address.  */
906       nraddr = irel->r_offset;
907       if ((irel->r_offset > addr
908            && irel->r_offset < toaddr)
909           || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
910               && irel->r_offset == toaddr))
911         nraddr -= count;
912
913       /* See if this reloc was for the bytes we have deleted, in which
914          case we no longer care about it.  Don't delete relocs which
915          represent addresses, though.  */
916       if (irel->r_offset >= addr
917           && irel->r_offset < addr + count
918           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
919           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
920           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
921           && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
922         irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
923                                      (int) R_SH_NONE);
924
925       /* If this is a PC relative reloc, see if the range it covers
926          includes the bytes we have deleted.  */
927       switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
928         {
929         default:
930           break;
931
932         case R_SH_DIR8WPN:
933         case R_SH_IND12W:
934         case R_SH_DIR8WPZ:
935         case R_SH_DIR8WPL:
936           start = irel->r_offset;
937           insn = bfd_get_16 (abfd, contents + nraddr);
938           break;
939         }
940
941       switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
942         {
943         default:
944           start = stop = addr;
945           break;
946
947         case R_SH_DIR32:
948           /* If this reloc is against a symbol defined in this
949              section, and the symbol will not be adjusted below, we
950              must check the addend to see it will put the value in
951              range to be adjusted, and hence must be changed.  */
952           if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
953             {
954               isym = isymbuf + ELF32_R_SYM (irel->r_info);
955               if (isym->st_shndx == sec_shndx
956                   && (isym->st_value <= addr
957                       || isym->st_value >= toaddr))
958                 {
959                   bfd_vma val;
960
961                   if (get_howto_table (abfd)[R_SH_DIR32].partial_inplace)
962                     {
963                       val = bfd_get_32 (abfd, contents + nraddr);
964                       val += isym->st_value;
965                       if (val > addr && val < toaddr)
966                         bfd_put_32 (abfd, val - count, contents + nraddr);
967                     }
968                   else
969                     {
970                       val = isym->st_value + irel->r_addend;
971                       if (val > addr && val < toaddr)
972                         irel->r_addend -= count;
973                     }
974                 }
975             }
976           start = stop = addr;
977           break;
978
979         case R_SH_DIR8WPN:
980           off = insn & 0xff;
981           if (off & 0x80)
982             off -= 0x100;
983           stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
984           break;
985
986         case R_SH_IND12W:
987           off = insn & 0xfff;
988           if (! off)
989             {
990               /* This has been made by previous relaxation.  Since the
991                  relocation will be against an external symbol, the
992                  final relocation will just do the right thing.  */
993               start = stop = addr;
994             }
995           else
996             {
997               if (off & 0x800)
998                 off -= 0x1000;
999               stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1000
1001               /* The addend will be against the section symbol, thus
1002                  for adjusting the addend, the relevant start is the
1003                  start of the section.
1004                  N.B. If we want to abandon in-place changes here and
1005                  test directly using symbol + addend, we have to take into
1006                  account that the addend has already been adjusted by -4.  */
1007               if (stop > addr && stop < toaddr)
1008                 irel->r_addend -= count;
1009             }
1010           break;
1011
1012         case R_SH_DIR8WPZ:
1013           off = insn & 0xff;
1014           stop = start + 4 + off * 2;
1015           break;
1016
1017         case R_SH_DIR8WPL:
1018           off = insn & 0xff;
1019           stop = (start & ~(bfd_vma) 3) + 4 + off * 4;
1020           break;
1021
1022         case R_SH_SWITCH8:
1023         case R_SH_SWITCH16:
1024         case R_SH_SWITCH32:
1025           /* These relocs types represent
1026                .word L2-L1
1027              The r_addend field holds the difference between the reloc
1028              address and L1.  That is the start of the reloc, and
1029              adding in the contents gives us the top.  We must adjust
1030              both the r_offset field and the section contents.
1031              N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1032              and the elf bfd r_offset is called r_vaddr.  */
1033
1034           stop = irel->r_offset;
1035           start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
1036
1037           if (start > addr
1038               && start < toaddr
1039               && (stop <= addr || stop >= toaddr))
1040             irel->r_addend += count;
1041           else if (stop > addr
1042                    && stop < toaddr
1043                    && (start <= addr || start >= toaddr))
1044             irel->r_addend -= count;
1045
1046           if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
1047             voff = bfd_get_signed_16 (abfd, contents + nraddr);
1048           else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
1049             voff = bfd_get_8 (abfd, contents + nraddr);
1050           else
1051             voff = bfd_get_signed_32 (abfd, contents + nraddr);
1052           stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1053
1054           break;
1055
1056         case R_SH_USES:
1057           start = irel->r_offset;
1058           stop = (bfd_vma) ((bfd_signed_vma) start
1059                             + (long) irel->r_addend
1060                             + 4);
1061           break;
1062         }
1063
1064       if (start > addr
1065           && start < toaddr
1066           && (stop <= addr || stop >= toaddr))
1067         adjust = count;
1068       else if (stop > addr
1069                && stop < toaddr
1070                && (start <= addr || start >= toaddr))
1071         adjust = - count;
1072       else
1073         adjust = 0;
1074
1075       if (adjust != 0)
1076         {
1077           oinsn = insn;
1078           overflow = FALSE;
1079           switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1080             {
1081             default:
1082               abort ();
1083               break;
1084
1085             case R_SH_DIR8WPN:
1086             case R_SH_DIR8WPZ:
1087               insn += adjust / 2;
1088               if ((oinsn & 0xff00) != (insn & 0xff00))
1089                 overflow = TRUE;
1090               bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
1091               break;
1092
1093             case R_SH_IND12W:
1094               insn += adjust / 2;
1095               if ((oinsn & 0xf000) != (insn & 0xf000))
1096                 overflow = TRUE;
1097               bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
1098               break;
1099
1100             case R_SH_DIR8WPL:
1101               BFD_ASSERT (adjust == count || count >= 4);
1102               if (count >= 4)
1103                 insn += adjust / 4;
1104               else
1105                 {
1106                   if ((irel->r_offset & 3) == 0)
1107                     ++insn;
1108                 }
1109               if ((oinsn & 0xff00) != (insn & 0xff00))
1110                 overflow = TRUE;
1111               bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
1112               break;
1113
1114             case R_SH_SWITCH8:
1115               voff += adjust;
1116               if (voff < 0 || voff >= 0xff)
1117                 overflow = TRUE;
1118               bfd_put_8 (abfd, voff, contents + nraddr);
1119               break;
1120
1121             case R_SH_SWITCH16:
1122               voff += adjust;
1123               if (voff < - 0x8000 || voff >= 0x8000)
1124                 overflow = TRUE;
1125               bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr);
1126               break;
1127
1128             case R_SH_SWITCH32:
1129               voff += adjust;
1130               bfd_put_signed_32 (abfd, (bfd_vma) voff, contents + nraddr);
1131               break;
1132
1133             case R_SH_USES:
1134               irel->r_addend += adjust;
1135               break;
1136             }
1137
1138           if (overflow)
1139             {
1140               _bfd_error_handler
1141                 /* xgettext:c-format */
1142                 (_("%pB: %#" PRIx64 ": fatal: reloc overflow while relaxing"),
1143                  abfd, (uint64_t) irel->r_offset);
1144               bfd_set_error (bfd_error_bad_value);
1145               return FALSE;
1146             }
1147         }
1148
1149       irel->r_offset = nraddr;
1150     }
1151
1152   /* Look through all the other sections.  If there contain any IMM32
1153      relocs against internal symbols which we are not going to adjust
1154      below, we may need to adjust the addends.  */
1155   for (o = abfd->sections; o != NULL; o = o->next)
1156     {
1157       Elf_Internal_Rela *internal_relocs;
1158       Elf_Internal_Rela *irelscan, *irelscanend;
1159       bfd_byte *ocontents;
1160
1161       if (o == sec
1162           || (o->flags & SEC_RELOC) == 0
1163           || o->reloc_count == 0)
1164         continue;
1165
1166       /* We always cache the relocs.  Perhaps, if info->keep_memory is
1167          FALSE, we should free them, if we are permitted to, when we
1168          leave sh_coff_relax_section.  */
1169       internal_relocs = (_bfd_elf_link_read_relocs
1170                          (abfd, o, NULL, (Elf_Internal_Rela *) NULL, TRUE));
1171       if (internal_relocs == NULL)
1172         return FALSE;
1173
1174       ocontents = NULL;
1175       irelscanend = internal_relocs + o->reloc_count;
1176       for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1177         {
1178           /* Dwarf line numbers use R_SH_SWITCH32 relocs.  */
1179           if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
1180             {
1181               bfd_vma start, stop;
1182               bfd_signed_vma voff;
1183
1184               if (ocontents == NULL)
1185                 {
1186                   if (elf_section_data (o)->this_hdr.contents != NULL)
1187                     ocontents = elf_section_data (o)->this_hdr.contents;
1188                   else
1189                     {
1190                       /* We always cache the section contents.
1191                          Perhaps, if info->keep_memory is FALSE, we
1192                          should free them, if we are permitted to,
1193                          when we leave sh_coff_relax_section.  */
1194                       if (!bfd_malloc_and_get_section (abfd, o, &ocontents))
1195                         {
1196                           if (ocontents != NULL)
1197                             free (ocontents);
1198                           return FALSE;
1199                         }
1200
1201                       elf_section_data (o)->this_hdr.contents = ocontents;
1202                     }
1203                 }
1204
1205               stop = irelscan->r_offset;
1206               start
1207                 = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
1208
1209               /* STOP is in a different section, so it won't change.  */
1210               if (start > addr && start < toaddr)
1211                 irelscan->r_addend += count;
1212
1213               voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
1214               stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1215
1216               if (start > addr
1217                   && start < toaddr
1218                   && (stop <= addr || stop >= toaddr))
1219                 bfd_put_signed_32 (abfd, (bfd_vma) voff + count,
1220                                    ocontents + irelscan->r_offset);
1221               else if (stop > addr
1222                        && stop < toaddr
1223                        && (start <= addr || start >= toaddr))
1224                 bfd_put_signed_32 (abfd, (bfd_vma) voff - count,
1225                                    ocontents + irelscan->r_offset);
1226             }
1227
1228           if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
1229             continue;
1230
1231           if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
1232             continue;
1233
1234
1235           isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1236           if (isym->st_shndx == sec_shndx
1237               && (isym->st_value <= addr
1238                   || isym->st_value >= toaddr))
1239             {
1240               bfd_vma val;
1241
1242               if (ocontents == NULL)
1243                 {
1244                   if (elf_section_data (o)->this_hdr.contents != NULL)
1245                     ocontents = elf_section_data (o)->this_hdr.contents;
1246                   else
1247                     {
1248                       /* We always cache the section contents.
1249                          Perhaps, if info->keep_memory is FALSE, we
1250                          should free them, if we are permitted to,
1251                          when we leave sh_coff_relax_section.  */
1252                       if (!bfd_malloc_and_get_section (abfd, o, &ocontents))
1253                         {
1254                           if (ocontents != NULL)
1255                             free (ocontents);
1256                           return FALSE;
1257                         }
1258
1259                       elf_section_data (o)->this_hdr.contents = ocontents;
1260                     }
1261                 }
1262
1263               val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
1264               val += isym->st_value;
1265               if (val > addr && val < toaddr)
1266                 bfd_put_32 (abfd, val - count,
1267                             ocontents + irelscan->r_offset);
1268             }
1269         }
1270     }
1271
1272   /* Adjust the local symbols defined in this section.  */
1273   isymend = isymbuf + symtab_hdr->sh_info;
1274   for (isym = isymbuf; isym < isymend; isym++)
1275     {
1276       if (isym->st_shndx == sec_shndx
1277           && isym->st_value > addr
1278           && isym->st_value < toaddr)
1279         isym->st_value -= count;
1280     }
1281
1282   /* Now adjust the global symbols defined in this section.  */
1283   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1284               - symtab_hdr->sh_info);
1285   sym_hashes = elf_sym_hashes (abfd);
1286   end_hashes = sym_hashes + symcount;
1287   for (; sym_hashes < end_hashes; sym_hashes++)
1288     {
1289       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1290       if ((sym_hash->root.type == bfd_link_hash_defined
1291            || sym_hash->root.type == bfd_link_hash_defweak)
1292           && sym_hash->root.u.def.section == sec
1293           && sym_hash->root.u.def.value > addr
1294           && sym_hash->root.u.def.value < toaddr)
1295         {
1296           sym_hash->root.u.def.value -= count;
1297         }
1298     }
1299
1300   /* See if we can move the ALIGN reloc forward.  We have adjusted
1301      r_offset for it already.  */
1302   if (irelalign != NULL)
1303     {
1304       bfd_vma alignto, alignaddr;
1305
1306       alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
1307       alignaddr = BFD_ALIGN (irelalign->r_offset,
1308                              1 << irelalign->r_addend);
1309       if (alignto != alignaddr)
1310         {
1311           /* Tail recursion.  */
1312           return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
1313                                             (int) (alignto - alignaddr));
1314         }
1315     }
1316
1317   return TRUE;
1318 }
1319
1320 /* Look for loads and stores which we can align to four byte
1321    boundaries.  This is like sh_align_loads in coff-sh.c.  */
1322
1323 static bfd_boolean
1324 sh_elf_align_loads (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
1325                     Elf_Internal_Rela *internal_relocs,
1326                     bfd_byte *contents ATTRIBUTE_UNUSED,
1327                     bfd_boolean *pswapped)
1328 {
1329   Elf_Internal_Rela *irel, *irelend;
1330   bfd_vma *labels = NULL;
1331   bfd_vma *label, *label_end;
1332   bfd_size_type amt;
1333
1334   *pswapped = FALSE;
1335
1336   irelend = internal_relocs + sec->reloc_count;
1337
1338   /* Get all the addresses with labels on them.  */
1339   amt = sec->reloc_count;
1340   amt *= sizeof (bfd_vma);
1341   labels = (bfd_vma *) bfd_malloc (amt);
1342   if (labels == NULL)
1343     goto error_return;
1344   label_end = labels;
1345   for (irel = internal_relocs; irel < irelend; irel++)
1346     {
1347       if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
1348         {
1349           *label_end = irel->r_offset;
1350           ++label_end;
1351         }
1352     }
1353
1354   /* Note that the assembler currently always outputs relocs in
1355      address order.  If that ever changes, this code will need to sort
1356      the label values and the relocs.  */
1357
1358   label = labels;
1359
1360   for (irel = internal_relocs; irel < irelend; irel++)
1361     {
1362       bfd_vma start, stop;
1363
1364       if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
1365         continue;
1366
1367       start = irel->r_offset;
1368
1369       for (irel++; irel < irelend; irel++)
1370         if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
1371           break;
1372       if (irel < irelend)
1373         stop = irel->r_offset;
1374       else
1375         stop = sec->size;
1376
1377       if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
1378                                      internal_relocs, &label,
1379                                      label_end, start, stop, pswapped))
1380         goto error_return;
1381     }
1382
1383   free (labels);
1384
1385   return TRUE;
1386
1387  error_return:
1388   if (labels != NULL)
1389     free (labels);
1390   return FALSE;
1391 }
1392
1393 /* Swap two SH instructions.  This is like sh_swap_insns in coff-sh.c.  */
1394
1395 static bfd_boolean
1396 sh_elf_swap_insns (bfd *abfd, asection *sec, void *relocs,
1397                    bfd_byte *contents, bfd_vma addr)
1398 {
1399   Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
1400   unsigned short i1, i2;
1401   Elf_Internal_Rela *irel, *irelend;
1402
1403   /* Swap the instructions themselves.  */
1404   i1 = bfd_get_16 (abfd, contents + addr);
1405   i2 = bfd_get_16 (abfd, contents + addr + 2);
1406   bfd_put_16 (abfd, (bfd_vma) i2, contents + addr);
1407   bfd_put_16 (abfd, (bfd_vma) i1, contents + addr + 2);
1408
1409   /* Adjust all reloc addresses.  */
1410   irelend = internal_relocs + sec->reloc_count;
1411   for (irel = internal_relocs; irel < irelend; irel++)
1412     {
1413       enum elf_sh_reloc_type type;
1414       int add;
1415
1416       /* There are a few special types of relocs that we don't want to
1417          adjust.  These relocs do not apply to the instruction itself,
1418          but are only associated with the address.  */
1419       type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
1420       if (type == R_SH_ALIGN
1421           || type == R_SH_CODE
1422           || type == R_SH_DATA
1423           || type == R_SH_LABEL)
1424         continue;
1425
1426       /* If an R_SH_USES reloc points to one of the addresses being
1427          swapped, we must adjust it.  It would be incorrect to do this
1428          for a jump, though, since we want to execute both
1429          instructions after the jump.  (We have avoided swapping
1430          around a label, so the jump will not wind up executing an
1431          instruction it shouldn't).  */
1432       if (type == R_SH_USES)
1433         {
1434           bfd_vma off;
1435
1436           off = irel->r_offset + 4 + irel->r_addend;
1437           if (off == addr)
1438             irel->r_offset += 2;
1439           else if (off == addr + 2)
1440             irel->r_offset -= 2;
1441         }
1442
1443       if (irel->r_offset == addr)
1444         {
1445           irel->r_offset += 2;
1446           add = -2;
1447         }
1448       else if (irel->r_offset == addr + 2)
1449         {
1450           irel->r_offset -= 2;
1451           add = 2;
1452         }
1453       else
1454         add = 0;
1455
1456       if (add != 0)
1457         {
1458           bfd_byte *loc;
1459           unsigned short insn, oinsn;
1460           bfd_boolean overflow;
1461
1462           loc = contents + irel->r_offset;
1463           overflow = FALSE;
1464           switch (type)
1465             {
1466             default:
1467               break;
1468
1469             case R_SH_DIR8WPN:
1470             case R_SH_DIR8WPZ:
1471               insn = bfd_get_16 (abfd, loc);
1472               oinsn = insn;
1473               insn += add / 2;
1474               if ((oinsn & 0xff00) != (insn & 0xff00))
1475                 overflow = TRUE;
1476               bfd_put_16 (abfd, (bfd_vma) insn, loc);
1477               break;
1478
1479             case R_SH_IND12W:
1480               insn = bfd_get_16 (abfd, loc);
1481               oinsn = insn;
1482               insn += add / 2;
1483               if ((oinsn & 0xf000) != (insn & 0xf000))
1484                 overflow = TRUE;
1485               bfd_put_16 (abfd, (bfd_vma) insn, loc);
1486               break;
1487
1488             case R_SH_DIR8WPL:
1489               /* This reloc ignores the least significant 3 bits of
1490                  the program counter before adding in the offset.
1491                  This means that if ADDR is at an even address, the
1492                  swap will not affect the offset.  If ADDR is an at an
1493                  odd address, then the instruction will be crossing a
1494                  four byte boundary, and must be adjusted.  */
1495               if ((addr & 3) != 0)
1496                 {
1497                   insn = bfd_get_16 (abfd, loc);
1498                   oinsn = insn;
1499                   insn += add / 2;
1500                   if ((oinsn & 0xff00) != (insn & 0xff00))
1501                     overflow = TRUE;
1502                   bfd_put_16 (abfd, (bfd_vma) insn, loc);
1503                 }
1504
1505               break;
1506             }
1507
1508           if (overflow)
1509             {
1510               _bfd_error_handler
1511                 /* xgettext:c-format */
1512                 (_("%pB: %#" PRIx64 ": fatal: reloc overflow while relaxing"),
1513                  abfd, (uint64_t) irel->r_offset);
1514               bfd_set_error (bfd_error_bad_value);
1515               return FALSE;
1516             }
1517         }
1518     }
1519
1520   return TRUE;
1521 }
1522 \f
1523 /* Describes one of the various PLT styles.  */
1524
1525 struct elf_sh_plt_info
1526 {
1527   /* The template for the first PLT entry, or NULL if there is no special
1528      first entry.  */
1529   const bfd_byte *plt0_entry;
1530
1531   /* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL.  */
1532   bfd_vma plt0_entry_size;
1533
1534   /* Index I is the offset into PLT0_ENTRY of a pointer to
1535      _GLOBAL_OFFSET_TABLE_ + I * 4.  The value is MINUS_ONE
1536      if there is no such pointer.  */
1537   bfd_vma plt0_got_fields[3];
1538
1539   /* The template for a symbol's PLT entry.  */
1540   const bfd_byte *symbol_entry;
1541
1542   /* The size of SYMBOL_ENTRY in bytes.  */
1543   bfd_vma symbol_entry_size;
1544
1545   /* Byte offsets of fields in SYMBOL_ENTRY.  Not all fields are used
1546      on all targets.  The comments by each member indicate the value
1547      that the field must hold.  */
1548   struct {
1549     bfd_vma got_entry; /* the address of the symbol's .got.plt entry */
1550     bfd_vma plt; /* .plt (or a branch to .plt on VxWorks) */
1551     bfd_vma reloc_offset; /* the offset of the symbol's JMP_SLOT reloc */
1552     bfd_boolean got20; /* TRUE if got_entry points to a movi20
1553                           instruction (instead of a constant pool
1554                           entry).  */
1555   } symbol_fields;
1556
1557   /* The offset of the resolver stub from the start of SYMBOL_ENTRY.  */
1558   bfd_vma symbol_resolve_offset;
1559
1560   /* A different PLT layout which can be used for the first
1561      MAX_SHORT_PLT entries.  It must share the same plt0.  NULL in
1562      other cases.  */
1563   const struct elf_sh_plt_info *short_plt;
1564 };
1565
1566 /* The size in bytes of an entry in the procedure linkage table.  */
1567
1568 #define ELF_PLT_ENTRY_SIZE 28
1569
1570 /* First entry in an absolute procedure linkage table look like this.  */
1571
1572 /* Note - this code has been "optimised" not to use r2.  r2 is used by
1573    GCC to return the address of large structures, so it should not be
1574    corrupted here.  This does mean however, that this PLT does not conform
1575    to the SH PIC ABI.  That spec says that r0 contains the type of the PLT
1576    and r2 contains the GOT id.  This version stores the GOT id in r0 and
1577    ignores the type.  Loaders can easily detect this difference however,
1578    since the type will always be 0 or 8, and the GOT ids will always be
1579    greater than or equal to 12.  */
1580 static const bfd_byte elf_sh_plt0_entry_be[ELF_PLT_ENTRY_SIZE] =
1581 {
1582   0xd0, 0x05,   /* mov.l 2f,r0 */
1583   0x60, 0x02,   /* mov.l @r0,r0 */
1584   0x2f, 0x06,   /* mov.l r0,@-r15 */
1585   0xd0, 0x03,   /* mov.l 1f,r0 */
1586   0x60, 0x02,   /* mov.l @r0,r0 */
1587   0x40, 0x2b,   /* jmp @r0 */
1588   0x60, 0xf6,   /*  mov.l @r15+,r0 */
1589   0x00, 0x09,   /* nop */
1590   0x00, 0x09,   /* nop */
1591   0x00, 0x09,   /* nop */
1592   0, 0, 0, 0,   /* 1: replaced with address of .got.plt + 8.  */
1593   0, 0, 0, 0,   /* 2: replaced with address of .got.plt + 4.  */
1594 };
1595
1596 static const bfd_byte elf_sh_plt0_entry_le[ELF_PLT_ENTRY_SIZE] =
1597 {
1598   0x05, 0xd0,   /* mov.l 2f,r0 */
1599   0x02, 0x60,   /* mov.l @r0,r0 */
1600   0x06, 0x2f,   /* mov.l r0,@-r15 */
1601   0x03, 0xd0,   /* mov.l 1f,r0 */
1602   0x02, 0x60,   /* mov.l @r0,r0 */
1603   0x2b, 0x40,   /* jmp @r0 */
1604   0xf6, 0x60,   /*  mov.l @r15+,r0 */
1605   0x09, 0x00,   /* nop */
1606   0x09, 0x00,   /* nop */
1607   0x09, 0x00,   /* nop */
1608   0, 0, 0, 0,   /* 1: replaced with address of .got.plt + 8.  */
1609   0, 0, 0, 0,   /* 2: replaced with address of .got.plt + 4.  */
1610 };
1611
1612 /* Sebsequent entries in an absolute procedure linkage table look like
1613    this.  */
1614
1615 static const bfd_byte elf_sh_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1616 {
1617   0xd0, 0x04,   /* mov.l 1f,r0 */
1618   0x60, 0x02,   /* mov.l @(r0,r12),r0 */
1619   0xd1, 0x02,   /* mov.l 0f,r1 */
1620   0x40, 0x2b,   /* jmp @r0 */
1621   0x60, 0x13,   /*  mov r1,r0 */
1622   0xd1, 0x03,   /* mov.l 2f,r1 */
1623   0x40, 0x2b,   /* jmp @r0 */
1624   0x00, 0x09,   /* nop */
1625   0, 0, 0, 0,   /* 0: replaced with address of .PLT0.  */
1626   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
1627   0, 0, 0, 0,   /* 2: replaced with offset into relocation table.  */
1628 };
1629
1630 static const bfd_byte elf_sh_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1631 {
1632   0x04, 0xd0,   /* mov.l 1f,r0 */
1633   0x02, 0x60,   /* mov.l @r0,r0 */
1634   0x02, 0xd1,   /* mov.l 0f,r1 */
1635   0x2b, 0x40,   /* jmp @r0 */
1636   0x13, 0x60,   /*  mov r1,r0 */
1637   0x03, 0xd1,   /* mov.l 2f,r1 */
1638   0x2b, 0x40,   /* jmp @r0 */
1639   0x09, 0x00,   /*  nop */
1640   0, 0, 0, 0,   /* 0: replaced with address of .PLT0.  */
1641   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
1642   0, 0, 0, 0,   /* 2: replaced with offset into relocation table.  */
1643 };
1644
1645 /* Entries in a PIC procedure linkage table look like this.  */
1646
1647 static const bfd_byte elf_sh_pic_plt_entry_be[ELF_PLT_ENTRY_SIZE] =
1648 {
1649   0xd0, 0x04,   /* mov.l 1f,r0 */
1650   0x00, 0xce,   /* mov.l @(r0,r12),r0 */
1651   0x40, 0x2b,   /* jmp @r0 */
1652   0x00, 0x09,   /*  nop */
1653   0x50, 0xc2,   /* mov.l @(8,r12),r0 */
1654   0xd1, 0x03,   /* mov.l 2f,r1 */
1655   0x40, 0x2b,   /* jmp @r0 */
1656   0x50, 0xc1,   /*  mov.l @(4,r12),r0 */
1657   0x00, 0x09,   /* nop */
1658   0x00, 0x09,   /* nop */
1659   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
1660   0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
1661 };
1662
1663 static const bfd_byte elf_sh_pic_plt_entry_le[ELF_PLT_ENTRY_SIZE] =
1664 {
1665   0x04, 0xd0,   /* mov.l 1f,r0 */
1666   0xce, 0x00,   /* mov.l @(r0,r12),r0 */
1667   0x2b, 0x40,   /* jmp @r0 */
1668   0x09, 0x00,   /*  nop */
1669   0xc2, 0x50,   /* mov.l @(8,r12),r0 */
1670   0x03, 0xd1,   /* mov.l 2f,r1 */
1671   0x2b, 0x40,   /* jmp @r0 */
1672   0xc1, 0x50,   /*  mov.l @(4,r12),r0 */
1673   0x09, 0x00,   /*  nop */
1674   0x09, 0x00,   /* nop */
1675   0, 0, 0, 0,   /* 1: replaced with address of this symbol in .got.  */
1676   0, 0, 0, 0    /* 2: replaced with offset into relocation table.  */
1677 };
1678
1679 static const struct elf_sh_plt_info elf_sh_plts[2][2] = {
1680   {
1681     {
1682       /* Big-endian non-PIC.  */
1683       elf_sh_plt0_entry_be,
1684       ELF_PLT_ENTRY_SIZE,
1685       { MINUS_ONE, 24, 20 },
1686       elf_sh_plt_entry_be,
1687       ELF_PLT_ENTRY_SIZE,
1688       { 20, 16, 24, FALSE },
1689       8,
1690       NULL
1691     },
1692     {
1693       /* Little-endian non-PIC.  */
1694       elf_sh_plt0_entry_le,
1695       ELF_PLT_ENTRY_SIZE,
1696       { MINUS_ONE, 24, 20 },
1697       elf_sh_plt_entry_le,
1698       ELF_PLT_ENTRY_SIZE,
1699       { 20, 16, 24, FALSE },
1700       8,
1701       NULL
1702     },
1703   },
1704   {
1705     {
1706       /* Big-endian PIC.  */
1707       elf_sh_plt0_entry_be,
1708       ELF_PLT_ENTRY_SIZE,
1709       { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1710       elf_sh_pic_plt_entry_be,
1711       ELF_PLT_ENTRY_SIZE,
1712       { 20, MINUS_ONE, 24, FALSE },
1713       8,
1714       NULL
1715     },
1716     {
1717       /* Little-endian PIC.  */
1718       elf_sh_plt0_entry_le,
1719       ELF_PLT_ENTRY_SIZE,
1720       { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1721       elf_sh_pic_plt_entry_le,
1722       ELF_PLT_ENTRY_SIZE,
1723       { 20, MINUS_ONE, 24, FALSE },
1724       8,
1725       NULL
1726     },
1727   }
1728 };
1729
1730 #define VXWORKS_PLT_HEADER_SIZE 12
1731 #define VXWORKS_PLT_ENTRY_SIZE 24
1732
1733 static const bfd_byte vxworks_sh_plt0_entry_be[VXWORKS_PLT_HEADER_SIZE] =
1734 {
1735   0xd1, 0x01,   /* mov.l @(8,pc),r1 */
1736   0x61, 0x12,   /* mov.l @r1,r1 */
1737   0x41, 0x2b,   /* jmp @r1 */
1738   0x00, 0x09,   /* nop */
1739   0, 0, 0, 0    /* 0: replaced with _GLOBAL_OFFSET_TABLE+8.  */
1740 };
1741
1742 static const bfd_byte vxworks_sh_plt0_entry_le[VXWORKS_PLT_HEADER_SIZE] =
1743 {
1744   0x01, 0xd1,   /* mov.l @(8,pc),r1 */
1745   0x12, 0x61,   /* mov.l @r1,r1 */
1746   0x2b, 0x41,   /* jmp @r1 */
1747   0x09, 0x00,   /* nop */
1748   0, 0, 0, 0    /* 0: replaced with _GLOBAL_OFFSET_TABLE+8.  */
1749 };
1750
1751 static const bfd_byte vxworks_sh_plt_entry_be[VXWORKS_PLT_ENTRY_SIZE] =
1752 {
1753   0xd0, 0x01,   /* mov.l @(8,pc),r0 */
1754   0x60, 0x02,   /* mov.l @r0,r0 */
1755   0x40, 0x2b,   /* jmp @r0 */
1756   0x00, 0x09,   /* nop */
1757   0, 0, 0, 0,   /* 0: replaced with address of this symbol in .got.  */
1758   0xd0, 0x01,   /* mov.l @(8,pc),r0 */
1759   0xa0, 0x00,   /* bra PLT (We need to fix the offset.)  */
1760   0x00, 0x09,   /* nop */
1761   0x00, 0x09,   /* nop */
1762   0, 0, 0, 0,   /* 1: replaced with offset into relocation table.  */
1763 };
1764
1765 static const bfd_byte vxworks_sh_plt_entry_le[VXWORKS_PLT_ENTRY_SIZE] =
1766 {
1767   0x01, 0xd0,   /* mov.l @(8,pc),r0 */
1768   0x02, 0x60,   /* mov.l @r0,r0 */
1769   0x2b, 0x40,   /* jmp @r0 */
1770   0x09, 0x00,   /* nop */
1771   0, 0, 0, 0,   /* 0: replaced with address of this symbol in .got.  */
1772   0x01, 0xd0,   /* mov.l @(8,pc),r0 */
1773   0x00, 0xa0,   /* bra PLT (We need to fix the offset.)  */
1774   0x09, 0x00,   /* nop */
1775   0x09, 0x00,   /* nop */
1776   0, 0, 0, 0,   /* 1: replaced with offset into relocation table.  */
1777 };
1778
1779 static const bfd_byte vxworks_sh_pic_plt_entry_be[VXWORKS_PLT_ENTRY_SIZE] =
1780 {
1781   0xd0, 0x01,   /* mov.l @(8,pc),r0 */
1782   0x00, 0xce,   /* mov.l @(r0,r12),r0 */
1783   0x40, 0x2b,   /* jmp @r0 */
1784   0x00, 0x09,   /* nop */
1785   0, 0, 0, 0,   /* 0: replaced with offset of this symbol in .got.  */
1786   0xd0, 0x01,   /* mov.l @(8,pc),r0 */
1787   0x51, 0xc2,   /* mov.l @(8,r12),r1 */
1788   0x41, 0x2b,   /* jmp @r1 */
1789   0x00, 0x09,   /* nop */
1790   0, 0, 0, 0,   /* 1: replaced with offset into relocation table.  */
1791 };
1792
1793 static const bfd_byte vxworks_sh_pic_plt_entry_le[VXWORKS_PLT_ENTRY_SIZE] =
1794 {
1795   0x01, 0xd0,   /* mov.l @(8,pc),r0 */
1796   0xce, 0x00,   /* mov.l @(r0,r12),r0 */
1797   0x2b, 0x40,   /* jmp @r0 */
1798   0x09, 0x00,   /* nop */
1799   0, 0, 0, 0,   /* 0: replaced with offset of this symbol in .got.  */
1800   0x01, 0xd0,   /* mov.l @(8,pc),r0 */
1801   0xc2, 0x51,   /* mov.l @(8,r12),r1 */
1802   0x2b, 0x41,   /* jmp @r1 */
1803   0x09, 0x00,   /* nop */
1804   0, 0, 0, 0,   /* 1: replaced with offset into relocation table.  */
1805 };
1806
1807 static const struct elf_sh_plt_info vxworks_sh_plts[2][2] = {
1808   {
1809     {
1810       /* Big-endian non-PIC.  */
1811       vxworks_sh_plt0_entry_be,
1812       VXWORKS_PLT_HEADER_SIZE,
1813       { MINUS_ONE, MINUS_ONE, 8 },
1814       vxworks_sh_plt_entry_be,
1815       VXWORKS_PLT_ENTRY_SIZE,
1816       { 8, 14, 20, FALSE },
1817       12,
1818       NULL
1819     },
1820     {
1821       /* Little-endian non-PIC.  */
1822       vxworks_sh_plt0_entry_le,
1823       VXWORKS_PLT_HEADER_SIZE,
1824       { MINUS_ONE, MINUS_ONE, 8 },
1825       vxworks_sh_plt_entry_le,
1826       VXWORKS_PLT_ENTRY_SIZE,
1827       { 8, 14, 20, FALSE },
1828       12,
1829       NULL
1830     },
1831   },
1832   {
1833     {
1834       /* Big-endian PIC.  */
1835       NULL,
1836       0,
1837       { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1838       vxworks_sh_pic_plt_entry_be,
1839       VXWORKS_PLT_ENTRY_SIZE,
1840       { 8, MINUS_ONE, 20, FALSE },
1841       12,
1842       NULL
1843     },
1844     {
1845       /* Little-endian PIC.  */
1846       NULL,
1847       0,
1848       { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1849       vxworks_sh_pic_plt_entry_le,
1850       VXWORKS_PLT_ENTRY_SIZE,
1851       { 8, MINUS_ONE, 20, FALSE },
1852       12,
1853       NULL
1854     },
1855   }
1856 };
1857
1858 /* FDPIC PLT entries.  Two unimplemented optimizations for lazy
1859    binding are to omit the lazy binding stub when linking with -z now
1860    and to move lazy binding stubs into a separate region for better
1861    cache behavior.  */
1862
1863 #define FDPIC_PLT_ENTRY_SIZE 28
1864 #define FDPIC_PLT_LAZY_OFFSET 20
1865
1866 /* FIXME: The lazy binding stub requires a plt0 - which may need to be
1867    duplicated if it is out of range, or which can be inlined.  So
1868    right now it is always inlined, which wastes a word per stub.  It
1869    might be easier to handle the duplication if we put the lazy
1870    stubs separately.  */
1871
1872 static const bfd_byte fdpic_sh_plt_entry_be[FDPIC_PLT_ENTRY_SIZE] =
1873 {
1874   0xd0, 0x02,   /* mov.l @(12,pc),r0 */
1875   0x01, 0xce,   /* mov.l @(r0,r12),r1 */
1876   0x70, 0x04,   /* add #4, r0 */
1877   0x41, 0x2b,   /* jmp @r1 */
1878   0x0c, 0xce,   /* mov.l @(r0,r12),r12 */
1879   0x00, 0x09,   /* nop */
1880   0, 0, 0, 0,   /* 0: replaced with offset of this symbol's funcdesc */
1881   0, 0, 0, 0,   /* 1: replaced with offset into relocation table.  */
1882   0x60, 0xc2,   /* mov.l @r12,r0 */
1883   0x40, 0x2b,   /* jmp @r0 */
1884   0x53, 0xc1,   /*  mov.l @(4,r12),r3 */
1885   0x00, 0x09,   /* nop */
1886 };
1887
1888 static const bfd_byte fdpic_sh_plt_entry_le[FDPIC_PLT_ENTRY_SIZE] =
1889 {
1890   0x02, 0xd0,   /* mov.l @(12,pc),r0 */
1891   0xce, 0x01,   /* mov.l @(r0,r12),r1 */
1892   0x04, 0x70,   /* add #4, r0 */
1893   0x2b, 0x41,   /* jmp @r1 */
1894   0xce, 0x0c,   /* mov.l @(r0,r12),r12 */
1895   0x09, 0x00,   /* nop */
1896   0, 0, 0, 0,   /* 0: replaced with offset of this symbol's funcdesc */
1897   0, 0, 0, 0,   /* 1: replaced with offset into relocation table.  */
1898   0xc2, 0x60,   /* mov.l @r12,r0 */
1899   0x2b, 0x40,   /* jmp @r0 */
1900   0xc1, 0x53,   /*  mov.l @(4,r12),r3 */
1901   0x09, 0x00,   /* nop */
1902 };
1903
1904 static const struct elf_sh_plt_info fdpic_sh_plts[2] = {
1905   {
1906     /* Big-endian PIC.  */
1907     NULL,
1908     0,
1909     { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1910     fdpic_sh_plt_entry_be,
1911     FDPIC_PLT_ENTRY_SIZE,
1912     { 12, MINUS_ONE, 16, FALSE },
1913     FDPIC_PLT_LAZY_OFFSET,
1914     NULL
1915   },
1916   {
1917     /* Little-endian PIC.  */
1918     NULL,
1919     0,
1920     { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1921     fdpic_sh_plt_entry_le,
1922     FDPIC_PLT_ENTRY_SIZE,
1923     { 12, MINUS_ONE, 16, FALSE },
1924     FDPIC_PLT_LAZY_OFFSET,
1925     NULL
1926   },
1927 };
1928
1929 /* On SH2A, we can use the movi20 instruction to generate shorter PLT
1930    entries for the first 64K slots.  We use the normal FDPIC PLT entry
1931    past that point; we could also use movi20s, which might be faster,
1932    but would not be any smaller.  */
1933
1934 #define FDPIC_SH2A_PLT_ENTRY_SIZE 24
1935 #define FDPIC_SH2A_PLT_LAZY_OFFSET 16
1936
1937 static const bfd_byte fdpic_sh2a_plt_entry_be[FDPIC_SH2A_PLT_ENTRY_SIZE] =
1938 {
1939   0, 0, 0, 0,   /* movi20 #gotofffuncdesc,r0 */
1940   0x01, 0xce,   /* mov.l @(r0,r12),r1 */
1941   0x70, 0x04,   /* add #4, r0 */
1942   0x41, 0x2b,   /* jmp @r1 */
1943   0x0c, 0xce,   /* mov.l @(r0,r12),r12 */
1944   0, 0, 0, 0,   /* 1: replaced with offset into relocation table.  */
1945   0x60, 0xc2,   /* mov.l @r12,r0 */
1946   0x40, 0x2b,   /* jmp @r0 */
1947   0x53, 0xc1,   /*  mov.l @(4,r12),r3 */
1948   0x00, 0x09,   /* nop */
1949 };
1950
1951 static const bfd_byte fdpic_sh2a_plt_entry_le[FDPIC_SH2A_PLT_ENTRY_SIZE] =
1952 {
1953   0, 0, 0, 0,   /* movi20 #gotofffuncdesc,r0 */
1954   0xce, 0x01,   /* mov.l @(r0,r12),r1 */
1955   0x04, 0x70,   /* add #4, r0 */
1956   0x2b, 0x41,   /* jmp @r1 */
1957   0xce, 0x0c,   /* mov.l @(r0,r12),r12 */
1958   0, 0, 0, 0,   /* 1: replaced with offset into relocation table.  */
1959   0xc2, 0x60,   /* mov.l @r12,r0 */
1960   0x2b, 0x40,   /* jmp @r0 */
1961   0xc1, 0x53,   /*  mov.l @(4,r12),r3 */
1962   0x09, 0x00,   /* nop */
1963 };
1964
1965 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_be = {
1966   /* Big-endian FDPIC, max index 64K.  */
1967   NULL,
1968   0,
1969   { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1970   fdpic_sh2a_plt_entry_be,
1971   FDPIC_SH2A_PLT_ENTRY_SIZE,
1972   { 0, MINUS_ONE, 12, TRUE },
1973   FDPIC_SH2A_PLT_LAZY_OFFSET,
1974   NULL
1975 };
1976
1977 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_le = {
1978   /* Little-endian FDPIC, max index 64K.  */
1979   NULL,
1980   0,
1981   { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1982   fdpic_sh2a_plt_entry_le,
1983   FDPIC_SH2A_PLT_ENTRY_SIZE,
1984   { 0, MINUS_ONE, 12, TRUE },
1985   FDPIC_SH2A_PLT_LAZY_OFFSET,
1986   NULL
1987 };
1988
1989 static const struct elf_sh_plt_info fdpic_sh2a_plts[2] = {
1990   {
1991     /* Big-endian PIC.  */
1992     NULL,
1993     0,
1994     { MINUS_ONE, MINUS_ONE, MINUS_ONE },
1995     fdpic_sh_plt_entry_be,
1996     FDPIC_PLT_ENTRY_SIZE,
1997     { 12, MINUS_ONE, 16, FALSE },
1998     FDPIC_PLT_LAZY_OFFSET,
1999     &fdpic_sh2a_short_plt_be
2000   },
2001   {
2002     /* Little-endian PIC.  */
2003     NULL,
2004     0,
2005     { MINUS_ONE, MINUS_ONE, MINUS_ONE },
2006     fdpic_sh_plt_entry_le,
2007     FDPIC_PLT_ENTRY_SIZE,
2008     { 12, MINUS_ONE, 16, FALSE },
2009     FDPIC_PLT_LAZY_OFFSET,
2010     &fdpic_sh2a_short_plt_le
2011   },
2012 };
2013
2014 /* Return the type of PLT associated with ABFD.  PIC_P is true if
2015    the object is position-independent.  */
2016
2017 static const struct elf_sh_plt_info *
2018 get_plt_info (bfd *abfd, bfd_boolean pic_p)
2019 {
2020   if (fdpic_object_p (abfd))
2021     {
2022       /* If any input file requires SH2A we can use a shorter PLT
2023          sequence.  */
2024       if (sh_get_arch_from_bfd_mach (bfd_get_mach (abfd)) & arch_sh2a_base)
2025         return &fdpic_sh2a_plts[!bfd_big_endian (abfd)];
2026       else
2027         return &fdpic_sh_plts[!bfd_big_endian (abfd)];
2028     }
2029   if (vxworks_object_p (abfd))
2030     return &vxworks_sh_plts[pic_p][!bfd_big_endian (abfd)];
2031   return &elf_sh_plts[pic_p][!bfd_big_endian (abfd)];
2032 }
2033
2034 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2035    VALUE is the field's value and CODE_P is true if VALUE refers to code,
2036    not data.  */
2037
2038 inline static void
2039 install_plt_field (bfd *output_bfd, bfd_boolean code_p ATTRIBUTE_UNUSED,
2040                    unsigned long value, bfd_byte *addr)
2041 {
2042   bfd_put_32 (output_bfd, value, addr);
2043 }
2044
2045 /* The number of PLT entries which can use a shorter PLT, if any.
2046    Currently always 64K, since only SH-2A FDPIC uses this; a
2047    20-bit movi20 can address that many function descriptors below
2048    _GLOBAL_OFFSET_TABLE_.  */
2049 #define MAX_SHORT_PLT 65536
2050
2051 /* Return the index of the PLT entry at byte offset OFFSET.  */
2052
2053 static bfd_vma
2054 get_plt_index (const struct elf_sh_plt_info *info, bfd_vma offset)
2055 {
2056   bfd_vma plt_index = 0;
2057
2058   offset -= info->plt0_entry_size;
2059   if (info->short_plt != NULL)
2060     {
2061       if (offset > MAX_SHORT_PLT * info->short_plt->symbol_entry_size)
2062         {
2063           plt_index = MAX_SHORT_PLT;
2064           offset -= MAX_SHORT_PLT * info->short_plt->symbol_entry_size;
2065         }
2066       else
2067         info = info->short_plt;
2068     }
2069   return plt_index + offset / info->symbol_entry_size;
2070 }
2071
2072 /* Do the inverse operation.  */
2073
2074 static bfd_vma
2075 get_plt_offset (const struct elf_sh_plt_info *info, bfd_vma plt_index)
2076 {
2077   bfd_vma offset = 0;
2078
2079   if (info->short_plt != NULL)
2080     {
2081       if (plt_index > MAX_SHORT_PLT)
2082         {
2083           offset = MAX_SHORT_PLT * info->short_plt->symbol_entry_size;
2084           plt_index -= MAX_SHORT_PLT;
2085         }
2086       else
2087         info = info->short_plt;
2088     }
2089   return (offset + info->plt0_entry_size
2090           + (plt_index * info->symbol_entry_size));
2091 }
2092
2093 union gotref
2094 {
2095   bfd_signed_vma refcount;
2096   bfd_vma offset;
2097 };
2098
2099 /* sh ELF linker hash entry.  */
2100
2101 struct elf_sh_link_hash_entry
2102 {
2103   struct elf_link_hash_entry root;
2104
2105   /* Track dynamic relocs copied for this symbol.  */
2106   struct elf_dyn_relocs *dyn_relocs;
2107
2108   bfd_signed_vma gotplt_refcount;
2109
2110   /* A local function descriptor, for FDPIC.  The refcount counts
2111      R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20
2112      relocations; the PLT and GOT entry are accounted
2113      for separately.  After adjust_dynamic_symbol, the offset is
2114      MINUS_ONE if there is no local descriptor (dynamic linker
2115      managed and no PLT entry, or undefined weak non-dynamic).
2116      During check_relocs we do not yet know whether the local
2117      descriptor will be canonical.  */
2118   union gotref funcdesc;
2119
2120   /* How many of the above refcounted relocations were R_SH_FUNCDESC,
2121      and thus require fixups or relocations.  */
2122   bfd_signed_vma abs_funcdesc_refcount;
2123
2124   enum got_type {
2125     GOT_UNKNOWN = 0, GOT_NORMAL, GOT_TLS_GD, GOT_TLS_IE, GOT_FUNCDESC
2126   } got_type;
2127 };
2128
2129 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2130
2131 struct sh_elf_obj_tdata
2132 {
2133   struct elf_obj_tdata root;
2134
2135   /* got_type for each local got entry.  */
2136   char *local_got_type;
2137
2138   /* Function descriptor refcount and offset for each local symbol.  */
2139   union gotref *local_funcdesc;
2140 };
2141
2142 #define sh_elf_tdata(abfd) \
2143   ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2144
2145 #define sh_elf_local_got_type(abfd) \
2146   (sh_elf_tdata (abfd)->local_got_type)
2147
2148 #define sh_elf_local_funcdesc(abfd) \
2149   (sh_elf_tdata (abfd)->local_funcdesc)
2150
2151 #define is_sh_elf(bfd) \
2152   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2153    && elf_tdata (bfd) != NULL \
2154    && elf_object_id (bfd) == SH_ELF_DATA)
2155
2156 /* Override the generic function because we need to store sh_elf_obj_tdata
2157    as the specific tdata.  */
2158
2159 static bfd_boolean
2160 sh_elf_mkobject (bfd *abfd)
2161 {
2162   return bfd_elf_allocate_object (abfd, sizeof (struct sh_elf_obj_tdata),
2163                                   SH_ELF_DATA);
2164 }
2165
2166 /* sh ELF linker hash table.  */
2167
2168 struct elf_sh_link_hash_table
2169 {
2170   struct elf_link_hash_table root;
2171
2172   /* Short-cuts to get to dynamic linker sections.  */
2173   asection *sdynbss;
2174   asection *srelbss;
2175   asection *sfuncdesc;
2176   asection *srelfuncdesc;
2177   asection *srofixup;
2178
2179   /* The (unloaded but important) VxWorks .rela.plt.unloaded section.  */
2180   asection *srelplt2;
2181
2182   /* Small local sym cache.  */
2183   struct sym_cache sym_cache;
2184
2185   /* A counter or offset to track a TLS got entry.  */
2186   union
2187     {
2188       bfd_signed_vma refcount;
2189       bfd_vma offset;
2190     } tls_ldm_got;
2191
2192   /* The type of PLT to use.  */
2193   const struct elf_sh_plt_info *plt_info;
2194
2195   /* True if the target system is VxWorks.  */
2196   bfd_boolean vxworks_p;
2197
2198   /* True if the target system uses FDPIC.  */
2199   bfd_boolean fdpic_p;
2200 };
2201
2202 /* Traverse an sh ELF linker hash table.  */
2203
2204 #define sh_elf_link_hash_traverse(table, func, info)                    \
2205   (elf_link_hash_traverse                                               \
2206    (&(table)->root,                                                     \
2207     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2208     (info)))
2209
2210 /* Get the sh ELF linker hash table from a link_info structure.  */
2211
2212 #define sh_elf_hash_table(p) \
2213   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2214   == SH_ELF_DATA ? ((struct elf_sh_link_hash_table *) ((p)->hash)) : NULL)
2215
2216 /* Create an entry in an sh ELF linker hash table.  */
2217
2218 static struct bfd_hash_entry *
2219 sh_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
2220                           struct bfd_hash_table *table,
2221                           const char *string)
2222 {
2223   struct elf_sh_link_hash_entry *ret =
2224     (struct elf_sh_link_hash_entry *) entry;
2225
2226   /* Allocate the structure if it has not already been allocated by a
2227      subclass.  */
2228   if (ret == (struct elf_sh_link_hash_entry *) NULL)
2229     ret = ((struct elf_sh_link_hash_entry *)
2230            bfd_hash_allocate (table,
2231                               sizeof (struct elf_sh_link_hash_entry)));
2232   if (ret == (struct elf_sh_link_hash_entry *) NULL)
2233     return (struct bfd_hash_entry *) ret;
2234
2235   /* Call the allocation method of the superclass.  */
2236   ret = ((struct elf_sh_link_hash_entry *)
2237          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2238                                      table, string));
2239   if (ret != (struct elf_sh_link_hash_entry *) NULL)
2240     {
2241       ret->dyn_relocs = NULL;
2242       ret->gotplt_refcount = 0;
2243       ret->funcdesc.refcount = 0;
2244       ret->abs_funcdesc_refcount = 0;
2245       ret->got_type = GOT_UNKNOWN;
2246     }
2247
2248   return (struct bfd_hash_entry *) ret;
2249 }
2250
2251 /* Create an sh ELF linker hash table.  */
2252
2253 static struct bfd_link_hash_table *
2254 sh_elf_link_hash_table_create (bfd *abfd)
2255 {
2256   struct elf_sh_link_hash_table *ret;
2257   bfd_size_type amt = sizeof (struct elf_sh_link_hash_table);
2258
2259   ret = (struct elf_sh_link_hash_table *) bfd_zmalloc (amt);
2260   if (ret == (struct elf_sh_link_hash_table *) NULL)
2261     return NULL;
2262
2263   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
2264                                       sh_elf_link_hash_newfunc,
2265                                       sizeof (struct elf_sh_link_hash_entry),
2266                                       SH_ELF_DATA))
2267     {
2268       free (ret);
2269       return NULL;
2270     }
2271
2272   ret->vxworks_p = vxworks_object_p (abfd);
2273   ret->fdpic_p = fdpic_object_p (abfd);
2274
2275   return &ret->root.root;
2276 }
2277
2278 static bfd_boolean
2279 sh_elf_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
2280                             struct bfd_link_info *info, asection *p)
2281 {
2282   struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
2283
2284   /* Non-FDPIC binaries do not need dynamic symbols for sections.  */
2285   if (!htab->fdpic_p)
2286     return TRUE;
2287
2288   /* We need dynamic symbols for every section, since segments can
2289      relocate independently.  */
2290   switch (elf_section_data (p)->this_hdr.sh_type)
2291     {
2292     case SHT_PROGBITS:
2293     case SHT_NOBITS:
2294       /* If sh_type is yet undecided, assume it could be
2295          SHT_PROGBITS/SHT_NOBITS.  */
2296     case SHT_NULL:
2297       return FALSE;
2298
2299       /* There shouldn't be section relative relocations
2300          against any other section.  */
2301     default:
2302       return TRUE;
2303     }
2304 }
2305
2306 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2307    shortcuts to them in our hash table.  */
2308
2309 static bfd_boolean
2310 create_got_section (bfd *dynobj, struct bfd_link_info *info)
2311 {
2312   struct elf_sh_link_hash_table *htab;
2313
2314   if (! _bfd_elf_create_got_section (dynobj, info))
2315     return FALSE;
2316
2317   htab = sh_elf_hash_table (info);
2318   if (htab == NULL)
2319     return FALSE;
2320
2321   htab->sfuncdesc = bfd_make_section_anyway_with_flags (dynobj, ".got.funcdesc",
2322                                                         (SEC_ALLOC | SEC_LOAD
2323                                                          | SEC_HAS_CONTENTS
2324                                                          | SEC_IN_MEMORY
2325                                                          | SEC_LINKER_CREATED));
2326   if (htab->sfuncdesc == NULL
2327       || ! bfd_set_section_alignment (dynobj, htab->sfuncdesc, 2))
2328     return FALSE;
2329
2330   htab->srelfuncdesc = bfd_make_section_anyway_with_flags (dynobj,
2331                                                            ".rela.got.funcdesc",
2332                                                            (SEC_ALLOC | SEC_LOAD
2333                                                             | SEC_HAS_CONTENTS
2334                                                             | SEC_IN_MEMORY
2335                                                             | SEC_LINKER_CREATED
2336                                                             | SEC_READONLY));
2337   if (htab->srelfuncdesc == NULL
2338       || ! bfd_set_section_alignment (dynobj, htab->srelfuncdesc, 2))
2339     return FALSE;
2340
2341   /* Also create .rofixup.  */
2342   htab->srofixup = bfd_make_section_anyway_with_flags (dynobj, ".rofixup",
2343                                                        (SEC_ALLOC | SEC_LOAD
2344                                                         | SEC_HAS_CONTENTS
2345                                                         | SEC_IN_MEMORY
2346                                                         | SEC_LINKER_CREATED
2347                                                         | SEC_READONLY));
2348   if (htab->srofixup == NULL
2349       || ! bfd_set_section_alignment (dynobj, htab->srofixup, 2))
2350     return FALSE;
2351
2352   return TRUE;
2353 }
2354
2355 /* Create dynamic sections when linking against a dynamic object.  */
2356
2357 static bfd_boolean
2358 sh_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2359 {
2360   struct elf_sh_link_hash_table *htab;
2361   flagword flags, pltflags;
2362   asection *s;
2363   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2364   int ptralign = 0;
2365
2366   switch (bed->s->arch_size)
2367     {
2368     case 32:
2369       ptralign = 2;
2370       break;
2371
2372     case 64:
2373       ptralign = 3;
2374       break;
2375
2376     default:
2377       bfd_set_error (bfd_error_bad_value);
2378       return FALSE;
2379     }
2380
2381   htab = sh_elf_hash_table (info);
2382   if (htab == NULL)
2383     return FALSE;
2384
2385   if (htab->root.dynamic_sections_created)
2386     return TRUE;
2387
2388   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2389      .rel[a].bss sections.  */
2390
2391   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2392            | SEC_LINKER_CREATED);
2393
2394   pltflags = flags;
2395   pltflags |= SEC_CODE;
2396   if (bed->plt_not_loaded)
2397     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2398   if (bed->plt_readonly)
2399     pltflags |= SEC_READONLY;
2400
2401   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2402   htab->root.splt = s;
2403   if (s == NULL
2404       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2405     return FALSE;
2406
2407   if (bed->want_plt_sym)
2408     {
2409       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2410          .plt section.  */
2411       struct elf_link_hash_entry *h;
2412       struct bfd_link_hash_entry *bh = NULL;
2413
2414       if (! (_bfd_generic_link_add_one_symbol
2415              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2416               (bfd_vma) 0, (const char *) NULL, FALSE,
2417               get_elf_backend_data (abfd)->collect, &bh)))
2418         return FALSE;
2419
2420       h = (struct elf_link_hash_entry *) bh;
2421       h->def_regular = 1;
2422       h->type = STT_OBJECT;
2423       htab->root.hplt = h;
2424
2425       if (bfd_link_pic (info)
2426           && ! bfd_elf_link_record_dynamic_symbol (info, h))
2427         return FALSE;
2428     }
2429
2430   s = bfd_make_section_anyway_with_flags (abfd,
2431                                           bed->default_use_rela_p
2432                                           ? ".rela.plt" : ".rel.plt",
2433                                           flags | SEC_READONLY);
2434   htab->root.srelplt = s;
2435   if (s == NULL
2436       || ! bfd_set_section_alignment (abfd, s, ptralign))
2437     return FALSE;
2438
2439   if (htab->root.sgot == NULL
2440       && !create_got_section (abfd, info))
2441     return FALSE;
2442
2443   if (bed->want_dynbss)
2444     {
2445       /* The .dynbss section is a place to put symbols which are defined
2446          by dynamic objects, are referenced by regular objects, and are
2447          not functions.  We must allocate space for them in the process
2448          image and use a R_*_COPY reloc to tell the dynamic linker to
2449          initialize them at run time.  The linker script puts the .dynbss
2450          section into the .bss section of the final image.  */
2451       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2452                                               SEC_ALLOC | SEC_LINKER_CREATED);
2453       htab->sdynbss = s;
2454       if (s == NULL)
2455         return FALSE;
2456
2457       /* The .rel[a].bss section holds copy relocs.  This section is not
2458          normally needed.  We need to create it here, though, so that the
2459          linker will map it to an output section.  We can't just create it
2460          only if we need it, because we will not know whether we need it
2461          until we have seen all the input files, and the first time the
2462          main linker code calls BFD after examining all the input files
2463          (size_dynamic_sections) the input sections have already been
2464          mapped to the output sections.  If the section turns out not to
2465          be needed, we can discard it later.  We will never need this
2466          section when generating a shared object, since they do not use
2467          copy relocs.  */
2468       if (! bfd_link_pic (info))
2469         {
2470           s = bfd_make_section_anyway_with_flags (abfd,
2471                                                   (bed->default_use_rela_p
2472                                                    ? ".rela.bss" : ".rel.bss"),
2473                                                   flags | SEC_READONLY);
2474           htab->srelbss = s;
2475           if (s == NULL
2476               || ! bfd_set_section_alignment (abfd, s, ptralign))
2477             return FALSE;
2478         }
2479     }
2480
2481   if (htab->vxworks_p)
2482     {
2483       if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
2484         return FALSE;
2485     }
2486
2487   return TRUE;
2488 }
2489 \f
2490 /* Find dynamic relocs for H that apply to read-only sections.  */
2491
2492 static asection *
2493 readonly_dynrelocs (struct elf_link_hash_entry *h)
2494 {
2495   struct elf_dyn_relocs *p;
2496
2497   for (p = sh_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
2498     {
2499       asection *s = p->sec->output_section;
2500
2501       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2502         return p->sec;
2503     }
2504   return NULL;
2505 }
2506
2507 /* Adjust a symbol defined by a dynamic object and referenced by a
2508    regular object.  The current definition is in some section of the
2509    dynamic object, but we're not including those sections.  We have to
2510    change the definition to something the rest of the link can
2511    understand.  */
2512
2513 static bfd_boolean
2514 sh_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2515                               struct elf_link_hash_entry *h)
2516 {
2517   struct elf_sh_link_hash_table *htab;
2518   asection *s;
2519
2520   htab = sh_elf_hash_table (info);
2521   if (htab == NULL)
2522     return FALSE;
2523
2524   /* Make sure we know what is going on here.  */
2525   BFD_ASSERT (htab->root.dynobj != NULL
2526               && (h->needs_plt
2527                   || h->is_weakalias
2528                   || (h->def_dynamic
2529                       && h->ref_regular
2530                       && !h->def_regular)));
2531
2532   /* If this is a function, put it in the procedure linkage table.  We
2533      will fill in the contents of the procedure linkage table later,
2534      when we know the address of the .got section.  */
2535   if (h->type == STT_FUNC
2536       || h->needs_plt)
2537     {
2538       if (h->plt.refcount <= 0
2539           || SYMBOL_CALLS_LOCAL (info, h)
2540           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2541               && h->root.type == bfd_link_hash_undefweak))
2542         {
2543           /* This case can occur if we saw a PLT reloc in an input
2544              file, but the symbol was never referred to by a dynamic
2545              object.  In such a case, we don't actually need to build
2546              a procedure linkage table, and we can just do a REL32
2547              reloc instead.  */
2548           h->plt.offset = (bfd_vma) -1;
2549           h->needs_plt = 0;
2550         }
2551
2552       return TRUE;
2553     }
2554   else
2555     h->plt.offset = (bfd_vma) -1;
2556
2557   /* If this is a weak symbol, and there is a real definition, the
2558      processor independent code will have arranged for us to see the
2559      real definition first, and we can just use the same value.  */
2560   if (h->is_weakalias)
2561     {
2562       struct elf_link_hash_entry *def = weakdef (h);
2563       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2564       h->root.u.def.section = def->root.u.def.section;
2565       h->root.u.def.value = def->root.u.def.value;
2566       if (info->nocopyreloc)
2567         h->non_got_ref = def->non_got_ref;
2568       return TRUE;
2569     }
2570
2571   /* This is a reference to a symbol defined by a dynamic object which
2572      is not a function.  */
2573
2574   /* If we are creating a shared library, we must presume that the
2575      only references to the symbol are via the global offset table.
2576      For such cases we need not do anything here; the relocations will
2577      be handled correctly by relocate_section.  */
2578   if (bfd_link_pic (info))
2579     return TRUE;
2580
2581   /* If there are no references to this symbol that do not use the
2582      GOT, we don't need to generate a copy reloc.  */
2583   if (!h->non_got_ref)
2584     return TRUE;
2585
2586   /* If -z nocopyreloc was given, we won't generate them either.  */
2587   if (0 && info->nocopyreloc)
2588     {
2589       h->non_got_ref = 0;
2590       return TRUE;
2591     }
2592
2593   /* If we don't find any dynamic relocs in read-only sections, then
2594      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2595   if (0 && !readonly_dynrelocs (h))
2596     {
2597       h->non_got_ref = 0;
2598       return TRUE;
2599     }
2600
2601   /* We must allocate the symbol in our .dynbss section, which will
2602      become part of the .bss section of the executable.  There will be
2603      an entry for this symbol in the .dynsym section.  The dynamic
2604      object will contain position independent code, so all references
2605      from the dynamic object to this symbol will go through the global
2606      offset table.  The dynamic linker will use the .dynsym entry to
2607      determine the address it must put in the global offset table, so
2608      both the dynamic object and the regular object will refer to the
2609      same memory location for the variable.  */
2610
2611   s = htab->sdynbss;
2612   BFD_ASSERT (s != NULL);
2613
2614   /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2615      copy the initial value out of the dynamic object and into the
2616      runtime process image.  We need to remember the offset into the
2617      .rela.bss section we are going to use.  */
2618   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2619     {
2620       asection *srel;
2621
2622       srel = htab->srelbss;
2623       BFD_ASSERT (srel != NULL);
2624       srel->size += sizeof (Elf32_External_Rela);
2625       h->needs_copy = 1;
2626     }
2627
2628   return _bfd_elf_adjust_dynamic_copy (info, h, s);
2629 }
2630
2631 /* Allocate space in .plt, .got and associated reloc sections for
2632    dynamic relocs.  */
2633
2634 static bfd_boolean
2635 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2636 {
2637   struct bfd_link_info *info;
2638   struct elf_sh_link_hash_table *htab;
2639   struct elf_sh_link_hash_entry *eh;
2640   struct elf_dyn_relocs *p;
2641
2642   if (h->root.type == bfd_link_hash_indirect)
2643     return TRUE;
2644
2645   info = (struct bfd_link_info *) inf;
2646   htab = sh_elf_hash_table (info);
2647   if (htab == NULL)
2648     return FALSE;
2649
2650   eh = (struct elf_sh_link_hash_entry *) h;
2651   if ((h->got.refcount > 0
2652        || h->forced_local)
2653       && eh->gotplt_refcount > 0)
2654     {
2655       /* The symbol has been forced local, or we have some direct got refs,
2656          so treat all the gotplt refs as got refs. */
2657       h->got.refcount += eh->gotplt_refcount;
2658       if (h->plt.refcount >= eh->gotplt_refcount)
2659         h->plt.refcount -= eh->gotplt_refcount;
2660     }
2661
2662   if (htab->root.dynamic_sections_created
2663       && h->plt.refcount > 0
2664       && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2665           || h->root.type != bfd_link_hash_undefweak))
2666     {
2667       /* Make sure this symbol is output as a dynamic symbol.
2668          Undefined weak syms won't yet be marked as dynamic.  */
2669       if (h->dynindx == -1
2670           && !h->forced_local)
2671         {
2672           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2673             return FALSE;
2674         }
2675
2676       if (bfd_link_pic (info)
2677           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2678         {
2679           asection *s = htab->root.splt;
2680           const struct elf_sh_plt_info *plt_info;
2681
2682           /* If this is the first .plt entry, make room for the special
2683              first entry.  */
2684           if (s->size == 0)
2685             s->size += htab->plt_info->plt0_entry_size;
2686
2687           h->plt.offset = s->size;
2688
2689           /* If this symbol is not defined in a regular file, and we are
2690              not generating a shared library, then set the symbol to this
2691              location in the .plt.  This is required to make function
2692              pointers compare as equal between the normal executable and
2693              the shared library.  Skip this for FDPIC, since the
2694              function's address will be the address of the canonical
2695              function descriptor.  */
2696           if (!htab->fdpic_p && !bfd_link_pic (info) && !h->def_regular)
2697             {
2698               h->root.u.def.section = s;
2699               h->root.u.def.value = h->plt.offset;
2700             }
2701
2702           /* Make room for this entry.  */
2703           plt_info = htab->plt_info;
2704           if (plt_info->short_plt != NULL
2705               && (get_plt_index (plt_info->short_plt, s->size) < MAX_SHORT_PLT))
2706             plt_info = plt_info->short_plt;
2707           s->size += plt_info->symbol_entry_size;
2708
2709           /* We also need to make an entry in the .got.plt section, which
2710              will be placed in the .got section by the linker script.  */
2711           if (!htab->fdpic_p)
2712             htab->root.sgotplt->size += 4;
2713           else
2714             htab->root.sgotplt->size += 8;
2715
2716           /* We also need to make an entry in the .rel.plt section.  */
2717           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
2718
2719           if (htab->vxworks_p && !bfd_link_pic (info))
2720             {
2721               /* VxWorks executables have a second set of relocations
2722                  for each PLT entry.  They go in a separate relocation
2723                  section, which is processed by the kernel loader.  */
2724
2725               /* There is a relocation for the initial PLT entry:
2726                  an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_.  */
2727               if (h->plt.offset == htab->plt_info->plt0_entry_size)
2728                 htab->srelplt2->size += sizeof (Elf32_External_Rela);
2729
2730               /* There are two extra relocations for each subsequent
2731                  PLT entry: an R_SH_DIR32 relocation for the GOT entry,
2732                  and an R_SH_DIR32 relocation for the PLT entry.  */
2733               htab->srelplt2->size += sizeof (Elf32_External_Rela) * 2;
2734             }
2735         }
2736       else
2737         {
2738           h->plt.offset = (bfd_vma) -1;
2739           h->needs_plt = 0;
2740         }
2741     }
2742   else
2743     {
2744       h->plt.offset = (bfd_vma) -1;
2745       h->needs_plt = 0;
2746     }
2747
2748   if (h->got.refcount > 0)
2749     {
2750       asection *s;
2751       bfd_boolean dyn;
2752       enum got_type got_type = sh_elf_hash_entry (h)->got_type;
2753
2754       /* Make sure this symbol is output as a dynamic symbol.
2755          Undefined weak syms won't yet be marked as dynamic.  */
2756       if (h->dynindx == -1
2757           && !h->forced_local)
2758         {
2759           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2760             return FALSE;
2761         }
2762
2763       s = htab->root.sgot;
2764       h->got.offset = s->size;
2765       s->size += 4;
2766       /* R_SH_TLS_GD needs 2 consecutive GOT slots.  */
2767       if (got_type == GOT_TLS_GD)
2768         s->size += 4;
2769       dyn = htab->root.dynamic_sections_created;
2770       if (!dyn)
2771         {
2772           /* No dynamic relocations required.  */
2773           if (htab->fdpic_p && !bfd_link_pic (info)
2774               && h->root.type != bfd_link_hash_undefweak
2775               && (got_type == GOT_NORMAL || got_type == GOT_FUNCDESC))
2776             htab->srofixup->size += 4;
2777         }
2778       /* No dynamic relocations required when IE->LE conversion happens.  */
2779       else if (got_type == GOT_TLS_IE
2780                && !h->def_dynamic
2781                && !bfd_link_pic (info))
2782         ;
2783       /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
2784          R_SH_TLS_GD needs one if local symbol and two if global.  */
2785       else if ((got_type == GOT_TLS_GD && h->dynindx == -1)
2786                || got_type == GOT_TLS_IE)
2787         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
2788       else if (got_type == GOT_TLS_GD)
2789         htab->root.srelgot->size += 2 * sizeof (Elf32_External_Rela);
2790       else if (got_type == GOT_FUNCDESC)
2791         {
2792           if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h))
2793             htab->srofixup->size += 4;
2794           else
2795             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
2796         }
2797       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2798                 || h->root.type != bfd_link_hash_undefweak)
2799                && (bfd_link_pic (info)
2800                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2801         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
2802       else if (htab->fdpic_p
2803                && !bfd_link_pic (info)
2804                && got_type == GOT_NORMAL
2805                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2806                    || h->root.type != bfd_link_hash_undefweak))
2807         htab->srofixup->size += 4;
2808     }
2809   else
2810     h->got.offset = (bfd_vma) -1;
2811
2812   /* Allocate space for any dynamic relocations to function
2813      descriptors, canonical or otherwise.  We need to relocate the
2814      reference unless it resolves to zero, which only happens for
2815      undefined weak symbols (either non-default visibility, or when
2816      static linking).  Any GOT slot is accounted for elsewhere.  */
2817   if (eh->abs_funcdesc_refcount > 0
2818       && (h->root.type != bfd_link_hash_undefweak
2819           || (htab->root.dynamic_sections_created
2820               && ! SYMBOL_CALLS_LOCAL (info, h))))
2821     {
2822       if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h))
2823         htab->srofixup->size += eh->abs_funcdesc_refcount * 4;
2824       else
2825         htab->root.srelgot->size
2826           += eh->abs_funcdesc_refcount * sizeof (Elf32_External_Rela);
2827     }
2828
2829   /* We must allocate a function descriptor if there are references to
2830      a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
2831      the dynamic linker isn't going to allocate it.  None of this
2832      applies if we already created one in .got.plt, but if the
2833      canonical function descriptor can be in this object, there
2834      won't be a PLT entry at all.  */
2835   if ((eh->funcdesc.refcount > 0
2836        || (h->got.offset != MINUS_ONE && eh->got_type == GOT_FUNCDESC))
2837       && h->root.type != bfd_link_hash_undefweak
2838       && SYMBOL_FUNCDESC_LOCAL (info, h))
2839     {
2840       /* Make room for this function descriptor.  */
2841       eh->funcdesc.offset = htab->sfuncdesc->size;
2842       htab->sfuncdesc->size += 8;
2843
2844       /* We will need a relocation or two fixups to initialize the
2845          function descriptor, so allocate those too.  */
2846       if (!bfd_link_pic (info) && SYMBOL_CALLS_LOCAL (info, h))
2847         htab->srofixup->size += 8;
2848       else
2849         htab->srelfuncdesc->size += sizeof (Elf32_External_Rela);
2850     }
2851
2852   if (eh->dyn_relocs == NULL)
2853     return TRUE;
2854
2855   /* In the shared -Bsymbolic case, discard space allocated for
2856      dynamic pc-relative relocs against symbols which turn out to be
2857      defined in regular objects.  For the normal shared case, discard
2858      space for pc-relative relocs that have become local due to symbol
2859      visibility changes.  */
2860
2861   if (bfd_link_pic (info))
2862     {
2863       if (SYMBOL_CALLS_LOCAL (info, h))
2864         {
2865           struct elf_dyn_relocs **pp;
2866
2867           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2868             {
2869               p->count -= p->pc_count;
2870               p->pc_count = 0;
2871               if (p->count == 0)
2872                 *pp = p->next;
2873               else
2874                 pp = &p->next;
2875             }
2876         }
2877
2878       if (htab->vxworks_p)
2879         {
2880           struct elf_dyn_relocs **pp;
2881
2882           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2883             {
2884               if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2885                 *pp = p->next;
2886               else
2887                 pp = &p->next;
2888             }
2889         }
2890
2891       /* Also discard relocs on undefined weak syms with non-default
2892          visibility.  */
2893       if (eh->dyn_relocs != NULL
2894           && h->root.type == bfd_link_hash_undefweak)
2895         {
2896           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2897               || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
2898             eh->dyn_relocs = NULL;
2899
2900           /* Make sure undefined weak symbols are output as a dynamic
2901              symbol in PIEs.  */
2902           else if (h->dynindx == -1
2903                    && !h->forced_local)
2904             {
2905               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2906                 return FALSE;
2907             }
2908         }
2909     }
2910   else
2911     {
2912       /* For the non-shared case, discard space for relocs against
2913          symbols which turn out to need copy relocs or are not
2914          dynamic.  */
2915
2916       if (!h->non_got_ref
2917           && ((h->def_dynamic
2918                && !h->def_regular)
2919               || (htab->root.dynamic_sections_created
2920                   && (h->root.type == bfd_link_hash_undefweak
2921                       || h->root.type == bfd_link_hash_undefined))))
2922         {
2923           /* Make sure this symbol is output as a dynamic symbol.
2924              Undefined weak syms won't yet be marked as dynamic.  */
2925           if (h->dynindx == -1
2926               && !h->forced_local)
2927             {
2928               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2929                 return FALSE;
2930             }
2931
2932           /* If that succeeded, we know we'll be keeping all the
2933              relocs.  */
2934           if (h->dynindx != -1)
2935             goto keep;
2936         }
2937
2938       eh->dyn_relocs = NULL;
2939
2940     keep: ;
2941     }
2942
2943   /* Finally, allocate space.  */
2944   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2945     {
2946       asection *sreloc = elf_section_data (p->sec)->sreloc;
2947       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2948
2949       /* If we need relocations, we do not need fixups.  */
2950       if (htab->fdpic_p && !bfd_link_pic (info))
2951         htab->srofixup->size -= 4 * (p->count - p->pc_count);
2952     }
2953
2954   return TRUE;
2955 }
2956
2957 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
2958    read-only sections.  */
2959
2960 static bfd_boolean
2961 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
2962 {
2963   asection *sec;
2964
2965   if (h->root.type == bfd_link_hash_indirect)
2966     return TRUE;
2967
2968   sec = readonly_dynrelocs (h);
2969   if (sec != NULL)
2970     {
2971       struct bfd_link_info *info = (struct bfd_link_info *) info_p;
2972
2973       info->flags |= DF_TEXTREL;
2974       info->callbacks->minfo
2975         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
2976          sec->owner, h->root.root.string, sec);
2977
2978       /* Not an error, just cut short the traversal.  */
2979       return FALSE;
2980     }
2981   return TRUE;
2982 }
2983
2984 /* This function is called after all the input files have been read,
2985    and the input sections have been assigned to output sections.
2986    It's a convenient place to determine the PLT style.  */
2987
2988 static bfd_boolean
2989 sh_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
2990 {
2991   sh_elf_hash_table (info)->plt_info = get_plt_info (output_bfd,
2992                                                      bfd_link_pic (info));
2993
2994   if (sh_elf_hash_table (info)->fdpic_p && !bfd_link_relocatable (info)
2995       && !bfd_elf_stack_segment_size (output_bfd, info,
2996                                       "__stacksize", DEFAULT_STACK_SIZE))
2997     return FALSE;
2998   return TRUE;
2999 }
3000
3001 /* Set the sizes of the dynamic sections.  */
3002
3003 static bfd_boolean
3004 sh_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3005                               struct bfd_link_info *info)
3006 {
3007   struct elf_sh_link_hash_table *htab;
3008   bfd *dynobj;
3009   asection *s;
3010   bfd_boolean relocs;
3011   bfd *ibfd;
3012
3013   htab = sh_elf_hash_table (info);
3014   if (htab == NULL)
3015     return FALSE;
3016
3017   dynobj = htab->root.dynobj;
3018   BFD_ASSERT (dynobj != NULL);
3019
3020   if (htab->root.dynamic_sections_created)
3021     {
3022       /* Set the contents of the .interp section to the interpreter.  */
3023       if (bfd_link_executable (info) && !info->nointerp)
3024         {
3025           s = bfd_get_linker_section (dynobj, ".interp");
3026           BFD_ASSERT (s != NULL);
3027           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3028           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3029         }
3030     }
3031
3032   /* Set up .got offsets for local syms, and space for local dynamic
3033      relocs.  */
3034   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3035     {
3036       bfd_signed_vma *local_got;
3037       bfd_signed_vma *end_local_got;
3038       union gotref *local_funcdesc, *end_local_funcdesc;
3039       char *local_got_type;
3040       bfd_size_type locsymcount;
3041       Elf_Internal_Shdr *symtab_hdr;
3042       asection *srel;
3043
3044       if (! is_sh_elf (ibfd))
3045         continue;
3046
3047       for (s = ibfd->sections; s != NULL; s = s->next)
3048         {
3049           struct elf_dyn_relocs *p;
3050
3051           for (p = ((struct elf_dyn_relocs *)
3052                     elf_section_data (s)->local_dynrel);
3053                p != NULL;
3054                p = p->next)
3055             {
3056               if (! bfd_is_abs_section (p->sec)
3057                   && bfd_is_abs_section (p->sec->output_section))
3058                 {
3059                   /* Input section has been discarded, either because
3060                      it is a copy of a linkonce section or due to
3061                      linker script /DISCARD/, so we'll be discarding
3062                      the relocs too.  */
3063                 }
3064               else if (htab->vxworks_p
3065                        && strcmp (p->sec->output_section->name,
3066                                   ".tls_vars") == 0)
3067                 {
3068                   /* Relocations in vxworks .tls_vars sections are
3069                      handled specially by the loader.  */
3070                 }
3071               else if (p->count != 0)
3072                 {
3073                   srel = elf_section_data (p->sec)->sreloc;
3074                   srel->size += p->count * sizeof (Elf32_External_Rela);
3075                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3076                     {
3077                       info->flags |= DF_TEXTREL;
3078                       info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
3079                                               p->sec->owner, p->sec);
3080                     }
3081
3082                   /* If we need relocations, we do not need fixups.  */
3083                   if (htab->fdpic_p && !bfd_link_pic (info))
3084                     htab->srofixup->size -= 4 * (p->count - p->pc_count);
3085                 }
3086             }
3087         }
3088
3089       symtab_hdr = &elf_symtab_hdr (ibfd);
3090       locsymcount = symtab_hdr->sh_info;
3091       s = htab->root.sgot;
3092       srel = htab->root.srelgot;
3093
3094       local_got = elf_local_got_refcounts (ibfd);
3095       if (local_got)
3096         {
3097           end_local_got = local_got + locsymcount;
3098           local_got_type = sh_elf_local_got_type (ibfd);
3099           local_funcdesc = sh_elf_local_funcdesc (ibfd);
3100           for (; local_got < end_local_got; ++local_got)
3101             {
3102               if (*local_got > 0)
3103                 {
3104                   *local_got = s->size;
3105                   s->size += 4;
3106                   if (*local_got_type == GOT_TLS_GD)
3107                     s->size += 4;
3108                   if (bfd_link_pic (info))
3109                     srel->size += sizeof (Elf32_External_Rela);
3110                   else
3111                     htab->srofixup->size += 4;
3112
3113                   if (*local_got_type == GOT_FUNCDESC)
3114                     {
3115                       if (local_funcdesc == NULL)
3116                         {
3117                           bfd_size_type size;
3118
3119                           size = locsymcount * sizeof (union gotref);
3120                           local_funcdesc = (union gotref *) bfd_zalloc (ibfd,
3121                                                                         size);
3122                           if (local_funcdesc == NULL)
3123                             return FALSE;
3124                           sh_elf_local_funcdesc (ibfd) = local_funcdesc;
3125                           local_funcdesc += (local_got
3126                                              - elf_local_got_refcounts (ibfd));
3127                         }
3128                       local_funcdesc->refcount++;
3129                       ++local_funcdesc;
3130                     }
3131                 }
3132               else
3133                 *local_got = (bfd_vma) -1;
3134               ++local_got_type;
3135             }
3136         }
3137
3138       local_funcdesc = sh_elf_local_funcdesc (ibfd);
3139       if (local_funcdesc)
3140         {
3141           end_local_funcdesc = local_funcdesc + locsymcount;
3142
3143           for (; local_funcdesc < end_local_funcdesc; ++local_funcdesc)
3144             {
3145               if (local_funcdesc->refcount > 0)
3146                 {
3147                   local_funcdesc->offset = htab->sfuncdesc->size;
3148                   htab->sfuncdesc->size += 8;
3149                   if (!bfd_link_pic (info))
3150                     htab->srofixup->size += 8;
3151                   else
3152                     htab->srelfuncdesc->size += sizeof (Elf32_External_Rela);
3153                 }
3154               else
3155                 local_funcdesc->offset = MINUS_ONE;
3156             }
3157         }
3158
3159     }
3160
3161   if (htab->tls_ldm_got.refcount > 0)
3162     {
3163       /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3164          relocs.  */
3165       htab->tls_ldm_got.offset = htab->root.sgot->size;
3166       htab->root.sgot->size += 8;
3167       htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3168     }
3169   else
3170     htab->tls_ldm_got.offset = -1;
3171
3172   /* Only the reserved entries should be present.  For FDPIC, they go at
3173      the end of .got.plt.  */
3174   if (htab->fdpic_p)
3175     {
3176       BFD_ASSERT (htab->root.sgotplt && htab->root.sgotplt->size == 12);
3177       htab->root.sgotplt->size = 0;
3178     }
3179
3180   /* Allocate global sym .plt and .got entries, and space for global
3181      sym dynamic relocs.  */
3182   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
3183
3184   /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3185      end of the FDPIC .got.plt.  */
3186   if (htab->fdpic_p)
3187     {
3188       htab->root.hgot->root.u.def.value = htab->root.sgotplt->size;
3189       htab->root.sgotplt->size += 12;
3190     }
3191
3192   /* At the very end of the .rofixup section is a pointer to the GOT.  */
3193   if (htab->fdpic_p && htab->srofixup != NULL)
3194     htab->srofixup->size += 4;
3195
3196   /* We now have determined the sizes of the various dynamic sections.
3197      Allocate memory for them.  */
3198   relocs = FALSE;
3199   for (s = dynobj->sections; s != NULL; s = s->next)
3200     {
3201       if ((s->flags & SEC_LINKER_CREATED) == 0)
3202         continue;
3203
3204       if (s == htab->root.splt
3205           || s == htab->root.sgot
3206           || s == htab->root.sgotplt
3207           || s == htab->sfuncdesc
3208           || s == htab->srofixup
3209           || s == htab->sdynbss)
3210         {
3211           /* Strip this section if we don't need it; see the
3212              comment below.  */
3213         }
3214       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3215         {
3216           if (s->size != 0 && s != htab->root.srelplt && s != htab->srelplt2)
3217             relocs = TRUE;
3218
3219           /* We use the reloc_count field as a counter if we need
3220              to copy relocs into the output file.  */
3221           s->reloc_count = 0;
3222         }
3223       else
3224         {
3225           /* It's not one of our sections, so don't allocate space.  */
3226           continue;
3227         }
3228
3229       if (s->size == 0)
3230         {
3231           /* If we don't need this section, strip it from the
3232              output file.  This is mostly to handle .rela.bss and
3233              .rela.plt.  We must create both sections in
3234              create_dynamic_sections, because they must be created
3235              before the linker maps input sections to output
3236              sections.  The linker does that before
3237              adjust_dynamic_symbol is called, and it is that
3238              function which decides whether anything needs to go
3239              into these sections.  */
3240
3241           s->flags |= SEC_EXCLUDE;
3242           continue;
3243         }
3244
3245       if ((s->flags & SEC_HAS_CONTENTS) == 0)
3246         continue;
3247
3248       /* Allocate memory for the section contents.  We use bfd_zalloc
3249          here in case unused entries are not reclaimed before the
3250          section's contents are written out.  This should not happen,
3251          but this way if it does, we get a R_SH_NONE reloc instead
3252          of garbage.  */
3253       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3254       if (s->contents == NULL)
3255         return FALSE;
3256     }
3257
3258   if (htab->root.dynamic_sections_created)
3259     {
3260       /* Add some entries to the .dynamic section.  We fill in the
3261          values later, in sh_elf_finish_dynamic_sections, but we
3262          must add the entries now so that we get the correct size for
3263          the .dynamic section.  The DT_DEBUG entry is filled in by the
3264          dynamic linker and used by the debugger.  */
3265 #define add_dynamic_entry(TAG, VAL) \
3266   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3267
3268       if (bfd_link_executable (info))
3269         {
3270           if (! add_dynamic_entry (DT_DEBUG, 0))
3271             return FALSE;
3272         }
3273
3274       if (htab->root.splt->size != 0)
3275         {
3276           if (! add_dynamic_entry (DT_PLTGOT, 0)
3277               || ! add_dynamic_entry (DT_PLTRELSZ, 0)
3278               || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
3279               || ! add_dynamic_entry (DT_JMPREL, 0))
3280             return FALSE;
3281         }
3282       else if ((elf_elfheader (output_bfd)->e_flags & EF_SH_FDPIC))
3283         {
3284           if (! add_dynamic_entry (DT_PLTGOT, 0))
3285             return FALSE;
3286         }
3287
3288       if (relocs)
3289         {
3290           if (! add_dynamic_entry (DT_RELA, 0)
3291               || ! add_dynamic_entry (DT_RELASZ, 0)
3292               || ! add_dynamic_entry (DT_RELAENT,
3293                                       sizeof (Elf32_External_Rela)))
3294             return FALSE;
3295
3296           /* If any dynamic relocs apply to a read-only section,
3297              then we need a DT_TEXTREL entry.  */
3298           if ((info->flags & DF_TEXTREL) == 0)
3299             elf_link_hash_traverse (&htab->root, maybe_set_textrel, info);
3300
3301           if ((info->flags & DF_TEXTREL) != 0)
3302             {
3303               if (! add_dynamic_entry (DT_TEXTREL, 0))
3304                 return FALSE;
3305             }
3306         }
3307       if (htab->vxworks_p
3308           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3309         return FALSE;
3310     }
3311 #undef add_dynamic_entry
3312
3313   return TRUE;
3314 }
3315 \f
3316 /* Add a dynamic relocation to the SRELOC section.  */
3317
3318 inline static bfd_vma
3319 sh_elf_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
3320                       int reloc_type, long dynindx, bfd_vma addend)
3321 {
3322   Elf_Internal_Rela outrel;
3323   bfd_vma reloc_offset;
3324
3325   outrel.r_offset = offset;
3326   outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
3327   outrel.r_addend = addend;
3328
3329   reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rela);
3330   BFD_ASSERT (reloc_offset < sreloc->size);
3331   bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3332                              sreloc->contents + reloc_offset);
3333   sreloc->reloc_count++;
3334
3335   return reloc_offset;
3336 }
3337
3338 /* Add an FDPIC read-only fixup.  */
3339
3340 inline static void
3341 sh_elf_add_rofixup (bfd *output_bfd, asection *srofixup, bfd_vma offset)
3342 {
3343   bfd_vma fixup_offset;
3344
3345   fixup_offset = srofixup->reloc_count++ * 4;
3346   BFD_ASSERT (fixup_offset < srofixup->size);
3347   bfd_put_32 (output_bfd, offset, srofixup->contents + fixup_offset);
3348 }
3349
3350 /* Return the offset of the generated .got section from the
3351    _GLOBAL_OFFSET_TABLE_ symbol.  */
3352
3353 static bfd_signed_vma
3354 sh_elf_got_offset (struct elf_sh_link_hash_table *htab)
3355 {
3356   return (htab->root.sgot->output_offset - htab->root.sgotplt->output_offset
3357           - htab->root.hgot->root.u.def.value);
3358 }
3359
3360 /* Find the segment number in which OSEC, and output section, is
3361    located.  */
3362
3363 static unsigned
3364 sh_elf_osec_to_segment (bfd *output_bfd, asection *osec)
3365 {
3366   Elf_Internal_Phdr *p = NULL;
3367
3368   if (output_bfd->xvec->flavour == bfd_target_elf_flavour
3369       /* PR ld/17110: Do not look for output segments in an input bfd.  */
3370       && output_bfd->direction != read_direction)
3371     p = _bfd_elf_find_segment_containing_section (output_bfd, osec);
3372
3373   /* FIXME: Nothing ever says what this index is relative to.  The kernel
3374      supplies data in terms of the number of load segments but this is
3375      a phdr index and the first phdr may not be a load segment.  */
3376   return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1;
3377 }
3378
3379 static bfd_boolean
3380 sh_elf_osec_readonly_p (bfd *output_bfd, asection *osec)
3381 {
3382   unsigned seg = sh_elf_osec_to_segment (output_bfd, osec);
3383
3384   return (seg != (unsigned) -1
3385           && ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W));
3386 }
3387
3388 /* Generate the initial contents of a local function descriptor, along
3389    with any relocations or fixups required.  */
3390 static bfd_boolean
3391 sh_elf_initialize_funcdesc (bfd *output_bfd,
3392                             struct bfd_link_info *info,
3393                             struct elf_link_hash_entry *h,
3394                             bfd_vma offset,
3395                             asection *section,
3396                             bfd_vma value)
3397 {
3398   struct elf_sh_link_hash_table *htab;
3399   int dynindx;
3400   bfd_vma addr, seg;
3401
3402   htab = sh_elf_hash_table (info);
3403
3404   /* FIXME: The ABI says that the offset to the function goes in the
3405      descriptor, along with the segment index.  We're RELA, so it could
3406      go in the reloc instead... */
3407
3408   if (h != NULL && SYMBOL_CALLS_LOCAL (info, h))
3409     {
3410       section = h->root.u.def.section;
3411       value = h->root.u.def.value;
3412     }
3413
3414   if (h == NULL || SYMBOL_CALLS_LOCAL (info, h))
3415     {
3416       dynindx = elf_section_data (section->output_section)->dynindx;
3417       addr = value + section->output_offset;
3418       seg = sh_elf_osec_to_segment (output_bfd, section->output_section);
3419     }
3420   else
3421     {
3422       BFD_ASSERT (h->dynindx != -1);
3423       dynindx = h->dynindx;
3424       addr = seg = 0;
3425     }
3426
3427   if (!bfd_link_pic (info) && SYMBOL_CALLS_LOCAL (info, h))
3428     {
3429       if (h == NULL || h->root.type != bfd_link_hash_undefweak)
3430         {
3431           sh_elf_add_rofixup (output_bfd, htab->srofixup,
3432                               offset
3433                               + htab->sfuncdesc->output_section->vma
3434                               + htab->sfuncdesc->output_offset);
3435           sh_elf_add_rofixup (output_bfd, htab->srofixup,
3436                               offset + 4
3437                               + htab->sfuncdesc->output_section->vma
3438                               + htab->sfuncdesc->output_offset);
3439         }
3440
3441       /* There are no dynamic relocations so fill in the final
3442          address and gp value (barring fixups).  */
3443       addr += section->output_section->vma;
3444       seg = htab->root.hgot->root.u.def.value
3445         + htab->root.hgot->root.u.def.section->output_section->vma
3446         + htab->root.hgot->root.u.def.section->output_offset;
3447     }
3448   else
3449     sh_elf_add_dyn_reloc (output_bfd, htab->srelfuncdesc,
3450                           offset
3451                           + htab->sfuncdesc->output_section->vma
3452                           + htab->sfuncdesc->output_offset,
3453                           R_SH_FUNCDESC_VALUE, dynindx, 0);
3454
3455   bfd_put_32 (output_bfd, addr, htab->sfuncdesc->contents + offset);
3456   bfd_put_32 (output_bfd, seg, htab->sfuncdesc->contents + offset + 4);
3457
3458   return TRUE;
3459 }
3460
3461 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3462    VALUE is the field's value.  Return bfd_reloc_ok if successful or an error
3463    otherwise.  */
3464
3465 static bfd_reloc_status_type
3466 install_movi20_field (bfd *output_bfd, unsigned long relocation,
3467                       bfd *input_bfd, asection *input_section,
3468                       bfd_byte *contents, bfd_vma offset)
3469 {
3470   unsigned long cur_val;
3471   bfd_byte *addr;
3472   bfd_reloc_status_type r;
3473
3474   if (offset > bfd_get_section_limit (input_bfd, input_section))
3475     return bfd_reloc_outofrange;
3476
3477   r = bfd_check_overflow (complain_overflow_signed, 20, 0,
3478                           bfd_arch_bits_per_address (input_bfd), relocation);
3479   if (r != bfd_reloc_ok)
3480     return r;
3481
3482   addr = contents + offset;
3483   cur_val = bfd_get_16 (output_bfd, addr);
3484   bfd_put_16 (output_bfd, cur_val | ((relocation & 0xf0000) >> 12), addr);
3485   bfd_put_16 (output_bfd, relocation & 0xffff, addr + 2);
3486
3487   return bfd_reloc_ok;
3488 }
3489
3490 /* Relocate an SH ELF section.  */
3491
3492 static bfd_boolean
3493 sh_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
3494                          bfd *input_bfd, asection *input_section,
3495                          bfd_byte *contents, Elf_Internal_Rela *relocs,
3496                          Elf_Internal_Sym *local_syms,
3497                          asection **local_sections)
3498 {
3499   struct elf_sh_link_hash_table *htab;
3500   Elf_Internal_Shdr *symtab_hdr;
3501   struct elf_link_hash_entry **sym_hashes;
3502   Elf_Internal_Rela *rel, *relend;
3503   bfd_vma *local_got_offsets;
3504   asection *sgot = NULL;
3505   asection *sgotplt = NULL;
3506   asection *splt = NULL;
3507   asection *sreloc = NULL;
3508   asection *srelgot = NULL;
3509   bfd_boolean is_vxworks_tls;
3510   unsigned isec_segment, got_segment, plt_segment, check_segment[2];
3511   bfd_boolean fdpic_p = FALSE;
3512
3513   BFD_ASSERT (is_sh_elf (input_bfd));
3514
3515   htab = sh_elf_hash_table (info);
3516   if (htab != NULL)
3517     {
3518       sgot = htab->root.sgot;
3519       sgotplt = htab->root.sgotplt;
3520       srelgot = htab->root.srelgot;
3521       splt = htab->root.splt;
3522       fdpic_p = htab->fdpic_p;
3523     }
3524   symtab_hdr = &elf_symtab_hdr (input_bfd);
3525   sym_hashes = elf_sym_hashes (input_bfd);
3526   local_got_offsets = elf_local_got_offsets (input_bfd);
3527
3528   isec_segment = sh_elf_osec_to_segment (output_bfd,
3529                                          input_section->output_section);
3530   if (fdpic_p && sgot)
3531     got_segment = sh_elf_osec_to_segment (output_bfd,
3532                                           sgot->output_section);
3533   else
3534     got_segment = -1;
3535   if (fdpic_p && splt)
3536     plt_segment = sh_elf_osec_to_segment (output_bfd,
3537                                           splt->output_section);
3538   else
3539     plt_segment = -1;
3540
3541   /* We have to handle relocations in vxworks .tls_vars sections
3542      specially, because the dynamic loader is 'weird'.  */
3543   is_vxworks_tls = (htab && htab->vxworks_p && bfd_link_pic (info)
3544                     && !strcmp (input_section->output_section->name,
3545                                 ".tls_vars"));
3546
3547   rel = relocs;
3548   relend = relocs + input_section->reloc_count;
3549   for (; rel < relend; rel++)
3550     {
3551       int r_type;
3552       reloc_howto_type *howto;
3553       unsigned long r_symndx;
3554       Elf_Internal_Sym *sym;
3555       asection *sec;
3556       struct elf_link_hash_entry *h;
3557       bfd_vma relocation;
3558       bfd_vma addend = (bfd_vma) 0;
3559       bfd_reloc_status_type r;
3560       int seen_stt_datalabel = 0;
3561       bfd_vma off;
3562       enum got_type got_type;
3563       const char *symname = NULL;
3564       bfd_boolean resolved_to_zero;
3565
3566       r_symndx = ELF32_R_SYM (rel->r_info);
3567
3568       r_type = ELF32_R_TYPE (rel->r_info);
3569
3570       /* Many of the relocs are only used for relaxing, and are
3571          handled entirely by the relaxation code.  */
3572       if (r_type >= (int) R_SH_GNU_VTINHERIT
3573           && r_type <= (int) R_SH_LABEL)
3574         continue;
3575       if (r_type == (int) R_SH_NONE)
3576         continue;
3577
3578       if (r_type < 0
3579           || r_type >= R_SH_max
3580           || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
3581               && r_type <= (int) R_SH_LAST_INVALID_RELOC)
3582           || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
3583               && r_type <= (int) R_SH_LAST_INVALID_RELOC_2)
3584           || (   r_type >= (int) R_SH_FIRST_INVALID_RELOC_3
3585               && r_type <= (int) R_SH_LAST_INVALID_RELOC_3)
3586           || (   r_type >= (int) R_SH_FIRST_INVALID_RELOC_4
3587               && r_type <= (int) R_SH_LAST_INVALID_RELOC_4)
3588           || (   r_type >= (int) R_SH_FIRST_INVALID_RELOC_5
3589               && r_type <= (int) R_SH_LAST_INVALID_RELOC_5)
3590           || (   r_type >= (int) R_SH_FIRST_INVALID_RELOC_6
3591               && r_type <= (int) R_SH_LAST_INVALID_RELOC_6))
3592         {
3593           bfd_set_error (bfd_error_bad_value);
3594           return FALSE;
3595         }
3596
3597       howto = get_howto_table (output_bfd) + r_type;
3598
3599       /* For relocs that aren't partial_inplace, we get the addend from
3600          the relocation.  */
3601       if (! howto->partial_inplace)
3602         addend = rel->r_addend;
3603
3604       resolved_to_zero = FALSE;
3605       h = NULL;
3606       sym = NULL;
3607       sec = NULL;
3608       check_segment[0] = -1;
3609       check_segment[1] = -1;
3610       if (r_symndx < symtab_hdr->sh_info)
3611         {
3612           sym = local_syms + r_symndx;
3613           sec = local_sections[r_symndx];
3614
3615           symname = bfd_elf_string_from_elf_section
3616             (input_bfd, symtab_hdr->sh_link, sym->st_name);
3617           if (symname == NULL || *symname == '\0')
3618             symname = bfd_section_name (input_bfd, sec);
3619
3620           relocation = (sec->output_section->vma
3621                         + sec->output_offset
3622                         + sym->st_value);
3623           /* A local symbol never has STO_SH5_ISA32, so we don't need
3624              datalabel processing here.  Make sure this does not change
3625              without notice.  */
3626           if ((sym->st_other & STO_SH5_ISA32) != 0)
3627             (*info->callbacks->reloc_dangerous)
3628               (info,
3629                _("unexpected STO_SH5_ISA32 on local symbol is not handled"),
3630                input_bfd, input_section, rel->r_offset);
3631
3632           if (sec != NULL && discarded_section (sec))
3633             /* Handled below.  */
3634             ;
3635           else if (bfd_link_relocatable (info))
3636             {
3637               /* This is a relocatable link.  We don't have to change
3638                  anything, unless the reloc is against a section symbol,
3639                  in which case we have to adjust according to where the
3640                  section symbol winds up in the output section.  */
3641               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3642                 {
3643                   if (! howto->partial_inplace)
3644                     {
3645                       /* For relocations with the addend in the
3646                          relocation, we need just to update the addend.
3647                          All real relocs are of type partial_inplace; this
3648                          code is mostly for completeness.  */
3649                       rel->r_addend += sec->output_offset;
3650
3651                       continue;
3652                     }
3653
3654                   /* Relocs of type partial_inplace need to pick up the
3655                      contents in the contents and add the offset resulting
3656                      from the changed location of the section symbol.
3657                      Using _bfd_final_link_relocate (e.g. goto
3658                      final_link_relocate) here would be wrong, because
3659                      relocations marked pc_relative would get the current
3660                      location subtracted, and we must only do that at the
3661                      final link.  */
3662                   r = _bfd_relocate_contents (howto, input_bfd,
3663                                               sec->output_offset
3664                                               + sym->st_value,
3665                                               contents + rel->r_offset);
3666                   goto relocation_done;
3667                 }
3668
3669               continue;
3670             }
3671           else if (! howto->partial_inplace)
3672             {
3673               relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3674               addend = rel->r_addend;
3675             }
3676           else if ((sec->flags & SEC_MERGE)
3677                    && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3678             {
3679               asection *msec;
3680
3681               if (howto->rightshift || howto->src_mask != 0xffffffff)
3682                 {
3683                   _bfd_error_handler
3684                     /* xgettext:c-format */
3685                     (_("%pB(%pA+%#" PRIx64 "): "
3686                        "%s relocation against SEC_MERGE section"),
3687                      input_bfd, input_section,
3688                      (uint64_t) rel->r_offset, howto->name);
3689                   return FALSE;
3690                 }
3691
3692               addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
3693               msec = sec;
3694               addend =
3695                 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
3696                 - relocation;
3697               addend += msec->output_section->vma + msec->output_offset;
3698               bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
3699               addend = 0;
3700             }
3701         }
3702       else
3703         {
3704           /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro.  */
3705
3706           relocation = 0;
3707           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3708           symname = h->root.root.string;
3709           while (h->root.type == bfd_link_hash_indirect
3710                  || h->root.type == bfd_link_hash_warning)
3711             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3712           if (h->root.type == bfd_link_hash_defined
3713               || h->root.type == bfd_link_hash_defweak)
3714             {
3715               bfd_boolean dyn;
3716
3717               dyn = htab ? htab->root.dynamic_sections_created : FALSE;
3718               sec = h->root.u.def.section;
3719               /* In these cases, we don't need the relocation value.
3720                  We check specially because in some obscure cases
3721                  sec->output_section will be NULL.  */
3722               if (r_type == R_SH_GOTPC
3723                   || r_type == R_SH_GOTPC_LOW16
3724                   || r_type == R_SH_GOTPC_MEDLOW16
3725                   || r_type == R_SH_GOTPC_MEDHI16
3726                   || r_type == R_SH_GOTPC_HI16
3727                   || ((r_type == R_SH_PLT32
3728                        || r_type == R_SH_PLT_LOW16
3729                        || r_type == R_SH_PLT_MEDLOW16
3730                        || r_type == R_SH_PLT_MEDHI16
3731                        || r_type == R_SH_PLT_HI16)
3732                       && h->plt.offset != (bfd_vma) -1)
3733                   || ((r_type == R_SH_GOT32
3734                        || r_type == R_SH_GOT20
3735                        || r_type == R_SH_GOTFUNCDESC
3736                        || r_type == R_SH_GOTFUNCDESC20
3737                        || r_type == R_SH_GOTOFFFUNCDESC
3738                        || r_type == R_SH_GOTOFFFUNCDESC20
3739                        || r_type == R_SH_FUNCDESC
3740                        || r_type == R_SH_GOT_LOW16
3741                        || r_type == R_SH_GOT_MEDLOW16
3742                        || r_type == R_SH_GOT_MEDHI16
3743                        || r_type == R_SH_GOT_HI16)
3744                       && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
3745                                                           bfd_link_pic (info),
3746                                                           h)
3747                       && (! bfd_link_pic (info)
3748                           || (! info->symbolic && h->dynindx != -1)
3749                           || !h->def_regular))
3750                   /* The cases above are those in which relocation is
3751                      overwritten in the switch block below.  The cases
3752                      below are those in which we must defer relocation
3753                      to run-time, because we can't resolve absolute
3754                      addresses when creating a shared library.  */
3755                   || (bfd_link_pic (info)
3756                       && ((! info->symbolic && h->dynindx != -1)
3757                           || !h->def_regular)
3758                       && ((r_type == R_SH_DIR32
3759                            && !h->forced_local)
3760                           || (r_type == R_SH_REL32
3761                               && !SYMBOL_CALLS_LOCAL (info, h)))
3762                       && ((input_section->flags & SEC_ALLOC) != 0
3763                           /* DWARF will emit R_SH_DIR32 relocations in its
3764                              sections against symbols defined externally
3765                              in shared libraries.  We can't do anything
3766                              with them here.  */
3767                           || ((input_section->flags & SEC_DEBUGGING) != 0
3768                               && h->def_dynamic)))
3769                   /* Dynamic relocs are not propagated for SEC_DEBUGGING
3770                      sections because such sections are not SEC_ALLOC and
3771                      thus ld.so will not process them.  */
3772                   || (sec->output_section == NULL
3773                       && ((input_section->flags & SEC_DEBUGGING) != 0
3774                           && h->def_dynamic))
3775                   || (sec->output_section == NULL
3776                       && (sh_elf_hash_entry (h)->got_type == GOT_TLS_IE
3777                           || sh_elf_hash_entry (h)->got_type == GOT_TLS_GD)))
3778                 ;
3779               else if (sec->output_section != NULL)
3780                 relocation = ((h->root.u.def.value
3781                               + sec->output_section->vma
3782                               + sec->output_offset)
3783                               /* A STO_SH5_ISA32 causes a "bitor 1" to the
3784                                  symbol value, unless we've seen
3785                                  STT_DATALABEL on the way to it.  */
3786                               | ((h->other & STO_SH5_ISA32) != 0
3787                                  && ! seen_stt_datalabel));
3788               else if (!bfd_link_relocatable (info)
3789                        && (_bfd_elf_section_offset (output_bfd, info,
3790                                                     input_section,
3791                                                     rel->r_offset)
3792                            != (bfd_vma) -1))
3793                 {
3794                   _bfd_error_handler
3795                     /* xgettext:c-format */
3796                     (_("%pB(%pA+%#" PRIx64 "): "
3797                        "unresolvable %s relocation against symbol `%s'"),
3798                      input_bfd,
3799                      input_section,
3800                      (uint64_t) rel->r_offset,
3801                      howto->name,
3802                      h->root.root.string);
3803                   return FALSE;
3804                 }
3805             }
3806           else if (h->root.type == bfd_link_hash_undefweak)
3807             resolved_to_zero = UNDEFWEAK_NO_DYNAMIC_RELOC (info, h);
3808           else if (info->unresolved_syms_in_objects == RM_IGNORE
3809                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3810             ;
3811           else if (!bfd_link_relocatable (info))
3812             (*info->callbacks->undefined_symbol)
3813               (info, h->root.root.string, input_bfd,
3814                input_section, rel->r_offset,
3815                (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
3816                 || ELF_ST_VISIBILITY (h->other)));
3817         }
3818
3819       if (sec != NULL && discarded_section (sec))
3820         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3821                                          rel, 1, relend, howto, 0, contents);
3822
3823       if (bfd_link_relocatable (info))
3824         continue;
3825
3826       /* Check for inter-segment relocations in FDPIC files.  Most
3827          relocations connect the relocation site to the location of
3828          the target symbol, but there are some exceptions below.  */
3829       check_segment[0] = isec_segment;
3830       if (sec != NULL)
3831         check_segment[1] = sh_elf_osec_to_segment (output_bfd,
3832                                                    sec->output_section);
3833       else
3834         check_segment[1] = -1;
3835
3836       switch ((int) r_type)
3837         {
3838         final_link_relocate:
3839           /* COFF relocs don't use the addend. The addend is used for
3840              R_SH_DIR32 to be compatible with other compilers.  */
3841           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3842                                         contents, rel->r_offset,
3843                                         relocation, addend);
3844           break;
3845
3846         case R_SH_IND12W:
3847           goto final_link_relocate;
3848
3849         case R_SH_DIR8WPN:
3850         case R_SH_DIR8WPZ:
3851         case R_SH_DIR8WPL:
3852           /* If the reloc is against the start of this section, then
3853              the assembler has already taken care of it and the reloc
3854              is here only to assist in relaxing.  If the reloc is not
3855              against the start of this section, then it's against an
3856              external symbol and we must deal with it ourselves.  */
3857           if (input_section->output_section->vma + input_section->output_offset
3858               != relocation)
3859             {
3860               int disp = (relocation
3861                           - input_section->output_section->vma
3862                           - input_section->output_offset
3863                           - rel->r_offset);
3864               int mask = 0;
3865               switch (r_type)
3866                 {
3867                 case R_SH_DIR8WPN:
3868                 case R_SH_DIR8WPZ: mask = 1; break;
3869                 case R_SH_DIR8WPL: mask = 3; break;
3870                 default: mask = 0; break;
3871                 }
3872               if (disp & mask)
3873                 {
3874                   _bfd_error_handler
3875                     /* xgettext:c-format */
3876                     (_("%pB: %#" PRIx64 ": fatal: "
3877                        "unaligned branch target for relax-support relocation"),
3878                      input_section->owner,
3879                      (uint64_t) rel->r_offset);
3880                   bfd_set_error (bfd_error_bad_value);
3881                   return FALSE;
3882                 }
3883               relocation -= 4;
3884               goto final_link_relocate;
3885             }
3886           r = bfd_reloc_ok;
3887           break;
3888
3889         default:
3890           bfd_set_error (bfd_error_bad_value);
3891           return FALSE;
3892
3893         case R_SH_DIR16:
3894         case R_SH_DIR8:
3895         case R_SH_DIR8U:
3896         case R_SH_DIR8S:
3897         case R_SH_DIR4U:
3898           goto final_link_relocate;
3899
3900         case R_SH_DIR8UL:
3901         case R_SH_DIR4UL:
3902           if (relocation & 3)
3903             {
3904               _bfd_error_handler
3905                 /* xgettext:c-format */
3906                 (_("%pB: %#" PRIx64 ": fatal: "
3907                    "unaligned %s relocation %#" PRIx64),
3908                  input_section->owner, (uint64_t) rel->r_offset,
3909                  howto->name, (uint64_t) relocation);
3910               bfd_set_error (bfd_error_bad_value);
3911               return FALSE;
3912             }
3913           goto final_link_relocate;
3914
3915         case R_SH_DIR8UW:
3916         case R_SH_DIR8SW:
3917         case R_SH_DIR4UW:
3918           if (relocation & 1)
3919             {
3920               _bfd_error_handler
3921                 /* xgettext:c-format */
3922                 (_("%pB: %#" PRIx64 ": fatal: "
3923                    "unaligned %s relocation %#" PRIx64 ""),
3924                  input_section->owner,
3925                  (uint64_t) rel->r_offset, howto->name,
3926                  (uint64_t) relocation);
3927               bfd_set_error (bfd_error_bad_value);
3928               return FALSE;
3929             }
3930           goto final_link_relocate;
3931
3932         case R_SH_PSHA:
3933           if ((signed int)relocation < -32
3934               || (signed int)relocation > 32)
3935             {
3936               _bfd_error_handler
3937                 /* xgettext:c-format */
3938                 (_("%pB: %#" PRIx64 ": fatal: R_SH_PSHA relocation %" PRId64
3939                    " not in range -32..32"),
3940                  input_section->owner,
3941                  (uint64_t) rel->r_offset,
3942                  (int64_t) relocation);
3943               bfd_set_error (bfd_error_bad_value);
3944               return FALSE;
3945             }
3946           goto final_link_relocate;
3947
3948         case R_SH_PSHL:
3949           if ((signed int)relocation < -16
3950               || (signed int)relocation > 16)
3951             {
3952               _bfd_error_handler
3953                 /* xgettext:c-format */
3954                 (_("%pB: %#" PRIx64 ": fatal: R_SH_PSHL relocation %" PRId64
3955                    " not in range -32..32"),
3956                  input_section->owner,
3957                  (uint64_t) rel->r_offset,
3958                  (int64_t) relocation);
3959               bfd_set_error (bfd_error_bad_value);
3960               return FALSE;
3961             }
3962           goto final_link_relocate;
3963
3964         case R_SH_DIR32:
3965         case R_SH_REL32:
3966           if (bfd_link_pic (info)
3967               && (h == NULL
3968                   || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3969                       && !resolved_to_zero)
3970                   || h->root.type != bfd_link_hash_undefweak)
3971               && r_symndx != STN_UNDEF
3972               && (input_section->flags & SEC_ALLOC) != 0
3973               && !is_vxworks_tls
3974               && (r_type == R_SH_DIR32
3975                   || !SYMBOL_CALLS_LOCAL (info, h)))
3976             {
3977               Elf_Internal_Rela outrel;
3978               bfd_byte *loc;
3979               bfd_boolean skip, relocate;
3980
3981               /* When generating a shared object, these relocations
3982                  are copied into the output file to be resolved at run
3983                  time.  */
3984
3985               if (sreloc == NULL)
3986                 {
3987                   sreloc = _bfd_elf_get_dynamic_reloc_section
3988                     (input_bfd, input_section, /*rela?*/ TRUE);
3989                   if (sreloc == NULL)
3990                     return FALSE;
3991                 }
3992
3993               skip = FALSE;
3994               relocate = FALSE;
3995
3996               outrel.r_offset =
3997                 _bfd_elf_section_offset (output_bfd, info, input_section,
3998                                          rel->r_offset);
3999               if (outrel.r_offset == (bfd_vma) -1)
4000                 skip = TRUE;
4001               else if (outrel.r_offset == (bfd_vma) -2)
4002                 skip = TRUE, relocate = TRUE;
4003               outrel.r_offset += (input_section->output_section->vma
4004                                   + input_section->output_offset);
4005
4006               if (skip)
4007                 memset (&outrel, 0, sizeof outrel);
4008               else if (r_type == R_SH_REL32)
4009                 {
4010                   BFD_ASSERT (h != NULL && h->dynindx != -1);
4011                   outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
4012                   outrel.r_addend
4013                     = (howto->partial_inplace
4014                        ? bfd_get_32 (input_bfd, contents + rel->r_offset)
4015                        : addend);
4016                 }
4017               else if (fdpic_p
4018                        && (h == NULL
4019                            || ((info->symbolic || h->dynindx == -1)
4020                                && h->def_regular)))
4021                 {
4022                   int dynindx;
4023
4024                   BFD_ASSERT (sec != NULL);
4025                   BFD_ASSERT (sec->output_section != NULL);
4026                   dynindx = elf_section_data (sec->output_section)->dynindx;
4027                   outrel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
4028                   outrel.r_addend = relocation;
4029                   outrel.r_addend
4030                     += (howto->partial_inplace
4031                         ? bfd_get_32 (input_bfd, contents + rel->r_offset)
4032                         : addend);
4033                   outrel.r_addend -= sec->output_section->vma;
4034                 }
4035               else
4036                 {
4037                   /* h->dynindx may be -1 if this symbol was marked to
4038                      become local.  */
4039                   if (h == NULL
4040                       || ((info->symbolic || h->dynindx == -1)
4041                           && h->def_regular))
4042                     {
4043                       relocate = howto->partial_inplace;
4044                       outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4045                     }
4046                   else
4047                     {
4048                       BFD_ASSERT (h->dynindx != -1);
4049                       outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
4050                     }
4051                   outrel.r_addend = relocation;
4052                   outrel.r_addend
4053                     += (howto->partial_inplace
4054                         ? bfd_get_32 (input_bfd, contents + rel->r_offset)
4055                         : addend);
4056                 }
4057
4058               loc = sreloc->contents;
4059               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4060               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4061
4062               check_segment[0] = check_segment[1] = -1;
4063
4064               /* If this reloc is against an external symbol, we do
4065                  not want to fiddle with the addend.  Otherwise, we
4066                  need to include the symbol value so that it becomes
4067                  an addend for the dynamic reloc.  */
4068               if (! relocate)
4069                 continue;
4070             }
4071           else if (fdpic_p && !bfd_link_pic (info)
4072                    && r_type == R_SH_DIR32
4073                    && (input_section->flags & SEC_ALLOC) != 0)
4074             {
4075               bfd_vma offset;
4076
4077               BFD_ASSERT (htab);
4078
4079                 if (sh_elf_osec_readonly_p (output_bfd,
4080                                             input_section->output_section))
4081                   {
4082                     _bfd_error_handler
4083                       /* xgettext:c-format */
4084                       (_("%pB(%pA+%#" PRIx64 "): "
4085                          "cannot emit fixup to `%s' in read-only section"),
4086                        input_bfd,
4087                        input_section,
4088                        (uint64_t) rel->r_offset,
4089                        symname);
4090                     return FALSE;
4091                   }
4092
4093               offset = _bfd_elf_section_offset (output_bfd, info,
4094                                                 input_section, rel->r_offset);
4095               if (offset != (bfd_vma)-1)
4096                 sh_elf_add_rofixup (output_bfd, htab->srofixup,
4097                                     input_section->output_section->vma
4098                                     + input_section->output_offset
4099                                     + rel->r_offset);
4100
4101               check_segment[0] = check_segment[1] = -1;
4102             }
4103             /* We don't want warnings for non-NULL tests on undefined weak
4104                symbols.  */
4105             else if (r_type == R_SH_REL32
4106                      && h
4107                      && h->root.type == bfd_link_hash_undefweak)
4108               check_segment[0] = check_segment[1] = -1;
4109           goto final_link_relocate;
4110
4111         case R_SH_GOTPLT32:
4112           /* Relocation is to the entry for this symbol in the
4113              procedure linkage table.  */
4114
4115           if (h == NULL
4116               || h->forced_local
4117               || ! bfd_link_pic (info)
4118               || info->symbolic
4119               || h->dynindx == -1
4120               || h->plt.offset == (bfd_vma) -1
4121               || h->got.offset != (bfd_vma) -1)
4122             goto force_got;
4123
4124           /* Relocation is to the entry for this symbol in the global
4125              offset table extension for the procedure linkage table.  */
4126
4127           BFD_ASSERT (htab);
4128           BFD_ASSERT (sgotplt != NULL);
4129           relocation = (sgotplt->output_offset
4130                         + (get_plt_index (htab->plt_info, h->plt.offset)
4131                            + 3) * 4);
4132
4133 #ifdef GOT_BIAS
4134           relocation -= GOT_BIAS;
4135 #endif
4136
4137           goto final_link_relocate;
4138
4139         force_got:
4140         case R_SH_GOT32:
4141         case R_SH_GOT20:
4142           /* Relocation is to the entry for this symbol in the global
4143              offset table.  */
4144
4145           BFD_ASSERT (htab);
4146           BFD_ASSERT (sgot != NULL);
4147           check_segment[0] = check_segment[1] = -1;
4148
4149           if (h != NULL)
4150             {
4151               bfd_boolean dyn;
4152
4153               off = h->got.offset;
4154               BFD_ASSERT (off != (bfd_vma) -1);
4155
4156               dyn = htab->root.dynamic_sections_created;
4157               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4158                                                      bfd_link_pic (info),
4159                                                      h)
4160                   || (bfd_link_pic (info)
4161                       && SYMBOL_REFERENCES_LOCAL (info, h))
4162                   || ((ELF_ST_VISIBILITY (h->other)
4163                        || resolved_to_zero)
4164                       && h->root.type == bfd_link_hash_undefweak))
4165                 {
4166                   /* This is actually a static link, or it is a
4167                      -Bsymbolic link and the symbol is defined
4168                      locally, or the symbol was forced to be local
4169                      because of a version file.  We must initialize
4170                      this entry in the global offset table.  Since the
4171                      offset must always be a multiple of 4, we use the
4172                      least significant bit to record whether we have
4173                      initialized it already.
4174
4175                      When doing a dynamic link, we create a .rela.got
4176                      relocation entry to initialize the value.  This
4177                      is done in the finish_dynamic_symbol routine.  */
4178                   if ((off & 1) != 0)
4179                     off &= ~1;
4180                   else
4181                     {
4182                       bfd_put_32 (output_bfd, relocation,
4183                                   sgot->contents + off);
4184                       h->got.offset |= 1;
4185
4186                       /* If we initialize the GOT entry here with a valid
4187                          symbol address, also add a fixup.  */
4188                       if (fdpic_p && !bfd_link_pic (info)
4189                           && sh_elf_hash_entry (h)->got_type == GOT_NORMAL
4190                           && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4191                               || h->root.type != bfd_link_hash_undefweak))
4192                         sh_elf_add_rofixup (output_bfd, htab->srofixup,
4193                                             sgot->output_section->vma
4194                                             + sgot->output_offset
4195                                             + off);
4196                     }
4197                 }
4198
4199               relocation = sh_elf_got_offset (htab) + off;
4200             }
4201           else
4202             {
4203               BFD_ASSERT (local_got_offsets != NULL
4204                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
4205
4206               off = local_got_offsets[r_symndx];
4207
4208               /* The offset must always be a multiple of 4.  We use
4209                  the least significant bit to record whether we have
4210                  already generated the necessary reloc.  */
4211               if ((off & 1) != 0)
4212                 off &= ~1;
4213               else
4214                 {
4215                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4216
4217                   if (bfd_link_pic (info))
4218                     {
4219                       Elf_Internal_Rela outrel;
4220                       bfd_byte *loc;
4221
4222                       outrel.r_offset = (sgot->output_section->vma
4223                                          + sgot->output_offset
4224                                          + off);
4225                       if (fdpic_p)
4226                         {
4227                           int dynindx
4228                             = elf_section_data (sec->output_section)->dynindx;
4229                           outrel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
4230                           outrel.r_addend = relocation;
4231                           outrel.r_addend -= sec->output_section->vma;
4232                         }
4233                       else
4234                         {
4235                           outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4236                           outrel.r_addend = relocation;
4237                         }
4238                       loc = srelgot->contents;
4239                       loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
4240                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4241                     }
4242                   else if (fdpic_p
4243                            && (sh_elf_local_got_type (input_bfd) [r_symndx]
4244                                == GOT_NORMAL))
4245                     sh_elf_add_rofixup (output_bfd, htab->srofixup,
4246                                         sgot->output_section->vma
4247                                         + sgot->output_offset
4248                                         + off);
4249
4250                   local_got_offsets[r_symndx] |= 1;
4251                 }
4252
4253               relocation = sh_elf_got_offset (htab) + off;
4254             }
4255
4256 #ifdef GOT_BIAS
4257           relocation -= GOT_BIAS;
4258 #endif
4259
4260           if (r_type == R_SH_GOT20)
4261             {
4262               r = install_movi20_field (output_bfd, relocation + addend,
4263                                         input_bfd, input_section, contents,
4264                                         rel->r_offset);
4265               break;
4266             }
4267           else
4268             goto final_link_relocate;
4269
4270         case R_SH_GOTOFF:
4271         case R_SH_GOTOFF20:
4272           /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4273              we place at the start of the .got.plt section.  This is the same
4274              as the start of the output .got section, unless there are function
4275              descriptors in front of it.  */
4276           BFD_ASSERT (htab);
4277           BFD_ASSERT (sgotplt != NULL);
4278           check_segment[0] = got_segment;
4279           relocation -= sgotplt->output_section->vma + sgotplt->output_offset
4280             + htab->root.hgot->root.u.def.value;
4281
4282 #ifdef GOT_BIAS
4283           relocation -= GOT_BIAS;
4284 #endif
4285
4286           addend = rel->r_addend;
4287
4288           if (r_type == R_SH_GOTOFF20)
4289             {
4290               r = install_movi20_field (output_bfd, relocation + addend,
4291                                         input_bfd, input_section, contents,
4292                                         rel->r_offset);
4293               break;
4294             }
4295           else
4296             goto final_link_relocate;
4297
4298         case R_SH_GOTPC:
4299           /* Use global offset table as symbol value.  */
4300
4301           BFD_ASSERT (sgotplt != NULL);
4302           relocation = sgotplt->output_section->vma + sgotplt->output_offset;
4303
4304 #ifdef GOT_BIAS
4305           relocation += GOT_BIAS;
4306 #endif
4307
4308           addend = rel->r_addend;
4309
4310           goto final_link_relocate;
4311
4312         case R_SH_PLT32:
4313           /* Relocation is to the entry for this symbol in the
4314              procedure linkage table.  */
4315
4316           /* Resolve a PLT reloc against a local symbol directly,
4317              without using the procedure linkage table.  */
4318           if (h == NULL)
4319             goto final_link_relocate;
4320
4321           /* We don't want to warn on calls to undefined weak symbols,
4322              as calls to them must be protected by non-NULL tests
4323              anyway, and unprotected calls would invoke undefined
4324              behavior.  */
4325           if (h->root.type == bfd_link_hash_undefweak)
4326             check_segment[0] = check_segment[1] = -1;
4327
4328           if (h->forced_local)
4329             goto final_link_relocate;
4330
4331           if (h->plt.offset == (bfd_vma) -1)
4332             {
4333               /* We didn't make a PLT entry for this symbol.  This
4334                  happens when statically linking PIC code, or when
4335                  using -Bsymbolic.  */
4336               goto final_link_relocate;
4337             }
4338
4339           BFD_ASSERT (splt != NULL);
4340           check_segment[1] = plt_segment;
4341           relocation = (splt->output_section->vma
4342                         + splt->output_offset
4343                         + h->plt.offset);
4344
4345           addend = rel->r_addend;
4346
4347           goto final_link_relocate;
4348
4349         /* Relocation is to the canonical function descriptor for this
4350            symbol, possibly via the GOT.  Initialize the GOT
4351            entry and function descriptor if necessary.  */
4352         case R_SH_GOTFUNCDESC:
4353         case R_SH_GOTFUNCDESC20:
4354         case R_SH_FUNCDESC:
4355           {
4356             int dynindx = -1;
4357             asection *reloc_section;
4358             bfd_vma reloc_offset;
4359             int reloc_type = R_SH_FUNCDESC;
4360
4361             BFD_ASSERT (htab);
4362
4363             check_segment[0] = check_segment[1] = -1;
4364
4365             /* FIXME: See what FRV does for global symbols in the
4366                executable, with --export-dynamic.  Do they need ld.so
4367                to allocate official descriptors?  See what this code
4368                does.  */
4369
4370             relocation = 0;
4371             addend = 0;
4372
4373             if (r_type == R_SH_FUNCDESC)
4374               {
4375                 reloc_section = input_section;
4376                 reloc_offset = rel->r_offset;
4377               }
4378             else
4379               {
4380                 reloc_section = sgot;
4381
4382                 if (h != NULL)
4383                   reloc_offset = h->got.offset;
4384                 else
4385                   {
4386                     BFD_ASSERT (local_got_offsets != NULL);
4387                     reloc_offset = local_got_offsets[r_symndx];
4388                   }
4389                 BFD_ASSERT (reloc_offset != MINUS_ONE);
4390
4391                 if (reloc_offset & 1)
4392                   {
4393                     reloc_offset &= ~1;
4394                     goto funcdesc_done_got;
4395                   }
4396               }
4397
4398             if (h && h->root.type == bfd_link_hash_undefweak
4399                 && (SYMBOL_CALLS_LOCAL (info, h)
4400                     || !htab->root.dynamic_sections_created))
4401               /* Undefined weak symbol which will not be dynamically
4402                  resolved later; leave it at zero.  */
4403               goto funcdesc_leave_zero;
4404             else if (SYMBOL_CALLS_LOCAL (info, h)
4405                      && ! SYMBOL_FUNCDESC_LOCAL (info, h))
4406               {
4407                 /* If the symbol needs a non-local function descriptor
4408                    but binds locally (i.e., its visibility is
4409                    protected), emit a dynamic relocation decayed to
4410                    section+offset.  This is an optimization; the dynamic
4411                    linker would resolve our function descriptor request
4412                    to our copy of the function anyway.  */
4413                 dynindx = elf_section_data (h->root.u.def.section
4414                                             ->output_section)->dynindx;
4415                 relocation += h->root.u.def.section->output_offset
4416                   + h->root.u.def.value;
4417               }
4418             else if (! SYMBOL_FUNCDESC_LOCAL (info, h))
4419               {
4420                 /* If the symbol is dynamic and there will be dynamic
4421                    symbol resolution because we are or are linked with a
4422                    shared library, emit a FUNCDESC relocation such that
4423                    the dynamic linker will allocate the function
4424                    descriptor.  */
4425                 BFD_ASSERT (h->dynindx != -1);
4426                 dynindx = h->dynindx;
4427               }
4428             else
4429               {
4430                 bfd_vma offset;
4431
4432                 /* Otherwise, we know we have a private function
4433                    descriptor, so reference it directly.  */
4434                 reloc_type = R_SH_DIR32;
4435                 dynindx = elf_section_data (htab->sfuncdesc
4436                                             ->output_section)->dynindx;
4437
4438                 if (h)
4439                   {
4440                     offset = sh_elf_hash_entry (h)->funcdesc.offset;
4441                     BFD_ASSERT (offset != MINUS_ONE);
4442                     if ((offset & 1) == 0)
4443                       {
4444                         if (!sh_elf_initialize_funcdesc (output_bfd, info, h,
4445                                                          offset, NULL, 0))
4446                           return FALSE;
4447                         sh_elf_hash_entry (h)->funcdesc.offset |= 1;
4448                       }
4449                   }
4450                 else
4451                   {
4452                     union gotref *local_funcdesc;
4453
4454                     local_funcdesc = sh_elf_local_funcdesc (input_bfd);
4455                     offset = local_funcdesc[r_symndx].offset;
4456                     BFD_ASSERT (offset != MINUS_ONE);
4457                     if ((offset & 1) == 0)
4458                       {
4459                         if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL,
4460                                                          offset, sec,
4461                                                          sym->st_value))
4462                           return FALSE;
4463                         local_funcdesc[r_symndx].offset |= 1;
4464                       }
4465                   }
4466
4467                 relocation = htab->sfuncdesc->output_offset + (offset & ~1);
4468               }
4469
4470             if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h))
4471               {
4472                 bfd_vma offset;
4473
4474                 if (sh_elf_osec_readonly_p (output_bfd,
4475                                             reloc_section->output_section))
4476                   {
4477                     _bfd_error_handler
4478                       /* xgettext:c-format */
4479                       (_("%pB(%pA+%#" PRIx64 "): "
4480                          "cannot emit fixup to `%s' in read-only section"),
4481                        input_bfd,
4482                        input_section,
4483                        (uint64_t) rel->r_offset,
4484                        symname);
4485                     return FALSE;
4486                   }
4487
4488                 offset = _bfd_elf_section_offset (output_bfd, info,
4489                                                   reloc_section, reloc_offset);
4490
4491                 if (offset != (bfd_vma)-1)
4492                   sh_elf_add_rofixup (output_bfd, htab->srofixup,
4493                                       offset
4494                                       + reloc_section->output_section->vma
4495                                       + reloc_section->output_offset);
4496               }
4497             else if ((reloc_section->output_section->flags
4498                       & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
4499               {
4500                 bfd_vma offset;
4501
4502                 if (sh_elf_osec_readonly_p (output_bfd,
4503                                             reloc_section->output_section))
4504                   {
4505                     info->callbacks->warning
4506                       (info,
4507                        _("cannot emit dynamic relocations in read-only section"),
4508                        symname, input_bfd, reloc_section, reloc_offset);
4509                     return FALSE;
4510                   }
4511
4512                 offset = _bfd_elf_section_offset (output_bfd, info,
4513                                                   reloc_section, reloc_offset);
4514
4515                 if (offset != (bfd_vma)-1)
4516                   sh_elf_add_dyn_reloc (output_bfd, srelgot,
4517                                         offset
4518                                         + reloc_section->output_section->vma
4519                                         + reloc_section->output_offset,
4520                                         reloc_type, dynindx, relocation);
4521
4522                 if (r_type == R_SH_FUNCDESC)
4523                   {
4524                     r = bfd_reloc_ok;
4525                     break;
4526                   }
4527                 else
4528                   {
4529                     relocation = 0;
4530                     goto funcdesc_leave_zero;
4531                   }
4532               }
4533
4534             if (SYMBOL_FUNCDESC_LOCAL (info, h))
4535               relocation += htab->sfuncdesc->output_section->vma;
4536           funcdesc_leave_zero:
4537             if (r_type != R_SH_FUNCDESC)
4538               {
4539                 bfd_put_32 (output_bfd, relocation,
4540                             reloc_section->contents + reloc_offset);
4541                 if (h != NULL)
4542                   h->got.offset |= 1;
4543                 else
4544                   local_got_offsets[r_symndx] |= 1;
4545
4546               funcdesc_done_got:
4547
4548                 relocation = sh_elf_got_offset (htab) + reloc_offset;
4549 #ifdef GOT_BIAS
4550                 relocation -= GOT_BIAS;
4551 #endif
4552               }
4553             if (r_type == R_SH_GOTFUNCDESC20)
4554               {
4555                 r = install_movi20_field (output_bfd, relocation + addend,
4556                                           input_bfd, input_section, contents,
4557                                           rel->r_offset);
4558                 break;
4559               }
4560             else
4561               goto final_link_relocate;
4562           }
4563           break;
4564
4565         case R_SH_GOTOFFFUNCDESC:
4566         case R_SH_GOTOFFFUNCDESC20:
4567           /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
4568              executable and --export-dynamic.  If such symbols get
4569              ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
4570              for them.  */
4571           BFD_ASSERT (htab);
4572
4573           check_segment[0] = check_segment[1] = -1;
4574           relocation = 0;
4575           addend = rel->r_addend;
4576
4577           if (h && (h->root.type == bfd_link_hash_undefweak
4578                     || !SYMBOL_FUNCDESC_LOCAL (info, h)))
4579             {
4580               _bfd_error_handler
4581                 /* xgettext:c-format */
4582                 (_("%pB(%pA+%#" PRIx64 "): "
4583                    "%s relocation against external symbol \"%s\""),
4584                  input_bfd, input_section, (uint64_t) rel->r_offset,
4585                  howto->name, h->root.root.string);
4586               return FALSE;
4587             }
4588           else
4589             {
4590               bfd_vma offset;
4591
4592               /* Otherwise, we know we have a private function
4593                  descriptor, so reference it directly.  */
4594               if (h)
4595                 {
4596                   offset = sh_elf_hash_entry (h)->funcdesc.offset;
4597                   BFD_ASSERT (offset != MINUS_ONE);
4598                   if ((offset & 1) == 0)
4599                     {
4600                       if (!sh_elf_initialize_funcdesc (output_bfd, info, h,
4601                                                        offset, NULL, 0))
4602                         return FALSE;
4603                       sh_elf_hash_entry (h)->funcdesc.offset |= 1;
4604                     }
4605                 }
4606               else
4607                 {
4608                   union gotref *local_funcdesc;
4609
4610                   local_funcdesc = sh_elf_local_funcdesc (input_bfd);
4611                   offset = local_funcdesc[r_symndx].offset;
4612                   BFD_ASSERT (offset != MINUS_ONE);
4613                   if ((offset & 1) == 0)
4614                     {
4615                       if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL,
4616                                                        offset, sec,
4617                                                        sym->st_value))
4618                         return FALSE;
4619                       local_funcdesc[r_symndx].offset |= 1;
4620                     }
4621                 }
4622
4623               relocation = htab->sfuncdesc->output_offset + (offset & ~1);
4624             }
4625
4626           relocation -= (htab->root.hgot->root.u.def.value
4627                          + sgotplt->output_offset);
4628 #ifdef GOT_BIAS
4629           relocation -= GOT_BIAS;
4630 #endif
4631
4632           if (r_type == R_SH_GOTOFFFUNCDESC20)
4633             {
4634               r = install_movi20_field (output_bfd, relocation + addend,
4635                                         input_bfd, input_section, contents,
4636                                         rel->r_offset);
4637               break;
4638             }
4639           else
4640             goto final_link_relocate;
4641
4642         case R_SH_LOOP_START:
4643           {
4644             static bfd_vma start, end;
4645
4646             start = (relocation + rel->r_addend
4647                      - (sec->output_section->vma + sec->output_offset));
4648             r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
4649                                    rel->r_offset, sec, start, end);
4650             break;
4651
4652         case R_SH_LOOP_END:
4653             end = (relocation + rel->r_addend
4654                    - (sec->output_section->vma + sec->output_offset));
4655             r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
4656                                    rel->r_offset, sec, start, end);
4657             break;
4658           }
4659
4660         case R_SH_TLS_GD_32:
4661         case R_SH_TLS_IE_32:
4662           BFD_ASSERT (htab);
4663           check_segment[0] = check_segment[1] = -1;
4664           r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
4665           got_type = GOT_UNKNOWN;
4666           if (h == NULL && local_got_offsets)
4667             got_type = sh_elf_local_got_type (input_bfd) [r_symndx];
4668           else if (h != NULL)
4669             {
4670               got_type = sh_elf_hash_entry (h)->got_type;
4671               if (! bfd_link_pic (info)
4672                   && (h->dynindx == -1
4673                       || h->def_regular))
4674                 r_type = R_SH_TLS_LE_32;
4675             }
4676
4677           if (r_type == R_SH_TLS_GD_32 && got_type == GOT_TLS_IE)
4678             r_type = R_SH_TLS_IE_32;
4679
4680           if (r_type == R_SH_TLS_LE_32)
4681             {
4682               bfd_vma offset;
4683               unsigned short insn;
4684
4685               if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_GD_32)
4686                 {
4687                   /* GD->LE transition:
4688                        mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4689                        jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4690                        1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4691                      We change it into:
4692                        mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
4693                        nop; nop; ...
4694                        1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:.  */
4695
4696                   offset = rel->r_offset;
4697                   if (offset < 16)
4698                     {
4699                       _bfd_error_handler
4700                         /* xgettext:c-format */
4701                         (_("%pB(%pA): offset in relocation for GD->LE translation is too small: %#" PRIx64),
4702                          input_bfd, input_section, (uint64_t) offset);
4703                       return FALSE;
4704                     }
4705
4706                   /* Size of GD instructions is 16 or 18.  */
4707                   offset -= 16;
4708                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
4709                   if ((insn & 0xff00) == 0xc700)
4710                     {
4711                       BFD_ASSERT (offset >= 2);
4712                       offset -= 2;
4713                       insn = bfd_get_16 (input_bfd, contents + offset + 0);
4714                     }
4715
4716                   if ((insn & 0xff00) != 0xd400)
4717                     _bfd_error_handler
4718                       /* xgettext:c-format */  /* The backslash is to prevent bogus trigraph detection.  */
4719                       (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0xd4?\?)"),
4720                        input_bfd, input_section, (uint64_t) offset, (int) insn);
4721
4722                   insn = bfd_get_16 (input_bfd, contents + offset + 2);
4723
4724                   if ((insn & 0xff00) != 0xc700)
4725                     _bfd_error_handler
4726                       /* xgettext:c-format */
4727                       (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0xc7?\?)"),
4728                        input_bfd, input_section, (uint64_t) offset, (int) insn);
4729
4730                   insn = bfd_get_16 (input_bfd, contents + offset + 4);
4731                   if ((insn & 0xff00) != 0xd100)
4732                     _bfd_error_handler
4733                       /* xgettext:c-format */
4734                       (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0xd1?\?)"),
4735                        input_bfd, input_section, (uint64_t) offset, (int) insn);
4736
4737                   insn = bfd_get_16 (input_bfd, contents + offset + 6);
4738                   if (insn != 0x310c)
4739                     _bfd_error_handler
4740                       /* xgettext:c-format */
4741                       (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x310c)"),
4742                        input_bfd, input_section, (uint64_t) offset, (int) insn);
4743
4744                   insn = bfd_get_16 (input_bfd, contents + offset + 8);
4745                   if (insn != 0x410b)
4746                     _bfd_error_handler
4747                       /* xgettext:c-format */
4748                       (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x410b)"),
4749                        input_bfd, input_section, (uint64_t) offset, (int) insn);
4750
4751                   insn = bfd_get_16 (input_bfd, contents + offset + 10);
4752                   if (insn != 0x34cc)
4753                     _bfd_error_handler
4754                       /* xgettext:c-format */
4755                       (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x34cc)"),
4756                        input_bfd, input_section, (uint64_t) offset, (int) insn);
4757
4758                   bfd_put_16 (output_bfd, 0x0012, contents + offset + 2);
4759                   bfd_put_16 (output_bfd, 0x304c, contents + offset + 4);
4760                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
4761                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
4762                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
4763                 }
4764               else
4765                 {
4766                   int target;
4767
4768                   /* IE->LE transition:
4769                          mov.l 1f,r0;
4770                          stc gbr,rN;
4771                          mov.l @(r0,r12),rM;
4772                          bra 2f;
4773                          add ...;
4774                          .align 2;
4775                        1: x@GOTTPOFF;
4776                        2:
4777                      We change it into:
4778                          mov.l .Ln,rM;
4779                          stc gbr,rN;
4780                          nop;
4781                          ...;
4782                        1: x@TPOFF;
4783                        2:.  */
4784
4785                   offset = rel->r_offset;
4786                   if (offset < 16)
4787                     {
4788                       _bfd_error_handler
4789                         /* xgettext:c-format */
4790                         (_("%pB(%pA): offset in relocation for IE->LE translation is too small: %#" PRIx64),
4791                          input_bfd, input_section, (uint64_t) offset);
4792                       return FALSE;
4793                     }
4794
4795                   /* Size of IE instructions is 10 or 12.  */
4796                   offset -= 10;
4797                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
4798                   if ((insn & 0xf0ff) == 0x0012)
4799                     {
4800                       BFD_ASSERT (offset >= 2);
4801                       offset -= 2;
4802                       insn = bfd_get_16 (input_bfd, contents + offset + 0);
4803                     }
4804
4805                   if ((insn & 0xff00) != 0xd000)
4806                     _bfd_error_handler
4807                       /* xgettext:c-format */
4808                       (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0xd0??: mov.l)"),
4809                        input_bfd, input_section, (uint64_t) offset, (int) insn);
4810
4811                   target = insn & 0x00ff;
4812
4813                   insn = bfd_get_16 (input_bfd, contents + offset + 2);
4814                   if ((insn & 0xf0ff) != 0x0012)
4815                     _bfd_error_handler
4816                       /* xgettext:c-format */
4817                       (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x0?12: stc)"),
4818                        input_bfd, input_section, (uint64_t) (offset + 2), (int) insn);
4819
4820                   insn = bfd_get_16 (input_bfd, contents + offset + 4);
4821                   if ((insn & 0xf0ff) != 0x00ce)
4822                     _bfd_error_handler
4823                       /* xgettext:c-format */
4824                       (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x0?ce: mov.l)"),
4825                        input_bfd, input_section, (uint64_t) (offset + 4), (int) insn);
4826
4827                   insn = 0xd000 | (insn & 0x0f00) | target;
4828                   bfd_put_16 (output_bfd, insn, contents + offset + 0);
4829                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
4830                 }
4831
4832               bfd_put_32 (output_bfd, tpoff (info, relocation),
4833                           contents + rel->r_offset);
4834               continue;
4835             }
4836
4837           if (sgot == NULL || sgotplt == NULL)
4838             abort ();
4839
4840           if (h != NULL)
4841             off = h->got.offset;
4842           else
4843             {
4844               if (local_got_offsets == NULL)
4845                 abort ();
4846
4847               off = local_got_offsets[r_symndx];
4848             }
4849
4850           /* Relocate R_SH_TLS_IE_32 directly when statically linking.  */
4851           if (r_type == R_SH_TLS_IE_32
4852               && ! htab->root.dynamic_sections_created)
4853             {
4854               off &= ~1;
4855               bfd_put_32 (output_bfd, tpoff (info, relocation),
4856                           sgot->contents + off);
4857               bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off,
4858                           contents + rel->r_offset);
4859               continue;
4860             }
4861
4862           if ((off & 1) != 0)
4863             off &= ~1;
4864           else
4865             {
4866               Elf_Internal_Rela outrel;
4867               bfd_byte *loc;
4868               int dr_type, indx;
4869
4870               outrel.r_offset = (sgot->output_section->vma
4871                                  + sgot->output_offset + off);
4872
4873               if (h == NULL || h->dynindx == -1)
4874                 indx = 0;
4875               else
4876                 indx = h->dynindx;
4877
4878               dr_type = (r_type == R_SH_TLS_GD_32 ? R_SH_TLS_DTPMOD32 :
4879                          R_SH_TLS_TPOFF32);
4880               if (dr_type == R_SH_TLS_TPOFF32 && indx == 0)
4881                 outrel.r_addend = relocation - dtpoff_base (info);
4882               else
4883                 outrel.r_addend = 0;
4884               outrel.r_info = ELF32_R_INFO (indx, dr_type);
4885               loc = srelgot->contents;
4886               loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
4887               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4888
4889               if (r_type == R_SH_TLS_GD_32)
4890                 {
4891                   if (indx == 0)
4892                     {
4893                       bfd_put_32 (output_bfd,
4894                                   relocation - dtpoff_base (info),
4895                                   sgot->contents + off + 4);
4896                     }
4897                   else
4898                     {
4899                       outrel.r_info = ELF32_R_INFO (indx,
4900                                                     R_SH_TLS_DTPOFF32);
4901                       outrel.r_offset += 4;
4902                       outrel.r_addend = 0;
4903                       srelgot->reloc_count++;
4904                       loc += sizeof (Elf32_External_Rela);
4905                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4906                     }
4907                 }
4908
4909               if (h != NULL)
4910                 h->got.offset |= 1;
4911               else
4912                 local_got_offsets[r_symndx] |= 1;
4913             }
4914
4915           if (off >= (bfd_vma) -2)
4916             abort ();
4917
4918           if (r_type == (int) ELF32_R_TYPE (rel->r_info))
4919             relocation = sh_elf_got_offset (htab) + off;
4920           else
4921             {
4922               bfd_vma offset;
4923               unsigned short insn;
4924
4925               /* GD->IE transition:
4926                    mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4927                    jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4928                    1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4929                  We change it into:
4930                    mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
4931                    nop; nop; bra 3f; nop; .align 2;
4932                    1: .long x@TPOFF; 2:...; 3:.  */
4933
4934               offset = rel->r_offset;
4935               if (offset < 16)
4936                 {
4937                   _bfd_error_handler
4938                     /* xgettext:c-format */
4939                     (_("%pB(%pA): offset in relocation for GD->IE translation is too small: %#" PRIx64),
4940                      input_bfd, input_section, (uint64_t) offset);
4941                   return FALSE;
4942                 }
4943
4944               /* Size of GD instructions is 16 or 18.  */
4945               offset -= 16;
4946               insn = bfd_get_16 (input_bfd, contents + offset + 0);
4947               if ((insn & 0xff00) == 0xc700)
4948                 {
4949                   BFD_ASSERT (offset >= 2);
4950                   offset -= 2;
4951                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
4952                 }
4953
4954               BFD_ASSERT ((insn & 0xff00) == 0xd400);
4955
4956               /* Replace mov.l 1f,R4 with mov.l 1f,r0.  */
4957               bfd_put_16 (output_bfd, insn & 0xf0ff, contents + offset);
4958
4959               insn = bfd_get_16 (input_bfd, contents + offset + 2);
4960               BFD_ASSERT ((insn & 0xff00) == 0xc700);
4961               insn = bfd_get_16 (input_bfd, contents + offset + 4);
4962               BFD_ASSERT ((insn & 0xff00) == 0xd100);
4963               insn = bfd_get_16 (input_bfd, contents + offset + 6);
4964               BFD_ASSERT (insn == 0x310c);
4965               insn = bfd_get_16 (input_bfd, contents + offset + 8);
4966               BFD_ASSERT (insn == 0x410b);
4967               insn = bfd_get_16 (input_bfd, contents + offset + 10);
4968               BFD_ASSERT (insn == 0x34cc);
4969
4970               bfd_put_16 (output_bfd, 0x0412, contents + offset + 2);
4971               bfd_put_16 (output_bfd, 0x00ce, contents + offset + 4);
4972               bfd_put_16 (output_bfd, 0x304c, contents + offset + 6);
4973               bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
4974               bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
4975
4976               bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off,
4977                           contents + rel->r_offset);
4978
4979               continue;
4980           }
4981
4982           addend = rel->r_addend;
4983
4984           goto final_link_relocate;
4985
4986         case R_SH_TLS_LD_32:
4987           BFD_ASSERT (htab);
4988           check_segment[0] = check_segment[1] = -1;
4989           if (! bfd_link_pic (info))
4990             {
4991               bfd_vma offset;
4992               unsigned short insn;
4993
4994               /* LD->LE transition:
4995                    mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4996                    jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4997                    1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
4998                  We change it into:
4999                    stc gbr,r0; nop; nop; nop;
5000                    nop; nop; bra 3f; ...; 3:.  */
5001
5002               offset = rel->r_offset;
5003               if (offset < 16)
5004                 {
5005                   _bfd_error_handler
5006                     /* xgettext:c-format */
5007                     (_("%pB(%pA): offset in relocation for LD->LE translation is too small: %#" PRIx64),
5008                      input_bfd, input_section, (uint64_t) offset);
5009                   return FALSE;
5010                 }
5011
5012               /* Size of LD instructions is 16 or 18.  */
5013               offset -= 16;
5014               insn = bfd_get_16 (input_bfd, contents + offset + 0);
5015               if ((insn & 0xff00) == 0xc700)
5016                 {
5017                   BFD_ASSERT (offset >= 2);
5018                   offset -= 2;
5019                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
5020                 }
5021
5022               BFD_ASSERT ((insn & 0xff00) == 0xd400);
5023               insn = bfd_get_16 (input_bfd, contents + offset + 2);
5024               BFD_ASSERT ((insn & 0xff00) == 0xc700);
5025               insn = bfd_get_16 (input_bfd, contents + offset + 4);
5026               BFD_ASSERT ((insn & 0xff00) == 0xd100);
5027               insn = bfd_get_16 (input_bfd, contents + offset + 6);
5028               BFD_ASSERT (insn == 0x310c);
5029               insn = bfd_get_16 (input_bfd, contents + offset + 8);
5030               BFD_ASSERT (insn == 0x410b);
5031               insn = bfd_get_16 (input_bfd, contents + offset + 10);
5032               BFD_ASSERT (insn == 0x34cc);
5033
5034               bfd_put_16 (output_bfd, 0x0012, contents + offset + 0);
5035               bfd_put_16 (output_bfd, 0x0009, contents + offset + 2);
5036               bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5037               bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5038               bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5039               bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5040
5041               continue;
5042             }
5043
5044           if (sgot == NULL || sgotplt == NULL)
5045             abort ();
5046
5047           off = htab->tls_ldm_got.offset;
5048           if (off & 1)
5049             off &= ~1;
5050           else
5051             {
5052               Elf_Internal_Rela outrel;
5053               bfd_byte *loc;
5054
5055               outrel.r_offset = (sgot->output_section->vma
5056                                  + sgot->output_offset + off);
5057               outrel.r_addend = 0;
5058               outrel.r_info = ELF32_R_INFO (0, R_SH_TLS_DTPMOD32);
5059               loc = srelgot->contents;
5060               loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5061               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5062               htab->tls_ldm_got.offset |= 1;
5063             }
5064
5065           relocation = sh_elf_got_offset (htab) + off;
5066           addend = rel->r_addend;
5067
5068           goto final_link_relocate;
5069
5070         case R_SH_TLS_LDO_32:
5071           check_segment[0] = check_segment[1] = -1;
5072           if (! bfd_link_pic (info))
5073             relocation = tpoff (info, relocation);
5074           else
5075             relocation -= dtpoff_base (info);
5076
5077           addend = rel->r_addend;
5078           goto final_link_relocate;
5079
5080         case R_SH_TLS_LE_32:
5081           {
5082             int indx;
5083             Elf_Internal_Rela outrel;
5084             bfd_byte *loc;
5085
5086             check_segment[0] = check_segment[1] = -1;
5087
5088             if (!bfd_link_dll (info))
5089               {
5090                 relocation = tpoff (info, relocation);
5091                 addend = rel->r_addend;
5092                 goto final_link_relocate;
5093               }
5094
5095             if (sreloc == NULL)
5096               {
5097                 sreloc = _bfd_elf_get_dynamic_reloc_section
5098                   (input_bfd, input_section, /*rela?*/ TRUE);
5099                 if (sreloc == NULL)
5100                   return FALSE;
5101               }
5102
5103             if (h == NULL || h->dynindx == -1)
5104               indx = 0;
5105             else
5106               indx = h->dynindx;
5107
5108             outrel.r_offset = (input_section->output_section->vma
5109                                + input_section->output_offset
5110                                + rel->r_offset);
5111             outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5112             if (indx == 0)
5113               outrel.r_addend = relocation - dtpoff_base (info);
5114             else
5115               outrel.r_addend = 0;
5116
5117             loc = sreloc->contents;
5118             loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5119             bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5120             continue;
5121           }
5122         }
5123
5124     relocation_done:
5125       if (fdpic_p && check_segment[0] != (unsigned) -1
5126           && check_segment[0] != check_segment[1])
5127         {
5128           /* We don't want duplicate errors for undefined symbols.  */
5129           if (!h || h->root.type != bfd_link_hash_undefined)
5130             {
5131               if (bfd_link_pic (info))
5132                 {
5133                   info->callbacks->einfo
5134                     /* xgettext:c-format */
5135                     (_("%X%C: relocation to \"%s\" references a different segment\n"),
5136                      input_bfd, input_section, rel->r_offset, symname);
5137                   return FALSE;
5138                 }
5139               else
5140                 info->callbacks->einfo
5141                   /* xgettext:c-format */
5142                   (_("%C: warning: relocation to \"%s\" references a different segment\n"),
5143                    input_bfd, input_section, rel->r_offset, symname);
5144             }
5145
5146           elf_elfheader (output_bfd)->e_flags |= EF_SH_PIC;
5147         }
5148
5149       if (r != bfd_reloc_ok)
5150         {
5151           switch (r)
5152             {
5153             default:
5154             case bfd_reloc_outofrange:
5155               abort ();
5156             case bfd_reloc_overflow:
5157               {
5158                 const char *name;
5159
5160                 if (h != NULL)
5161                   name = NULL;
5162                 else
5163                   {
5164                     name = (bfd_elf_string_from_elf_section
5165                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
5166                     if (name == NULL)
5167                       return FALSE;
5168                     if (*name == '\0')
5169                       name = bfd_section_name (input_bfd, sec);
5170                   }
5171                 (*info->callbacks->reloc_overflow)
5172                   (info, (h ? &h->root : NULL), name, howto->name,
5173                    (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
5174               }
5175               break;
5176             }
5177         }
5178     }
5179
5180   return TRUE;
5181 }
5182
5183 /* This is a version of bfd_generic_get_relocated_section_contents
5184    which uses sh_elf_relocate_section.  */
5185
5186 static bfd_byte *
5187 sh_elf_get_relocated_section_contents (bfd *output_bfd,
5188                                        struct bfd_link_info *link_info,
5189                                        struct bfd_link_order *link_order,
5190                                        bfd_byte *data,
5191                                        bfd_boolean relocatable,
5192                                        asymbol **symbols)
5193 {
5194   Elf_Internal_Shdr *symtab_hdr;
5195   asection *input_section = link_order->u.indirect.section;
5196   bfd *input_bfd = input_section->owner;
5197   asection **sections = NULL;
5198   Elf_Internal_Rela *internal_relocs = NULL;
5199   Elf_Internal_Sym *isymbuf = NULL;
5200
5201   /* We only need to handle the case of relaxing, or of having a
5202      particular set of section contents, specially.  */
5203   if (relocatable
5204       || elf_section_data (input_section)->this_hdr.contents == NULL)
5205     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
5206                                                        link_order, data,
5207                                                        relocatable,
5208                                                        symbols);
5209
5210   symtab_hdr = &elf_symtab_hdr (input_bfd);
5211
5212   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
5213           (size_t) input_section->size);
5214
5215   if ((input_section->flags & SEC_RELOC) != 0
5216       && input_section->reloc_count > 0)
5217     {
5218       asection **secpp;
5219       Elf_Internal_Sym *isym, *isymend;
5220       bfd_size_type amt;
5221
5222       internal_relocs = (_bfd_elf_link_read_relocs
5223                          (input_bfd, input_section, NULL,
5224                           (Elf_Internal_Rela *) NULL, FALSE));
5225       if (internal_relocs == NULL)
5226         goto error_return;
5227
5228       if (symtab_hdr->sh_info != 0)
5229         {
5230           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5231           if (isymbuf == NULL)
5232             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
5233                                             symtab_hdr->sh_info, 0,
5234                                             NULL, NULL, NULL);
5235           if (isymbuf == NULL)
5236             goto error_return;
5237         }
5238
5239       amt = symtab_hdr->sh_info;
5240       amt *= sizeof (asection *);
5241       sections = (asection **) bfd_malloc (amt);
5242       if (sections == NULL && amt != 0)
5243         goto error_return;
5244
5245       isymend = isymbuf + symtab_hdr->sh_info;
5246       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
5247         {
5248           asection *isec;
5249
5250           if (isym->st_shndx == SHN_UNDEF)
5251             isec = bfd_und_section_ptr;
5252           else if (isym->st_shndx == SHN_ABS)
5253             isec = bfd_abs_section_ptr;
5254           else if (isym->st_shndx == SHN_COMMON)
5255             isec = bfd_com_section_ptr;
5256           else
5257             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
5258
5259           *secpp = isec;
5260         }
5261
5262       if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
5263                                      input_section, data, internal_relocs,
5264                                      isymbuf, sections))
5265         goto error_return;
5266
5267       if (sections != NULL)
5268         free (sections);
5269       if (isymbuf != NULL
5270           && symtab_hdr->contents != (unsigned char *) isymbuf)
5271         free (isymbuf);
5272       if (elf_section_data (input_section)->relocs != internal_relocs)
5273         free (internal_relocs);
5274     }
5275
5276   return data;
5277
5278  error_return:
5279   if (sections != NULL)
5280     free (sections);
5281   if (isymbuf != NULL
5282       && symtab_hdr->contents != (unsigned char *) isymbuf)
5283     free (isymbuf);
5284   if (internal_relocs != NULL
5285       && elf_section_data (input_section)->relocs != internal_relocs)
5286     free (internal_relocs);
5287   return NULL;
5288 }
5289
5290 /* Return the base VMA address which should be subtracted from real addresses
5291    when resolving @dtpoff relocation.
5292    This is PT_TLS segment p_vaddr.  */
5293
5294 static bfd_vma
5295 dtpoff_base (struct bfd_link_info *info)
5296 {
5297   /* If tls_sec is NULL, we should have signalled an error already.  */
5298   if (elf_hash_table (info)->tls_sec == NULL)
5299     return 0;
5300   return elf_hash_table (info)->tls_sec->vma;
5301 }
5302
5303 /* Return the relocation value for R_SH_TLS_TPOFF32..  */
5304
5305 static bfd_vma
5306 tpoff (struct bfd_link_info *info, bfd_vma address)
5307 {
5308   /* If tls_sec is NULL, we should have signalled an error already.  */
5309   if (elf_hash_table (info)->tls_sec == NULL)
5310     return 0;
5311   /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5312      structure which has 2 pointer fields.  */
5313   return (address - elf_hash_table (info)->tls_sec->vma
5314           + align_power ((bfd_vma) 8,
5315                          elf_hash_table (info)->tls_sec->alignment_power));
5316 }
5317
5318 static asection *
5319 sh_elf_gc_mark_hook (asection *sec,
5320                      struct bfd_link_info *info,
5321                      Elf_Internal_Rela *rel,
5322                      struct elf_link_hash_entry *h,
5323                      Elf_Internal_Sym *sym)
5324 {
5325   if (h != NULL)
5326     switch (ELF32_R_TYPE (rel->r_info))
5327       {
5328       case R_SH_GNU_VTINHERIT:
5329       case R_SH_GNU_VTENTRY:
5330         return NULL;
5331       }
5332
5333   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5334 }
5335
5336 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
5337
5338 static void
5339 sh_elf_copy_indirect_symbol (struct bfd_link_info *info,
5340                              struct elf_link_hash_entry *dir,
5341                              struct elf_link_hash_entry *ind)
5342 {
5343   struct elf_sh_link_hash_entry *edir, *eind;
5344
5345   edir = (struct elf_sh_link_hash_entry *) dir;
5346   eind = (struct elf_sh_link_hash_entry *) ind;
5347
5348   if (eind->dyn_relocs != NULL)
5349     {
5350       if (edir->dyn_relocs != NULL)
5351         {
5352           struct elf_dyn_relocs **pp;
5353           struct elf_dyn_relocs *p;
5354
5355           /* Add reloc counts against the indirect sym to the direct sym
5356              list.  Merge any entries against the same section.  */
5357           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
5358             {
5359               struct elf_dyn_relocs *q;
5360
5361               for (q = edir->dyn_relocs; q != NULL; q = q->next)
5362                 if (q->sec == p->sec)
5363                   {
5364                     q->pc_count += p->pc_count;
5365                     q->count += p->count;
5366                     *pp = p->next;
5367                     break;
5368                   }
5369               if (q == NULL)
5370                 pp = &p->next;
5371             }
5372           *pp = edir->dyn_relocs;
5373         }
5374
5375       edir->dyn_relocs = eind->dyn_relocs;
5376       eind->dyn_relocs = NULL;
5377     }
5378   edir->gotplt_refcount = eind->gotplt_refcount;
5379   eind->gotplt_refcount = 0;
5380   edir->funcdesc.refcount += eind->funcdesc.refcount;
5381   eind->funcdesc.refcount = 0;
5382   edir->abs_funcdesc_refcount += eind->abs_funcdesc_refcount;
5383   eind->abs_funcdesc_refcount = 0;
5384
5385   if (ind->root.type == bfd_link_hash_indirect
5386       && dir->got.refcount <= 0)
5387     {
5388       edir->got_type = eind->got_type;
5389       eind->got_type = GOT_UNKNOWN;
5390     }
5391
5392   if (ind->root.type != bfd_link_hash_indirect
5393       && dir->dynamic_adjusted)
5394     {
5395       /* If called to transfer flags for a weakdef during processing
5396          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
5397          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
5398       if (dir->versioned != versioned_hidden)
5399         dir->ref_dynamic |= ind->ref_dynamic;
5400       dir->ref_regular |= ind->ref_regular;
5401       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
5402       dir->needs_plt |= ind->needs_plt;
5403     }
5404   else
5405     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
5406 }
5407
5408 static int
5409 sh_elf_optimized_tls_reloc (struct bfd_link_info *info, int r_type,
5410                             int is_local)
5411 {
5412   if (bfd_link_pic (info))
5413     return r_type;
5414
5415   switch (r_type)
5416     {
5417     case R_SH_TLS_GD_32:
5418     case R_SH_TLS_IE_32:
5419       if (is_local)
5420         return R_SH_TLS_LE_32;
5421       return R_SH_TLS_IE_32;
5422     case R_SH_TLS_LD_32:
5423       return R_SH_TLS_LE_32;
5424     }
5425
5426   return r_type;
5427 }
5428
5429 /* Look through the relocs for a section during the first phase.
5430    Since we don't do .gots or .plts, we just need to consider the
5431    virtual table relocs for gc.  */
5432
5433 static bfd_boolean
5434 sh_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
5435                      const Elf_Internal_Rela *relocs)
5436 {
5437   Elf_Internal_Shdr *symtab_hdr;
5438   struct elf_link_hash_entry **sym_hashes;
5439   struct elf_sh_link_hash_table *htab;
5440   const Elf_Internal_Rela *rel;
5441   const Elf_Internal_Rela *rel_end;
5442   asection *sreloc;
5443   unsigned int r_type;
5444   enum got_type got_type, old_got_type;
5445
5446   sreloc = NULL;
5447
5448   if (bfd_link_relocatable (info))
5449     return TRUE;
5450
5451   /* Don't do anything special with non-loaded, non-alloced sections.
5452      In particular, any relocs in such sections should not affect GOT
5453      and PLT reference counting (ie. we don't allow them to create GOT
5454      or PLT entries), there's no possibility or desire to optimize TLS
5455      relocs, and there's not much point in propagating relocs to shared
5456      libs that the dynamic linker won't relocate.  */
5457   if ((sec->flags & SEC_ALLOC) == 0)
5458     return TRUE;
5459
5460   BFD_ASSERT (is_sh_elf (abfd));
5461
5462   symtab_hdr = &elf_symtab_hdr (abfd);
5463   sym_hashes = elf_sym_hashes (abfd);
5464
5465   htab = sh_elf_hash_table (info);
5466   if (htab == NULL)
5467     return FALSE;
5468
5469   rel_end = relocs + sec->reloc_count;
5470   for (rel = relocs; rel < rel_end; rel++)
5471     {
5472       struct elf_link_hash_entry *h;
5473       unsigned long r_symndx;
5474
5475       r_symndx = ELF32_R_SYM (rel->r_info);
5476       r_type = ELF32_R_TYPE (rel->r_info);
5477
5478       if (r_symndx < symtab_hdr->sh_info)
5479         h = NULL;
5480       else
5481         {
5482           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5483           while (h->root.type == bfd_link_hash_indirect
5484                  || h->root.type == bfd_link_hash_warning)
5485             h = (struct elf_link_hash_entry *) h->root.u.i.link;
5486         }
5487
5488       r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
5489       if (! bfd_link_pic (info)
5490           && r_type == R_SH_TLS_IE_32
5491           && h != NULL
5492           && h->root.type != bfd_link_hash_undefined
5493           && h->root.type != bfd_link_hash_undefweak
5494           && (h->dynindx == -1
5495               || h->def_regular))
5496         r_type = R_SH_TLS_LE_32;
5497
5498       if (htab->fdpic_p)
5499         switch (r_type)
5500           {
5501           case R_SH_GOTOFFFUNCDESC:
5502           case R_SH_GOTOFFFUNCDESC20:
5503           case R_SH_FUNCDESC:
5504           case R_SH_GOTFUNCDESC:
5505           case R_SH_GOTFUNCDESC20:
5506             if (h != NULL)
5507               {
5508                 if (h->dynindx == -1)
5509                   switch (ELF_ST_VISIBILITY (h->other))
5510                     {
5511                     case STV_INTERNAL:
5512                     case STV_HIDDEN:
5513                       break;
5514                     default:
5515                       bfd_elf_link_record_dynamic_symbol (info, h);
5516                       break;
5517                     }
5518               }
5519             break;
5520           }
5521
5522       /* Some relocs require a global offset table.  */
5523       if (htab->root.sgot == NULL)
5524         {
5525           switch (r_type)
5526             {
5527             case R_SH_DIR32:
5528               /* This may require an rofixup.  */
5529               if (!htab->fdpic_p)
5530                 break;
5531               /* Fall through.  */
5532             case R_SH_GOTPLT32:
5533             case R_SH_GOT32:
5534             case R_SH_GOT20:
5535             case R_SH_GOTOFF:
5536             case R_SH_GOTOFF20:
5537             case R_SH_FUNCDESC:
5538             case R_SH_GOTFUNCDESC:
5539             case R_SH_GOTFUNCDESC20:
5540             case R_SH_GOTOFFFUNCDESC:
5541             case R_SH_GOTOFFFUNCDESC20:
5542             case R_SH_GOTPC:
5543             case R_SH_TLS_GD_32:
5544             case R_SH_TLS_LD_32:
5545             case R_SH_TLS_IE_32:
5546               if (htab->root.dynobj == NULL)
5547                 htab->root.dynobj = abfd;
5548               if (!create_got_section (htab->root.dynobj, info))
5549                 return FALSE;
5550               break;
5551
5552             default:
5553               break;
5554             }
5555         }
5556
5557       switch (r_type)
5558         {
5559           /* This relocation describes the C++ object vtable hierarchy.
5560              Reconstruct it for later use during GC.  */
5561         case R_SH_GNU_VTINHERIT:
5562           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5563             return FALSE;
5564           break;
5565
5566           /* This relocation describes which C++ vtable entries are actually
5567              used.  Record for later use during GC.  */
5568         case R_SH_GNU_VTENTRY:
5569           BFD_ASSERT (h != NULL);
5570           if (h != NULL
5571               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5572             return FALSE;
5573           break;
5574
5575         case R_SH_TLS_IE_32:
5576           if (bfd_link_pic (info))
5577             info->flags |= DF_STATIC_TLS;
5578
5579           /* FALLTHROUGH */
5580         force_got:
5581         case R_SH_TLS_GD_32:
5582         case R_SH_GOT32:
5583         case R_SH_GOT20:
5584         case R_SH_GOTFUNCDESC:
5585         case R_SH_GOTFUNCDESC20:
5586           switch (r_type)
5587             {
5588             default:
5589               got_type = GOT_NORMAL;
5590               break;
5591             case R_SH_TLS_GD_32:
5592               got_type = GOT_TLS_GD;
5593               break;
5594             case R_SH_TLS_IE_32:
5595               got_type = GOT_TLS_IE;
5596               break;
5597             case R_SH_GOTFUNCDESC:
5598             case R_SH_GOTFUNCDESC20:
5599               got_type = GOT_FUNCDESC;
5600               break;
5601             }
5602
5603           if (h != NULL)
5604             {
5605               h->got.refcount += 1;
5606               old_got_type = sh_elf_hash_entry (h)->got_type;
5607             }
5608           else
5609             {
5610               bfd_signed_vma *local_got_refcounts;
5611
5612               /* This is a global offset table entry for a local
5613                  symbol.  */
5614               local_got_refcounts = elf_local_got_refcounts (abfd);
5615               if (local_got_refcounts == NULL)
5616                 {
5617                   bfd_size_type size;
5618
5619                   size = symtab_hdr->sh_info;
5620                   size *= sizeof (bfd_signed_vma);
5621                   size += symtab_hdr->sh_info;
5622                   local_got_refcounts = ((bfd_signed_vma *)
5623                                          bfd_zalloc (abfd, size));
5624                   if (local_got_refcounts == NULL)
5625                     return FALSE;
5626                   elf_local_got_refcounts (abfd) = local_got_refcounts;
5627                   sh_elf_local_got_type (abfd)
5628                     = (char *) (local_got_refcounts + symtab_hdr->sh_info);
5629                 }
5630               local_got_refcounts[r_symndx] += 1;
5631               old_got_type = sh_elf_local_got_type (abfd) [r_symndx];
5632             }
5633
5634           /* If a TLS symbol is accessed using IE at least once,
5635              there is no point to use dynamic model for it.  */
5636           if (old_got_type != got_type && old_got_type != GOT_UNKNOWN
5637               && (old_got_type != GOT_TLS_GD || got_type != GOT_TLS_IE))
5638             {
5639               if (old_got_type == GOT_TLS_IE && got_type == GOT_TLS_GD)
5640                 got_type = GOT_TLS_IE;
5641               else
5642                 {
5643                   if ((old_got_type == GOT_FUNCDESC || got_type == GOT_FUNCDESC)
5644                       && (old_got_type == GOT_NORMAL || got_type == GOT_NORMAL))
5645                     _bfd_error_handler
5646                       /* xgettext:c-format */
5647                       (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
5648                        abfd, h->root.root.string);
5649                   else if (old_got_type == GOT_FUNCDESC
5650                            || got_type == GOT_FUNCDESC)
5651                     _bfd_error_handler
5652                       /* xgettext:c-format */
5653                       (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
5654                        abfd, h->root.root.string);
5655                   else
5656                     _bfd_error_handler
5657                       /* xgettext:c-format */
5658                       (_("%pB: `%s' accessed both as normal and thread local symbol"),
5659                        abfd, h->root.root.string);
5660                   return FALSE;
5661                 }
5662             }
5663
5664           if (old_got_type != got_type)
5665             {
5666               if (h != NULL)
5667                 sh_elf_hash_entry (h)->got_type = got_type;
5668               else
5669                 sh_elf_local_got_type (abfd) [r_symndx] = got_type;
5670             }
5671
5672           break;
5673
5674         case R_SH_TLS_LD_32:
5675           sh_elf_hash_table(info)->tls_ldm_got.refcount += 1;
5676           break;
5677
5678         case R_SH_FUNCDESC:
5679         case R_SH_GOTOFFFUNCDESC:
5680         case R_SH_GOTOFFFUNCDESC20:
5681           if (rel->r_addend)
5682             {
5683               _bfd_error_handler
5684                 (_("%pB: Function descriptor relocation with non-zero addend"),
5685                  abfd);
5686               return FALSE;
5687             }
5688
5689           if (h == NULL)
5690             {
5691               union gotref *local_funcdesc;
5692
5693               /* We need a function descriptor for a local symbol.  */
5694               local_funcdesc = sh_elf_local_funcdesc (abfd);
5695               if (local_funcdesc == NULL)
5696                 {
5697                   bfd_size_type size;
5698
5699                   size = symtab_hdr->sh_info * sizeof (union gotref);
5700                   local_funcdesc = (union gotref *) bfd_zalloc (abfd, size);
5701                   if (local_funcdesc == NULL)
5702                     return FALSE;
5703                   sh_elf_local_funcdesc (abfd) = local_funcdesc;
5704                 }
5705               local_funcdesc[r_symndx].refcount += 1;
5706
5707               if (r_type == R_SH_FUNCDESC)
5708                 {
5709                   if (!bfd_link_pic (info))
5710                     htab->srofixup->size += 4;
5711                   else
5712                     htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5713                 }
5714             }
5715           else
5716             {
5717               sh_elf_hash_entry (h)->funcdesc.refcount++;
5718               if (r_type == R_SH_FUNCDESC)
5719                 sh_elf_hash_entry (h)->abs_funcdesc_refcount++;
5720
5721               /* If there is a function descriptor reference, then
5722                  there should not be any non-FDPIC references.  */
5723               old_got_type = sh_elf_hash_entry (h)->got_type;
5724               if (old_got_type != GOT_FUNCDESC && old_got_type != GOT_UNKNOWN)
5725                 {
5726                   if (old_got_type == GOT_NORMAL)
5727                     _bfd_error_handler
5728                       /* xgettext:c-format */
5729                       (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
5730                        abfd, h->root.root.string);
5731                   else
5732                     _bfd_error_handler
5733                       /* xgettext:c-format */
5734                       (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
5735                        abfd, h->root.root.string);
5736                 }
5737             }
5738           break;
5739
5740         case R_SH_GOTPLT32:
5741           /* If this is a local symbol, we resolve it directly without
5742              creating a procedure linkage table entry.  */
5743
5744           if (h == NULL
5745               || h->forced_local
5746               || ! bfd_link_pic (info)
5747               || info->symbolic
5748               || h->dynindx == -1)
5749             goto force_got;
5750
5751           h->needs_plt = 1;
5752           h->plt.refcount += 1;
5753           ((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1;
5754
5755           break;
5756
5757         case R_SH_PLT32:
5758           /* This symbol requires a procedure linkage table entry.  We
5759              actually build the entry in adjust_dynamic_symbol,
5760              because this might be a case of linking PIC code which is
5761              never referenced by a dynamic object, in which case we
5762              don't need to generate a procedure linkage table entry
5763              after all.  */
5764
5765           /* If this is a local symbol, we resolve it directly without
5766              creating a procedure linkage table entry.  */
5767           if (h == NULL)
5768             continue;
5769
5770           if (h->forced_local)
5771             break;
5772
5773           h->needs_plt = 1;
5774           h->plt.refcount += 1;
5775           break;
5776
5777         case R_SH_DIR32:
5778         case R_SH_REL32:
5779           if (h != NULL && ! bfd_link_pic (info))
5780             {
5781               h->non_got_ref = 1;
5782               h->plt.refcount += 1;
5783             }
5784
5785           /* If we are creating a shared library, and this is a reloc
5786              against a global symbol, or a non PC relative reloc
5787              against a local symbol, then we need to copy the reloc
5788              into the shared library.  However, if we are linking with
5789              -Bsymbolic, we do not need to copy a reloc against a
5790              global symbol which is defined in an object we are
5791              including in the link (i.e., DEF_REGULAR is set).  At
5792              this point we have not seen all the input files, so it is
5793              possible that DEF_REGULAR is not set now but will be set
5794              later (it is never cleared).  We account for that
5795              possibility below by storing information in the
5796              dyn_relocs field of the hash table entry. A similar
5797              situation occurs when creating shared libraries and symbol
5798              visibility changes render the symbol local.
5799
5800              If on the other hand, we are creating an executable, we
5801              may need to keep relocations for symbols satisfied by a
5802              dynamic library if we manage to avoid copy relocs for the
5803              symbol.  */
5804           if ((bfd_link_pic (info)
5805                && (sec->flags & SEC_ALLOC) != 0
5806                && (r_type != R_SH_REL32
5807                    || (h != NULL
5808                        && (! info->symbolic
5809                            || h->root.type == bfd_link_hash_defweak
5810                            || !h->def_regular))))
5811               || (! bfd_link_pic (info)
5812                   && (sec->flags & SEC_ALLOC) != 0
5813                   && h != NULL
5814                   && (h->root.type == bfd_link_hash_defweak
5815                       || !h->def_regular)))
5816             {
5817               struct elf_dyn_relocs *p;
5818               struct elf_dyn_relocs **head;
5819
5820               if (htab->root.dynobj == NULL)
5821                 htab->root.dynobj = abfd;
5822
5823               /* When creating a shared object, we must copy these
5824                  reloc types into the output file.  We create a reloc
5825                  section in dynobj and make room for this reloc.  */
5826               if (sreloc == NULL)
5827                 {
5828                   sreloc = _bfd_elf_make_dynamic_reloc_section
5829                     (sec, htab->root.dynobj, 2, abfd, /*rela?*/ TRUE);
5830
5831                   if (sreloc == NULL)
5832                     return FALSE;
5833                 }
5834
5835               /* If this is a global symbol, we count the number of
5836                  relocations we need for this symbol.  */
5837               if (h != NULL)
5838                 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
5839               else
5840                 {
5841                   /* Track dynamic relocs needed for local syms too.  */
5842                   asection *s;
5843                   void *vpp;
5844                   Elf_Internal_Sym *isym;
5845
5846                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5847                                                 abfd, r_symndx);
5848                   if (isym == NULL)
5849                     return FALSE;
5850
5851                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5852                   if (s == NULL)
5853                     s = sec;
5854
5855                   vpp = &elf_section_data (s)->local_dynrel;
5856                   head = (struct elf_dyn_relocs **) vpp;
5857                 }
5858
5859               p = *head;
5860               if (p == NULL || p->sec != sec)
5861                 {
5862                   bfd_size_type amt = sizeof (*p);
5863                   p = bfd_alloc (htab->root.dynobj, amt);
5864                   if (p == NULL)
5865                     return FALSE;
5866                   p->next = *head;
5867                   *head = p;
5868                   p->sec = sec;
5869                   p->count = 0;
5870                   p->pc_count = 0;
5871                 }
5872
5873               p->count += 1;
5874               if (r_type == R_SH_REL32)
5875                 p->pc_count += 1;
5876             }
5877
5878           /* Allocate the fixup regardless of whether we need a relocation.
5879              If we end up generating the relocation, we'll unallocate the
5880              fixup.  */
5881           if (htab->fdpic_p && !bfd_link_pic (info)
5882               && r_type == R_SH_DIR32
5883               && (sec->flags & SEC_ALLOC) != 0)
5884             htab->srofixup->size += 4;
5885           break;
5886
5887         case R_SH_TLS_LE_32:
5888           if (bfd_link_dll (info))
5889             {
5890               _bfd_error_handler
5891                 (_("%pB: TLS local exec code cannot be linked into shared objects"),
5892                  abfd);
5893               return FALSE;
5894             }
5895
5896           break;
5897
5898         case R_SH_TLS_LDO_32:
5899           /* Nothing to do.  */
5900           break;
5901
5902         default:
5903           break;
5904         }
5905     }
5906
5907   return TRUE;
5908 }
5909
5910 #ifndef sh_elf_set_mach_from_flags
5911 static unsigned int sh_ef_bfd_table[] = { EF_SH_BFD_TABLE };
5912
5913 static bfd_boolean
5914 sh_elf_set_mach_from_flags (bfd *abfd)
5915 {
5916   flagword flags = elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK;
5917
5918   if (flags >= ARRAY_SIZE (sh_ef_bfd_table))
5919     return FALSE;
5920
5921   if (sh_ef_bfd_table[flags] == 0)
5922     return FALSE;
5923
5924   bfd_default_set_arch_mach (abfd, bfd_arch_sh, sh_ef_bfd_table[flags]);
5925
5926   return TRUE;
5927 }
5928
5929
5930 /* Reverse table lookup for sh_ef_bfd_table[].
5931    Given a bfd MACH value from archures.c
5932    return the equivalent ELF flags from the table.
5933    Return -1 if no match is found.  */
5934
5935 int
5936 sh_elf_get_flags_from_mach (unsigned long mach)
5937 {
5938   int i = ARRAY_SIZE (sh_ef_bfd_table) - 1;
5939
5940   for (; i>0; i--)
5941     if (sh_ef_bfd_table[i] == mach)
5942       return i;
5943
5944   /* shouldn't get here */
5945   BFD_FAIL();
5946
5947   return -1;
5948 }
5949 #endif /* not sh_elf_set_mach_from_flags */
5950
5951 #ifndef sh_elf_copy_private_data
5952 /* Copy backend specific data from one object module to another */
5953
5954 static bfd_boolean
5955 sh_elf_copy_private_data (bfd * ibfd, bfd * obfd)
5956 {
5957   if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
5958     return TRUE;
5959
5960   if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
5961     return FALSE;
5962
5963   return sh_elf_set_mach_from_flags (obfd);
5964 }
5965 #endif /* not sh_elf_copy_private_data */
5966
5967 #ifndef sh_elf_merge_private_data
5968
5969 /* This function returns the ELF architecture number that
5970    corresponds to the given arch_sh* flags.  */
5971
5972 int
5973 sh_find_elf_flags (unsigned int arch_set)
5974 {
5975   extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int);
5976   unsigned long bfd_mach = sh_get_bfd_mach_from_arch_set (arch_set);
5977
5978   return sh_elf_get_flags_from_mach (bfd_mach);
5979 }
5980
5981 /* Merge the architecture type of two BFD files, such that the
5982    resultant architecture supports all the features required
5983    by the two input BFDs.
5984    If the input BFDs are multually incompatible - i.e. one uses
5985    DSP while the other uses FPU - or there is no known architecture
5986    that fits the requirements then an error is emitted.  */
5987
5988 static bfd_boolean
5989 sh_merge_bfd_arch (bfd *ibfd, struct bfd_link_info *info)
5990 {
5991   bfd *obfd = info->output_bfd;
5992   unsigned int old_arch, new_arch, merged_arch;
5993
5994   if (! _bfd_generic_verify_endian_match (ibfd, info))
5995     return FALSE;
5996
5997   old_arch = sh_get_arch_up_from_bfd_mach (bfd_get_mach (obfd));
5998   new_arch = sh_get_arch_up_from_bfd_mach (bfd_get_mach (ibfd));
5999
6000   merged_arch = SH_MERGE_ARCH_SET (old_arch, new_arch);
6001
6002   if (!SH_VALID_CO_ARCH_SET (merged_arch))
6003     {
6004       _bfd_error_handler
6005         /* xgettext:c-format */
6006         (_("%pB: uses %s instructions while previous modules "
6007            "use %s instructions"),
6008          ibfd,
6009          SH_ARCH_SET_HAS_DSP (new_arch) ? "dsp" : "floating point",
6010          SH_ARCH_SET_HAS_DSP (new_arch) ? "floating point" : "dsp");
6011       bfd_set_error (bfd_error_bad_value);
6012       return FALSE;
6013     }
6014   else if (!SH_VALID_ARCH_SET (merged_arch))
6015     {
6016       _bfd_error_handler
6017         /* xgettext:c-format */
6018         (_("internal error: merge of architecture '%s' with "
6019            "architecture '%s' produced unknown architecture"),
6020          bfd_printable_name (obfd),
6021          bfd_printable_name (ibfd));
6022       bfd_set_error (bfd_error_bad_value);
6023       return FALSE;
6024     }
6025
6026   bfd_default_set_arch_mach (obfd, bfd_arch_sh,
6027                              sh_get_bfd_mach_from_arch_set (merged_arch));
6028
6029   return TRUE;
6030 }
6031
6032 /* This routine initialises the elf flags when required and
6033    calls sh_merge_bfd_arch() to check dsp/fpu compatibility.  */
6034
6035 static bfd_boolean
6036 sh_elf_merge_private_data (bfd *ibfd, struct bfd_link_info *info)
6037 {
6038   bfd *obfd = info->output_bfd;
6039
6040   if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
6041     return TRUE;
6042
6043   if (! elf_flags_init (obfd))
6044     {
6045       /* This happens when ld starts out with a 'blank' output file.  */
6046       elf_flags_init (obfd) = TRUE;
6047       elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6048       sh_elf_set_mach_from_flags (obfd);
6049       if (elf_elfheader (obfd)->e_flags & EF_SH_FDPIC)
6050         elf_elfheader (obfd)->e_flags &= ~EF_SH_PIC;
6051     }
6052
6053   if (! sh_merge_bfd_arch (ibfd, info))
6054     {
6055       _bfd_error_handler (_("%pB: uses instructions which are incompatible "
6056                             "with instructions used in previous modules"),
6057                           ibfd);
6058       bfd_set_error (bfd_error_bad_value);
6059       return FALSE;
6060     }
6061
6062   elf_elfheader (obfd)->e_flags &= ~EF_SH_MACH_MASK;
6063   elf_elfheader (obfd)->e_flags |=
6064     sh_elf_get_flags_from_mach (bfd_get_mach (obfd));
6065
6066   if (fdpic_object_p (ibfd) != fdpic_object_p (obfd))
6067     {
6068       _bfd_error_handler (_("%pB: attempt to mix FDPIC and non-FDPIC objects"),
6069                           ibfd);
6070       bfd_set_error (bfd_error_bad_value);
6071       return FALSE;
6072     }
6073
6074   return TRUE;
6075 }
6076 #endif /* not sh_elf_merge_private_data */
6077
6078 /* Override the generic function because we need to store sh_elf_obj_tdata
6079    as the specific tdata.  We set also the machine architecture from flags
6080    here.  */
6081
6082 static bfd_boolean
6083 sh_elf_object_p (bfd *abfd)
6084 {
6085   if (! sh_elf_set_mach_from_flags (abfd))
6086     return FALSE;
6087
6088   return (((elf_elfheader (abfd)->e_flags & EF_SH_FDPIC) != 0)
6089           == fdpic_object_p (abfd));
6090 }
6091
6092 /* Finish up dynamic symbol handling.  We set the contents of various
6093    dynamic sections here.  */
6094
6095 static bfd_boolean
6096 sh_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
6097                               struct elf_link_hash_entry *h,
6098                               Elf_Internal_Sym *sym)
6099 {
6100   struct elf_sh_link_hash_table *htab;
6101
6102   htab = sh_elf_hash_table (info);
6103   if (htab == NULL)
6104     return FALSE;
6105
6106   if (h->plt.offset != (bfd_vma) -1)
6107     {
6108       asection *splt;
6109       asection *sgotplt;
6110       asection *srelplt;
6111
6112       bfd_vma plt_index;
6113       bfd_vma got_offset;
6114       Elf_Internal_Rela rel;
6115       bfd_byte *loc;
6116       const struct elf_sh_plt_info *plt_info;
6117
6118       /* This symbol has an entry in the procedure linkage table.  Set
6119          it up.  */
6120
6121       BFD_ASSERT (h->dynindx != -1);
6122
6123       splt = htab->root.splt;
6124       sgotplt = htab->root.sgotplt;
6125       srelplt = htab->root.srelplt;
6126       BFD_ASSERT (splt != NULL && sgotplt != NULL && srelplt != NULL);
6127
6128       /* Get the index in the procedure linkage table which
6129          corresponds to this symbol.  This is the index of this symbol
6130          in all the symbols for which we are making plt entries.  The
6131          first entry in the procedure linkage table is reserved.  */
6132       plt_index = get_plt_index (htab->plt_info, h->plt.offset);
6133
6134       plt_info = htab->plt_info;
6135       if (plt_info->short_plt != NULL && plt_index <= MAX_SHORT_PLT)
6136         plt_info = plt_info->short_plt;
6137
6138       /* Get the offset into the .got table of the entry that
6139          corresponds to this function.  */
6140       if (htab->fdpic_p)
6141         /* The offset must be relative to the GOT symbol, twelve bytes
6142            before the end of .got.plt.  Each descriptor is eight
6143            bytes.  */
6144         got_offset = plt_index * 8 + 12 - sgotplt->size;
6145       else
6146         /* Each .got entry is 4 bytes.  The first three are
6147            reserved.  */
6148         got_offset = (plt_index + 3) * 4;
6149
6150 #ifdef GOT_BIAS
6151       if (bfd_link_pic (info))
6152         got_offset -= GOT_BIAS;
6153 #endif
6154
6155       /* Fill in the entry in the procedure linkage table.  */
6156       memcpy (splt->contents + h->plt.offset,
6157               plt_info->symbol_entry,
6158               plt_info->symbol_entry_size);
6159
6160       if (bfd_link_pic (info) || htab->fdpic_p)
6161         {
6162           if (plt_info->symbol_fields.got20)
6163             {
6164               bfd_reloc_status_type r;
6165               r = install_movi20_field (output_bfd, got_offset,
6166                                         splt->owner, splt, splt->contents,
6167                                         h->plt.offset
6168                                         + plt_info->symbol_fields.got_entry);
6169               BFD_ASSERT (r == bfd_reloc_ok);
6170             }
6171           else
6172             install_plt_field (output_bfd, FALSE, got_offset,
6173                                (splt->contents
6174                                 + h->plt.offset
6175                                 + plt_info->symbol_fields.got_entry));
6176         }
6177       else
6178         {
6179           BFD_ASSERT (!plt_info->symbol_fields.got20);
6180
6181           install_plt_field (output_bfd, FALSE,
6182                              (sgotplt->output_section->vma
6183                               + sgotplt->output_offset
6184                               + got_offset),
6185                              (splt->contents
6186                               + h->plt.offset
6187                               + plt_info->symbol_fields.got_entry));
6188           if (htab->vxworks_p)
6189             {
6190               unsigned int reachable_plts, plts_per_4k;
6191               int distance;
6192
6193               /* Divide the PLT into groups.  The first group contains
6194                  REACHABLE_PLTS entries and the other groups contain
6195                  PLTS_PER_4K entries.  Entries in the first group can
6196                  branch directly to .plt; those in later groups branch
6197                  to the last element of the previous group.  */
6198               /* ??? It would be better to create multiple copies of
6199                  the common resolver stub.  */
6200               reachable_plts = ((4096
6201                                  - plt_info->plt0_entry_size
6202                                  - (plt_info->symbol_fields.plt + 4))
6203                                 / plt_info->symbol_entry_size) + 1;
6204               plts_per_4k = (4096 / plt_info->symbol_entry_size);
6205               if (plt_index < reachable_plts)
6206                 distance = -(h->plt.offset
6207                              + plt_info->symbol_fields.plt);
6208               else
6209                 distance = -(((plt_index - reachable_plts) % plts_per_4k + 1)
6210                              * plt_info->symbol_entry_size);
6211
6212               /* Install the 'bra' with this offset.  */
6213               bfd_put_16 (output_bfd,
6214                           0xa000 | (0x0fff & ((distance - 4) / 2)),
6215                           (splt->contents
6216                            + h->plt.offset
6217                            + plt_info->symbol_fields.plt));
6218             }
6219           else
6220             install_plt_field (output_bfd, TRUE,
6221                                splt->output_section->vma + splt->output_offset,
6222                                (splt->contents
6223                                 + h->plt.offset
6224                                 + plt_info->symbol_fields.plt));
6225         }
6226
6227       /* Make got_offset relative to the start of .got.plt.  */
6228 #ifdef GOT_BIAS
6229       if (bfd_link_pic (info))
6230         got_offset += GOT_BIAS;
6231 #endif
6232       if (htab->fdpic_p)
6233         got_offset = plt_index * 8;
6234
6235       if (plt_info->symbol_fields.reloc_offset != MINUS_ONE)
6236         install_plt_field (output_bfd, FALSE,
6237                            plt_index * sizeof (Elf32_External_Rela),
6238                            (splt->contents
6239                             + h->plt.offset
6240                             + plt_info->symbol_fields.reloc_offset));
6241
6242       /* Fill in the entry in the global offset table.  */
6243       bfd_put_32 (output_bfd,
6244                   (splt->output_section->vma
6245                    + splt->output_offset
6246                    + h->plt.offset
6247                    + plt_info->symbol_resolve_offset),
6248                   sgotplt->contents + got_offset);
6249       if (htab->fdpic_p)
6250         bfd_put_32 (output_bfd,
6251                     sh_elf_osec_to_segment (output_bfd, splt->output_section),
6252                     sgotplt->contents + got_offset + 4);
6253
6254       /* Fill in the entry in the .rela.plt section.  */
6255       rel.r_offset = (sgotplt->output_section->vma
6256                       + sgotplt->output_offset
6257                       + got_offset);
6258       if (htab->fdpic_p)
6259         rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_FUNCDESC_VALUE);
6260       else
6261         rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
6262       rel.r_addend = 0;
6263 #ifdef GOT_BIAS
6264       rel.r_addend = GOT_BIAS;
6265 #endif
6266       loc = srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
6267       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6268
6269       if (htab->vxworks_p && !bfd_link_pic (info))
6270         {
6271           /* Create the .rela.plt.unloaded relocations for this PLT entry.
6272              Begin by pointing LOC to the first such relocation.  */
6273           loc = (htab->srelplt2->contents
6274                  + (plt_index * 2 + 1) * sizeof (Elf32_External_Rela));
6275
6276           /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
6277              for the PLT entry's pointer to the .got.plt entry.  */
6278           rel.r_offset = (splt->output_section->vma
6279                           + splt->output_offset
6280                           + h->plt.offset
6281                           + plt_info->symbol_fields.got_entry);
6282           rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32);
6283           rel.r_addend = got_offset;
6284           bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6285           loc += sizeof (Elf32_External_Rela);
6286
6287           /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
6288              the .got.plt entry, which initially points to .plt.  */
6289           rel.r_offset = (sgotplt->output_section->vma
6290                           + sgotplt->output_offset
6291                           + got_offset);
6292           rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_SH_DIR32);
6293           rel.r_addend = 0;
6294           bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6295         }
6296
6297       if (!h->def_regular)
6298         {
6299           /* Mark the symbol as undefined, rather than as defined in
6300              the .plt section.  Leave the value alone.  */
6301           sym->st_shndx = SHN_UNDEF;
6302         }
6303     }
6304
6305   if (h->got.offset != (bfd_vma) -1
6306       && sh_elf_hash_entry (h)->got_type != GOT_TLS_GD
6307       && sh_elf_hash_entry (h)->got_type != GOT_TLS_IE
6308       && sh_elf_hash_entry (h)->got_type != GOT_FUNCDESC)
6309     {
6310       asection *sgot;
6311       asection *srelgot;
6312       Elf_Internal_Rela rel;
6313       bfd_byte *loc;
6314
6315       /* This symbol has an entry in the global offset table.  Set it
6316          up.  */
6317
6318       sgot = htab->root.sgot;
6319       srelgot = htab->root.srelgot;
6320       BFD_ASSERT (sgot != NULL && srelgot != NULL);
6321
6322       rel.r_offset = (sgot->output_section->vma
6323                       + sgot->output_offset
6324                       + (h->got.offset &~ (bfd_vma) 1));
6325
6326       /* If this is a static link, or it is a -Bsymbolic link and the
6327          symbol is defined locally or was forced to be local because
6328          of a version file, we just want to emit a RELATIVE reloc.
6329          The entry in the global offset table will already have been
6330          initialized in the relocate_section function.  */
6331       if (bfd_link_pic (info)
6332           && SYMBOL_REFERENCES_LOCAL (info, h))
6333         {
6334           if (htab->fdpic_p)
6335             {
6336               asection *sec = h->root.u.def.section;
6337               int dynindx
6338                 = elf_section_data (sec->output_section)->dynindx;
6339
6340               rel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
6341               rel.r_addend = (h->root.u.def.value
6342                               + h->root.u.def.section->output_offset);
6343             }
6344           else
6345             {
6346               rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
6347               rel.r_addend = (h->root.u.def.value
6348                               + h->root.u.def.section->output_section->vma
6349                               + h->root.u.def.section->output_offset);
6350             }
6351         }
6352       else
6353         {
6354           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
6355           rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
6356           rel.r_addend = 0;
6357         }
6358
6359       loc = srelgot->contents;
6360       loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
6361       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6362     }
6363
6364   if (h->needs_copy)
6365     {
6366       asection *s;
6367       Elf_Internal_Rela rel;
6368       bfd_byte *loc;
6369
6370       /* This symbol needs a copy reloc.  Set it up.  */
6371
6372       BFD_ASSERT (h->dynindx != -1
6373                   && (h->root.type == bfd_link_hash_defined
6374                       || h->root.type == bfd_link_hash_defweak));
6375
6376       s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
6377       BFD_ASSERT (s != NULL);
6378
6379       rel.r_offset = (h->root.u.def.value
6380                       + h->root.u.def.section->output_section->vma
6381                       + h->root.u.def.section->output_offset);
6382       rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
6383       rel.r_addend = 0;
6384       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
6385       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6386     }
6387
6388   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  On VxWorks,
6389      _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
6390      ".got" section.  */
6391   if (h == htab->root.hdynamic
6392       || (!htab->vxworks_p && h == htab->root.hgot))
6393     sym->st_shndx = SHN_ABS;
6394
6395   return TRUE;
6396 }
6397
6398 /* Finish up the dynamic sections.  */
6399
6400 static bfd_boolean
6401 sh_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
6402 {
6403   struct elf_sh_link_hash_table *htab;
6404   asection *sgotplt;
6405   asection *sdyn;
6406
6407   htab = sh_elf_hash_table (info);
6408   if (htab == NULL)
6409     return FALSE;
6410
6411   sgotplt = htab->root.sgotplt;
6412   sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic");
6413
6414   if (htab->root.dynamic_sections_created)
6415     {
6416       asection *splt;
6417       Elf32_External_Dyn *dyncon, *dynconend;
6418
6419       BFD_ASSERT (sgotplt != NULL && sdyn != NULL);
6420
6421       dyncon = (Elf32_External_Dyn *) sdyn->contents;
6422       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
6423       for (; dyncon < dynconend; dyncon++)
6424         {
6425           Elf_Internal_Dyn dyn;
6426           asection *s;
6427
6428           bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn);
6429
6430           switch (dyn.d_tag)
6431             {
6432             default:
6433               if (htab->vxworks_p
6434                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
6435                 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6436               break;
6437
6438             case DT_PLTGOT:
6439               BFD_ASSERT (htab->root.hgot != NULL);
6440               s = htab->root.hgot->root.u.def.section;
6441               dyn.d_un.d_ptr = htab->root.hgot->root.u.def.value
6442                 + s->output_section->vma + s->output_offset;
6443               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6444               break;
6445
6446             case DT_JMPREL:
6447               s = htab->root.srelplt->output_section;
6448               BFD_ASSERT (s != NULL);
6449               dyn.d_un.d_ptr = s->vma;
6450               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6451               break;
6452
6453             case DT_PLTRELSZ:
6454               s = htab->root.srelplt->output_section;
6455               BFD_ASSERT (s != NULL);
6456               dyn.d_un.d_val = s->size;
6457               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6458               break;
6459             }
6460         }
6461
6462       /* Fill in the first entry in the procedure linkage table.  */
6463       splt = htab->root.splt;
6464       if (splt && splt->size > 0 && htab->plt_info->plt0_entry)
6465         {
6466           unsigned int i;
6467
6468           memcpy (splt->contents,
6469                   htab->plt_info->plt0_entry,
6470                   htab->plt_info->plt0_entry_size);
6471           for (i = 0; i < ARRAY_SIZE (htab->plt_info->plt0_got_fields); i++)
6472             if (htab->plt_info->plt0_got_fields[i] != MINUS_ONE)
6473               install_plt_field (output_bfd, FALSE,
6474                                  (sgotplt->output_section->vma
6475                                   + sgotplt->output_offset
6476                                   + (i * 4)),
6477                                  (splt->contents
6478                                   + htab->plt_info->plt0_got_fields[i]));
6479
6480           if (htab->vxworks_p)
6481             {
6482               /* Finalize the .rela.plt.unloaded contents.  */
6483               Elf_Internal_Rela rel;
6484               bfd_byte *loc;
6485
6486               /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
6487                  first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8.  */
6488               loc = htab->srelplt2->contents;
6489               rel.r_offset = (splt->output_section->vma
6490                               + splt->output_offset
6491                               + htab->plt_info->plt0_got_fields[2]);
6492               rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32);
6493               rel.r_addend = 8;
6494               bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6495               loc += sizeof (Elf32_External_Rela);
6496
6497               /* Fix up the remaining .rela.plt.unloaded relocations.
6498                  They may have the wrong symbol index for _G_O_T_ or
6499                  _P_L_T_ depending on the order in which symbols were
6500                  output.  */
6501               while (loc < htab->srelplt2->contents + htab->srelplt2->size)
6502                 {
6503                   /* The PLT entry's pointer to the .got.plt slot.  */
6504                   bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
6505                   rel.r_info = ELF32_R_INFO (htab->root.hgot->indx,
6506                                              R_SH_DIR32);
6507                   bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6508                   loc += sizeof (Elf32_External_Rela);
6509
6510                   /* The .got.plt slot's pointer to .plt.  */
6511                   bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
6512                   rel.r_info = ELF32_R_INFO (htab->root.hplt->indx,
6513                                              R_SH_DIR32);
6514                   bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6515                   loc += sizeof (Elf32_External_Rela);
6516                 }
6517             }
6518
6519           /* UnixWare sets the entsize of .plt to 4, although that doesn't
6520              really seem like the right value.  */
6521           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
6522         }
6523     }
6524
6525   /* Fill in the first three entries in the global offset table.  */
6526   if (sgotplt && sgotplt->size > 0 && !htab->fdpic_p)
6527     {
6528       if (sdyn == NULL)
6529         bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
6530       else
6531         bfd_put_32 (output_bfd,
6532                     sdyn->output_section->vma + sdyn->output_offset,
6533                     sgotplt->contents);
6534       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
6535       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
6536     }
6537
6538   if (sgotplt && sgotplt->size > 0)
6539     elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
6540
6541   /* At the very end of the .rofixup section is a pointer to the GOT.  */
6542   if (htab->fdpic_p && htab->srofixup != NULL)
6543     {
6544       struct elf_link_hash_entry *hgot = htab->root.hgot;
6545       bfd_vma got_value = hgot->root.u.def.value
6546         + hgot->root.u.def.section->output_section->vma
6547         + hgot->root.u.def.section->output_offset;
6548
6549       sh_elf_add_rofixup (output_bfd, htab->srofixup, got_value);
6550
6551       /* Make sure we allocated and generated the same number of fixups.  */
6552       BFD_ASSERT (htab->srofixup->reloc_count * 4 == htab->srofixup->size);
6553     }
6554
6555   if (htab->srelfuncdesc)
6556     BFD_ASSERT (htab->srelfuncdesc->reloc_count * sizeof (Elf32_External_Rela)
6557                 == htab->srelfuncdesc->size);
6558
6559   if (htab->root.srelgot)
6560     BFD_ASSERT (htab->root.srelgot->reloc_count * sizeof (Elf32_External_Rela)
6561                 == htab->root.srelgot->size);
6562
6563   return TRUE;
6564 }
6565
6566 static enum elf_reloc_type_class
6567 sh_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
6568                          const asection *rel_sec ATTRIBUTE_UNUSED,
6569                          const Elf_Internal_Rela *rela)
6570 {
6571   switch ((int) ELF32_R_TYPE (rela->r_info))
6572     {
6573     case R_SH_RELATIVE:
6574       return reloc_class_relative;
6575     case R_SH_JMP_SLOT:
6576       return reloc_class_plt;
6577     case R_SH_COPY:
6578       return reloc_class_copy;
6579     default:
6580       return reloc_class_normal;
6581     }
6582 }
6583
6584 #if !defined SH_TARGET_ALREADY_DEFINED
6585 /* Support for Linux core dump NOTE sections.  */
6586
6587 static bfd_boolean
6588 elf32_shlin_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
6589 {
6590   int offset;
6591   unsigned int size;
6592
6593   switch (note->descsz)
6594     {
6595       default:
6596         return FALSE;
6597
6598       case 168:         /* Linux/SH */
6599         /* pr_cursig */
6600         elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
6601
6602         /* pr_pid */
6603         elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
6604
6605         /* pr_reg */
6606         offset = 72;
6607         size = 92;
6608
6609         break;
6610     }
6611
6612   /* Make a ".reg/999" section.  */
6613   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
6614                                           size, note->descpos + offset);
6615 }
6616
6617 static bfd_boolean
6618 elf32_shlin_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
6619 {
6620   switch (note->descsz)
6621     {
6622       default:
6623         return FALSE;
6624
6625       case 124:         /* Linux/SH elf_prpsinfo */
6626         elf_tdata (abfd)->core->program
6627          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
6628         elf_tdata (abfd)->core->command
6629          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
6630     }
6631
6632   /* Note that for some reason, a spurious space is tacked
6633      onto the end of the args in some (at least one anyway)
6634      implementations, so strip it off if it exists.  */
6635
6636   {
6637     char *command = elf_tdata (abfd)->core->command;
6638     int n = strlen (command);
6639
6640     if (0 < n && command[n - 1] == ' ')
6641       command[n - 1] = '\0';
6642   }
6643
6644   return TRUE;
6645 }
6646 #endif /* not SH_TARGET_ALREADY_DEFINED */
6647
6648
6649 /* Return address for Ith PLT stub in section PLT, for relocation REL
6650    or (bfd_vma) -1 if it should not be included.  */
6651
6652 static bfd_vma
6653 sh_elf_plt_sym_val (bfd_vma i, const asection *plt,
6654                     const arelent *rel ATTRIBUTE_UNUSED)
6655 {
6656   const struct elf_sh_plt_info *plt_info;
6657
6658   plt_info = get_plt_info (plt->owner, (plt->owner->flags & DYNAMIC) != 0);
6659   return plt->vma + get_plt_offset (plt_info, i);
6660 }
6661
6662 /* Decide whether to attempt to turn absptr or lsda encodings in
6663    shared libraries into pcrel within the given input section.  */
6664
6665 static bfd_boolean
6666 sh_elf_use_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
6667                               struct bfd_link_info *info,
6668                               asection *eh_frame_section ATTRIBUTE_UNUSED)
6669 {
6670   struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
6671
6672   /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
6673   if (htab->fdpic_p)
6674     return FALSE;
6675
6676   return TRUE;
6677 }
6678
6679 /* Adjust the contents of an eh_frame_hdr section before they're output.  */
6680
6681 static bfd_byte
6682 sh_elf_encode_eh_address (bfd *abfd,
6683                           struct bfd_link_info *info,
6684                           asection *osec, bfd_vma offset,
6685                           asection *loc_sec, bfd_vma loc_offset,
6686                           bfd_vma *encoded)
6687 {
6688   struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
6689   struct elf_link_hash_entry *h;
6690
6691   if (!htab->fdpic_p)
6692     return _bfd_elf_encode_eh_address (abfd, info, osec, offset, loc_sec,
6693                                        loc_offset, encoded);
6694
6695   h = htab->root.hgot;
6696   BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
6697
6698   if (! h || (sh_elf_osec_to_segment (abfd, osec)
6699               == sh_elf_osec_to_segment (abfd, loc_sec->output_section)))
6700     return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
6701                                        loc_sec, loc_offset, encoded);
6702
6703   BFD_ASSERT (sh_elf_osec_to_segment (abfd, osec)
6704               == (sh_elf_osec_to_segment
6705                   (abfd, h->root.u.def.section->output_section)));
6706
6707   *encoded = osec->vma + offset
6708     - (h->root.u.def.value
6709        + h->root.u.def.section->output_section->vma
6710        + h->root.u.def.section->output_offset);
6711
6712   return DW_EH_PE_datarel | DW_EH_PE_sdata4;
6713 }
6714
6715 #if !defined SH_TARGET_ALREADY_DEFINED
6716 #define TARGET_BIG_SYM          sh_elf32_vec
6717 #define TARGET_BIG_NAME         "elf32-sh"
6718 #define TARGET_LITTLE_SYM       sh_elf32_le_vec
6719 #define TARGET_LITTLE_NAME      "elf32-shl"
6720 #endif
6721
6722 #define ELF_ARCH                bfd_arch_sh
6723 #define ELF_TARGET_ID           SH_ELF_DATA
6724 #define ELF_MACHINE_CODE        EM_SH
6725 #ifdef __QNXTARGET__
6726 #define ELF_MAXPAGESIZE         0x1000
6727 #else
6728 #define ELF_MAXPAGESIZE         0x80
6729 #endif
6730
6731 #define elf_symbol_leading_char '_'
6732
6733 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
6734 #define bfd_elf32_bfd_reloc_name_lookup \
6735                                         sh_elf_reloc_name_lookup
6736 #define elf_info_to_howto               sh_elf_info_to_howto
6737 #define bfd_elf32_bfd_relax_section     sh_elf_relax_section
6738 #define elf_backend_relocate_section    sh_elf_relocate_section
6739 #define bfd_elf32_bfd_get_relocated_section_contents \
6740                                         sh_elf_get_relocated_section_contents
6741 #define bfd_elf32_mkobject              sh_elf_mkobject
6742 #define elf_backend_object_p            sh_elf_object_p
6743 #define bfd_elf32_bfd_copy_private_bfd_data \
6744                                         sh_elf_copy_private_data
6745 #define bfd_elf32_bfd_merge_private_bfd_data \
6746                                         sh_elf_merge_private_data
6747
6748 #define elf_backend_gc_mark_hook        sh_elf_gc_mark_hook
6749 #define elf_backend_check_relocs        sh_elf_check_relocs
6750 #define elf_backend_copy_indirect_symbol \
6751                                         sh_elf_copy_indirect_symbol
6752 #define elf_backend_create_dynamic_sections \
6753                                         sh_elf_create_dynamic_sections
6754 #define bfd_elf32_bfd_link_hash_table_create \
6755                                         sh_elf_link_hash_table_create
6756 #define elf_backend_adjust_dynamic_symbol \
6757                                         sh_elf_adjust_dynamic_symbol
6758 #define elf_backend_always_size_sections \
6759                                         sh_elf_always_size_sections
6760 #define elf_backend_size_dynamic_sections \
6761                                         sh_elf_size_dynamic_sections
6762 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
6763 #define elf_backend_finish_dynamic_symbol \
6764                                         sh_elf_finish_dynamic_symbol
6765 #define elf_backend_finish_dynamic_sections \
6766                                         sh_elf_finish_dynamic_sections
6767 #define elf_backend_reloc_type_class    sh_elf_reloc_type_class
6768 #define elf_backend_plt_sym_val         sh_elf_plt_sym_val
6769 #define elf_backend_can_make_relative_eh_frame \
6770                                         sh_elf_use_relative_eh_frame
6771 #define elf_backend_can_make_lsda_relative_eh_frame \
6772                                         sh_elf_use_relative_eh_frame
6773 #define elf_backend_encode_eh_address \
6774                                         sh_elf_encode_eh_address
6775
6776 #define elf_backend_stack_align         8
6777 #define elf_backend_can_gc_sections     1
6778 #define elf_backend_can_refcount        1
6779 #define elf_backend_want_got_plt        1
6780 #define elf_backend_plt_readonly        1
6781 #define elf_backend_want_plt_sym        0
6782 #define elf_backend_got_header_size     12
6783 #define elf_backend_dtrel_excludes_plt  1
6784
6785 #define elf_backend_linux_prpsinfo32_ugid16     TRUE
6786
6787 #if !defined SH_TARGET_ALREADY_DEFINED
6788
6789 #include "elf32-target.h"
6790
6791 /* NetBSD support.  */
6792 #undef  TARGET_BIG_SYM
6793 #define TARGET_BIG_SYM                  sh_elf32_nbsd_vec
6794 #undef  TARGET_BIG_NAME
6795 #define TARGET_BIG_NAME                 "elf32-sh-nbsd"
6796 #undef  TARGET_LITTLE_SYM
6797 #define TARGET_LITTLE_SYM               sh_elf32_nbsd_le_vec
6798 #undef  TARGET_LITTLE_NAME
6799 #define TARGET_LITTLE_NAME              "elf32-shl-nbsd"
6800 #undef  ELF_MAXPAGESIZE
6801 #define ELF_MAXPAGESIZE                 0x10000
6802 #undef  ELF_COMMONPAGESIZE
6803 #undef  elf_symbol_leading_char
6804 #define elf_symbol_leading_char         0
6805 #undef  elf32_bed
6806 #define elf32_bed                       elf32_sh_nbsd_bed
6807
6808 #include "elf32-target.h"
6809
6810
6811 /* Linux support.  */
6812 #undef  TARGET_BIG_SYM
6813 #define TARGET_BIG_SYM                  sh_elf32_linux_be_vec
6814 #undef  TARGET_BIG_NAME
6815 #define TARGET_BIG_NAME                 "elf32-shbig-linux"
6816 #undef  TARGET_LITTLE_SYM
6817 #define TARGET_LITTLE_SYM               sh_elf32_linux_vec
6818 #undef  TARGET_LITTLE_NAME
6819 #define TARGET_LITTLE_NAME              "elf32-sh-linux"
6820 #undef  ELF_COMMONPAGESIZE
6821 #define ELF_COMMONPAGESIZE              0x1000
6822
6823 #undef  elf_backend_grok_prstatus
6824 #define elf_backend_grok_prstatus       elf32_shlin_grok_prstatus
6825 #undef  elf_backend_grok_psinfo
6826 #define elf_backend_grok_psinfo         elf32_shlin_grok_psinfo
6827 #undef  elf32_bed
6828 #define elf32_bed                       elf32_sh_lin_bed
6829
6830 #include "elf32-target.h"
6831
6832
6833 /* FDPIC support.  */
6834 #undef  TARGET_BIG_SYM
6835 #define TARGET_BIG_SYM                  sh_elf32_fdpic_be_vec
6836 #undef  TARGET_BIG_NAME
6837 #define TARGET_BIG_NAME                 "elf32-shbig-fdpic"
6838 #undef  TARGET_LITTLE_SYM
6839 #define TARGET_LITTLE_SYM               sh_elf32_fdpic_le_vec
6840 #undef  TARGET_LITTLE_NAME
6841 #define TARGET_LITTLE_NAME              "elf32-sh-fdpic"
6842
6843 #undef  elf32_bed
6844 #define elf32_bed                       elf32_sh_fd_bed
6845
6846 #include "elf32-target.h"
6847
6848 #undef elf_backend_modify_program_headers
6849
6850 /* VxWorks support.  */
6851 #undef  TARGET_BIG_SYM
6852 #define TARGET_BIG_SYM                  sh_elf32_vxworks_vec
6853 #undef  TARGET_BIG_NAME
6854 #define TARGET_BIG_NAME                 "elf32-sh-vxworks"
6855 #undef  TARGET_LITTLE_SYM
6856 #define TARGET_LITTLE_SYM               sh_elf32_vxworks_le_vec
6857 #undef  TARGET_LITTLE_NAME
6858 #define TARGET_LITTLE_NAME              "elf32-shl-vxworks"
6859 #undef  elf32_bed
6860 #define elf32_bed                       elf32_sh_vxworks_bed
6861
6862 #undef  elf_backend_want_plt_sym
6863 #define elf_backend_want_plt_sym        1
6864 #undef  elf_symbol_leading_char
6865 #define elf_symbol_leading_char         '_'
6866 #define elf_backend_want_got_underscore 1
6867 #undef  elf_backend_grok_prstatus
6868 #undef  elf_backend_grok_psinfo
6869 #undef  elf_backend_add_symbol_hook
6870 #define elf_backend_add_symbol_hook     elf_vxworks_add_symbol_hook
6871 #undef  elf_backend_link_output_symbol_hook
6872 #define elf_backend_link_output_symbol_hook \
6873                                         elf_vxworks_link_output_symbol_hook
6874 #undef  elf_backend_emit_relocs
6875 #define elf_backend_emit_relocs         elf_vxworks_emit_relocs
6876 #undef  elf_backend_final_write_processing
6877 #define elf_backend_final_write_processing \
6878                                         elf_vxworks_final_write_processing
6879 #undef  ELF_MAXPAGESIZE
6880 #define ELF_MAXPAGESIZE                 0x1000
6881 #undef  ELF_COMMONPAGESIZE
6882
6883 #include "elf32-target.h"
6884
6885 #endif /* not SH_TARGET_ALREADY_DEFINED */