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                   BFD_ASSERT (offset >= 16);
4698                   /* Size of GD instructions is 16 or 18.  */
4699                   offset -= 16;
4700                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
4701                   if ((insn & 0xff00) == 0xc700)
4702                     {
4703                       BFD_ASSERT (offset >= 2);
4704                       offset -= 2;
4705                       insn = bfd_get_16 (input_bfd, contents + offset + 0);
4706                     }
4707
4708                   BFD_ASSERT ((insn & 0xff00) == 0xd400);
4709                   insn = bfd_get_16 (input_bfd, contents + offset + 2);
4710                   BFD_ASSERT ((insn & 0xff00) == 0xc700);
4711                   insn = bfd_get_16 (input_bfd, contents + offset + 4);
4712                   BFD_ASSERT ((insn & 0xff00) == 0xd100);
4713                   insn = bfd_get_16 (input_bfd, contents + offset + 6);
4714                   BFD_ASSERT (insn == 0x310c);
4715                   insn = bfd_get_16 (input_bfd, contents + offset + 8);
4716                   BFD_ASSERT (insn == 0x410b);
4717                   insn = bfd_get_16 (input_bfd, contents + offset + 10);
4718                   BFD_ASSERT (insn == 0x34cc);
4719
4720                   bfd_put_16 (output_bfd, 0x0012, contents + offset + 2);
4721                   bfd_put_16 (output_bfd, 0x304c, contents + offset + 4);
4722                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
4723                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
4724                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
4725                 }
4726               else
4727                 {
4728                   int target;
4729
4730                   /* IE->LE transition:
4731                      mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
4732                      bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
4733                      We change it into:
4734                      mov.l .Ln,rM; stc gbr,rN; nop; ...;
4735                      1: x@TPOFF; 2:.  */
4736
4737                   offset = rel->r_offset;
4738                   BFD_ASSERT (offset >= 16);
4739                   /* Size of IE instructions is 10 or 12.  */
4740                   offset -= 10;
4741                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
4742                   if ((insn & 0xf0ff) == 0x0012)
4743                     {
4744                       BFD_ASSERT (offset >= 2);
4745                       offset -= 2;
4746                       insn = bfd_get_16 (input_bfd, contents + offset + 0);
4747                     }
4748
4749                   BFD_ASSERT ((insn & 0xff00) == 0xd000);
4750                   target = insn & 0x00ff;
4751                   insn = bfd_get_16 (input_bfd, contents + offset + 2);
4752                   BFD_ASSERT ((insn & 0xf0ff) == 0x0012);
4753                   insn = bfd_get_16 (input_bfd, contents + offset + 4);
4754                   BFD_ASSERT ((insn & 0xf0ff) == 0x00ce);
4755                   insn = 0xd000 | (insn & 0x0f00) | target;
4756                   bfd_put_16 (output_bfd, insn, contents + offset + 0);
4757                   bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
4758                 }
4759
4760               bfd_put_32 (output_bfd, tpoff (info, relocation),
4761                           contents + rel->r_offset);
4762               continue;
4763             }
4764
4765           if (sgot == NULL || sgotplt == NULL)
4766             abort ();
4767
4768           if (h != NULL)
4769             off = h->got.offset;
4770           else
4771             {
4772               if (local_got_offsets == NULL)
4773                 abort ();
4774
4775               off = local_got_offsets[r_symndx];
4776             }
4777
4778           /* Relocate R_SH_TLS_IE_32 directly when statically linking.  */
4779           if (r_type == R_SH_TLS_IE_32
4780               && ! htab->root.dynamic_sections_created)
4781             {
4782               off &= ~1;
4783               bfd_put_32 (output_bfd, tpoff (info, relocation),
4784                           sgot->contents + off);
4785               bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off,
4786                           contents + rel->r_offset);
4787               continue;
4788             }
4789
4790           if ((off & 1) != 0)
4791             off &= ~1;
4792           else
4793             {
4794               Elf_Internal_Rela outrel;
4795               bfd_byte *loc;
4796               int dr_type, indx;
4797
4798               outrel.r_offset = (sgot->output_section->vma
4799                                  + sgot->output_offset + off);
4800
4801               if (h == NULL || h->dynindx == -1)
4802                 indx = 0;
4803               else
4804                 indx = h->dynindx;
4805
4806               dr_type = (r_type == R_SH_TLS_GD_32 ? R_SH_TLS_DTPMOD32 :
4807                          R_SH_TLS_TPOFF32);
4808               if (dr_type == R_SH_TLS_TPOFF32 && indx == 0)
4809                 outrel.r_addend = relocation - dtpoff_base (info);
4810               else
4811                 outrel.r_addend = 0;
4812               outrel.r_info = ELF32_R_INFO (indx, dr_type);
4813               loc = srelgot->contents;
4814               loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
4815               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4816
4817               if (r_type == R_SH_TLS_GD_32)
4818                 {
4819                   if (indx == 0)
4820                     {
4821                       bfd_put_32 (output_bfd,
4822                                   relocation - dtpoff_base (info),
4823                                   sgot->contents + off + 4);
4824                     }
4825                   else
4826                     {
4827                       outrel.r_info = ELF32_R_INFO (indx,
4828                                                     R_SH_TLS_DTPOFF32);
4829                       outrel.r_offset += 4;
4830                       outrel.r_addend = 0;
4831                       srelgot->reloc_count++;
4832                       loc += sizeof (Elf32_External_Rela);
4833                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4834                     }
4835                 }
4836
4837               if (h != NULL)
4838                 h->got.offset |= 1;
4839               else
4840                 local_got_offsets[r_symndx] |= 1;
4841             }
4842
4843           if (off >= (bfd_vma) -2)
4844             abort ();
4845
4846           if (r_type == (int) ELF32_R_TYPE (rel->r_info))
4847             relocation = sh_elf_got_offset (htab) + off;
4848           else
4849             {
4850               bfd_vma offset;
4851               unsigned short insn;
4852
4853               /* GD->IE transition:
4854                    mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4855                    jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4856                    1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
4857                  We change it into:
4858                    mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
4859                    nop; nop; bra 3f; nop; .align 2;
4860                    1: .long x@TPOFF; 2:...; 3:.  */
4861
4862               offset = rel->r_offset;
4863               BFD_ASSERT (offset >= 16);
4864               /* Size of GD instructions is 16 or 18.  */
4865               offset -= 16;
4866               insn = bfd_get_16 (input_bfd, contents + offset + 0);
4867               if ((insn & 0xff00) == 0xc700)
4868                 {
4869                   BFD_ASSERT (offset >= 2);
4870                   offset -= 2;
4871                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
4872                 }
4873
4874               BFD_ASSERT ((insn & 0xff00) == 0xd400);
4875
4876               /* Replace mov.l 1f,R4 with mov.l 1f,r0.  */
4877               bfd_put_16 (output_bfd, insn & 0xf0ff, contents + offset);
4878
4879               insn = bfd_get_16 (input_bfd, contents + offset + 2);
4880               BFD_ASSERT ((insn & 0xff00) == 0xc700);
4881               insn = bfd_get_16 (input_bfd, contents + offset + 4);
4882               BFD_ASSERT ((insn & 0xff00) == 0xd100);
4883               insn = bfd_get_16 (input_bfd, contents + offset + 6);
4884               BFD_ASSERT (insn == 0x310c);
4885               insn = bfd_get_16 (input_bfd, contents + offset + 8);
4886               BFD_ASSERT (insn == 0x410b);
4887               insn = bfd_get_16 (input_bfd, contents + offset + 10);
4888               BFD_ASSERT (insn == 0x34cc);
4889
4890               bfd_put_16 (output_bfd, 0x0412, contents + offset + 2);
4891               bfd_put_16 (output_bfd, 0x00ce, contents + offset + 4);
4892               bfd_put_16 (output_bfd, 0x304c, contents + offset + 6);
4893               bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
4894               bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
4895
4896               bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off,
4897                           contents + rel->r_offset);
4898
4899               continue;
4900           }
4901
4902           addend = rel->r_addend;
4903
4904           goto final_link_relocate;
4905
4906         case R_SH_TLS_LD_32:
4907           BFD_ASSERT (htab);
4908           check_segment[0] = check_segment[1] = -1;
4909           if (! bfd_link_pic (info))
4910             {
4911               bfd_vma offset;
4912               unsigned short insn;
4913
4914               /* LD->LE transition:
4915                    mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
4916                    jsr @r1; add r12,r4; bra 3f; nop; .align 2;
4917                    1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
4918                  We change it into:
4919                    stc gbr,r0; nop; nop; nop;
4920                    nop; nop; bra 3f; ...; 3:.  */
4921
4922               offset = rel->r_offset;
4923               BFD_ASSERT (offset >= 16);
4924               /* Size of LD instructions is 16 or 18.  */
4925               offset -= 16;
4926               insn = bfd_get_16 (input_bfd, contents + offset + 0);
4927               if ((insn & 0xff00) == 0xc700)
4928                 {
4929                   BFD_ASSERT (offset >= 2);
4930                   offset -= 2;
4931                   insn = bfd_get_16 (input_bfd, contents + offset + 0);
4932                 }
4933
4934               BFD_ASSERT ((insn & 0xff00) == 0xd400);
4935               insn = bfd_get_16 (input_bfd, contents + offset + 2);
4936               BFD_ASSERT ((insn & 0xff00) == 0xc700);
4937               insn = bfd_get_16 (input_bfd, contents + offset + 4);
4938               BFD_ASSERT ((insn & 0xff00) == 0xd100);
4939               insn = bfd_get_16 (input_bfd, contents + offset + 6);
4940               BFD_ASSERT (insn == 0x310c);
4941               insn = bfd_get_16 (input_bfd, contents + offset + 8);
4942               BFD_ASSERT (insn == 0x410b);
4943               insn = bfd_get_16 (input_bfd, contents + offset + 10);
4944               BFD_ASSERT (insn == 0x34cc);
4945
4946               bfd_put_16 (output_bfd, 0x0012, contents + offset + 0);
4947               bfd_put_16 (output_bfd, 0x0009, contents + offset + 2);
4948               bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
4949               bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
4950               bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
4951               bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
4952
4953               continue;
4954             }
4955
4956           if (sgot == NULL || sgotplt == NULL)
4957             abort ();
4958
4959           off = htab->tls_ldm_got.offset;
4960           if (off & 1)
4961             off &= ~1;
4962           else
4963             {
4964               Elf_Internal_Rela outrel;
4965               bfd_byte *loc;
4966
4967               outrel.r_offset = (sgot->output_section->vma
4968                                  + sgot->output_offset + off);
4969               outrel.r_addend = 0;
4970               outrel.r_info = ELF32_R_INFO (0, R_SH_TLS_DTPMOD32);
4971               loc = srelgot->contents;
4972               loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
4973               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4974               htab->tls_ldm_got.offset |= 1;
4975             }
4976
4977           relocation = sh_elf_got_offset (htab) + off;
4978           addend = rel->r_addend;
4979
4980           goto final_link_relocate;
4981
4982         case R_SH_TLS_LDO_32:
4983           check_segment[0] = check_segment[1] = -1;
4984           if (! bfd_link_pic (info))
4985             relocation = tpoff (info, relocation);
4986           else
4987             relocation -= dtpoff_base (info);
4988
4989           addend = rel->r_addend;
4990           goto final_link_relocate;
4991
4992         case R_SH_TLS_LE_32:
4993           {
4994             int indx;
4995             Elf_Internal_Rela outrel;
4996             bfd_byte *loc;
4997
4998             check_segment[0] = check_segment[1] = -1;
4999
5000             if (!bfd_link_dll (info))
5001               {
5002                 relocation = tpoff (info, relocation);
5003                 addend = rel->r_addend;
5004                 goto final_link_relocate;
5005               }
5006
5007             if (sreloc == NULL)
5008               {
5009                 sreloc = _bfd_elf_get_dynamic_reloc_section
5010                   (input_bfd, input_section, /*rela?*/ TRUE);
5011                 if (sreloc == NULL)
5012                   return FALSE;
5013               }
5014
5015             if (h == NULL || h->dynindx == -1)
5016               indx = 0;
5017             else
5018               indx = h->dynindx;
5019
5020             outrel.r_offset = (input_section->output_section->vma
5021                                + input_section->output_offset
5022                                + rel->r_offset);
5023             outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5024             if (indx == 0)
5025               outrel.r_addend = relocation - dtpoff_base (info);
5026             else
5027               outrel.r_addend = 0;
5028
5029             loc = sreloc->contents;
5030             loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5031             bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5032             continue;
5033           }
5034         }
5035
5036     relocation_done:
5037       if (fdpic_p && check_segment[0] != (unsigned) -1
5038           && check_segment[0] != check_segment[1])
5039         {
5040           /* We don't want duplicate errors for undefined symbols.  */
5041           if (!h || h->root.type != bfd_link_hash_undefined)
5042             {
5043               if (bfd_link_pic (info))
5044                 {
5045                   info->callbacks->einfo
5046                     /* xgettext:c-format */
5047                     (_("%X%C: relocation to \"%s\" references a different segment\n"),
5048                      input_bfd, input_section, rel->r_offset, symname);
5049                   return FALSE;
5050                 }
5051               else
5052                 info->callbacks->einfo
5053                   /* xgettext:c-format */
5054                   (_("%C: warning: relocation to \"%s\" references a different segment\n"),
5055                    input_bfd, input_section, rel->r_offset, symname);
5056             }
5057
5058           elf_elfheader (output_bfd)->e_flags |= EF_SH_PIC;
5059         }
5060
5061       if (r != bfd_reloc_ok)
5062         {
5063           switch (r)
5064             {
5065             default:
5066             case bfd_reloc_outofrange:
5067               abort ();
5068             case bfd_reloc_overflow:
5069               {
5070                 const char *name;
5071
5072                 if (h != NULL)
5073                   name = NULL;
5074                 else
5075                   {
5076                     name = (bfd_elf_string_from_elf_section
5077                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
5078                     if (name == NULL)
5079                       return FALSE;
5080                     if (*name == '\0')
5081                       name = bfd_section_name (input_bfd, sec);
5082                   }
5083                 (*info->callbacks->reloc_overflow)
5084                   (info, (h ? &h->root : NULL), name, howto->name,
5085                    (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
5086               }
5087               break;
5088             }
5089         }
5090     }
5091
5092   return TRUE;
5093 }
5094
5095 /* This is a version of bfd_generic_get_relocated_section_contents
5096    which uses sh_elf_relocate_section.  */
5097
5098 static bfd_byte *
5099 sh_elf_get_relocated_section_contents (bfd *output_bfd,
5100                                        struct bfd_link_info *link_info,
5101                                        struct bfd_link_order *link_order,
5102                                        bfd_byte *data,
5103                                        bfd_boolean relocatable,
5104                                        asymbol **symbols)
5105 {
5106   Elf_Internal_Shdr *symtab_hdr;
5107   asection *input_section = link_order->u.indirect.section;
5108   bfd *input_bfd = input_section->owner;
5109   asection **sections = NULL;
5110   Elf_Internal_Rela *internal_relocs = NULL;
5111   Elf_Internal_Sym *isymbuf = NULL;
5112
5113   /* We only need to handle the case of relaxing, or of having a
5114      particular set of section contents, specially.  */
5115   if (relocatable
5116       || elf_section_data (input_section)->this_hdr.contents == NULL)
5117     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
5118                                                        link_order, data,
5119                                                        relocatable,
5120                                                        symbols);
5121
5122   symtab_hdr = &elf_symtab_hdr (input_bfd);
5123
5124   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
5125           (size_t) input_section->size);
5126
5127   if ((input_section->flags & SEC_RELOC) != 0
5128       && input_section->reloc_count > 0)
5129     {
5130       asection **secpp;
5131       Elf_Internal_Sym *isym, *isymend;
5132       bfd_size_type amt;
5133
5134       internal_relocs = (_bfd_elf_link_read_relocs
5135                          (input_bfd, input_section, NULL,
5136                           (Elf_Internal_Rela *) NULL, FALSE));
5137       if (internal_relocs == NULL)
5138         goto error_return;
5139
5140       if (symtab_hdr->sh_info != 0)
5141         {
5142           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5143           if (isymbuf == NULL)
5144             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
5145                                             symtab_hdr->sh_info, 0,
5146                                             NULL, NULL, NULL);
5147           if (isymbuf == NULL)
5148             goto error_return;
5149         }
5150
5151       amt = symtab_hdr->sh_info;
5152       amt *= sizeof (asection *);
5153       sections = (asection **) bfd_malloc (amt);
5154       if (sections == NULL && amt != 0)
5155         goto error_return;
5156
5157       isymend = isymbuf + symtab_hdr->sh_info;
5158       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
5159         {
5160           asection *isec;
5161
5162           if (isym->st_shndx == SHN_UNDEF)
5163             isec = bfd_und_section_ptr;
5164           else if (isym->st_shndx == SHN_ABS)
5165             isec = bfd_abs_section_ptr;
5166           else if (isym->st_shndx == SHN_COMMON)
5167             isec = bfd_com_section_ptr;
5168           else
5169             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
5170
5171           *secpp = isec;
5172         }
5173
5174       if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
5175                                      input_section, data, internal_relocs,
5176                                      isymbuf, sections))
5177         goto error_return;
5178
5179       if (sections != NULL)
5180         free (sections);
5181       if (isymbuf != NULL
5182           && symtab_hdr->contents != (unsigned char *) isymbuf)
5183         free (isymbuf);
5184       if (elf_section_data (input_section)->relocs != internal_relocs)
5185         free (internal_relocs);
5186     }
5187
5188   return data;
5189
5190  error_return:
5191   if (sections != NULL)
5192     free (sections);
5193   if (isymbuf != NULL
5194       && symtab_hdr->contents != (unsigned char *) isymbuf)
5195     free (isymbuf);
5196   if (internal_relocs != NULL
5197       && elf_section_data (input_section)->relocs != internal_relocs)
5198     free (internal_relocs);
5199   return NULL;
5200 }
5201
5202 /* Return the base VMA address which should be subtracted from real addresses
5203    when resolving @dtpoff relocation.
5204    This is PT_TLS segment p_vaddr.  */
5205
5206 static bfd_vma
5207 dtpoff_base (struct bfd_link_info *info)
5208 {
5209   /* If tls_sec is NULL, we should have signalled an error already.  */
5210   if (elf_hash_table (info)->tls_sec == NULL)
5211     return 0;
5212   return elf_hash_table (info)->tls_sec->vma;
5213 }
5214
5215 /* Return the relocation value for R_SH_TLS_TPOFF32..  */
5216
5217 static bfd_vma
5218 tpoff (struct bfd_link_info *info, bfd_vma address)
5219 {
5220   /* If tls_sec is NULL, we should have signalled an error already.  */
5221   if (elf_hash_table (info)->tls_sec == NULL)
5222     return 0;
5223   /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5224      structure which has 2 pointer fields.  */
5225   return (address - elf_hash_table (info)->tls_sec->vma
5226           + align_power ((bfd_vma) 8,
5227                          elf_hash_table (info)->tls_sec->alignment_power));
5228 }
5229
5230 static asection *
5231 sh_elf_gc_mark_hook (asection *sec,
5232                      struct bfd_link_info *info,
5233                      Elf_Internal_Rela *rel,
5234                      struct elf_link_hash_entry *h,
5235                      Elf_Internal_Sym *sym)
5236 {
5237   if (h != NULL)
5238     switch (ELF32_R_TYPE (rel->r_info))
5239       {
5240       case R_SH_GNU_VTINHERIT:
5241       case R_SH_GNU_VTENTRY:
5242         return NULL;
5243       }
5244
5245   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5246 }
5247
5248 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
5249
5250 static void
5251 sh_elf_copy_indirect_symbol (struct bfd_link_info *info,
5252                              struct elf_link_hash_entry *dir,
5253                              struct elf_link_hash_entry *ind)
5254 {
5255   struct elf_sh_link_hash_entry *edir, *eind;
5256
5257   edir = (struct elf_sh_link_hash_entry *) dir;
5258   eind = (struct elf_sh_link_hash_entry *) ind;
5259
5260   if (eind->dyn_relocs != NULL)
5261     {
5262       if (edir->dyn_relocs != NULL)
5263         {
5264           struct elf_dyn_relocs **pp;
5265           struct elf_dyn_relocs *p;
5266
5267           /* Add reloc counts against the indirect sym to the direct sym
5268              list.  Merge any entries against the same section.  */
5269           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
5270             {
5271               struct elf_dyn_relocs *q;
5272
5273               for (q = edir->dyn_relocs; q != NULL; q = q->next)
5274                 if (q->sec == p->sec)
5275                   {
5276                     q->pc_count += p->pc_count;
5277                     q->count += p->count;
5278                     *pp = p->next;
5279                     break;
5280                   }
5281               if (q == NULL)
5282                 pp = &p->next;
5283             }
5284           *pp = edir->dyn_relocs;
5285         }
5286
5287       edir->dyn_relocs = eind->dyn_relocs;
5288       eind->dyn_relocs = NULL;
5289     }
5290   edir->gotplt_refcount = eind->gotplt_refcount;
5291   eind->gotplt_refcount = 0;
5292   edir->funcdesc.refcount += eind->funcdesc.refcount;
5293   eind->funcdesc.refcount = 0;
5294   edir->abs_funcdesc_refcount += eind->abs_funcdesc_refcount;
5295   eind->abs_funcdesc_refcount = 0;
5296
5297   if (ind->root.type == bfd_link_hash_indirect
5298       && dir->got.refcount <= 0)
5299     {
5300       edir->got_type = eind->got_type;
5301       eind->got_type = GOT_UNKNOWN;
5302     }
5303
5304   if (ind->root.type != bfd_link_hash_indirect
5305       && dir->dynamic_adjusted)
5306     {
5307       /* If called to transfer flags for a weakdef during processing
5308          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
5309          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
5310       if (dir->versioned != versioned_hidden)
5311         dir->ref_dynamic |= ind->ref_dynamic;
5312       dir->ref_regular |= ind->ref_regular;
5313       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
5314       dir->needs_plt |= ind->needs_plt;
5315     }
5316   else
5317     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
5318 }
5319
5320 static int
5321 sh_elf_optimized_tls_reloc (struct bfd_link_info *info, int r_type,
5322                             int is_local)
5323 {
5324   if (bfd_link_pic (info))
5325     return r_type;
5326
5327   switch (r_type)
5328     {
5329     case R_SH_TLS_GD_32:
5330     case R_SH_TLS_IE_32:
5331       if (is_local)
5332         return R_SH_TLS_LE_32;
5333       return R_SH_TLS_IE_32;
5334     case R_SH_TLS_LD_32:
5335       return R_SH_TLS_LE_32;
5336     }
5337
5338   return r_type;
5339 }
5340
5341 /* Look through the relocs for a section during the first phase.
5342    Since we don't do .gots or .plts, we just need to consider the
5343    virtual table relocs for gc.  */
5344
5345 static bfd_boolean
5346 sh_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
5347                      const Elf_Internal_Rela *relocs)
5348 {
5349   Elf_Internal_Shdr *symtab_hdr;
5350   struct elf_link_hash_entry **sym_hashes;
5351   struct elf_sh_link_hash_table *htab;
5352   const Elf_Internal_Rela *rel;
5353   const Elf_Internal_Rela *rel_end;
5354   asection *sreloc;
5355   unsigned int r_type;
5356   enum got_type got_type, old_got_type;
5357
5358   sreloc = NULL;
5359
5360   if (bfd_link_relocatable (info))
5361     return TRUE;
5362
5363   /* Don't do anything special with non-loaded, non-alloced sections.
5364      In particular, any relocs in such sections should not affect GOT
5365      and PLT reference counting (ie. we don't allow them to create GOT
5366      or PLT entries), there's no possibility or desire to optimize TLS
5367      relocs, and there's not much point in propagating relocs to shared
5368      libs that the dynamic linker won't relocate.  */
5369   if ((sec->flags & SEC_ALLOC) == 0)
5370     return TRUE;
5371
5372   BFD_ASSERT (is_sh_elf (abfd));
5373
5374   symtab_hdr = &elf_symtab_hdr (abfd);
5375   sym_hashes = elf_sym_hashes (abfd);
5376
5377   htab = sh_elf_hash_table (info);
5378   if (htab == NULL)
5379     return FALSE;
5380
5381   rel_end = relocs + sec->reloc_count;
5382   for (rel = relocs; rel < rel_end; rel++)
5383     {
5384       struct elf_link_hash_entry *h;
5385       unsigned long r_symndx;
5386
5387       r_symndx = ELF32_R_SYM (rel->r_info);
5388       r_type = ELF32_R_TYPE (rel->r_info);
5389
5390       if (r_symndx < symtab_hdr->sh_info)
5391         h = NULL;
5392       else
5393         {
5394           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5395           while (h->root.type == bfd_link_hash_indirect
5396                  || h->root.type == bfd_link_hash_warning)
5397             h = (struct elf_link_hash_entry *) h->root.u.i.link;
5398         }
5399
5400       r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
5401       if (! bfd_link_pic (info)
5402           && r_type == R_SH_TLS_IE_32
5403           && h != NULL
5404           && h->root.type != bfd_link_hash_undefined
5405           && h->root.type != bfd_link_hash_undefweak
5406           && (h->dynindx == -1
5407               || h->def_regular))
5408         r_type = R_SH_TLS_LE_32;
5409
5410       if (htab->fdpic_p)
5411         switch (r_type)
5412           {
5413           case R_SH_GOTOFFFUNCDESC:
5414           case R_SH_GOTOFFFUNCDESC20:
5415           case R_SH_FUNCDESC:
5416           case R_SH_GOTFUNCDESC:
5417           case R_SH_GOTFUNCDESC20:
5418             if (h != NULL)
5419               {
5420                 if (h->dynindx == -1)
5421                   switch (ELF_ST_VISIBILITY (h->other))
5422                     {
5423                     case STV_INTERNAL:
5424                     case STV_HIDDEN:
5425                       break;
5426                     default:
5427                       bfd_elf_link_record_dynamic_symbol (info, h);
5428                       break;
5429                     }
5430               }
5431             break;
5432           }
5433
5434       /* Some relocs require a global offset table.  */
5435       if (htab->root.sgot == NULL)
5436         {
5437           switch (r_type)
5438             {
5439             case R_SH_DIR32:
5440               /* This may require an rofixup.  */
5441               if (!htab->fdpic_p)
5442                 break;
5443               /* Fall through.  */
5444             case R_SH_GOTPLT32:
5445             case R_SH_GOT32:
5446             case R_SH_GOT20:
5447             case R_SH_GOTOFF:
5448             case R_SH_GOTOFF20:
5449             case R_SH_FUNCDESC:
5450             case R_SH_GOTFUNCDESC:
5451             case R_SH_GOTFUNCDESC20:
5452             case R_SH_GOTOFFFUNCDESC:
5453             case R_SH_GOTOFFFUNCDESC20:
5454             case R_SH_GOTPC:
5455             case R_SH_TLS_GD_32:
5456             case R_SH_TLS_LD_32:
5457             case R_SH_TLS_IE_32:
5458               if (htab->root.dynobj == NULL)
5459                 htab->root.dynobj = abfd;
5460               if (!create_got_section (htab->root.dynobj, info))
5461                 return FALSE;
5462               break;
5463
5464             default:
5465               break;
5466             }
5467         }
5468
5469       switch (r_type)
5470         {
5471           /* This relocation describes the C++ object vtable hierarchy.
5472              Reconstruct it for later use during GC.  */
5473         case R_SH_GNU_VTINHERIT:
5474           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5475             return FALSE;
5476           break;
5477
5478           /* This relocation describes which C++ vtable entries are actually
5479              used.  Record for later use during GC.  */
5480         case R_SH_GNU_VTENTRY:
5481           BFD_ASSERT (h != NULL);
5482           if (h != NULL
5483               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5484             return FALSE;
5485           break;
5486
5487         case R_SH_TLS_IE_32:
5488           if (bfd_link_pic (info))
5489             info->flags |= DF_STATIC_TLS;
5490
5491           /* FALLTHROUGH */
5492         force_got:
5493         case R_SH_TLS_GD_32:
5494         case R_SH_GOT32:
5495         case R_SH_GOT20:
5496         case R_SH_GOTFUNCDESC:
5497         case R_SH_GOTFUNCDESC20:
5498           switch (r_type)
5499             {
5500             default:
5501               got_type = GOT_NORMAL;
5502               break;
5503             case R_SH_TLS_GD_32:
5504               got_type = GOT_TLS_GD;
5505               break;
5506             case R_SH_TLS_IE_32:
5507               got_type = GOT_TLS_IE;
5508               break;
5509             case R_SH_GOTFUNCDESC:
5510             case R_SH_GOTFUNCDESC20:
5511               got_type = GOT_FUNCDESC;
5512               break;
5513             }
5514
5515           if (h != NULL)
5516             {
5517               h->got.refcount += 1;
5518               old_got_type = sh_elf_hash_entry (h)->got_type;
5519             }
5520           else
5521             {
5522               bfd_signed_vma *local_got_refcounts;
5523
5524               /* This is a global offset table entry for a local
5525                  symbol.  */
5526               local_got_refcounts = elf_local_got_refcounts (abfd);
5527               if (local_got_refcounts == NULL)
5528                 {
5529                   bfd_size_type size;
5530
5531                   size = symtab_hdr->sh_info;
5532                   size *= sizeof (bfd_signed_vma);
5533                   size += symtab_hdr->sh_info;
5534                   local_got_refcounts = ((bfd_signed_vma *)
5535                                          bfd_zalloc (abfd, size));
5536                   if (local_got_refcounts == NULL)
5537                     return FALSE;
5538                   elf_local_got_refcounts (abfd) = local_got_refcounts;
5539                   sh_elf_local_got_type (abfd)
5540                     = (char *) (local_got_refcounts + symtab_hdr->sh_info);
5541                 }
5542               local_got_refcounts[r_symndx] += 1;
5543               old_got_type = sh_elf_local_got_type (abfd) [r_symndx];
5544             }
5545
5546           /* If a TLS symbol is accessed using IE at least once,
5547              there is no point to use dynamic model for it.  */
5548           if (old_got_type != got_type && old_got_type != GOT_UNKNOWN
5549               && (old_got_type != GOT_TLS_GD || got_type != GOT_TLS_IE))
5550             {
5551               if (old_got_type == GOT_TLS_IE && got_type == GOT_TLS_GD)
5552                 got_type = GOT_TLS_IE;
5553               else
5554                 {
5555                   if ((old_got_type == GOT_FUNCDESC || got_type == GOT_FUNCDESC)
5556                       && (old_got_type == GOT_NORMAL || got_type == GOT_NORMAL))
5557                     _bfd_error_handler
5558                       /* xgettext:c-format */
5559                       (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
5560                        abfd, h->root.root.string);
5561                   else if (old_got_type == GOT_FUNCDESC
5562                            || got_type == GOT_FUNCDESC)
5563                     _bfd_error_handler
5564                       /* xgettext:c-format */
5565                       (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
5566                        abfd, h->root.root.string);
5567                   else
5568                     _bfd_error_handler
5569                       /* xgettext:c-format */
5570                       (_("%pB: `%s' accessed both as normal and thread local symbol"),
5571                        abfd, h->root.root.string);
5572                   return FALSE;
5573                 }
5574             }
5575
5576           if (old_got_type != got_type)
5577             {
5578               if (h != NULL)
5579                 sh_elf_hash_entry (h)->got_type = got_type;
5580               else
5581                 sh_elf_local_got_type (abfd) [r_symndx] = got_type;
5582             }
5583
5584           break;
5585
5586         case R_SH_TLS_LD_32:
5587           sh_elf_hash_table(info)->tls_ldm_got.refcount += 1;
5588           break;
5589
5590         case R_SH_FUNCDESC:
5591         case R_SH_GOTOFFFUNCDESC:
5592         case R_SH_GOTOFFFUNCDESC20:
5593           if (rel->r_addend)
5594             {
5595               _bfd_error_handler
5596                 (_("%pB: Function descriptor relocation with non-zero addend"),
5597                  abfd);
5598               return FALSE;
5599             }
5600
5601           if (h == NULL)
5602             {
5603               union gotref *local_funcdesc;
5604
5605               /* We need a function descriptor for a local symbol.  */
5606               local_funcdesc = sh_elf_local_funcdesc (abfd);
5607               if (local_funcdesc == NULL)
5608                 {
5609                   bfd_size_type size;
5610
5611                   size = symtab_hdr->sh_info * sizeof (union gotref);
5612                   local_funcdesc = (union gotref *) bfd_zalloc (abfd, size);
5613                   if (local_funcdesc == NULL)
5614                     return FALSE;
5615                   sh_elf_local_funcdesc (abfd) = local_funcdesc;
5616                 }
5617               local_funcdesc[r_symndx].refcount += 1;
5618
5619               if (r_type == R_SH_FUNCDESC)
5620                 {
5621                   if (!bfd_link_pic (info))
5622                     htab->srofixup->size += 4;
5623                   else
5624                     htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5625                 }
5626             }
5627           else
5628             {
5629               sh_elf_hash_entry (h)->funcdesc.refcount++;
5630               if (r_type == R_SH_FUNCDESC)
5631                 sh_elf_hash_entry (h)->abs_funcdesc_refcount++;
5632
5633               /* If there is a function descriptor reference, then
5634                  there should not be any non-FDPIC references.  */
5635               old_got_type = sh_elf_hash_entry (h)->got_type;
5636               if (old_got_type != GOT_FUNCDESC && old_got_type != GOT_UNKNOWN)
5637                 {
5638                   if (old_got_type == GOT_NORMAL)
5639                     _bfd_error_handler
5640                       /* xgettext:c-format */
5641                       (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
5642                        abfd, h->root.root.string);
5643                   else
5644                     _bfd_error_handler
5645                       /* xgettext:c-format */
5646                       (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
5647                        abfd, h->root.root.string);
5648                 }
5649             }
5650           break;
5651
5652         case R_SH_GOTPLT32:
5653           /* If this is a local symbol, we resolve it directly without
5654              creating a procedure linkage table entry.  */
5655
5656           if (h == NULL
5657               || h->forced_local
5658               || ! bfd_link_pic (info)
5659               || info->symbolic
5660               || h->dynindx == -1)
5661             goto force_got;
5662
5663           h->needs_plt = 1;
5664           h->plt.refcount += 1;
5665           ((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1;
5666
5667           break;
5668
5669         case R_SH_PLT32:
5670           /* This symbol requires a procedure linkage table entry.  We
5671              actually build the entry in adjust_dynamic_symbol,
5672              because this might be a case of linking PIC code which is
5673              never referenced by a dynamic object, in which case we
5674              don't need to generate a procedure linkage table entry
5675              after all.  */
5676
5677           /* If this is a local symbol, we resolve it directly without
5678              creating a procedure linkage table entry.  */
5679           if (h == NULL)
5680             continue;
5681
5682           if (h->forced_local)
5683             break;
5684
5685           h->needs_plt = 1;
5686           h->plt.refcount += 1;
5687           break;
5688
5689         case R_SH_DIR32:
5690         case R_SH_REL32:
5691           if (h != NULL && ! bfd_link_pic (info))
5692             {
5693               h->non_got_ref = 1;
5694               h->plt.refcount += 1;
5695             }
5696
5697           /* If we are creating a shared library, and this is a reloc
5698              against a global symbol, or a non PC relative reloc
5699              against a local symbol, then we need to copy the reloc
5700              into the shared library.  However, if we are linking with
5701              -Bsymbolic, we do not need to copy a reloc against a
5702              global symbol which is defined in an object we are
5703              including in the link (i.e., DEF_REGULAR is set).  At
5704              this point we have not seen all the input files, so it is
5705              possible that DEF_REGULAR is not set now but will be set
5706              later (it is never cleared).  We account for that
5707              possibility below by storing information in the
5708              dyn_relocs field of the hash table entry. A similar
5709              situation occurs when creating shared libraries and symbol
5710              visibility changes render the symbol local.
5711
5712              If on the other hand, we are creating an executable, we
5713              may need to keep relocations for symbols satisfied by a
5714              dynamic library if we manage to avoid copy relocs for the
5715              symbol.  */
5716           if ((bfd_link_pic (info)
5717                && (sec->flags & SEC_ALLOC) != 0
5718                && (r_type != R_SH_REL32
5719                    || (h != NULL
5720                        && (! info->symbolic
5721                            || h->root.type == bfd_link_hash_defweak
5722                            || !h->def_regular))))
5723               || (! bfd_link_pic (info)
5724                   && (sec->flags & SEC_ALLOC) != 0
5725                   && h != NULL
5726                   && (h->root.type == bfd_link_hash_defweak
5727                       || !h->def_regular)))
5728             {
5729               struct elf_dyn_relocs *p;
5730               struct elf_dyn_relocs **head;
5731
5732               if (htab->root.dynobj == NULL)
5733                 htab->root.dynobj = abfd;
5734
5735               /* When creating a shared object, we must copy these
5736                  reloc types into the output file.  We create a reloc
5737                  section in dynobj and make room for this reloc.  */
5738               if (sreloc == NULL)
5739                 {
5740                   sreloc = _bfd_elf_make_dynamic_reloc_section
5741                     (sec, htab->root.dynobj, 2, abfd, /*rela?*/ TRUE);
5742
5743                   if (sreloc == NULL)
5744                     return FALSE;
5745                 }
5746
5747               /* If this is a global symbol, we count the number of
5748                  relocations we need for this symbol.  */
5749               if (h != NULL)
5750                 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
5751               else
5752                 {
5753                   /* Track dynamic relocs needed for local syms too.  */
5754                   asection *s;
5755                   void *vpp;
5756                   Elf_Internal_Sym *isym;
5757
5758                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5759                                                 abfd, r_symndx);
5760                   if (isym == NULL)
5761                     return FALSE;
5762
5763                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5764                   if (s == NULL)
5765                     s = sec;
5766
5767                   vpp = &elf_section_data (s)->local_dynrel;
5768                   head = (struct elf_dyn_relocs **) vpp;
5769                 }
5770
5771               p = *head;
5772               if (p == NULL || p->sec != sec)
5773                 {
5774                   bfd_size_type amt = sizeof (*p);
5775                   p = bfd_alloc (htab->root.dynobj, amt);
5776                   if (p == NULL)
5777                     return FALSE;
5778                   p->next = *head;
5779                   *head = p;
5780                   p->sec = sec;
5781                   p->count = 0;
5782                   p->pc_count = 0;
5783                 }
5784
5785               p->count += 1;
5786               if (r_type == R_SH_REL32)
5787                 p->pc_count += 1;
5788             }
5789
5790           /* Allocate the fixup regardless of whether we need a relocation.
5791              If we end up generating the relocation, we'll unallocate the
5792              fixup.  */
5793           if (htab->fdpic_p && !bfd_link_pic (info)
5794               && r_type == R_SH_DIR32
5795               && (sec->flags & SEC_ALLOC) != 0)
5796             htab->srofixup->size += 4;
5797           break;
5798
5799         case R_SH_TLS_LE_32:
5800           if (bfd_link_dll (info))
5801             {
5802               _bfd_error_handler
5803                 (_("%pB: TLS local exec code cannot be linked into shared objects"),
5804                  abfd);
5805               return FALSE;
5806             }
5807
5808           break;
5809
5810         case R_SH_TLS_LDO_32:
5811           /* Nothing to do.  */
5812           break;
5813
5814         default:
5815           break;
5816         }
5817     }
5818
5819   return TRUE;
5820 }
5821
5822 #ifndef sh_elf_set_mach_from_flags
5823 static unsigned int sh_ef_bfd_table[] = { EF_SH_BFD_TABLE };
5824
5825 static bfd_boolean
5826 sh_elf_set_mach_from_flags (bfd *abfd)
5827 {
5828   flagword flags = elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK;
5829
5830   if (flags >= ARRAY_SIZE (sh_ef_bfd_table))
5831     return FALSE;
5832
5833   if (sh_ef_bfd_table[flags] == 0)
5834     return FALSE;
5835
5836   bfd_default_set_arch_mach (abfd, bfd_arch_sh, sh_ef_bfd_table[flags]);
5837
5838   return TRUE;
5839 }
5840
5841
5842 /* Reverse table lookup for sh_ef_bfd_table[].
5843    Given a bfd MACH value from archures.c
5844    return the equivalent ELF flags from the table.
5845    Return -1 if no match is found.  */
5846
5847 int
5848 sh_elf_get_flags_from_mach (unsigned long mach)
5849 {
5850   int i = ARRAY_SIZE (sh_ef_bfd_table) - 1;
5851
5852   for (; i>0; i--)
5853     if (sh_ef_bfd_table[i] == mach)
5854       return i;
5855
5856   /* shouldn't get here */
5857   BFD_FAIL();
5858
5859   return -1;
5860 }
5861 #endif /* not sh_elf_set_mach_from_flags */
5862
5863 #ifndef sh_elf_copy_private_data
5864 /* Copy backend specific data from one object module to another */
5865
5866 static bfd_boolean
5867 sh_elf_copy_private_data (bfd * ibfd, bfd * obfd)
5868 {
5869   if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
5870     return TRUE;
5871
5872   if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
5873     return FALSE;
5874
5875   return sh_elf_set_mach_from_flags (obfd);
5876 }
5877 #endif /* not sh_elf_copy_private_data */
5878
5879 #ifndef sh_elf_merge_private_data
5880
5881 /* This function returns the ELF architecture number that
5882    corresponds to the given arch_sh* flags.  */
5883
5884 int
5885 sh_find_elf_flags (unsigned int arch_set)
5886 {
5887   extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int);
5888   unsigned long bfd_mach = sh_get_bfd_mach_from_arch_set (arch_set);
5889
5890   return sh_elf_get_flags_from_mach (bfd_mach);
5891 }
5892
5893 /* Merge the architecture type of two BFD files, such that the
5894    resultant architecture supports all the features required
5895    by the two input BFDs.
5896    If the input BFDs are multually incompatible - i.e. one uses
5897    DSP while the other uses FPU - or there is no known architecture
5898    that fits the requirements then an error is emitted.  */
5899
5900 static bfd_boolean
5901 sh_merge_bfd_arch (bfd *ibfd, struct bfd_link_info *info)
5902 {
5903   bfd *obfd = info->output_bfd;
5904   unsigned int old_arch, new_arch, merged_arch;
5905
5906   if (! _bfd_generic_verify_endian_match (ibfd, info))
5907     return FALSE;
5908
5909   old_arch = sh_get_arch_up_from_bfd_mach (bfd_get_mach (obfd));
5910   new_arch = sh_get_arch_up_from_bfd_mach (bfd_get_mach (ibfd));
5911
5912   merged_arch = SH_MERGE_ARCH_SET (old_arch, new_arch);
5913
5914   if (!SH_VALID_CO_ARCH_SET (merged_arch))
5915     {
5916       _bfd_error_handler
5917         /* xgettext:c-format */
5918         (_("%pB: uses %s instructions while previous modules "
5919            "use %s instructions"),
5920          ibfd,
5921          SH_ARCH_SET_HAS_DSP (new_arch) ? "dsp" : "floating point",
5922          SH_ARCH_SET_HAS_DSP (new_arch) ? "floating point" : "dsp");
5923       bfd_set_error (bfd_error_bad_value);
5924       return FALSE;
5925     }
5926   else if (!SH_VALID_ARCH_SET (merged_arch))
5927     {
5928       _bfd_error_handler
5929         /* xgettext:c-format */
5930         (_("internal error: merge of architecture '%s' with "
5931            "architecture '%s' produced unknown architecture"),
5932          bfd_printable_name (obfd),
5933          bfd_printable_name (ibfd));
5934       bfd_set_error (bfd_error_bad_value);
5935       return FALSE;
5936     }
5937
5938   bfd_default_set_arch_mach (obfd, bfd_arch_sh,
5939                              sh_get_bfd_mach_from_arch_set (merged_arch));
5940
5941   return TRUE;
5942 }
5943
5944 /* This routine initialises the elf flags when required and
5945    calls sh_merge_bfd_arch() to check dsp/fpu compatibility.  */
5946
5947 static bfd_boolean
5948 sh_elf_merge_private_data (bfd *ibfd, struct bfd_link_info *info)
5949 {
5950   bfd *obfd = info->output_bfd;
5951
5952   if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd))
5953     return TRUE;
5954
5955   if (! elf_flags_init (obfd))
5956     {
5957       /* This happens when ld starts out with a 'blank' output file.  */
5958       elf_flags_init (obfd) = TRUE;
5959       elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
5960       sh_elf_set_mach_from_flags (obfd);
5961       if (elf_elfheader (obfd)->e_flags & EF_SH_FDPIC)
5962         elf_elfheader (obfd)->e_flags &= ~EF_SH_PIC;
5963     }
5964
5965   if (! sh_merge_bfd_arch (ibfd, info))
5966     {
5967       _bfd_error_handler (_("%pB: uses instructions which are incompatible "
5968                             "with instructions used in previous modules"),
5969                           ibfd);
5970       bfd_set_error (bfd_error_bad_value);
5971       return FALSE;
5972     }
5973
5974   elf_elfheader (obfd)->e_flags &= ~EF_SH_MACH_MASK;
5975   elf_elfheader (obfd)->e_flags |=
5976     sh_elf_get_flags_from_mach (bfd_get_mach (obfd));
5977
5978   if (fdpic_object_p (ibfd) != fdpic_object_p (obfd))
5979     {
5980       _bfd_error_handler (_("%pB: attempt to mix FDPIC and non-FDPIC objects"),
5981                           ibfd);
5982       bfd_set_error (bfd_error_bad_value);
5983       return FALSE;
5984     }
5985
5986   return TRUE;
5987 }
5988 #endif /* not sh_elf_merge_private_data */
5989
5990 /* Override the generic function because we need to store sh_elf_obj_tdata
5991    as the specific tdata.  We set also the machine architecture from flags
5992    here.  */
5993
5994 static bfd_boolean
5995 sh_elf_object_p (bfd *abfd)
5996 {
5997   if (! sh_elf_set_mach_from_flags (abfd))
5998     return FALSE;
5999
6000   return (((elf_elfheader (abfd)->e_flags & EF_SH_FDPIC) != 0)
6001           == fdpic_object_p (abfd));
6002 }
6003
6004 /* Finish up dynamic symbol handling.  We set the contents of various
6005    dynamic sections here.  */
6006
6007 static bfd_boolean
6008 sh_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
6009                               struct elf_link_hash_entry *h,
6010                               Elf_Internal_Sym *sym)
6011 {
6012   struct elf_sh_link_hash_table *htab;
6013
6014   htab = sh_elf_hash_table (info);
6015   if (htab == NULL)
6016     return FALSE;
6017
6018   if (h->plt.offset != (bfd_vma) -1)
6019     {
6020       asection *splt;
6021       asection *sgotplt;
6022       asection *srelplt;
6023
6024       bfd_vma plt_index;
6025       bfd_vma got_offset;
6026       Elf_Internal_Rela rel;
6027       bfd_byte *loc;
6028       const struct elf_sh_plt_info *plt_info;
6029
6030       /* This symbol has an entry in the procedure linkage table.  Set
6031          it up.  */
6032
6033       BFD_ASSERT (h->dynindx != -1);
6034
6035       splt = htab->root.splt;
6036       sgotplt = htab->root.sgotplt;
6037       srelplt = htab->root.srelplt;
6038       BFD_ASSERT (splt != NULL && sgotplt != NULL && srelplt != NULL);
6039
6040       /* Get the index in the procedure linkage table which
6041          corresponds to this symbol.  This is the index of this symbol
6042          in all the symbols for which we are making plt entries.  The
6043          first entry in the procedure linkage table is reserved.  */
6044       plt_index = get_plt_index (htab->plt_info, h->plt.offset);
6045
6046       plt_info = htab->plt_info;
6047       if (plt_info->short_plt != NULL && plt_index <= MAX_SHORT_PLT)
6048         plt_info = plt_info->short_plt;
6049
6050       /* Get the offset into the .got table of the entry that
6051          corresponds to this function.  */
6052       if (htab->fdpic_p)
6053         /* The offset must be relative to the GOT symbol, twelve bytes
6054            before the end of .got.plt.  Each descriptor is eight
6055            bytes.  */
6056         got_offset = plt_index * 8 + 12 - sgotplt->size;
6057       else
6058         /* Each .got entry is 4 bytes.  The first three are
6059            reserved.  */
6060         got_offset = (plt_index + 3) * 4;
6061
6062 #ifdef GOT_BIAS
6063       if (bfd_link_pic (info))
6064         got_offset -= GOT_BIAS;
6065 #endif
6066
6067       /* Fill in the entry in the procedure linkage table.  */
6068       memcpy (splt->contents + h->plt.offset,
6069               plt_info->symbol_entry,
6070               plt_info->symbol_entry_size);
6071
6072       if (bfd_link_pic (info) || htab->fdpic_p)
6073         {
6074           if (plt_info->symbol_fields.got20)
6075             {
6076               bfd_reloc_status_type r;
6077               r = install_movi20_field (output_bfd, got_offset,
6078                                         splt->owner, splt, splt->contents,
6079                                         h->plt.offset
6080                                         + plt_info->symbol_fields.got_entry);
6081               BFD_ASSERT (r == bfd_reloc_ok);
6082             }
6083           else
6084             install_plt_field (output_bfd, FALSE, got_offset,
6085                                (splt->contents
6086                                 + h->plt.offset
6087                                 + plt_info->symbol_fields.got_entry));
6088         }
6089       else
6090         {
6091           BFD_ASSERT (!plt_info->symbol_fields.got20);
6092
6093           install_plt_field (output_bfd, FALSE,
6094                              (sgotplt->output_section->vma
6095                               + sgotplt->output_offset
6096                               + got_offset),
6097                              (splt->contents
6098                               + h->plt.offset
6099                               + plt_info->symbol_fields.got_entry));
6100           if (htab->vxworks_p)
6101             {
6102               unsigned int reachable_plts, plts_per_4k;
6103               int distance;
6104
6105               /* Divide the PLT into groups.  The first group contains
6106                  REACHABLE_PLTS entries and the other groups contain
6107                  PLTS_PER_4K entries.  Entries in the first group can
6108                  branch directly to .plt; those in later groups branch
6109                  to the last element of the previous group.  */
6110               /* ??? It would be better to create multiple copies of
6111                  the common resolver stub.  */
6112               reachable_plts = ((4096
6113                                  - plt_info->plt0_entry_size
6114                                  - (plt_info->symbol_fields.plt + 4))
6115                                 / plt_info->symbol_entry_size) + 1;
6116               plts_per_4k = (4096 / plt_info->symbol_entry_size);
6117               if (plt_index < reachable_plts)
6118                 distance = -(h->plt.offset
6119                              + plt_info->symbol_fields.plt);
6120               else
6121                 distance = -(((plt_index - reachable_plts) % plts_per_4k + 1)
6122                              * plt_info->symbol_entry_size);
6123
6124               /* Install the 'bra' with this offset.  */
6125               bfd_put_16 (output_bfd,
6126                           0xa000 | (0x0fff & ((distance - 4) / 2)),
6127                           (splt->contents
6128                            + h->plt.offset
6129                            + plt_info->symbol_fields.plt));
6130             }
6131           else
6132             install_plt_field (output_bfd, TRUE,
6133                                splt->output_section->vma + splt->output_offset,
6134                                (splt->contents
6135                                 + h->plt.offset
6136                                 + plt_info->symbol_fields.plt));
6137         }
6138
6139       /* Make got_offset relative to the start of .got.plt.  */
6140 #ifdef GOT_BIAS
6141       if (bfd_link_pic (info))
6142         got_offset += GOT_BIAS;
6143 #endif
6144       if (htab->fdpic_p)
6145         got_offset = plt_index * 8;
6146
6147       if (plt_info->symbol_fields.reloc_offset != MINUS_ONE)
6148         install_plt_field (output_bfd, FALSE,
6149                            plt_index * sizeof (Elf32_External_Rela),
6150                            (splt->contents
6151                             + h->plt.offset
6152                             + plt_info->symbol_fields.reloc_offset));
6153
6154       /* Fill in the entry in the global offset table.  */
6155       bfd_put_32 (output_bfd,
6156                   (splt->output_section->vma
6157                    + splt->output_offset
6158                    + h->plt.offset
6159                    + plt_info->symbol_resolve_offset),
6160                   sgotplt->contents + got_offset);
6161       if (htab->fdpic_p)
6162         bfd_put_32 (output_bfd,
6163                     sh_elf_osec_to_segment (output_bfd, splt->output_section),
6164                     sgotplt->contents + got_offset + 4);
6165
6166       /* Fill in the entry in the .rela.plt section.  */
6167       rel.r_offset = (sgotplt->output_section->vma
6168                       + sgotplt->output_offset
6169                       + got_offset);
6170       if (htab->fdpic_p)
6171         rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_FUNCDESC_VALUE);
6172       else
6173         rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
6174       rel.r_addend = 0;
6175 #ifdef GOT_BIAS
6176       rel.r_addend = GOT_BIAS;
6177 #endif
6178       loc = srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
6179       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6180
6181       if (htab->vxworks_p && !bfd_link_pic (info))
6182         {
6183           /* Create the .rela.plt.unloaded relocations for this PLT entry.
6184              Begin by pointing LOC to the first such relocation.  */
6185           loc = (htab->srelplt2->contents
6186                  + (plt_index * 2 + 1) * sizeof (Elf32_External_Rela));
6187
6188           /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
6189              for the PLT entry's pointer to the .got.plt entry.  */
6190           rel.r_offset = (splt->output_section->vma
6191                           + splt->output_offset
6192                           + h->plt.offset
6193                           + plt_info->symbol_fields.got_entry);
6194           rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32);
6195           rel.r_addend = got_offset;
6196           bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6197           loc += sizeof (Elf32_External_Rela);
6198
6199           /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
6200              the .got.plt entry, which initially points to .plt.  */
6201           rel.r_offset = (sgotplt->output_section->vma
6202                           + sgotplt->output_offset
6203                           + got_offset);
6204           rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_SH_DIR32);
6205           rel.r_addend = 0;
6206           bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6207         }
6208
6209       if (!h->def_regular)
6210         {
6211           /* Mark the symbol as undefined, rather than as defined in
6212              the .plt section.  Leave the value alone.  */
6213           sym->st_shndx = SHN_UNDEF;
6214         }
6215     }
6216
6217   if (h->got.offset != (bfd_vma) -1
6218       && sh_elf_hash_entry (h)->got_type != GOT_TLS_GD
6219       && sh_elf_hash_entry (h)->got_type != GOT_TLS_IE
6220       && sh_elf_hash_entry (h)->got_type != GOT_FUNCDESC)
6221     {
6222       asection *sgot;
6223       asection *srelgot;
6224       Elf_Internal_Rela rel;
6225       bfd_byte *loc;
6226
6227       /* This symbol has an entry in the global offset table.  Set it
6228          up.  */
6229
6230       sgot = htab->root.sgot;
6231       srelgot = htab->root.srelgot;
6232       BFD_ASSERT (sgot != NULL && srelgot != NULL);
6233
6234       rel.r_offset = (sgot->output_section->vma
6235                       + sgot->output_offset
6236                       + (h->got.offset &~ (bfd_vma) 1));
6237
6238       /* If this is a static link, or it is a -Bsymbolic link and the
6239          symbol is defined locally or was forced to be local because
6240          of a version file, we just want to emit a RELATIVE reloc.
6241          The entry in the global offset table will already have been
6242          initialized in the relocate_section function.  */
6243       if (bfd_link_pic (info)
6244           && SYMBOL_REFERENCES_LOCAL (info, h))
6245         {
6246           if (htab->fdpic_p)
6247             {
6248               asection *sec = h->root.u.def.section;
6249               int dynindx
6250                 = elf_section_data (sec->output_section)->dynindx;
6251
6252               rel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32);
6253               rel.r_addend = (h->root.u.def.value
6254                               + h->root.u.def.section->output_offset);
6255             }
6256           else
6257             {
6258               rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
6259               rel.r_addend = (h->root.u.def.value
6260                               + h->root.u.def.section->output_section->vma
6261                               + h->root.u.def.section->output_offset);
6262             }
6263         }
6264       else
6265         {
6266           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
6267           rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
6268           rel.r_addend = 0;
6269         }
6270
6271       loc = srelgot->contents;
6272       loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
6273       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6274     }
6275
6276   if (h->needs_copy)
6277     {
6278       asection *s;
6279       Elf_Internal_Rela rel;
6280       bfd_byte *loc;
6281
6282       /* This symbol needs a copy reloc.  Set it up.  */
6283
6284       BFD_ASSERT (h->dynindx != -1
6285                   && (h->root.type == bfd_link_hash_defined
6286                       || h->root.type == bfd_link_hash_defweak));
6287
6288       s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
6289       BFD_ASSERT (s != NULL);
6290
6291       rel.r_offset = (h->root.u.def.value
6292                       + h->root.u.def.section->output_section->vma
6293                       + h->root.u.def.section->output_offset);
6294       rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
6295       rel.r_addend = 0;
6296       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
6297       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6298     }
6299
6300   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  On VxWorks,
6301      _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
6302      ".got" section.  */
6303   if (h == htab->root.hdynamic
6304       || (!htab->vxworks_p && h == htab->root.hgot))
6305     sym->st_shndx = SHN_ABS;
6306
6307   return TRUE;
6308 }
6309
6310 /* Finish up the dynamic sections.  */
6311
6312 static bfd_boolean
6313 sh_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
6314 {
6315   struct elf_sh_link_hash_table *htab;
6316   asection *sgotplt;
6317   asection *sdyn;
6318
6319   htab = sh_elf_hash_table (info);
6320   if (htab == NULL)
6321     return FALSE;
6322
6323   sgotplt = htab->root.sgotplt;
6324   sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic");
6325
6326   if (htab->root.dynamic_sections_created)
6327     {
6328       asection *splt;
6329       Elf32_External_Dyn *dyncon, *dynconend;
6330
6331       BFD_ASSERT (sgotplt != NULL && sdyn != NULL);
6332
6333       dyncon = (Elf32_External_Dyn *) sdyn->contents;
6334       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
6335       for (; dyncon < dynconend; dyncon++)
6336         {
6337           Elf_Internal_Dyn dyn;
6338           asection *s;
6339
6340           bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn);
6341
6342           switch (dyn.d_tag)
6343             {
6344             default:
6345               if (htab->vxworks_p
6346                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
6347                 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6348               break;
6349
6350             case DT_PLTGOT:
6351               BFD_ASSERT (htab->root.hgot != NULL);
6352               s = htab->root.hgot->root.u.def.section;
6353               dyn.d_un.d_ptr = htab->root.hgot->root.u.def.value
6354                 + s->output_section->vma + s->output_offset;
6355               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6356               break;
6357
6358             case DT_JMPREL:
6359               s = htab->root.srelplt->output_section;
6360               BFD_ASSERT (s != NULL);
6361               dyn.d_un.d_ptr = s->vma;
6362               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6363               break;
6364
6365             case DT_PLTRELSZ:
6366               s = htab->root.srelplt->output_section;
6367               BFD_ASSERT (s != NULL);
6368               dyn.d_un.d_val = s->size;
6369               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6370               break;
6371             }
6372         }
6373
6374       /* Fill in the first entry in the procedure linkage table.  */
6375       splt = htab->root.splt;
6376       if (splt && splt->size > 0 && htab->plt_info->plt0_entry)
6377         {
6378           unsigned int i;
6379
6380           memcpy (splt->contents,
6381                   htab->plt_info->plt0_entry,
6382                   htab->plt_info->plt0_entry_size);
6383           for (i = 0; i < ARRAY_SIZE (htab->plt_info->plt0_got_fields); i++)
6384             if (htab->plt_info->plt0_got_fields[i] != MINUS_ONE)
6385               install_plt_field (output_bfd, FALSE,
6386                                  (sgotplt->output_section->vma
6387                                   + sgotplt->output_offset
6388                                   + (i * 4)),
6389                                  (splt->contents
6390                                   + htab->plt_info->plt0_got_fields[i]));
6391
6392           if (htab->vxworks_p)
6393             {
6394               /* Finalize the .rela.plt.unloaded contents.  */
6395               Elf_Internal_Rela rel;
6396               bfd_byte *loc;
6397
6398               /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
6399                  first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8.  */
6400               loc = htab->srelplt2->contents;
6401               rel.r_offset = (splt->output_section->vma
6402                               + splt->output_offset
6403                               + htab->plt_info->plt0_got_fields[2]);
6404               rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32);
6405               rel.r_addend = 8;
6406               bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6407               loc += sizeof (Elf32_External_Rela);
6408
6409               /* Fix up the remaining .rela.plt.unloaded relocations.
6410                  They may have the wrong symbol index for _G_O_T_ or
6411                  _P_L_T_ depending on the order in which symbols were
6412                  output.  */
6413               while (loc < htab->srelplt2->contents + htab->srelplt2->size)
6414                 {
6415                   /* The PLT entry's pointer to the .got.plt slot.  */
6416                   bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
6417                   rel.r_info = ELF32_R_INFO (htab->root.hgot->indx,
6418                                              R_SH_DIR32);
6419                   bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6420                   loc += sizeof (Elf32_External_Rela);
6421
6422                   /* The .got.plt slot's pointer to .plt.  */
6423                   bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
6424                   rel.r_info = ELF32_R_INFO (htab->root.hplt->indx,
6425                                              R_SH_DIR32);
6426                   bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6427                   loc += sizeof (Elf32_External_Rela);
6428                 }
6429             }
6430
6431           /* UnixWare sets the entsize of .plt to 4, although that doesn't
6432              really seem like the right value.  */
6433           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
6434         }
6435     }
6436
6437   /* Fill in the first three entries in the global offset table.  */
6438   if (sgotplt && sgotplt->size > 0 && !htab->fdpic_p)
6439     {
6440       if (sdyn == NULL)
6441         bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
6442       else
6443         bfd_put_32 (output_bfd,
6444                     sdyn->output_section->vma + sdyn->output_offset,
6445                     sgotplt->contents);
6446       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
6447       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
6448     }
6449
6450   if (sgotplt && sgotplt->size > 0)
6451     elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
6452
6453   /* At the very end of the .rofixup section is a pointer to the GOT.  */
6454   if (htab->fdpic_p && htab->srofixup != NULL)
6455     {
6456       struct elf_link_hash_entry *hgot = htab->root.hgot;
6457       bfd_vma got_value = hgot->root.u.def.value
6458         + hgot->root.u.def.section->output_section->vma
6459         + hgot->root.u.def.section->output_offset;
6460
6461       sh_elf_add_rofixup (output_bfd, htab->srofixup, got_value);
6462
6463       /* Make sure we allocated and generated the same number of fixups.  */
6464       BFD_ASSERT (htab->srofixup->reloc_count * 4 == htab->srofixup->size);
6465     }
6466
6467   if (htab->srelfuncdesc)
6468     BFD_ASSERT (htab->srelfuncdesc->reloc_count * sizeof (Elf32_External_Rela)
6469                 == htab->srelfuncdesc->size);
6470
6471   if (htab->root.srelgot)
6472     BFD_ASSERT (htab->root.srelgot->reloc_count * sizeof (Elf32_External_Rela)
6473                 == htab->root.srelgot->size);
6474
6475   return TRUE;
6476 }
6477
6478 static enum elf_reloc_type_class
6479 sh_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
6480                          const asection *rel_sec ATTRIBUTE_UNUSED,
6481                          const Elf_Internal_Rela *rela)
6482 {
6483   switch ((int) ELF32_R_TYPE (rela->r_info))
6484     {
6485     case R_SH_RELATIVE:
6486       return reloc_class_relative;
6487     case R_SH_JMP_SLOT:
6488       return reloc_class_plt;
6489     case R_SH_COPY:
6490       return reloc_class_copy;
6491     default:
6492       return reloc_class_normal;
6493     }
6494 }
6495
6496 #if !defined SH_TARGET_ALREADY_DEFINED
6497 /* Support for Linux core dump NOTE sections.  */
6498
6499 static bfd_boolean
6500 elf32_shlin_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
6501 {
6502   int offset;
6503   unsigned int size;
6504
6505   switch (note->descsz)
6506     {
6507       default:
6508         return FALSE;
6509
6510       case 168:         /* Linux/SH */
6511         /* pr_cursig */
6512         elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
6513
6514         /* pr_pid */
6515         elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
6516
6517         /* pr_reg */
6518         offset = 72;
6519         size = 92;
6520
6521         break;
6522     }
6523
6524   /* Make a ".reg/999" section.  */
6525   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
6526                                           size, note->descpos + offset);
6527 }
6528
6529 static bfd_boolean
6530 elf32_shlin_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
6531 {
6532   switch (note->descsz)
6533     {
6534       default:
6535         return FALSE;
6536
6537       case 124:         /* Linux/SH elf_prpsinfo */
6538         elf_tdata (abfd)->core->program
6539          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
6540         elf_tdata (abfd)->core->command
6541          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
6542     }
6543
6544   /* Note that for some reason, a spurious space is tacked
6545      onto the end of the args in some (at least one anyway)
6546      implementations, so strip it off if it exists.  */
6547
6548   {
6549     char *command = elf_tdata (abfd)->core->command;
6550     int n = strlen (command);
6551
6552     if (0 < n && command[n - 1] == ' ')
6553       command[n - 1] = '\0';
6554   }
6555
6556   return TRUE;
6557 }
6558 #endif /* not SH_TARGET_ALREADY_DEFINED */
6559
6560
6561 /* Return address for Ith PLT stub in section PLT, for relocation REL
6562    or (bfd_vma) -1 if it should not be included.  */
6563
6564 static bfd_vma
6565 sh_elf_plt_sym_val (bfd_vma i, const asection *plt,
6566                     const arelent *rel ATTRIBUTE_UNUSED)
6567 {
6568   const struct elf_sh_plt_info *plt_info;
6569
6570   plt_info = get_plt_info (plt->owner, (plt->owner->flags & DYNAMIC) != 0);
6571   return plt->vma + get_plt_offset (plt_info, i);
6572 }
6573
6574 /* Decide whether to attempt to turn absptr or lsda encodings in
6575    shared libraries into pcrel within the given input section.  */
6576
6577 static bfd_boolean
6578 sh_elf_use_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
6579                               struct bfd_link_info *info,
6580                               asection *eh_frame_section ATTRIBUTE_UNUSED)
6581 {
6582   struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
6583
6584   /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
6585   if (htab->fdpic_p)
6586     return FALSE;
6587
6588   return TRUE;
6589 }
6590
6591 /* Adjust the contents of an eh_frame_hdr section before they're output.  */
6592
6593 static bfd_byte
6594 sh_elf_encode_eh_address (bfd *abfd,
6595                           struct bfd_link_info *info,
6596                           asection *osec, bfd_vma offset,
6597                           asection *loc_sec, bfd_vma loc_offset,
6598                           bfd_vma *encoded)
6599 {
6600   struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info);
6601   struct elf_link_hash_entry *h;
6602
6603   if (!htab->fdpic_p)
6604     return _bfd_elf_encode_eh_address (abfd, info, osec, offset, loc_sec,
6605                                        loc_offset, encoded);
6606
6607   h = htab->root.hgot;
6608   BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
6609
6610   if (! h || (sh_elf_osec_to_segment (abfd, osec)
6611               == sh_elf_osec_to_segment (abfd, loc_sec->output_section)))
6612     return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
6613                                        loc_sec, loc_offset, encoded);
6614
6615   BFD_ASSERT (sh_elf_osec_to_segment (abfd, osec)
6616               == (sh_elf_osec_to_segment
6617                   (abfd, h->root.u.def.section->output_section)));
6618
6619   *encoded = osec->vma + offset
6620     - (h->root.u.def.value
6621        + h->root.u.def.section->output_section->vma
6622        + h->root.u.def.section->output_offset);
6623
6624   return DW_EH_PE_datarel | DW_EH_PE_sdata4;
6625 }
6626
6627 #if !defined SH_TARGET_ALREADY_DEFINED
6628 #define TARGET_BIG_SYM          sh_elf32_vec
6629 #define TARGET_BIG_NAME         "elf32-sh"
6630 #define TARGET_LITTLE_SYM       sh_elf32_le_vec
6631 #define TARGET_LITTLE_NAME      "elf32-shl"
6632 #endif
6633
6634 #define ELF_ARCH                bfd_arch_sh
6635 #define ELF_TARGET_ID           SH_ELF_DATA
6636 #define ELF_MACHINE_CODE        EM_SH
6637 #ifdef __QNXTARGET__
6638 #define ELF_MAXPAGESIZE         0x1000
6639 #else
6640 #define ELF_MAXPAGESIZE         0x80
6641 #endif
6642
6643 #define elf_symbol_leading_char '_'
6644
6645 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
6646 #define bfd_elf32_bfd_reloc_name_lookup \
6647                                         sh_elf_reloc_name_lookup
6648 #define elf_info_to_howto               sh_elf_info_to_howto
6649 #define bfd_elf32_bfd_relax_section     sh_elf_relax_section
6650 #define elf_backend_relocate_section    sh_elf_relocate_section
6651 #define bfd_elf32_bfd_get_relocated_section_contents \
6652                                         sh_elf_get_relocated_section_contents
6653 #define bfd_elf32_mkobject              sh_elf_mkobject
6654 #define elf_backend_object_p            sh_elf_object_p
6655 #define bfd_elf32_bfd_copy_private_bfd_data \
6656                                         sh_elf_copy_private_data
6657 #define bfd_elf32_bfd_merge_private_bfd_data \
6658                                         sh_elf_merge_private_data
6659
6660 #define elf_backend_gc_mark_hook        sh_elf_gc_mark_hook
6661 #define elf_backend_check_relocs        sh_elf_check_relocs
6662 #define elf_backend_copy_indirect_symbol \
6663                                         sh_elf_copy_indirect_symbol
6664 #define elf_backend_create_dynamic_sections \
6665                                         sh_elf_create_dynamic_sections
6666 #define bfd_elf32_bfd_link_hash_table_create \
6667                                         sh_elf_link_hash_table_create
6668 #define elf_backend_adjust_dynamic_symbol \
6669                                         sh_elf_adjust_dynamic_symbol
6670 #define elf_backend_always_size_sections \
6671                                         sh_elf_always_size_sections
6672 #define elf_backend_size_dynamic_sections \
6673                                         sh_elf_size_dynamic_sections
6674 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
6675 #define elf_backend_finish_dynamic_symbol \
6676                                         sh_elf_finish_dynamic_symbol
6677 #define elf_backend_finish_dynamic_sections \
6678                                         sh_elf_finish_dynamic_sections
6679 #define elf_backend_reloc_type_class    sh_elf_reloc_type_class
6680 #define elf_backend_plt_sym_val         sh_elf_plt_sym_val
6681 #define elf_backend_can_make_relative_eh_frame \
6682                                         sh_elf_use_relative_eh_frame
6683 #define elf_backend_can_make_lsda_relative_eh_frame \
6684                                         sh_elf_use_relative_eh_frame
6685 #define elf_backend_encode_eh_address \
6686                                         sh_elf_encode_eh_address
6687
6688 #define elf_backend_stack_align         8
6689 #define elf_backend_can_gc_sections     1
6690 #define elf_backend_can_refcount        1
6691 #define elf_backend_want_got_plt        1
6692 #define elf_backend_plt_readonly        1
6693 #define elf_backend_want_plt_sym        0
6694 #define elf_backend_got_header_size     12
6695 #define elf_backend_dtrel_excludes_plt  1
6696
6697 #define elf_backend_linux_prpsinfo32_ugid16     TRUE
6698
6699 #if !defined SH_TARGET_ALREADY_DEFINED
6700
6701 #include "elf32-target.h"
6702
6703 /* NetBSD support.  */
6704 #undef  TARGET_BIG_SYM
6705 #define TARGET_BIG_SYM                  sh_elf32_nbsd_vec
6706 #undef  TARGET_BIG_NAME
6707 #define TARGET_BIG_NAME                 "elf32-sh-nbsd"
6708 #undef  TARGET_LITTLE_SYM
6709 #define TARGET_LITTLE_SYM               sh_elf32_nbsd_le_vec
6710 #undef  TARGET_LITTLE_NAME
6711 #define TARGET_LITTLE_NAME              "elf32-shl-nbsd"
6712 #undef  ELF_MAXPAGESIZE
6713 #define ELF_MAXPAGESIZE                 0x10000
6714 #undef  ELF_COMMONPAGESIZE
6715 #undef  elf_symbol_leading_char
6716 #define elf_symbol_leading_char         0
6717 #undef  elf32_bed
6718 #define elf32_bed                       elf32_sh_nbsd_bed
6719
6720 #include "elf32-target.h"
6721
6722
6723 /* Linux support.  */
6724 #undef  TARGET_BIG_SYM
6725 #define TARGET_BIG_SYM                  sh_elf32_linux_be_vec
6726 #undef  TARGET_BIG_NAME
6727 #define TARGET_BIG_NAME                 "elf32-shbig-linux"
6728 #undef  TARGET_LITTLE_SYM
6729 #define TARGET_LITTLE_SYM               sh_elf32_linux_vec
6730 #undef  TARGET_LITTLE_NAME
6731 #define TARGET_LITTLE_NAME              "elf32-sh-linux"
6732 #undef  ELF_COMMONPAGESIZE
6733 #define ELF_COMMONPAGESIZE              0x1000
6734
6735 #undef  elf_backend_grok_prstatus
6736 #define elf_backend_grok_prstatus       elf32_shlin_grok_prstatus
6737 #undef  elf_backend_grok_psinfo
6738 #define elf_backend_grok_psinfo         elf32_shlin_grok_psinfo
6739 #undef  elf32_bed
6740 #define elf32_bed                       elf32_sh_lin_bed
6741
6742 #include "elf32-target.h"
6743
6744
6745 /* FDPIC support.  */
6746 #undef  TARGET_BIG_SYM
6747 #define TARGET_BIG_SYM                  sh_elf32_fdpic_be_vec
6748 #undef  TARGET_BIG_NAME
6749 #define TARGET_BIG_NAME                 "elf32-shbig-fdpic"
6750 #undef  TARGET_LITTLE_SYM
6751 #define TARGET_LITTLE_SYM               sh_elf32_fdpic_le_vec
6752 #undef  TARGET_LITTLE_NAME
6753 #define TARGET_LITTLE_NAME              "elf32-sh-fdpic"
6754
6755 #undef  elf32_bed
6756 #define elf32_bed                       elf32_sh_fd_bed
6757
6758 #include "elf32-target.h"
6759
6760 #undef elf_backend_modify_program_headers
6761
6762 /* VxWorks support.  */
6763 #undef  TARGET_BIG_SYM
6764 #define TARGET_BIG_SYM                  sh_elf32_vxworks_vec
6765 #undef  TARGET_BIG_NAME
6766 #define TARGET_BIG_NAME                 "elf32-sh-vxworks"
6767 #undef  TARGET_LITTLE_SYM
6768 #define TARGET_LITTLE_SYM               sh_elf32_vxworks_le_vec
6769 #undef  TARGET_LITTLE_NAME
6770 #define TARGET_LITTLE_NAME              "elf32-shl-vxworks"
6771 #undef  elf32_bed
6772 #define elf32_bed                       elf32_sh_vxworks_bed
6773
6774 #undef  elf_backend_want_plt_sym
6775 #define elf_backend_want_plt_sym        1
6776 #undef  elf_symbol_leading_char
6777 #define elf_symbol_leading_char         '_'
6778 #define elf_backend_want_got_underscore 1
6779 #undef  elf_backend_grok_prstatus
6780 #undef  elf_backend_grok_psinfo
6781 #undef  elf_backend_add_symbol_hook
6782 #define elf_backend_add_symbol_hook     elf_vxworks_add_symbol_hook
6783 #undef  elf_backend_link_output_symbol_hook
6784 #define elf_backend_link_output_symbol_hook \
6785                                         elf_vxworks_link_output_symbol_hook
6786 #undef  elf_backend_emit_relocs
6787 #define elf_backend_emit_relocs         elf_vxworks_emit_relocs
6788 #undef  elf_backend_final_write_processing
6789 #define elf_backend_final_write_processing \
6790                                         elf_vxworks_final_write_processing
6791 #undef  ELF_MAXPAGESIZE
6792 #define ELF_MAXPAGESIZE                 0x1000
6793 #undef  ELF_COMMONPAGESIZE
6794
6795 #include "elf32-target.h"
6796
6797 #endif /* not SH_TARGET_ALREADY_DEFINED */