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