1 /* SuperH SH64-specific support for 64-bit ELF
2    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3    2010, 2011, 2012 Free Software Foundation, Inc.
4 
5    This file is part of BFD, the Binary File Descriptor library.
6 
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11 
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16 
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21 
22 #define SH64_ELF64
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/sh.h"
30 
31 /* Add a suffix for datalabel indirection symbols.  It must not match any
32    other symbols; user symbols with or without version or other
33    decoration.  It must only be used internally and not emitted by any
34    means.  */
35 #define DATALABEL_SUFFIX " DL"
36 
37 #define GOT_BIAS (-((long)-32768))
38 
39 #define PLT_ENTRY_SIZE 64
40 
41 /* Return size of a PLT entry.  */
42 #define elf_sh64_sizeof_plt(info) PLT_ENTRY_SIZE
43 
44 /* Return offset of the PLT0 address in an absolute PLT entry.  */
45 #define elf_sh64_plt_plt0_offset(info) 32
46 
47 /* Return offset of the linker in PLT0 entry.  */
48 #define elf_sh64_plt0_gotplt_offset(info) 0
49 
50 /* Return offset of the trampoline in PLT entry */
51 #define elf_sh64_plt_temp_offset(info) 33 /* Add one because it's SHmedia.  */
52 
53 /* Return offset of the symbol in PLT entry.  */
54 #define elf_sh64_plt_symbol_offset(info) 0
55 
56 /* Return offset of the relocation in PLT entry.  */
57 #define elf_sh64_plt_reloc_offset(info) (info->shared ? 52 : 44)
58 
59 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
60 
61 /* The sh linker needs to keep track of the number of relocs that it
62    decides to copy in check_relocs for each symbol.  This is so that
63    it can discard PC relative relocs if it doesn't need them when
64    linking with -Bsymbolic.  We store the information in a field
65    extending the regular ELF linker hash table.  */
66 
67 /* This structure keeps track of the number of PC relative relocs we
68    have copied for a given symbol.  */
69 
70 struct elf_sh64_pcrel_relocs_copied
71 {
72   /* Next section.  */
73   struct elf_sh64_pcrel_relocs_copied *next;
74   /* A section in dynobj.  */
75   asection *section;
76   /* Number of relocs copied in this section.  */
77   bfd_size_type count;
78 };
79 
80 /* sh ELF linker hash entry.  */
81 
82 struct elf_sh64_link_hash_entry
83 {
84   struct elf_link_hash_entry root;
85 
86   bfd_vma datalabel_got_offset;
87 
88   /* Number of PC relative relocs copied for this symbol.  */
89   struct elf_sh64_pcrel_relocs_copied *pcrel_relocs_copied;
90 };
91 
92 /* Traverse an sh ELF linker hash table.  */
93 
94 #define sh64_elf64_link_hash_traverse(table, func, info)	\
95   (elf_link_hash_traverse					\
96    ((table),							\
97     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
98     (info)))
99 
100 static bfd_reloc_status_type sh_elf64_ignore_reloc
101   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
102 static bfd_reloc_status_type sh_elf64_reloc
103   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
104 
105 static reloc_howto_type sh_elf64_howto_table[] = {
106   /* No relocation.  */
107   HOWTO (R_SH_NONE,		/* type */
108 	 0,			/* rightshift */
109 	 0,			/* size (0 = byte, 1 = short, 2 = long) */
110 	 0,			/* bitsize */
111 	 FALSE,			/* pc_relative */
112 	 0,			/* bitpos */
113 	 complain_overflow_dont, /* complain_on_overflow */
114 	 sh_elf64_ignore_reloc,	/* special_function */
115 	 "R_SH_NONE",		/* name */
116 	 FALSE,			/* partial_inplace */
117 	 0,			/* src_mask */
118 	 0,			/* dst_mask */
119 	 FALSE),		/* pcrel_offset */
120 
121   /* 32 bit absolute relocation.  Setting partial_inplace to TRUE and
122      src_mask to a non-zero value is similar to the COFF toolchain.  */
123   HOWTO (R_SH_DIR32,		/* type */
124 	 0,			/* rightshift */
125 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
126 	 32,			/* bitsize */
127 	 FALSE,			/* pc_relative */
128 	 0,			/* bitpos */
129 	 complain_overflow_bitfield, /* complain_on_overflow */
130 	 sh_elf64_reloc,		/* special_function */
131 	 "R_SH_DIR32",		/* name */
132 	 TRUE,			/* partial_inplace */
133 	 0xffffffff,		/* src_mask */
134 	 0xffffffff,		/* dst_mask */
135 	 FALSE),		/* pcrel_offset */
136 
137   /* 32 bit PC relative relocation.  */
138   HOWTO (R_SH_REL32,		/* type */
139 	 0,			/* rightshift */
140 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
141 	 32,			/* bitsize */
142 	 TRUE,			/* pc_relative */
143 	 0,			/* bitpos */
144 	 complain_overflow_signed, /* complain_on_overflow */
145 	 sh_elf64_ignore_reloc,	/* special_function */
146 	 "R_SH_REL32",		/* name */
147 	 FALSE,			/* partial_inplace */
148 	 0,			/* src_mask */
149 	 0xffffffff,		/* dst_mask */
150 	 TRUE),			/* pcrel_offset */
151 
152   /* For 32-bit sh, this is R_SH_DIR8WPN.  */
153   EMPTY_HOWTO (3),
154 
155   /* For 32-bit sh, this is R_SH_IND12W.  */
156   EMPTY_HOWTO (4),
157 
158   /* For 32-bit sh, this is R_SH_DIR8WPL.  */
159   EMPTY_HOWTO (5),
160 
161   /* For 32-bit sh, this is R_SH_DIR8WPZ.  */
162   EMPTY_HOWTO (6),
163 
164   /* For 32-bit sh, this is R_SH_DIR8BP.  */
165   EMPTY_HOWTO (7),
166 
167   /* For 32-bit sh, this is R_SH_DIR8W.  */
168   EMPTY_HOWTO (8),
169 
170   /* For 32-bit sh, this is R_SH_DIR8L.  */
171   EMPTY_HOWTO (9),
172 
173   EMPTY_HOWTO (10),
174   EMPTY_HOWTO (11),
175   EMPTY_HOWTO (12),
176   EMPTY_HOWTO (13),
177   EMPTY_HOWTO (14),
178   EMPTY_HOWTO (15),
179   EMPTY_HOWTO (16),
180   EMPTY_HOWTO (17),
181   EMPTY_HOWTO (18),
182   EMPTY_HOWTO (19),
183   EMPTY_HOWTO (20),
184   EMPTY_HOWTO (21),
185   EMPTY_HOWTO (22),
186   EMPTY_HOWTO (23),
187   EMPTY_HOWTO (24),
188 
189   /* The remaining relocs are a GNU extension used for relaxing.  The
190      final pass of the linker never needs to do anything with any of
191      these relocs.  Any required operations are handled by the
192      relaxation code.  */
193 
194   /* A 16 bit switch table entry.  This is generated for an expression
195      such as ``.word L1 - L2''.  The offset holds the difference
196      between the reloc address and L2.  */
197   HOWTO (R_SH_SWITCH16,		/* type */
198 	 0,			/* rightshift */
199 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
200 	 16,			/* bitsize */
201 	 FALSE,			/* pc_relative */
202 	 0,			/* bitpos */
203 	 complain_overflow_unsigned, /* complain_on_overflow */
204 	 sh_elf64_ignore_reloc,	/* special_function */
205 	 "R_SH_SWITCH16",	/* name */
206 	 FALSE,			/* partial_inplace */
207 	 0,			/* src_mask */
208 	 0,			/* dst_mask */
209 	 TRUE),			/* pcrel_offset */
210 
211   /* A 32 bit switch table entry.  This is generated for an expression
212      such as ``.long L1 - L2''.  The offset holds the difference
213      between the reloc address and L2.  */
214   HOWTO (R_SH_SWITCH32,		/* type */
215 	 0,			/* rightshift */
216 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
217 	 32,			/* bitsize */
218 	 FALSE,			/* pc_relative */
219 	 0,			/* bitpos */
220 	 complain_overflow_unsigned, /* complain_on_overflow */
221 	 sh_elf64_ignore_reloc,	/* special_function */
222 	 "R_SH_SWITCH32",	/* name */
223 	 FALSE,			/* partial_inplace */
224 	 0,			/* src_mask */
225 	 0,			/* dst_mask */
226 	 TRUE),			/* pcrel_offset */
227 
228   /* For 32-bit sh, this is R_SH_USES.  */
229   EMPTY_HOWTO (27),
230 
231   /* For 32-bit sh, this is R_SH_COUNT.  */
232   EMPTY_HOWTO (28),
233 
234   /* For 32-bit sh, this is R_SH_ALIGN.  FIXME: For linker relaxation,
235      this might be emitted.  When linker relaxation is implemented, we
236      might want to use it.  */
237   EMPTY_HOWTO (29),
238 
239   /* For 32-bit sh, this is R_SH_CODE.  FIXME: For linker relaxation,
240      this might be emitted.  When linker relaxation is implemented, we
241      might want to use it.  */
242   EMPTY_HOWTO (30),
243 
244   /* For 32-bit sh, this is R_SH_DATA.  FIXME: For linker relaxation,
245      this might be emitted.  When linker relaxation is implemented, we
246      might want to use it.  */
247   EMPTY_HOWTO (31),
248 
249   /* For 32-bit sh, this is R_SH_LABEL.  FIXME: For linker relaxation,
250      this might be emitted.  When linker relaxation is implemented, we
251      might want to use it.  */
252   EMPTY_HOWTO (32),
253 
254   /* An 8 bit switch table entry.  This is generated for an expression
255      such as ``.word L1 - L2''.  The offset holds the difference
256      between the reloc address and L2.  */
257   HOWTO (R_SH_SWITCH8,		/* type */
258 	 0,			/* rightshift */
259 	 0,			/* size (0 = byte, 1 = short, 2 = long) */
260 	 8,			/* bitsize */
261 	 FALSE,			/* pc_relative */
262 	 0,			/* bitpos */
263 	 complain_overflow_unsigned, /* complain_on_overflow */
264 	 sh_elf64_ignore_reloc,	/* special_function */
265 	 "R_SH_SWITCH8",	/* name */
266 	 FALSE,			/* partial_inplace */
267 	 0,			/* src_mask */
268 	 0,			/* dst_mask */
269 	 TRUE),			/* pcrel_offset */
270 
271   /* GNU extension to record C++ vtable hierarchy */
272   HOWTO (R_SH_GNU_VTINHERIT, /* type */
273          0,                     /* rightshift */
274          2,                     /* size (0 = byte, 1 = short, 2 = long) */
275          0,                     /* bitsize */
276          FALSE,                 /* pc_relative */
277          0,                     /* bitpos */
278          complain_overflow_dont, /* complain_on_overflow */
279          NULL,                  /* special_function */
280          "R_SH_GNU_VTINHERIT", /* name */
281          FALSE,                 /* partial_inplace */
282          0,                     /* src_mask */
283          0,                     /* dst_mask */
284          FALSE),                /* pcrel_offset */
285 
286   /* GNU extension to record C++ vtable member usage */
287   HOWTO (R_SH_GNU_VTENTRY,     /* type */
288          0,                     /* rightshift */
289          2,                     /* size (0 = byte, 1 = short, 2 = long) */
290          0,                     /* bitsize */
291          FALSE,                 /* pc_relative */
292          0,                     /* bitpos */
293          complain_overflow_dont, /* complain_on_overflow */
294          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
295          "R_SH_GNU_VTENTRY",   /* name */
296          FALSE,                 /* partial_inplace */
297          0,                     /* src_mask */
298          0,                     /* dst_mask */
299          FALSE),                /* pcrel_offset */
300 
301   /* For 32-bit sh, this is R_SH_LOOP_START.  */
302   EMPTY_HOWTO (36),
303 
304   /* For 32-bit sh, this is R_SH_LOOP_END.  */
305   EMPTY_HOWTO (37),
306 
307   EMPTY_HOWTO (38),
308   EMPTY_HOWTO (39),
309   EMPTY_HOWTO (40),
310   EMPTY_HOWTO (41),
311   EMPTY_HOWTO (42),
312   EMPTY_HOWTO (43),
313   EMPTY_HOWTO (44),
314 
315   /* Used in SHLLI.L and SHLRI.L.  */
316   HOWTO (R_SH_DIR5U,		/* type */
317 	 0,			/* rightshift */
318 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
319 	 5,			/* bitsize */
320 	 FALSE,			/* pc_relative */
321 	 10,			/* bitpos */
322 	 complain_overflow_unsigned, /* complain_on_overflow */
323 	 bfd_elf_generic_reloc,	/* special_function */
324 	 "R_SH_DIR5U",		/* name */
325 	 FALSE,			/* partial_inplace */
326 	 0,			/* src_mask */
327 	 0xfc00,		/* dst_mask */
328 	 FALSE),	       	/* pcrel_offset */
329 
330   /* Used in SHARI, SHLLI et al.  */
331   HOWTO (R_SH_DIR6U,		/* type */
332 	 0,			/* rightshift */
333 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
334 	 6,			/* bitsize */
335 	 FALSE,			/* pc_relative */
336 	 10,			/* bitpos */
337 	 complain_overflow_unsigned, /* complain_on_overflow */
338 	 bfd_elf_generic_reloc,	/* special_function */
339 	 "R_SH_DIR6U",		/* name */
340 	 FALSE,			/* partial_inplace */
341 	 0,			/* src_mask */
342 	 0xfc00,		/* dst_mask */
343 	 FALSE),	       	/* pcrel_offset */
344 
345   /* Used in BxxI, LDHI.L et al.  */
346   HOWTO (R_SH_DIR6S,		/* type */
347 	 0,			/* rightshift */
348 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
349 	 6,			/* bitsize */
350 	 FALSE,			/* pc_relative */
351 	 10,			/* bitpos */
352 	 complain_overflow_signed, /* complain_on_overflow */
353 	 bfd_elf_generic_reloc,	/* special_function */
354 	 "R_SH_DIR6S",		/* name */
355 	 FALSE,			/* partial_inplace */
356 	 0,			/* src_mask */
357 	 0xfc00,		/* dst_mask */
358 	 FALSE),	       	/* pcrel_offset */
359 
360   /* Used in ADDI, ANDI et al.  */
361   HOWTO (R_SH_DIR10S,		/* type */
362 	 0,			/* rightshift */
363 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
364 	 10,			/* bitsize */
365 	 FALSE,			/* pc_relative */
366 	 10,			/* bitpos */
367 	 complain_overflow_signed, /* complain_on_overflow */
368 	 bfd_elf_generic_reloc,	/* special_function */
369 	 "R_SH_DIR10S",		/* name */
370 	 FALSE,			/* partial_inplace */
371 	 0,			/* src_mask */
372 	 0xffc00,		/* dst_mask */
373 	 FALSE),	       	/* pcrel_offset */
374 
375   /* Used in LD.UW, ST.W et al.  */
376   HOWTO (R_SH_DIR10SW,	/* type */
377 	 1,			/* rightshift */
378 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
379 	 11,			/* bitsize */
380 	 FALSE,			/* pc_relative */
381 	 10,			/* bitpos */
382 	 complain_overflow_signed, /* complain_on_overflow */
383 	 bfd_elf_generic_reloc,	/* special_function */
384 	 "R_SH_DIR10SW",	/* name */
385 	 FALSE,			/* partial_inplace */
386 	 0,			/* src_mask */
387 	 0xffc00,		/* dst_mask */
388 	 FALSE),	       	/* pcrel_offset */
389 
390   /* Used in LD.L, FLD.S et al.  */
391   HOWTO (R_SH_DIR10SL,	/* type */
392 	 2,			/* rightshift */
393 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
394 	 12,			/* bitsize */
395 	 FALSE,			/* pc_relative */
396 	 10,			/* bitpos */
397 	 complain_overflow_signed, /* complain_on_overflow */
398 	 bfd_elf_generic_reloc,	/* special_function */
399 	 "R_SH_DIR10SL",	/* name */
400 	 FALSE,			/* partial_inplace */
401 	 0,			/* src_mask */
402 	 0xffc00,		/* dst_mask */
403 	 FALSE),	       	/* pcrel_offset */
404 
405   /* Used in FLD.D, FST.P et al.  */
406   HOWTO (R_SH_DIR10SQ,	/* type */
407 	 3,			/* rightshift */
408 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
409 	 13,			/* bitsize */
410 	 FALSE,			/* pc_relative */
411 	 10,			/* bitpos */
412 	 complain_overflow_signed, /* complain_on_overflow */
413 	 bfd_elf_generic_reloc,	/* special_function */
414 	 "R_SH_DIR10SQ",	/* name */
415 	 FALSE,			/* partial_inplace */
416 	 0,			/* src_mask */
417 	 0xffc00,		/* dst_mask */
418 	 FALSE),	       	/* pcrel_offset */
419 
420   EMPTY_HOWTO (52),
421   EMPTY_HOWTO (53),
422   EMPTY_HOWTO (54),
423   EMPTY_HOWTO (55),
424   EMPTY_HOWTO (56),
425   EMPTY_HOWTO (57),
426   EMPTY_HOWTO (58),
427   EMPTY_HOWTO (59),
428   EMPTY_HOWTO (60),
429   EMPTY_HOWTO (61),
430   EMPTY_HOWTO (62),
431   EMPTY_HOWTO (63),
432   EMPTY_HOWTO (64),
433   EMPTY_HOWTO (65),
434   EMPTY_HOWTO (66),
435   EMPTY_HOWTO (67),
436   EMPTY_HOWTO (68),
437   EMPTY_HOWTO (69),
438   EMPTY_HOWTO (70),
439   EMPTY_HOWTO (71),
440   EMPTY_HOWTO (72),
441   EMPTY_HOWTO (73),
442   EMPTY_HOWTO (74),
443   EMPTY_HOWTO (75),
444   EMPTY_HOWTO (76),
445   EMPTY_HOWTO (77),
446   EMPTY_HOWTO (78),
447   EMPTY_HOWTO (79),
448   EMPTY_HOWTO (80),
449   EMPTY_HOWTO (81),
450   EMPTY_HOWTO (82),
451   EMPTY_HOWTO (83),
452   EMPTY_HOWTO (84),
453   EMPTY_HOWTO (85),
454   EMPTY_HOWTO (86),
455   EMPTY_HOWTO (87),
456   EMPTY_HOWTO (88),
457   EMPTY_HOWTO (89),
458   EMPTY_HOWTO (90),
459   EMPTY_HOWTO (91),
460   EMPTY_HOWTO (92),
461   EMPTY_HOWTO (93),
462   EMPTY_HOWTO (94),
463   EMPTY_HOWTO (95),
464   EMPTY_HOWTO (96),
465   EMPTY_HOWTO (97),
466   EMPTY_HOWTO (98),
467   EMPTY_HOWTO (99),
468   EMPTY_HOWTO (100),
469   EMPTY_HOWTO (101),
470   EMPTY_HOWTO (102),
471   EMPTY_HOWTO (103),
472   EMPTY_HOWTO (104),
473   EMPTY_HOWTO (105),
474   EMPTY_HOWTO (106),
475   EMPTY_HOWTO (107),
476   EMPTY_HOWTO (108),
477   EMPTY_HOWTO (109),
478   EMPTY_HOWTO (110),
479   EMPTY_HOWTO (111),
480   EMPTY_HOWTO (112),
481   EMPTY_HOWTO (113),
482   EMPTY_HOWTO (114),
483   EMPTY_HOWTO (115),
484   EMPTY_HOWTO (116),
485   EMPTY_HOWTO (117),
486   EMPTY_HOWTO (118),
487   EMPTY_HOWTO (119),
488   EMPTY_HOWTO (120),
489   EMPTY_HOWTO (121),
490   EMPTY_HOWTO (122),
491   EMPTY_HOWTO (123),
492   EMPTY_HOWTO (124),
493   EMPTY_HOWTO (125),
494   EMPTY_HOWTO (126),
495   EMPTY_HOWTO (127),
496   EMPTY_HOWTO (128),
497   EMPTY_HOWTO (129),
498   EMPTY_HOWTO (130),
499   EMPTY_HOWTO (131),
500   EMPTY_HOWTO (132),
501   EMPTY_HOWTO (133),
502   EMPTY_HOWTO (134),
503   EMPTY_HOWTO (135),
504   EMPTY_HOWTO (136),
505   EMPTY_HOWTO (137),
506   EMPTY_HOWTO (138),
507   EMPTY_HOWTO (139),
508   EMPTY_HOWTO (140),
509   EMPTY_HOWTO (141),
510   EMPTY_HOWTO (142),
511   EMPTY_HOWTO (143),
512   EMPTY_HOWTO (144),
513   EMPTY_HOWTO (145),
514   EMPTY_HOWTO (146),
515   EMPTY_HOWTO (147),
516   EMPTY_HOWTO (148),
517   EMPTY_HOWTO (149),
518   EMPTY_HOWTO (150),
519   EMPTY_HOWTO (151),
520   EMPTY_HOWTO (152),
521   EMPTY_HOWTO (153),
522   EMPTY_HOWTO (154),
523   EMPTY_HOWTO (155),
524   EMPTY_HOWTO (156),
525   EMPTY_HOWTO (157),
526   EMPTY_HOWTO (158),
527   EMPTY_HOWTO (159),
528 
529   /* Relocs for dynamic linking for 32-bit SH would follow.  We don't have
530      any dynamic linking support for 64-bit SH at present.  */
531 
532   EMPTY_HOWTO (160),
533   EMPTY_HOWTO (161),
534   EMPTY_HOWTO (162),
535   EMPTY_HOWTO (163),
536   EMPTY_HOWTO (164),
537   EMPTY_HOWTO (165),
538   EMPTY_HOWTO (166),
539   EMPTY_HOWTO (167),
540   EMPTY_HOWTO (168),
541 
542   /* Back to SH5 relocations.  */
543   /* Used in MOVI and SHORI (x & 65536).  */
544   HOWTO (R_SH_GOT_LOW16,	/* type */
545 	 0,			/* rightshift */
546 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
547 	 64,			/* bitsize */
548 	 FALSE,			/* pc_relative */
549 	 10,			/* bitpos */
550 	 complain_overflow_dont, /* complain_on_overflow */
551 	 bfd_elf_generic_reloc,	/* special_function */
552 	 "R_SH_GOT_LOW16",    	/* name */
553 	 FALSE,			/* partial_inplace */
554 	 0,			/* src_mask */
555 	 0x3fffc00,		/* dst_mask */
556 	 FALSE),	       	/* pcrel_offset */
557 
558   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
559   HOWTO (R_SH_GOT_MEDLOW16,	/* type */
560 	 16,			/* rightshift */
561 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
562 	 64,			/* bitsize */
563 	 FALSE,			/* pc_relative */
564 	 10,			/* bitpos */
565 	 complain_overflow_dont, /* complain_on_overflow */
566 	 bfd_elf_generic_reloc,	/* special_function */
567 	 "R_SH_GOT_MEDLOW16",	/* name */
568 	 FALSE,			/* partial_inplace */
569 	 0,			/* src_mask */
570 	 0x3fffc00,		/* dst_mask */
571 	 FALSE),	       	/* pcrel_offset */
572 
573   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
574   HOWTO (R_SH_GOT_MEDHI16,	/* type */
575 	 32,			/* rightshift */
576 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
577 	 64,			/* bitsize */
578 	 FALSE,			/* pc_relative */
579 	 10,			/* bitpos */
580 	 complain_overflow_dont, /* complain_on_overflow */
581 	 bfd_elf_generic_reloc,	/* special_function */
582 	 "R_SH_GOT_MEDHI16",	/* name */
583 	 FALSE,			/* partial_inplace */
584 	 0,			/* src_mask */
585 	 0x3fffc00,		/* dst_mask */
586 	 FALSE),	       	/* pcrel_offset */
587 
588   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
589   HOWTO (R_SH_GOT_HI16,		/* type */
590 	 48,			/* rightshift */
591 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
592 	 64,			/* bitsize */
593 	 FALSE,			/* pc_relative */
594 	 10,			/* bitpos */
595 	 complain_overflow_dont, /* complain_on_overflow */
596 	 bfd_elf_generic_reloc,	/* special_function */
597 	 "R_SH_GOT_HI16",	/* name */
598 	 FALSE,			/* partial_inplace */
599 	 0,			/* src_mask */
600 	 0x3fffc00,		/* dst_mask */
601 	 FALSE),	       	/* pcrel_offset */
602 
603   /* Used in MOVI and SHORI (x & 65536).  */
604   HOWTO (R_SH_GOTPLT_LOW16,	/* type */
605 	 0,			/* rightshift */
606 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
607 	 64,			/* bitsize */
608 	 FALSE,			/* pc_relative */
609 	 10,			/* bitpos */
610 	 complain_overflow_dont, /* complain_on_overflow */
611 	 bfd_elf_generic_reloc,	/* special_function */
612 	 "R_SH_GOTPLT_LOW16",   /* name */
613 	 FALSE,			/* partial_inplace */
614 	 0,			/* src_mask */
615 	 0x3fffc00,		/* dst_mask */
616 	 FALSE),	       	/* pcrel_offset */
617 
618   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
619   HOWTO (R_SH_GOTPLT_MEDLOW16,	/* type */
620 	 16,			/* rightshift */
621 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
622 	 64,			/* bitsize */
623 	 FALSE,			/* pc_relative */
624 	 10,			/* bitpos */
625 	 complain_overflow_dont, /* complain_on_overflow */
626 	 bfd_elf_generic_reloc,	/* special_function */
627 	 "R_SH_GOTPLT_MEDLOW16", /* name */
628 	 FALSE,			/* partial_inplace */
629 	 0,			/* src_mask */
630 	 0x3fffc00,		/* dst_mask */
631 	 FALSE),	       	/* pcrel_offset */
632 
633   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
634   HOWTO (R_SH_GOTPLT_MEDHI16,	/* type */
635 	 32,			/* rightshift */
636 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
637 	 64,			/* bitsize */
638 	 FALSE,			/* pc_relative */
639 	 10,			/* bitpos */
640 	 complain_overflow_dont, /* complain_on_overflow */
641 	 bfd_elf_generic_reloc,	/* special_function */
642 	 "R_SH_GOTPLT_MEDHI16",	/* name */
643 	 FALSE,			/* partial_inplace */
644 	 0,			/* src_mask */
645 	 0x3fffc00,		/* dst_mask */
646 	 FALSE),	       	/* pcrel_offset */
647 
648   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
649   HOWTO (R_SH_GOTPLT_HI16,	/* type */
650 	 48,			/* rightshift */
651 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
652 	 64,			/* bitsize */
653 	 FALSE,			/* pc_relative */
654 	 10,			/* bitpos */
655 	 complain_overflow_dont, /* complain_on_overflow */
656 	 bfd_elf_generic_reloc,	/* special_function */
657 	 "R_SH_GOTPLT_HI16",	/* name */
658 	 FALSE,			/* partial_inplace */
659 	 0,			/* src_mask */
660 	 0x3fffc00,		/* dst_mask */
661 	 FALSE),	       	/* pcrel_offset */
662 
663   /* Used in MOVI and SHORI (x & 65536).  */
664   HOWTO (R_SH_PLT_LOW16,	/* type */
665 	 0,			/* rightshift */
666 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
667 	 64,			/* bitsize */
668 	 TRUE,			/* pc_relative */
669 	 10,			/* bitpos */
670 	 complain_overflow_dont, /* complain_on_overflow */
671 	 bfd_elf_generic_reloc,	/* special_function */
672 	 "R_SH_PLT_LOW16",    	/* name */
673 	 FALSE,			/* partial_inplace */
674 	 0,			/* src_mask */
675 	 0x3fffc00,		/* dst_mask */
676 	 TRUE),		       	/* pcrel_offset */
677 
678   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
679   HOWTO (R_SH_PLT_MEDLOW16,	/* type */
680 	 16,			/* rightshift */
681 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
682 	 64,			/* bitsize */
683 	 TRUE,			/* pc_relative */
684 	 10,			/* bitpos */
685 	 complain_overflow_dont, /* complain_on_overflow */
686 	 bfd_elf_generic_reloc,	/* special_function */
687 	 "R_SH_PLT_MEDLOW16",	/* name */
688 	 FALSE,			/* partial_inplace */
689 	 0,			/* src_mask */
690 	 0x3fffc00,		/* dst_mask */
691 	 TRUE),		       	/* pcrel_offset */
692 
693   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
694   HOWTO (R_SH_PLT_MEDHI16,	/* type */
695 	 32,			/* rightshift */
696 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
697 	 64,			/* bitsize */
698 	 TRUE,			/* pc_relative */
699 	 10,			/* bitpos */
700 	 complain_overflow_dont, /* complain_on_overflow */
701 	 bfd_elf_generic_reloc,	/* special_function */
702 	 "R_SH_PLT_MEDHI16",	/* name */
703 	 FALSE,			/* partial_inplace */
704 	 0,			/* src_mask */
705 	 0x3fffc00,		/* dst_mask */
706 	 TRUE),		       	/* pcrel_offset */
707 
708   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
709   HOWTO (R_SH_PLT_HI16,		/* type */
710 	 48,			/* rightshift */
711 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
712 	 64,			/* bitsize */
713 	 TRUE,			/* pc_relative */
714 	 10,			/* bitpos */
715 	 complain_overflow_dont, /* complain_on_overflow */
716 	 bfd_elf_generic_reloc,	/* special_function */
717 	 "R_SH_PLT_HI16",	/* name */
718 	 FALSE,			/* partial_inplace */
719 	 0,			/* src_mask */
720 	 0x3fffc00,		/* dst_mask */
721 	 TRUE),		       	/* pcrel_offset */
722 
723   /* Used in MOVI and SHORI (x & 65536).  */
724   HOWTO (R_SH_GOTOFF_LOW16,	/* type */
725 	 0,			/* rightshift */
726 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
727 	 64,			/* bitsize */
728 	 FALSE,			/* pc_relative */
729 	 10,			/* bitpos */
730 	 complain_overflow_dont, /* complain_on_overflow */
731 	 bfd_elf_generic_reloc,	/* special_function */
732 	 "R_SH_GOTOFF_LOW16",   /* name */
733 	 FALSE,			/* partial_inplace */
734 	 0,			/* src_mask */
735 	 0x3fffc00,		/* dst_mask */
736 	 FALSE),	       	/* pcrel_offset */
737 
738   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
739   HOWTO (R_SH_GOTOFF_MEDLOW16,	/* type */
740 	 16,			/* rightshift */
741 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
742 	 64,			/* bitsize */
743 	 FALSE,			/* pc_relative */
744 	 10,			/* bitpos */
745 	 complain_overflow_dont, /* complain_on_overflow */
746 	 bfd_elf_generic_reloc,	/* special_function */
747 	 "R_SH_GOTOFF_MEDLOW16", /* name */
748 	 FALSE,			/* partial_inplace */
749 	 0,			/* src_mask */
750 	 0x3fffc00,		/* dst_mask */
751 	 FALSE),	       	/* pcrel_offset */
752 
753   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
754   HOWTO (R_SH_GOTOFF_MEDHI16,	/* type */
755 	 32,			/* rightshift */
756 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
757 	 64,			/* bitsize */
758 	 FALSE,			/* pc_relative */
759 	 10,			/* bitpos */
760 	 complain_overflow_dont, /* complain_on_overflow */
761 	 bfd_elf_generic_reloc,	/* special_function */
762 	 "R_SH_GOTOFF_MEDHI16",	/* name */
763 	 FALSE,			/* partial_inplace */
764 	 0,			/* src_mask */
765 	 0x3fffc00,		/* dst_mask */
766 	 FALSE),	       	/* pcrel_offset */
767 
768   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
769   HOWTO (R_SH_GOTOFF_HI16,	/* type */
770 	 48,			/* rightshift */
771 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
772 	 64,			/* bitsize */
773 	 FALSE,			/* pc_relative */
774 	 10,			/* bitpos */
775 	 complain_overflow_dont, /* complain_on_overflow */
776 	 bfd_elf_generic_reloc,	/* special_function */
777 	 "R_SH_GOTOFF_HI16",	/* name */
778 	 FALSE,			/* partial_inplace */
779 	 0,			/* src_mask */
780 	 0x3fffc00,		/* dst_mask */
781 	 FALSE),	       	/* pcrel_offset */
782 
783   /* Used in MOVI and SHORI (x & 65536).  */
784   HOWTO (R_SH_GOTPC_LOW16,	/* type */
785 	 0,			/* rightshift */
786 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
787 	 64,			/* bitsize */
788 	 TRUE,			/* pc_relative */
789 	 10,			/* bitpos */
790 	 complain_overflow_dont, /* complain_on_overflow */
791 	 bfd_elf_generic_reloc,	/* special_function */
792 	 "R_SH_GOTPC_LOW16",    /* name */
793 	 FALSE,			/* partial_inplace */
794 	 0,			/* src_mask */
795 	 0x3fffc00,		/* dst_mask */
796 	 TRUE),		       	/* pcrel_offset */
797 
798   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
799   HOWTO (R_SH_GOTPC_MEDLOW16,	/* type */
800 	 16,			/* rightshift */
801 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
802 	 64,			/* bitsize */
803 	 TRUE,			/* pc_relative */
804 	 10,			/* bitpos */
805 	 complain_overflow_dont, /* complain_on_overflow */
806 	 bfd_elf_generic_reloc,	/* special_function */
807 	 "R_SH_GOTPC_MEDLOW16", /* name */
808 	 FALSE,			/* partial_inplace */
809 	 0,			/* src_mask */
810 	 0x3fffc00,		/* dst_mask */
811 	 TRUE),		       	/* pcrel_offset */
812 
813   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
814   HOWTO (R_SH_GOTPC_MEDHI16,	/* type */
815 	 32,			/* rightshift */
816 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
817 	 64,			/* bitsize */
818 	 TRUE,			/* pc_relative */
819 	 10,			/* bitpos */
820 	 complain_overflow_dont, /* complain_on_overflow */
821 	 bfd_elf_generic_reloc,	/* special_function */
822 	 "R_SH_GOTPC_MEDHI16",	/* name */
823 	 FALSE,			/* partial_inplace */
824 	 0,			/* src_mask */
825 	 0x3fffc00,		/* dst_mask */
826 	 TRUE),		       	/* pcrel_offset */
827 
828   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
829   HOWTO (R_SH_GOTPC_HI16,	/* type */
830 	 48,			/* rightshift */
831 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
832 	 64,			/* bitsize */
833 	 TRUE,			/* pc_relative */
834 	 10,			/* bitpos */
835 	 complain_overflow_dont, /* complain_on_overflow */
836 	 bfd_elf_generic_reloc,	/* special_function */
837 	 "R_SH_GOTPC_HI16",	/* name */
838 	 FALSE,			/* partial_inplace */
839 	 0,			/* src_mask */
840 	 0x3fffc00,		/* dst_mask */
841 	 TRUE),		       	/* pcrel_offset */
842 
843   /* Used in LD.L, FLD.S et al.  */
844   HOWTO (R_SH_GOT10BY4,		/* type */
845 	 2,			/* rightshift */
846 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
847 	 12,			/* bitsize */
848 	 FALSE,			/* pc_relative */
849 	 10,			/* bitpos */
850 	 complain_overflow_signed, /* complain_on_overflow */
851 	 bfd_elf_generic_reloc,	/* special_function */
852 	 "R_SH_GOT10BY4",	/* name */
853 	 FALSE,			/* partial_inplace */
854 	 0,			/* src_mask */
855 	 0xffc00,		/* dst_mask */
856 	 FALSE),	       	/* pcrel_offset */
857 
858   /* Used in LD.L, FLD.S et al.  */
859   HOWTO (R_SH_GOTPLT10BY4,	/* type */
860 	 2,			/* rightshift */
861 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
862 	 12,			/* bitsize */
863 	 FALSE,			/* pc_relative */
864 	 10,			/* bitpos */
865 	 complain_overflow_signed, /* complain_on_overflow */
866 	 bfd_elf_generic_reloc,	/* special_function */
867 	 "R_SH_GOTPLT10BY4",	/* name */
868 	 FALSE,			/* partial_inplace */
869 	 0,			/* src_mask */
870 	 0xffc00,		/* dst_mask */
871 	 FALSE),	       	/* pcrel_offset */
872 
873   /* Used in FLD.D, FST.P et al.  */
874   HOWTO (R_SH_GOT10BY8,		/* type */
875 	 3,			/* rightshift */
876 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
877 	 13,			/* bitsize */
878 	 FALSE,			/* pc_relative */
879 	 10,			/* bitpos */
880 	 complain_overflow_signed, /* complain_on_overflow */
881 	 bfd_elf_generic_reloc,	/* special_function */
882 	 "R_SH_GOT10BY8",	/* name */
883 	 FALSE,			/* partial_inplace */
884 	 0,			/* src_mask */
885 	 0xffc00,		/* dst_mask */
886 	 FALSE),	       	/* pcrel_offset */
887 
888   /* Used in FLD.D, FST.P et al.  */
889   HOWTO (R_SH_GOTPLT10BY8,	/* type */
890 	 3,			/* rightshift */
891 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
892 	 13,			/* bitsize */
893 	 FALSE,			/* pc_relative */
894 	 10,			/* bitpos */
895 	 complain_overflow_signed, /* complain_on_overflow */
896 	 bfd_elf_generic_reloc,	/* special_function */
897 	 "R_SH_GOTPLT10BY8",	/* name */
898 	 FALSE,			/* partial_inplace */
899 	 0,			/* src_mask */
900 	 0xffc00,		/* dst_mask */
901 	 FALSE),	       	/* pcrel_offset */
902 
903   HOWTO (R_SH_COPY64,		/* type */
904 	 0,			/* rightshift */
905 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
906 	 64,			/* bitsize */
907 	 FALSE,			/* pc_relative */
908 	 0,			/* bitpos */
909 	 complain_overflow_dont, /* complain_on_overflow */
910 	 bfd_elf_generic_reloc,	/* special_function */
911 	 "R_SH_COPY64", 	/* name */
912 	 FALSE,			/* partial_inplace */
913 	 0,			/* src_mask */
914 	 ((bfd_vma) 0) - 1,	/* dst_mask */
915 	 FALSE),	       	/* pcrel_offset */
916 
917   HOWTO (R_SH_GLOB_DAT64,	/* type */
918 	 0,			/* rightshift */
919 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
920 	 64,			/* bitsize */
921 	 FALSE,			/* pc_relative */
922 	 0,			/* bitpos */
923 	 complain_overflow_dont, /* complain_on_overflow */
924 	 bfd_elf_generic_reloc,	/* special_function */
925 	 "R_SH_GLOB_DAT64", 	/* name */
926 	 FALSE,			/* partial_inplace */
927 	 0,			/* src_mask */
928 	 ((bfd_vma) 0) - 1,	/* dst_mask */
929 	 FALSE),	       	/* pcrel_offset */
930 
931   HOWTO (R_SH_JMP_SLOT64,	/* type */
932 	 0,			/* rightshift */
933 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
934 	 64,			/* bitsize */
935 	 FALSE,			/* pc_relative */
936 	 0,			/* bitpos */
937 	 complain_overflow_dont, /* complain_on_overflow */
938 	 bfd_elf_generic_reloc,	/* special_function */
939 	 "R_SH_JMP_SLOT64", 	/* name */
940 	 FALSE,			/* partial_inplace */
941 	 0,			/* src_mask */
942 	 ((bfd_vma) 0) - 1,	/* dst_mask */
943 	 FALSE),	       	/* pcrel_offset */
944 
945   HOWTO (R_SH_RELATIVE64,	/* type */
946 	 0,			/* rightshift */
947 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
948 	 64,			/* bitsize */
949 	 FALSE,			/* pc_relative */
950 	 0,			/* bitpos */
951 	 complain_overflow_dont, /* complain_on_overflow */
952 	 bfd_elf_generic_reloc,	/* special_function */
953 	 "R_SH_RELATIVE64", 	/* name */
954 	 FALSE,			/* partial_inplace */
955 	 0,			/* src_mask */
956 	 ((bfd_vma) 0) - 1,	/* dst_mask */
957 	 FALSE),	       	/* pcrel_offset */
958 
959   EMPTY_HOWTO (197),
960   EMPTY_HOWTO (198),
961   EMPTY_HOWTO (199),
962   EMPTY_HOWTO (200),
963   EMPTY_HOWTO (201),
964   EMPTY_HOWTO (202),
965   EMPTY_HOWTO (203),
966   EMPTY_HOWTO (204),
967   EMPTY_HOWTO (205),
968   EMPTY_HOWTO (206),
969   EMPTY_HOWTO (207),
970   EMPTY_HOWTO (208),
971   EMPTY_HOWTO (209),
972   EMPTY_HOWTO (210),
973   EMPTY_HOWTO (211),
974   EMPTY_HOWTO (212),
975   EMPTY_HOWTO (213),
976   EMPTY_HOWTO (214),
977   EMPTY_HOWTO (215),
978   EMPTY_HOWTO (216),
979   EMPTY_HOWTO (217),
980   EMPTY_HOWTO (218),
981   EMPTY_HOWTO (219),
982   EMPTY_HOWTO (220),
983   EMPTY_HOWTO (221),
984   EMPTY_HOWTO (222),
985   EMPTY_HOWTO (223),
986   EMPTY_HOWTO (224),
987   EMPTY_HOWTO (225),
988   EMPTY_HOWTO (226),
989   EMPTY_HOWTO (227),
990   EMPTY_HOWTO (228),
991   EMPTY_HOWTO (229),
992   EMPTY_HOWTO (230),
993   EMPTY_HOWTO (231),
994   EMPTY_HOWTO (232),
995   EMPTY_HOWTO (233),
996   EMPTY_HOWTO (234),
997   EMPTY_HOWTO (235),
998   EMPTY_HOWTO (236),
999   EMPTY_HOWTO (237),
1000   EMPTY_HOWTO (238),
1001   EMPTY_HOWTO (239),
1002   EMPTY_HOWTO (240),
1003   EMPTY_HOWTO (241),
1004 
1005   /* Relocations for SHmedia code.  None of these are partial_inplace or
1006      use the field being relocated.  */
1007 
1008   /* The assembler will generate this reloc before a block of SHmedia
1009      instructions.  A section should be processed as assuming it contains
1010      data, unless this reloc is seen.  Note that a block of SHcompact
1011      instructions are instead preceded by R_SH_CODE.
1012      This is currently not implemented, but should be used for SHmedia
1013      linker relaxation.  */
1014   HOWTO (R_SH_SHMEDIA_CODE,	/* type */
1015 	 0,			/* rightshift */
1016 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
1017 	 0,			/* bitsize */
1018 	 FALSE,			/* pc_relative */
1019 	 0,			/* bitpos */
1020 	 complain_overflow_unsigned, /* complain_on_overflow */
1021 	 sh_elf64_ignore_reloc,	/* special_function */
1022 	 "R_SH_SHMEDIA_CODE",	/* name */
1023 	 FALSE,			/* partial_inplace */
1024 	 0,			/* src_mask */
1025 	 0,			/* dst_mask */
1026 	 FALSE),		/* pcrel_offset */
1027 
1028   /* The assembler will generate this reloc at a PTA or PTB instruction,
1029      and the linker checks the right type of target, or changes a PTA to a
1030      PTB, if the original insn was PT.  */
1031   HOWTO (R_SH_PT_16,		/* type */
1032 	 2,			/* rightshift */
1033 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1034 	 18,			/* bitsize */
1035 	 TRUE,			/* pc_relative */
1036 	 10,			/* bitpos */
1037 	 complain_overflow_signed, /* complain_on_overflow */
1038 	 bfd_elf_generic_reloc,	/* special_function */
1039 	 "R_SH_PT_16",		/* name */
1040 	 FALSE,			/* partial_inplace */
1041 	 0,			/* src_mask */
1042 	 0x3fffc00,		/* dst_mask */
1043 	 TRUE),			/* pcrel_offset */
1044 
1045   /* Used in unexpanded MOVI.  */
1046   HOWTO (R_SH_IMMS16,		/* type */
1047 	 0,			/* rightshift */
1048 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1049 	 16,			/* bitsize */
1050 	 FALSE,			/* pc_relative */
1051 	 10,			/* bitpos */
1052 	 complain_overflow_signed, /* complain_on_overflow */
1053 	 bfd_elf_generic_reloc,	/* special_function */
1054 	 "R_SH_IMMS16",		/* name */
1055 	 FALSE,			/* partial_inplace */
1056 	 0,			/* src_mask */
1057 	 0x3fffc00,		/* dst_mask */
1058 	 FALSE),	       	/* pcrel_offset */
1059 
1060   /* Used in SHORI.  */
1061   HOWTO (R_SH_IMMU16,		/* type */
1062 	 0,			/* rightshift */
1063 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1064 	 16,			/* bitsize */
1065 	 FALSE,			/* pc_relative */
1066 	 10,			/* bitpos */
1067 	 complain_overflow_unsigned, /* complain_on_overflow */
1068 	 bfd_elf_generic_reloc,	/* special_function */
1069 	 "R_SH_IMMU16",		/* name */
1070 	 FALSE,			/* partial_inplace */
1071 	 0,			/* src_mask */
1072 	 0x3fffc00,		/* dst_mask */
1073 	 FALSE),	       	/* pcrel_offset */
1074 
1075   /* Used in MOVI and SHORI (x & 65536).  */
1076   HOWTO (R_SH_IMM_LOW16,	/* type */
1077 	 0,			/* rightshift */
1078 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1079 	 64,			/* bitsize */
1080 	 FALSE,			/* pc_relative */
1081 	 10,			/* bitpos */
1082 	 complain_overflow_dont, /* complain_on_overflow */
1083 	 bfd_elf_generic_reloc,	/* special_function */
1084 	 "R_SH_IMM_LOW16",    	/* name */
1085 	 FALSE,			/* partial_inplace */
1086 	 0,			/* src_mask */
1087 	 0x3fffc00,		/* dst_mask */
1088 	 FALSE),	       	/* pcrel_offset */
1089 
1090   /* Used in MOVI and SHORI ((x - $) & 65536).  */
1091   HOWTO (R_SH_IMM_LOW16_PCREL,	/* type */
1092 	 0,			/* rightshift */
1093 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1094 	 64,			/* bitsize */
1095 	 TRUE,			/* pc_relative */
1096 	 10,			/* bitpos */
1097 	 complain_overflow_dont, /* complain_on_overflow */
1098 	 bfd_elf_generic_reloc,	/* special_function */
1099 	 "R_SH_IMM_LOW16_PCREL", /* name */
1100 	 FALSE,			/* partial_inplace */
1101 	 0,			/* src_mask */
1102 	 0x3fffc00,		/* dst_mask */
1103 	 TRUE),			/* pcrel_offset */
1104 
1105   /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
1106   HOWTO (R_SH_IMM_MEDLOW16,	/* type */
1107 	 16,			/* rightshift */
1108 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1109 	 64,			/* bitsize */
1110 	 FALSE,			/* pc_relative */
1111 	 10,			/* bitpos */
1112 	 complain_overflow_dont, /* complain_on_overflow */
1113 	 bfd_elf_generic_reloc,	/* special_function */
1114 	 "R_SH_IMM_MEDLOW16",	/* name */
1115 	 FALSE,			/* partial_inplace */
1116 	 0,			/* src_mask */
1117 	 0x3fffc00,		/* dst_mask */
1118 	 FALSE),	       	/* pcrel_offset */
1119 
1120   /* Used in MOVI and SHORI (((x - $) >> 16) & 65536).  */
1121   HOWTO (R_SH_IMM_MEDLOW16_PCREL, /* type */
1122 	 16,			/* rightshift */
1123 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1124 	 64,			/* bitsize */
1125 	 TRUE,			/* pc_relative */
1126 	 10,			/* bitpos */
1127 	 complain_overflow_dont, /* complain_on_overflow */
1128 	 bfd_elf_generic_reloc,	/* special_function */
1129 	 "R_SH_IMM_MEDLOW16_PCREL", /* name */
1130 	 FALSE,			/* partial_inplace */
1131 	 0,			/* src_mask */
1132 	 0x3fffc00,		/* dst_mask */
1133 	 TRUE),			/* pcrel_offset */
1134 
1135   /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
1136   HOWTO (R_SH_IMM_MEDHI16,	/* type */
1137 	 32,			/* rightshift */
1138 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1139 	 64,			/* bitsize */
1140 	 FALSE,			/* pc_relative */
1141 	 10,			/* bitpos */
1142 	 complain_overflow_dont, /* complain_on_overflow */
1143 	 bfd_elf_generic_reloc,	/* special_function */
1144 	 "R_SH_IMM_MEDHI16",	/* name */
1145 	 FALSE,			/* partial_inplace */
1146 	 0,			/* src_mask */
1147 	 0x3fffc00,		/* dst_mask */
1148 	 FALSE),	       	/* pcrel_offset */
1149 
1150   /* Used in MOVI and SHORI (((x - $) >> 32) & 65536).  */
1151   HOWTO (R_SH_IMM_MEDHI16_PCREL, /* type */
1152 	 32,			/* rightshift */
1153 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1154 	 64,			/* bitsize */
1155 	 TRUE,			/* pc_relative */
1156 	 10,			/* bitpos */
1157 	 complain_overflow_dont, /* complain_on_overflow */
1158 	 bfd_elf_generic_reloc,	/* special_function */
1159 	 "R_SH_IMM_MEDHI16_PCREL", /* name */
1160 	 FALSE,			/* partial_inplace */
1161 	 0,			/* src_mask */
1162 	 0x3fffc00,		/* dst_mask */
1163 	 TRUE),			/* pcrel_offset */
1164 
1165   /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
1166   HOWTO (R_SH_IMM_HI16,		/* type */
1167 	 48,			/* rightshift */
1168 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1169 	 64,			/* bitsize */
1170 	 FALSE,			/* pc_relative */
1171 	 10,			/* bitpos */
1172 	 complain_overflow_dont, /* complain_on_overflow */
1173 	 bfd_elf_generic_reloc,	/* special_function */
1174 	 "R_SH_IMM_HI16",	/* name */
1175 	 FALSE,			/* partial_inplace */
1176 	 0,			/* src_mask */
1177 	 0x3fffc00,		/* dst_mask */
1178 	 FALSE),	       	/* pcrel_offset */
1179 
1180   /* Used in MOVI and SHORI (((x - $) >> 48) & 65536).  */
1181   HOWTO (R_SH_IMM_HI16_PCREL,	/* type */
1182 	 48,			/* rightshift */
1183 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1184 	 64,			/* bitsize */
1185 	 TRUE,			/* pc_relative */
1186 	 10,			/* bitpos */
1187 	 complain_overflow_dont, /* complain_on_overflow */
1188 	 bfd_elf_generic_reloc,	/* special_function */
1189 	 "R_SH_IMM_HI16_PCREL", /* name */
1190 	 FALSE,			/* partial_inplace */
1191 	 0,			/* src_mask */
1192 	 0x3fffc00,		/* dst_mask */
1193 	 TRUE),			/* pcrel_offset */
1194 
1195   /* For the .uaquad pseudo.  */
1196   HOWTO (R_SH_64,		/* type */
1197 	 0,			/* rightshift */
1198 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
1199 	 64,			/* bitsize */
1200 	 FALSE,			/* pc_relative */
1201 	 0,			/* bitpos */
1202 	 complain_overflow_dont, /* complain_on_overflow */
1203 	 bfd_elf_generic_reloc,	/* special_function */
1204 	 "R_SH_64", 		/* name */
1205 	 FALSE,			/* partial_inplace */
1206 	 0,			/* src_mask */
1207 	 ((bfd_vma) 0) - 1,	/* dst_mask */
1208 	 FALSE),	       	/* pcrel_offset */
1209 
1210   /* For the .uaquad pseudo, (x - $).  */
1211   HOWTO (R_SH_64_PCREL,		/* type */
1212 	 48,			/* rightshift */
1213 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1214 	 64,			/* bitsize */
1215 	 TRUE,			/* pc_relative */
1216 	 10,			/* bitpos */
1217 	 complain_overflow_dont, /* complain_on_overflow */
1218 	 bfd_elf_generic_reloc,	/* special_function */
1219 	 "R_SH_64_PCREL",	/* name */
1220 	 FALSE,			/* partial_inplace */
1221 	 0,			/* src_mask */
1222 	 ((bfd_vma) 0) - 1,	/* dst_mask */
1223 	 TRUE),			/* pcrel_offset */
1224 
1225 };
1226 
1227 /* This function is used for relocs which are only used for relaxing,
1228    which the linker should otherwise ignore.  */
1229 
1230 static bfd_reloc_status_type
sh_elf64_ignore_reloc(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry,asymbol * symbol ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)1231 sh_elf64_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1232 		       asymbol *symbol ATTRIBUTE_UNUSED,
1233 		       void *data ATTRIBUTE_UNUSED, asection *input_section,
1234 		       bfd *output_bfd,
1235 		       char **error_message ATTRIBUTE_UNUSED)
1236 {
1237   if (output_bfd != NULL)
1238     reloc_entry->address += input_section->output_offset;
1239   return bfd_reloc_ok;
1240 }
1241 
1242 /* This function is used for normal relocs.  This used to be like the COFF
1243    function, and is almost certainly incorrect for other ELF targets.
1244 
1245    See sh_elf_reloc in elf32-sh.c for the original.  */
1246 
1247 static bfd_reloc_status_type
sh_elf64_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol_in,void * data,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)1248 sh_elf64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol_in,
1249 		void *data, asection *input_section, bfd *output_bfd,
1250 		char **error_message ATTRIBUTE_UNUSED)
1251 {
1252   unsigned long insn;
1253   bfd_vma sym_value;
1254   enum elf_sh_reloc_type r_type;
1255   bfd_vma addr = reloc_entry->address;
1256   bfd_byte *hit_data = addr + (bfd_byte *) data;
1257 
1258   r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
1259 
1260   if (output_bfd != NULL)
1261     {
1262       /* Partial linking--do nothing.  */
1263       reloc_entry->address += input_section->output_offset;
1264       return bfd_reloc_ok;
1265     }
1266 
1267   if (symbol_in != NULL
1268       && bfd_is_und_section (symbol_in->section))
1269     return bfd_reloc_undefined;
1270 
1271   if (bfd_is_com_section (symbol_in->section))
1272     sym_value = 0;
1273   else
1274     sym_value = (symbol_in->value +
1275 		 symbol_in->section->output_section->vma +
1276 		 symbol_in->section->output_offset);
1277 
1278   switch (r_type)
1279     {
1280     case R_SH_DIR32:
1281       insn = bfd_get_32 (abfd, hit_data);
1282       insn += sym_value + reloc_entry->addend;
1283       bfd_put_32 (abfd, insn, hit_data);
1284       break;
1285 
1286     default:
1287       abort ();
1288       break;
1289     }
1290 
1291   return bfd_reloc_ok;
1292 }
1293 
1294 /* This structure is used to map BFD reloc codes to SH ELF relocs.  */
1295 
1296 struct elf_reloc_map
1297 {
1298   bfd_reloc_code_real_type bfd_reloc_val;
1299   unsigned char elf_reloc_val;
1300 };
1301 
1302 /* An array mapping BFD reloc codes to SH ELF relocs.  */
1303 
1304 static const struct elf_reloc_map sh64_reloc_map[] =
1305 {
1306   { BFD_RELOC_NONE, R_SH_NONE },
1307   { BFD_RELOC_32, R_SH_DIR32 },
1308   { BFD_RELOC_CTOR, R_SH_DIR32 },
1309   { BFD_RELOC_32_PCREL, R_SH_REL32 },
1310   { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
1311   { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
1312   { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
1313   { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
1314   { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
1315   { BFD_RELOC_SH_GOT_LOW16, R_SH_GOT_LOW16 },
1316   { BFD_RELOC_SH_GOT_MEDLOW16, R_SH_GOT_MEDLOW16 },
1317   { BFD_RELOC_SH_GOT_MEDHI16, R_SH_GOT_MEDHI16 },
1318   { BFD_RELOC_SH_GOT_HI16, R_SH_GOT_HI16 },
1319   { BFD_RELOC_SH_GOTPLT_LOW16, R_SH_GOTPLT_LOW16 },
1320   { BFD_RELOC_SH_GOTPLT_MEDLOW16, R_SH_GOTPLT_MEDLOW16 },
1321   { BFD_RELOC_SH_GOTPLT_MEDHI16, R_SH_GOTPLT_MEDHI16 },
1322   { BFD_RELOC_SH_GOTPLT_HI16, R_SH_GOTPLT_HI16 },
1323   { BFD_RELOC_SH_PLT_LOW16, R_SH_PLT_LOW16 },
1324   { BFD_RELOC_SH_PLT_MEDLOW16, R_SH_PLT_MEDLOW16 },
1325   { BFD_RELOC_SH_PLT_MEDHI16, R_SH_PLT_MEDHI16 },
1326   { BFD_RELOC_SH_PLT_HI16, R_SH_PLT_HI16 },
1327   { BFD_RELOC_SH_GOTOFF_LOW16, R_SH_GOTOFF_LOW16 },
1328   { BFD_RELOC_SH_GOTOFF_MEDLOW16, R_SH_GOTOFF_MEDLOW16 },
1329   { BFD_RELOC_SH_GOTOFF_MEDHI16, R_SH_GOTOFF_MEDHI16 },
1330   { BFD_RELOC_SH_GOTOFF_HI16, R_SH_GOTOFF_HI16 },
1331   { BFD_RELOC_SH_GOTPC_LOW16, R_SH_GOTPC_LOW16 },
1332   { BFD_RELOC_SH_GOTPC_MEDLOW16, R_SH_GOTPC_MEDLOW16 },
1333   { BFD_RELOC_SH_GOTPC_MEDHI16, R_SH_GOTPC_MEDHI16 },
1334   { BFD_RELOC_SH_GOTPC_HI16, R_SH_GOTPC_HI16 },
1335   { BFD_RELOC_SH_COPY64, R_SH_COPY64 },
1336   { BFD_RELOC_SH_GLOB_DAT64, R_SH_GLOB_DAT64 },
1337   { BFD_RELOC_SH_JMP_SLOT64, R_SH_JMP_SLOT64 },
1338   { BFD_RELOC_SH_RELATIVE64, R_SH_RELATIVE64 },
1339   { BFD_RELOC_SH_GOT10BY4, R_SH_GOT10BY4 },
1340   { BFD_RELOC_SH_GOT10BY8, R_SH_GOT10BY8 },
1341   { BFD_RELOC_SH_GOTPLT10BY4, R_SH_GOTPLT10BY4 },
1342   { BFD_RELOC_SH_GOTPLT10BY8, R_SH_GOTPLT10BY8 },
1343   { BFD_RELOC_SH_PT_16, R_SH_PT_16 },
1344   { BFD_RELOC_SH_SHMEDIA_CODE, R_SH_SHMEDIA_CODE },
1345   { BFD_RELOC_SH_IMMU5, R_SH_DIR5U },
1346   { BFD_RELOC_SH_IMMS6, R_SH_DIR6S },
1347   { BFD_RELOC_SH_IMMU6, R_SH_DIR6U },
1348   { BFD_RELOC_SH_IMMS10, R_SH_DIR10S },
1349   { BFD_RELOC_SH_IMMS10BY2, R_SH_DIR10SW },
1350   { BFD_RELOC_SH_IMMS10BY4, R_SH_DIR10SL },
1351   { BFD_RELOC_SH_IMMS10BY8, R_SH_DIR10SQ },
1352   { BFD_RELOC_SH_IMMS16, R_SH_IMMS16 },
1353   { BFD_RELOC_SH_IMMU16, R_SH_IMMU16 },
1354   { BFD_RELOC_SH_IMM_LOW16, R_SH_IMM_LOW16 },
1355   { BFD_RELOC_SH_IMM_LOW16_PCREL, R_SH_IMM_LOW16_PCREL },
1356   { BFD_RELOC_SH_IMM_MEDLOW16, R_SH_IMM_MEDLOW16 },
1357   { BFD_RELOC_SH_IMM_MEDLOW16_PCREL, R_SH_IMM_MEDLOW16_PCREL },
1358   { BFD_RELOC_SH_IMM_MEDHI16, R_SH_IMM_MEDHI16 },
1359   { BFD_RELOC_SH_IMM_MEDHI16_PCREL, R_SH_IMM_MEDHI16_PCREL },
1360   { BFD_RELOC_SH_IMM_HI16, R_SH_IMM_HI16 },
1361   { BFD_RELOC_SH_IMM_HI16_PCREL, R_SH_IMM_HI16_PCREL },
1362   { BFD_RELOC_64, R_SH_64 },
1363   { BFD_RELOC_64_PCREL, R_SH_64_PCREL },
1364 };
1365 
1366 /* Given a BFD reloc code, return the howto structure for the
1367    corresponding SH ELf reloc.  */
1368 
1369 static reloc_howto_type *
sh_elf64_reloc_type_lookup(bfd * abfd ATTRIBUTE_UNUSED,bfd_reloc_code_real_type code)1370 sh_elf64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1371 			    bfd_reloc_code_real_type code)
1372 {
1373   unsigned int i;
1374 
1375   for (i = 0; i < sizeof (sh64_reloc_map) / sizeof (struct elf_reloc_map); i++)
1376     {
1377       if (sh64_reloc_map[i].bfd_reloc_val == code)
1378 	return &sh_elf64_howto_table[(int) sh64_reloc_map[i].elf_reloc_val];
1379     }
1380 
1381   return NULL;
1382 }
1383 
1384 static reloc_howto_type *
sh_elf64_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)1385 sh_elf64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1386 			    const char *r_name)
1387 {
1388   unsigned int i;
1389 
1390   for (i = 0;
1391        i < sizeof (sh_elf64_howto_table) / sizeof (sh_elf64_howto_table[0]);
1392        i++)
1393     if (sh_elf64_howto_table[i].name != NULL
1394 	&& strcasecmp (sh_elf64_howto_table[i].name, r_name) == 0)
1395       return &sh_elf64_howto_table[i];
1396 
1397   return NULL;
1398 }
1399 
1400 /* Given an ELF reloc, fill in the howto field of a relent.
1401 
1402    See sh_elf_info_to_howto in elf32-sh.c for the original.  */
1403 
1404 static void
sh_elf64_info_to_howto(bfd * abfd ATTRIBUTE_UNUSED,arelent * cache_ptr,Elf_Internal_Rela * dst)1405 sh_elf64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
1406 			Elf_Internal_Rela *dst)
1407 {
1408   unsigned int r;
1409 
1410   r = ELF64_R_TYPE (dst->r_info);
1411 
1412   BFD_ASSERT (r <= (unsigned int) R_SH_64_PCREL);
1413   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
1414   BFD_ASSERT (r < R_SH_DIR8WPN || r > R_SH_LAST_INVALID_RELOC_2);
1415   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_3 || r > R_SH_GOTPLT32);
1416   BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_4 || r > R_SH_LAST_INVALID_RELOC_4);
1417 
1418   cache_ptr->howto = &sh_elf64_howto_table[r];
1419 }
1420 
1421 /* Relocate an SH ELF section.
1422 
1423    See sh_elf_info_to_howto in elf32-sh.c for the original.  */
1424 
1425 static bfd_boolean
sh_elf64_relocate_section(bfd * output_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info,bfd * input_bfd,asection * input_section,bfd_byte * contents,Elf_Internal_Rela * relocs,Elf_Internal_Sym * local_syms,asection ** local_sections)1426 sh_elf64_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1427 			   struct bfd_link_info *info, bfd *input_bfd,
1428 			   asection *input_section, bfd_byte *contents,
1429 			   Elf_Internal_Rela *relocs,
1430 			   Elf_Internal_Sym *local_syms,
1431 			   asection **local_sections)
1432 {
1433   Elf_Internal_Shdr *symtab_hdr;
1434   struct elf_link_hash_entry **sym_hashes;
1435   Elf_Internal_Rela *rel, *relend;
1436   bfd *dynobj;
1437   bfd_vma *local_got_offsets;
1438   asection *sgot;
1439   asection *sgotplt;
1440   asection *splt;
1441   asection *sreloc;
1442   bfd_vma disp, dropped;
1443 
1444   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1445   sym_hashes = elf_sym_hashes (input_bfd);
1446   dynobj = elf_hash_table (info)->dynobj;
1447   local_got_offsets = elf_local_got_offsets (input_bfd);
1448 
1449   sgot = NULL;
1450   sgotplt = NULL;
1451   splt = NULL;
1452   sreloc = NULL;
1453 
1454   rel = relocs;
1455   relend = relocs + input_section->reloc_count;
1456   for (; rel < relend; rel++)
1457     {
1458       int r_type;
1459       reloc_howto_type *howto;
1460       unsigned long r_symndx;
1461       Elf_Internal_Sym *sym;
1462       asection *sec;
1463       struct elf_link_hash_entry *h;
1464       bfd_vma relocation;
1465       bfd_vma addend = (bfd_vma)0;
1466       bfd_reloc_status_type r;
1467       int seen_stt_datalabel = 0;
1468 
1469       r_symndx = ELF64_R_SYM (rel->r_info);
1470 
1471       r_type = ELF64_R_TYPE (rel->r_info);
1472 
1473       if (r_type == (int) R_SH_NONE)
1474 	continue;
1475 
1476       if (r_type < 0
1477 	  || r_type > R_SH_64_PCREL
1478 	  || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
1479 	      && r_type <= (int) R_SH_LAST_INVALID_RELOC)
1480 	  || (r_type >= (int) R_SH_DIR8WPN
1481 	      && r_type <= (int) R_SH_LAST_INVALID_RELOC)
1482 	  || (r_type >= (int) R_SH_GNU_VTINHERIT
1483 	      && r_type <= (int) R_SH_PSHL)
1484 	  || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
1485 	      && r_type <= R_SH_GOTPLT32)
1486 	  || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_4
1487 	      && r_type <= (int) R_SH_LAST_INVALID_RELOC_4))
1488 	{
1489 	  bfd_set_error (bfd_error_bad_value);
1490 	  return FALSE;
1491 	}
1492 
1493       howto = sh_elf64_howto_table + r_type;
1494 
1495       h = NULL;
1496       sym = NULL;
1497       sec = NULL;
1498       relocation = 0;
1499       if (r_symndx < symtab_hdr->sh_info)
1500 	{
1501 	  sym = local_syms + r_symndx;
1502 	  sec = local_sections[r_symndx];
1503 	  relocation = ((sec->output_section->vma
1504 			 + sec->output_offset
1505 			 + sym->st_value)
1506 			| ((sym->st_other & STO_SH5_ISA32) != 0));
1507 
1508 	  /* A local symbol never has STO_SH5_ISA32, so we don't need
1509 	     datalabel processing here.  Make sure this does not change
1510 	     without notice.  */
1511 	  if ((sym->st_other & STO_SH5_ISA32) != 0)
1512 	    ((*info->callbacks->reloc_dangerous)
1513 	     (info,
1514 	      _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
1515 	      input_bfd, input_section, rel->r_offset));
1516 
1517 	  if (sec != NULL && discarded_section (sec))
1518 	    /* Handled below.  */
1519 	    ;
1520 	  else if (info->relocatable)
1521 	    {
1522 	      /* This is a relocatable link.  We don't have to change
1523 		 anything, unless the reloc is against a section symbol,
1524 		 in which case we have to adjust according to where the
1525 		 section symbol winds up in the output section.  */
1526 	      if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1527 		goto final_link_relocate;
1528 
1529 	      continue;
1530 	    }
1531 	  else if (! howto->partial_inplace)
1532 	    {
1533 	      relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1534 	      relocation |= ((sym->st_other & STO_SH5_ISA32) != 0);
1535 	    }
1536 	  else if ((sec->flags & SEC_MERGE)
1537 		   && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1538 	    {
1539 	      asection *msec;
1540 
1541 	      if (howto->rightshift || howto->src_mask != 0xffffffff)
1542 		{
1543 		  (*_bfd_error_handler)
1544 		    (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
1545 		     input_bfd, input_section,
1546 		     (long) rel->r_offset, howto->name);
1547 		  return FALSE;
1548 		}
1549 
1550               addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
1551               msec = sec;
1552               addend =
1553 		_bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
1554 		- relocation;
1555 	      addend += msec->output_section->vma + msec->output_offset;
1556 	      bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
1557 	      addend = 0;
1558 	    }
1559 	}
1560       else
1561 	{
1562 	  /* ??? Could we use the RELOC_FOR_GLOBAL_SYMBOL macro here ?  */
1563 
1564 	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1565 	  while (h->root.type == bfd_link_hash_indirect
1566 		 || h->root.type == bfd_link_hash_warning)
1567 	    {
1568 	      /* If the reference passes a symbol marked with
1569 		 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
1570 		 doesn't count.  */
1571 	      seen_stt_datalabel |= h->type == STT_DATALABEL;
1572 	      h = (struct elf_link_hash_entry *) h->root.u.i.link;
1573 	    }
1574 
1575 	  if (h->root.type == bfd_link_hash_defined
1576 	      || h->root.type == bfd_link_hash_defweak)
1577 	    {
1578 	      sec = h->root.u.def.section;
1579 	      /* In these cases, we don't need the relocation value.
1580 		 We check specially because in some obscure cases
1581 		 sec->output_section will be NULL.  */
1582 	      if (r_type == R_SH_GOTPC_LOW16
1583 		  || r_type == R_SH_GOTPC_MEDLOW16
1584 		  || r_type == R_SH_GOTPC_MEDHI16
1585 		  || r_type == R_SH_GOTPC_HI16
1586 		  || ((r_type == R_SH_PLT_LOW16
1587 		       || r_type == R_SH_PLT_MEDLOW16
1588 		       || r_type == R_SH_PLT_MEDHI16
1589 		       || r_type == R_SH_PLT_HI16)
1590 		      && h->plt.offset != (bfd_vma) -1)
1591 		  || ((r_type == R_SH_GOT_LOW16
1592 		       || r_type == R_SH_GOT_MEDLOW16
1593 		       || r_type == R_SH_GOT_MEDHI16
1594 		       || r_type == R_SH_GOT_HI16)
1595 		      && elf_hash_table (info)->dynamic_sections_created
1596 		      && (! info->shared
1597 			  || (! info->symbolic && h->dynindx != -1)
1598 			  || !h->def_regular))
1599 		  /* The cases above are those in which relocation is
1600 		     overwritten in the switch block below.  The cases
1601 		     below are those in which we must defer relocation
1602 		     to run-time, because we can't resolve absolute
1603 		     addresses when creating a shared library.  */
1604 		  || (info->shared
1605 		      && ((! info->symbolic && h->dynindx != -1)
1606 			  || !h->def_regular)
1607 		      && ((r_type == R_SH_64
1608 			   && !(ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1609 				|| ELF_ST_VISIBILITY (h->other) == STV_HIDDEN))
1610 			  || r_type == R_SH_64_PCREL)
1611 		      && ((input_section->flags & SEC_ALLOC) != 0
1612 			  /* DWARF will emit R_SH_DIR32 relocations in its
1613 			     sections against symbols defined externally
1614 			     in shared libraries.  We can't do anything
1615 			     with them here.  */
1616 			  || (input_section->flags & SEC_DEBUGGING) != 0))
1617 		  /* Dynamic relocs are not propagated for SEC_DEBUGGING
1618 		     sections because such sections are not SEC_ALLOC and
1619 		     thus ld.so will not process them.  */
1620 		  || (sec->output_section == NULL
1621 		      && ((input_section->flags & SEC_DEBUGGING) != 0
1622 			  && h->def_dynamic)))
1623 		;
1624 	      else if (sec->output_section != NULL)
1625 		relocation = ((h->root.u.def.value
1626 			       + sec->output_section->vma
1627 			       + sec->output_offset)
1628 			      /* A STO_SH5_ISA32 causes a "bitor 1" to the
1629 				 symbol value, unless we've seen
1630 				 STT_DATALABEL on the way to it.  */
1631 			      | ((h->other & STO_SH5_ISA32) != 0
1632 				 && ! seen_stt_datalabel));
1633 	      else if (!info->relocatable
1634 		       && (_bfd_elf_section_offset (output_bfd, info,
1635 						    input_section,
1636 						    rel->r_offset)
1637 			   != (bfd_vma) -1))
1638 		{
1639 		  (*_bfd_error_handler)
1640 		    (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1641 		     input_bfd,
1642 		     input_section,
1643 		     (long) rel->r_offset,
1644 		     howto->name,
1645 		     h->root.root.string);
1646 		}
1647 	    }
1648 	  else if (h->root.type == bfd_link_hash_undefweak)
1649 	    ;
1650 	  else if (info->unresolved_syms_in_objects == RM_IGNORE
1651 		   && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1652 	    ;
1653 	  else if (!info->relocatable)
1654 	    {
1655 	      if (! ((*info->callbacks->undefined_symbol)
1656 		     (info, h->root.root.string, input_bfd,
1657 		      input_section, rel->r_offset,
1658 		      (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1659 		       || ELF_ST_VISIBILITY (h->other)))))
1660 		return FALSE;
1661 	    }
1662 	}
1663 
1664       if (sec != NULL && discarded_section (sec))
1665 	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1666 					 rel, 1, relend, howto, 0, contents);
1667 
1668       if (info->relocatable)
1669 	continue;
1670 
1671       disp = (relocation
1672 	      - input_section->output_section->vma
1673 	      - input_section->output_offset
1674 	      - rel->r_offset);
1675       dropped = 0;
1676       switch ((int)r_type)
1677 	{
1678 	case R_SH_PT_16:     dropped = disp & 2; break;
1679 	case R_SH_DIR10SW: dropped = disp & 1; break;
1680 	case R_SH_DIR10SL: dropped = disp & 3; break;
1681 	case R_SH_DIR10SQ: dropped = disp & 7; break;
1682 	}
1683       if (dropped != 0)
1684 	{
1685 	  (*_bfd_error_handler)
1686 	    (_("%s: error: unaligned relocation type %d at %08x reloc %08x\n"),
1687 	     bfd_get_filename (input_bfd), (int)r_type, (unsigned)rel->r_offset, (unsigned)relocation);
1688 	  bfd_set_error (bfd_error_bad_value);
1689 	  return FALSE;
1690 	}
1691       switch ((int)r_type)
1692 	{
1693 	case R_SH_64:
1694 	case R_SH_64_PCREL:
1695 	  if (info->shared
1696 	      && (input_section->flags & SEC_ALLOC) != 0
1697 	      && (r_type != R_SH_64_PCREL
1698 		  || (h != NULL
1699 		      && h->dynindx != -1
1700 		      && (! info->symbolic
1701 			  || !h->def_regular))))
1702 	    {
1703 	      Elf_Internal_Rela outrel;
1704 	      bfd_byte *loc;
1705 	      bfd_boolean skip, relocate;
1706 
1707 	      /* When generating a shared object, these relocations
1708 		 are copied into the output file to be resolved at run
1709 		 time.  */
1710 
1711 	      if (sreloc == NULL)
1712 		{
1713 		  sreloc = _bfd_elf_get_dynamic_reloc_section
1714 		    (input_bfd, input_section, /*rela?*/ TRUE);
1715 		  if (sreloc == NULL)
1716 		    return FALSE;
1717 		}
1718 
1719 	      skip = FALSE;
1720 	      relocate = FALSE;
1721 
1722 	      outrel.r_offset
1723 		= _bfd_elf_section_offset (output_bfd, info,
1724 					   input_section, rel->r_offset);
1725 
1726 	      if (outrel.r_offset == (bfd_vma) -1)
1727 		skip = TRUE;
1728 	      else if (outrel.r_offset == (bfd_vma) -2)
1729 		skip = TRUE, relocate = TRUE;
1730 
1731 	      outrel.r_offset += (input_section->output_section->vma
1732 				  + input_section->output_offset);
1733 
1734 	      if (skip)
1735 		memset (&outrel, 0, sizeof outrel);
1736 	      else if (r_type == R_SH_64_PCREL)
1737 		{
1738 		  BFD_ASSERT (h != NULL && h->dynindx != -1);
1739 		  outrel.r_info = ELF64_R_INFO (h->dynindx, R_SH_64_PCREL);
1740 		  outrel.r_addend = rel->r_addend;
1741 		}
1742 	      else
1743 		{
1744 		  /* h->dynindx may be -1 if this symbol was marked to
1745 		     become local.  */
1746 		  if (h == NULL
1747 		      || ((info->symbolic || h->dynindx == -1)
1748 			  && h->def_regular))
1749 		    {
1750 		      relocate = TRUE;
1751 		      outrel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
1752 		      outrel.r_addend = relocation + rel->r_addend;
1753 		    }
1754 		  else
1755 		    {
1756 		      BFD_ASSERT (h->dynindx != -1);
1757 		      outrel.r_info = ELF64_R_INFO (h->dynindx, R_SH_64);
1758 		      outrel.r_addend = relocation + rel->r_addend;
1759 		    }
1760 		}
1761 
1762 	      loc = sreloc->contents;
1763 	      loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
1764 	      bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1765 
1766 	      /* If this reloc is against an external symbol, we do
1767 		 not want to fiddle with the addend.  Otherwise, we
1768 		 need to include the symbol value so that it becomes
1769 		 an addend for the dynamic reloc.  */
1770 	      if (! relocate)
1771 		continue;
1772 	    }
1773 	  else if (r_type == R_SH_64)
1774 	    addend = rel->r_addend;
1775 	  goto final_link_relocate;
1776 
1777 	case R_SH_GOTPLT_LOW16:
1778 	case R_SH_GOTPLT_MEDLOW16:
1779 	case R_SH_GOTPLT_MEDHI16:
1780 	case R_SH_GOTPLT_HI16:
1781 	case R_SH_GOTPLT10BY4:
1782 	case R_SH_GOTPLT10BY8:
1783 	  /* Relocation is to the entry for this symbol in the
1784 	     procedure linkage table.  */
1785 
1786 	  if (h == NULL
1787 	      || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1788 	      || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
1789 	      || ! info->shared
1790 	      || info->symbolic
1791 	      || h->dynindx == -1
1792 	      || h->plt.offset == (bfd_vma) -1
1793 	      || h->got.offset != (bfd_vma) -1)
1794 	    goto force_got;
1795 
1796 	  /* Relocation is to the entry for this symbol in the global
1797 	     offset table extension for the procedure linkage table.  */
1798 	  if (sgotplt == NULL)
1799 	    {
1800 	      sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
1801 	      BFD_ASSERT (sgotplt != NULL);
1802 	    }
1803 
1804 	  relocation = (sgotplt->output_offset
1805 			+ ((h->plt.offset / elf_sh64_sizeof_plt (info)
1806 			    - 1 + 3) * 8));
1807 
1808 	  relocation -= GOT_BIAS;
1809 
1810 	  goto final_link_relocate;
1811 
1812 	force_got:
1813 	case R_SH_GOT_LOW16:
1814 	case R_SH_GOT_MEDLOW16:
1815 	case R_SH_GOT_MEDHI16:
1816 	case R_SH_GOT_HI16:
1817 	case R_SH_GOT10BY4:
1818 	case R_SH_GOT10BY8:
1819 	  /* Relocation is to the entry for this symbol in the global
1820 	     offset table.  */
1821 	  if (sgot == NULL)
1822 	    {
1823 	      sgot = bfd_get_linker_section (dynobj, ".got");
1824 	      BFD_ASSERT (sgot != NULL);
1825 	    }
1826 
1827 	  if (h != NULL)
1828 	    {
1829 	      bfd_vma off;
1830 
1831 	      off = h->got.offset;
1832 	      if (seen_stt_datalabel)
1833 		{
1834 		  struct elf_sh64_link_hash_entry *hsh;
1835 
1836 		  hsh = (struct elf_sh64_link_hash_entry *)h;
1837 		  off = hsh->datalabel_got_offset;
1838 		}
1839 	      BFD_ASSERT (off != (bfd_vma) -1);
1840 
1841 	      if (! elf_hash_table (info)->dynamic_sections_created
1842 		  || (info->shared
1843 		      && (info->symbolic || h->dynindx == -1
1844 			  || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1845 			  || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
1846 		      && h->def_regular))
1847 		{
1848 		  /* This is actually a static link, or it is a
1849 		     -Bsymbolic link and the symbol is defined
1850 		     locally, or the symbol was forced to be local
1851 		     because of a version file.  We must initialize
1852 		     this entry in the global offset table.  Since the
1853 		     offset must always be a multiple of 4, we use the
1854 		     least significant bit to record whether we have
1855 		     initialized it already.
1856 
1857 		     When doing a dynamic link, we create a .rela.got
1858 		     relocation entry to initialize the value.  This
1859 		     is done in the finish_dynamic_symbol routine.  */
1860 		  if ((off & 1) != 0)
1861 		    off &= ~1;
1862 		  else
1863 		    {
1864 		      bfd_put_64 (output_bfd, relocation,
1865 				  sgot->contents + off);
1866 		      if (seen_stt_datalabel)
1867 			{
1868 			  struct elf_sh64_link_hash_entry *hsh;
1869 
1870 			  hsh = (struct elf_sh64_link_hash_entry *)h;
1871 			  hsh->datalabel_got_offset |= 1;
1872 			}
1873 		      else
1874 			h->got.offset |= 1;
1875 		    }
1876 		}
1877 
1878 	      relocation = sgot->output_offset + off;
1879 	    }
1880 	  else
1881 	    {
1882 	      bfd_vma off;
1883 
1884 	      if (rel->r_addend)
1885 		{
1886 		  BFD_ASSERT (local_got_offsets != NULL
1887 			      && (local_got_offsets[symtab_hdr->sh_info
1888 						    + r_symndx]
1889 				  != (bfd_vma) -1));
1890 
1891 		  off = local_got_offsets[symtab_hdr->sh_info
1892 					  + r_symndx];
1893 		}
1894 	      else
1895 		{
1896 		  BFD_ASSERT (local_got_offsets != NULL
1897 			      && local_got_offsets[r_symndx] != (bfd_vma) -1);
1898 
1899 		  off = local_got_offsets[r_symndx];
1900 		}
1901 
1902 	      /* The offset must always be a multiple of 8.  We use
1903 		 the least significant bit to record whether we have
1904 		 already generated the necessary reloc.  */
1905 	      if ((off & 1) != 0)
1906 		off &= ~1;
1907 	      else
1908 		{
1909 		  bfd_put_64 (output_bfd, relocation, sgot->contents + off);
1910 
1911 		  if (info->shared)
1912 		    {
1913 		      asection *s;
1914 		      Elf_Internal_Rela outrel;
1915 		      bfd_byte *loc;
1916 
1917 		      s = bfd_get_linker_section (dynobj, ".rela.got");
1918 		      BFD_ASSERT (s != NULL);
1919 
1920 		      outrel.r_offset = (sgot->output_section->vma
1921 					 + sgot->output_offset
1922 					 + off);
1923 		      outrel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
1924 		      outrel.r_addend = relocation;
1925 		      loc = s->contents;
1926 		      loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
1927 		      bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1928 		    }
1929 
1930 		  if (rel->r_addend)
1931 		    local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
1932 		  else
1933 		    local_got_offsets[r_symndx] |= 1;
1934 		}
1935 
1936 	      relocation = sgot->output_offset + off;
1937 	    }
1938 
1939  	  relocation -= GOT_BIAS;
1940 
1941 	  goto final_link_relocate;
1942 
1943 	case R_SH_GOTOFF_LOW16:
1944 	case R_SH_GOTOFF_MEDLOW16:
1945 	case R_SH_GOTOFF_MEDHI16:
1946 	case R_SH_GOTOFF_HI16:
1947 	  /* Relocation is relative to the start of the global offset
1948 	     table.  */
1949 
1950 	  if (sgot == NULL)
1951 	    {
1952 	      sgot = bfd_get_linker_section (dynobj, ".got");
1953 	      BFD_ASSERT (sgot != NULL);
1954 	    }
1955 
1956 	  /* Note that sgot->output_offset is not involved in this
1957 	     calculation.  We always want the start of .got.  If we
1958 	     defined _GLOBAL_OFFSET_TABLE in a different way, as is
1959 	     permitted by the ABI, we might have to change this
1960 	     calculation.  */
1961 	  relocation -= sgot->output_section->vma;
1962 
1963 	  relocation -= GOT_BIAS;
1964 
1965 	  addend = rel->r_addend;
1966 
1967 	  goto final_link_relocate;
1968 
1969 	case R_SH_GOTPC_LOW16:
1970 	case R_SH_GOTPC_MEDLOW16:
1971 	case R_SH_GOTPC_MEDHI16:
1972 	case R_SH_GOTPC_HI16:
1973 	  /* Use global offset table as symbol value.  */
1974 
1975 	  if (sgot == NULL)
1976 	    {
1977 	      sgot = bfd_get_linker_section (dynobj, ".got");
1978 	      BFD_ASSERT (sgot != NULL);
1979 	    }
1980 
1981 	  relocation = sgot->output_section->vma;
1982 
1983 	  relocation += GOT_BIAS;
1984 
1985 	  addend = rel->r_addend;
1986 
1987 	  goto final_link_relocate;
1988 
1989 	case R_SH_PLT_LOW16:
1990 	case R_SH_PLT_MEDLOW16:
1991 	case R_SH_PLT_MEDHI16:
1992 	case R_SH_PLT_HI16:
1993 	  /* Relocation is to the entry for this symbol in the
1994 	     procedure linkage table.  */
1995 
1996 	  /* Resolve a PLT reloc against a local symbol directly,
1997 	     without using the procedure linkage table.  */
1998 	  if (h == NULL)
1999 	    goto final_link_relocate;
2000 
2001 	  if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2002 	      || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
2003 	    goto final_link_relocate;
2004 
2005 	  if (h->plt.offset == (bfd_vma) -1)
2006 	    {
2007 	      /* We didn't make a PLT entry for this symbol.  This
2008 		 happens when statically linking PIC code, or when
2009 		 using -Bsymbolic.  */
2010 	      goto final_link_relocate;
2011 	    }
2012 
2013 	  if (splt == NULL)
2014 	    {
2015 	      splt = bfd_get_linker_section (dynobj, ".plt");
2016 	      BFD_ASSERT (splt != NULL);
2017 	    }
2018 
2019 	  relocation = (splt->output_section->vma
2020 			+ splt->output_offset
2021 			+ h->plt.offset);
2022 	  relocation++;
2023 
2024 	  addend = rel->r_addend;
2025 
2026 	  goto final_link_relocate;
2027 
2028 	case R_SH_DIR32:
2029 	case R_SH_SHMEDIA_CODE:
2030 	case R_SH_PT_16:
2031 	case R_SH_DIR5U:
2032 	case R_SH_DIR6S:
2033 	case R_SH_DIR6U:
2034 	case R_SH_DIR10S:
2035 	case R_SH_DIR10SW:
2036 	case R_SH_DIR10SL:
2037 	case R_SH_DIR10SQ:
2038 	case R_SH_IMMS16:
2039 	case R_SH_IMMU16:
2040 	case R_SH_IMM_LOW16:
2041 	case R_SH_IMM_LOW16_PCREL:
2042 	case R_SH_IMM_MEDLOW16:
2043 	case R_SH_IMM_MEDLOW16_PCREL:
2044 	case R_SH_IMM_MEDHI16:
2045 	case R_SH_IMM_MEDHI16_PCREL:
2046 	case R_SH_IMM_HI16:
2047 	case R_SH_IMM_HI16_PCREL:
2048 	  addend = rel->r_addend;
2049 	  /* Fall through.  */
2050 	case R_SH_REL32:
2051 	final_link_relocate:
2052 	  r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2053 					contents, rel->r_offset,
2054 					relocation, addend);
2055 	  break;
2056 
2057 	default:
2058 	  bfd_set_error (bfd_error_bad_value);
2059 	  return FALSE;
2060 
2061 	}
2062 
2063       if (r != bfd_reloc_ok)
2064 	{
2065 	  switch (r)
2066 	    {
2067 	    default:
2068 	    case bfd_reloc_outofrange:
2069 	      abort ();
2070 	    case bfd_reloc_overflow:
2071 	      {
2072 		const char *name;
2073 
2074 		if (h != NULL)
2075 		  name = NULL;
2076 		else
2077 		  {
2078 		    name = (bfd_elf_string_from_elf_section
2079 			    (input_bfd, symtab_hdr->sh_link, sym->st_name));
2080 		    if (name == NULL)
2081 		      return FALSE;
2082 		    if (*name == '\0')
2083 		      name = bfd_section_name (input_bfd, sec);
2084 		  }
2085 		if (! ((*info->callbacks->reloc_overflow)
2086 		       (info, (h ? &h->root : NULL), name, howto->name,
2087 			(bfd_vma) 0, input_bfd, input_section,
2088 			rel->r_offset)))
2089 		  return FALSE;
2090 	      }
2091 	      break;
2092 	    }
2093 	}
2094     }
2095 
2096   return TRUE;
2097 }
2098 
2099 /* This is a version of bfd_generic_get_relocated_section_contents
2100    that uses sh_elf64_relocate_section.
2101 
2102    See sh_elf_relocate_section in elf32-sh.c for the original.  */
2103 
2104 static bfd_byte *
sh_elf64_get_relocated_section_contents(bfd * output_bfd,struct bfd_link_info * link_info,struct bfd_link_order * link_order,bfd_byte * data,bfd_boolean relocatable,asymbol ** symbols)2105 sh_elf64_get_relocated_section_contents (bfd *output_bfd,
2106 					 struct bfd_link_info *link_info,
2107 					 struct bfd_link_order *link_order,
2108 					 bfd_byte *data,
2109 					 bfd_boolean relocatable,
2110 					 asymbol **symbols)
2111 {
2112   Elf_Internal_Shdr *symtab_hdr;
2113   asection *input_section = link_order->u.indirect.section;
2114   bfd *input_bfd = input_section->owner;
2115   asection **sections = NULL;
2116   Elf_Internal_Rela *internal_relocs = NULL;
2117   Elf_Internal_Sym *isymbuf = NULL;
2118 
2119   /* We only need to handle the case of relaxing, or of having a
2120      particular set of section contents, specially.  */
2121   if (relocatable
2122       || elf_section_data (input_section)->this_hdr.contents == NULL)
2123     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2124 						       link_order, data,
2125 						       relocatable,
2126 						       symbols);
2127 
2128   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2129 
2130   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2131 	  input_section->size);
2132 
2133   if ((input_section->flags & SEC_RELOC) != 0
2134       && input_section->reloc_count > 0)
2135     {
2136       Elf_Internal_Sym *isymp;
2137       Elf_Internal_Sym *isymend;
2138       asection **secpp;
2139 
2140       /* Read this BFD's local symbols.  */
2141       if (symtab_hdr->sh_info != 0)
2142 	{
2143 	  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2144 	  if (isymbuf == NULL)
2145 	    isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2146 					    symtab_hdr->sh_info, 0,
2147 					    NULL, NULL, NULL);
2148 	  if (isymbuf == NULL)
2149 	    goto error_return;
2150 	}
2151 
2152       internal_relocs = (_bfd_elf_link_read_relocs
2153 			 (input_bfd, input_section, NULL,
2154 			  (Elf_Internal_Rela *) NULL, FALSE));
2155       if (internal_relocs == NULL)
2156 	goto error_return;
2157 
2158       sections = (asection **) bfd_malloc (symtab_hdr->sh_info
2159 					   * sizeof (asection *));
2160       if (sections == NULL && symtab_hdr->sh_info > 0)
2161 	goto error_return;
2162 
2163       secpp = sections;
2164       isymend = isymbuf + symtab_hdr->sh_info;
2165       for (isymp = isymbuf; isymp < isymend; ++isymp, ++secpp)
2166 	{
2167 	  asection *isec;
2168 
2169 	  if (isymp->st_shndx == SHN_UNDEF)
2170 	    isec = bfd_und_section_ptr;
2171 	  else if (isymp->st_shndx == SHN_ABS)
2172 	    isec = bfd_abs_section_ptr;
2173 	  else if (isymp->st_shndx == SHN_COMMON)
2174 	    isec = bfd_com_section_ptr;
2175 	  else
2176 	    isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
2177 
2178 	  *secpp = isec;
2179 	}
2180 
2181       if (! sh_elf64_relocate_section (output_bfd, link_info, input_bfd,
2182 				       input_section, data, internal_relocs,
2183 				       isymbuf, sections))
2184 	goto error_return;
2185 
2186       if (sections != NULL)
2187 	free (sections);
2188       if (internal_relocs != elf_section_data (input_section)->relocs)
2189 	free (internal_relocs);
2190       if (isymbuf != NULL
2191 	  && (unsigned char *) isymbuf != symtab_hdr->contents)
2192 	free (isymbuf);
2193     }
2194 
2195   return data;
2196 
2197  error_return:
2198   if (sections != NULL)
2199     free (sections);
2200   if (internal_relocs != NULL
2201       && internal_relocs != elf_section_data (input_section)->relocs)
2202     free (internal_relocs);
2203   if (isymbuf != NULL
2204       && (unsigned char *) isymbuf != symtab_hdr->contents)
2205     free (isymbuf);
2206   return NULL;
2207 }
2208 
2209 /* Set the SHF_SH5_ISA32 flag for ISA SHmedia code sections.  */
2210 
2211 static bfd_boolean
sh64_elf64_fake_sections(bfd * output_bfd ATTRIBUTE_UNUSED,Elf_Internal_Shdr * elf_section_hdr,asection * asect)2212 sh64_elf64_fake_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2213 			  Elf_Internal_Shdr *elf_section_hdr,
2214 			  asection *asect)
2215 {
2216   /* Code sections can only contain SH64 code, so mark them as such.  */
2217   if (bfd_get_section_flags (output_bfd, asect) & SEC_CODE)
2218     elf_section_hdr->sh_flags |= SHF_SH5_ISA32;
2219 
2220   return TRUE;
2221 }
2222 
2223 static bfd_boolean
sh_elf64_set_mach_from_flags(bfd * abfd)2224 sh_elf64_set_mach_from_flags (bfd *abfd)
2225 {
2226   flagword flags = elf_elfheader (abfd)->e_flags;
2227 
2228   switch (flags & EF_SH_MACH_MASK)
2229     {
2230     case EF_SH5:
2231       /* Just one, but keep the switch construct to make additions easy.  */
2232       bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh5);
2233       break;
2234 
2235     default:
2236       bfd_set_error (bfd_error_wrong_format);
2237       return FALSE;
2238     }
2239   return TRUE;
2240 }
2241 
2242 /* Function to keep SH64 specific file flags.
2243 
2244    See sh64_elf_set_private_flags in elf32-sh64.c for the original.  */
2245 
2246 static bfd_boolean
sh_elf64_set_private_flags(bfd * abfd,flagword flags)2247 sh_elf64_set_private_flags (bfd *abfd, flagword flags)
2248 {
2249   BFD_ASSERT (! elf_flags_init (abfd)
2250 	      || elf_elfheader (abfd)->e_flags == flags);
2251 
2252   elf_elfheader (abfd)->e_flags = flags;
2253   elf_flags_init (abfd) = TRUE;
2254   return sh_elf64_set_mach_from_flags (abfd);
2255 }
2256 
2257 /* Copy the SHF_SH5_ISA32 attribute that we keep on all sections with
2258    code, to keep attributes the same as for SHmedia in 32-bit ELF.  */
2259 
2260 static bfd_boolean
sh_elf64_copy_private_data_internal(bfd * ibfd,bfd * obfd)2261 sh_elf64_copy_private_data_internal (bfd *ibfd, bfd *obfd)
2262 {
2263   Elf_Internal_Shdr **o_shdrp;
2264   asection *isec;
2265   asection *osec;
2266 
2267   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2268       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2269     return TRUE;
2270 
2271   o_shdrp = elf_elfsections (obfd);
2272   for (osec = obfd->sections; osec; osec = osec->next)
2273     {
2274       int oIndex = ((struct bfd_elf_section_data *) elf_section_data (osec))->this_idx;
2275       for (isec = ibfd->sections; isec; isec = isec->next)
2276 	{
2277 	  if (strcmp (osec->name, isec->name) == 0)
2278 	    {
2279 	      /* Note that we're not disallowing mixing data and code.  */
2280 	      if ((elf_section_data (isec)->this_hdr.sh_flags
2281 		   & SHF_SH5_ISA32) != 0)
2282 		o_shdrp[oIndex]->sh_flags |= SHF_SH5_ISA32;
2283 	      break;
2284 	    }
2285 	}
2286     }
2287 
2288   /* Copy object attributes.  */
2289   _bfd_elf_copy_obj_attributes (ibfd, obfd);
2290 
2291   return sh_elf64_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
2292 }
2293 
2294 static bfd_boolean
sh_elf64_copy_private_data(bfd * ibfd,bfd * obfd)2295 sh_elf64_copy_private_data (bfd *ibfd, bfd *obfd)
2296 {
2297   return sh_elf64_copy_private_data_internal (ibfd, obfd);
2298 }
2299 
2300 static bfd_boolean
sh_elf64_merge_private_data(bfd * ibfd,bfd * obfd)2301 sh_elf64_merge_private_data (bfd *ibfd, bfd *obfd)
2302 {
2303   flagword old_flags, new_flags;
2304 
2305   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
2306     return FALSE;
2307 
2308   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2309       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2310     return TRUE;
2311 
2312   if (bfd_get_arch_size (ibfd) != bfd_get_arch_size (obfd))
2313     {
2314       const char *msg;
2315 
2316       if (bfd_get_arch_size (ibfd) == 32
2317 	  && bfd_get_arch_size (obfd) == 64)
2318 	msg = _("%s: compiled as 32-bit object and %s is 64-bit");
2319       else if (bfd_get_arch_size (ibfd) == 64
2320 	       && bfd_get_arch_size (obfd) == 32)
2321 	msg = _("%s: compiled as 64-bit object and %s is 32-bit");
2322       else
2323 	msg = _("%s: object size does not match that of target %s");
2324 
2325       (*_bfd_error_handler) (msg, bfd_get_filename (ibfd),
2326 			     bfd_get_filename (obfd));
2327       bfd_set_error (bfd_error_wrong_format);
2328       return FALSE;
2329     }
2330 
2331   old_flags = elf_elfheader (obfd)->e_flags;
2332   new_flags = elf_elfheader (ibfd)->e_flags;
2333   if (! elf_flags_init (obfd))
2334     {
2335       /* This happens when ld starts out with a 'blank' output file.  */
2336       elf_flags_init (obfd) = TRUE;
2337       elf_elfheader (obfd)->e_flags = old_flags = new_flags;
2338     }
2339   /* We don't allow linking in anything else than SH64 code, and since
2340      this is a 64-bit ELF, we assume the 64-bit ABI is used.  Add code
2341      here as things change.  */
2342   else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
2343     {
2344       (*_bfd_error_handler)
2345 	("%s: does not use the SH64 64-bit ABI as previous modules do",
2346 	 bfd_get_filename (ibfd));
2347       bfd_set_error (bfd_error_bad_value);
2348       return FALSE;
2349     }
2350 
2351   sh_elf64_copy_private_data_internal (ibfd, obfd);
2352 
2353   /* I can't think of anything sane other than old_flags being EF_SH5 and
2354      that we need to preserve that.  */
2355   elf_elfheader (obfd)->e_flags = old_flags;
2356 
2357   return sh_elf64_set_mach_from_flags (obfd);
2358 }
2359 
2360 /* Return the section that should be marked against GC for a given
2361    relocation.  */
2362 
2363 static asection *
sh_elf64_gc_mark_hook(asection * sec,struct bfd_link_info * info,Elf_Internal_Rela * rel,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym)2364 sh_elf64_gc_mark_hook (asection *sec,
2365 		       struct bfd_link_info *info,
2366 		       Elf_Internal_Rela *rel,
2367 		       struct elf_link_hash_entry *h,
2368 		       Elf_Internal_Sym *sym)
2369 {
2370   if (h != NULL)
2371     switch (ELF64_R_TYPE (rel->r_info))
2372       {
2373       case R_SH_GNU_VTINHERIT:
2374       case R_SH_GNU_VTENTRY:
2375 	return NULL;
2376       }
2377 
2378   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2379 }
2380 
2381 /* Look through the relocs for a section during the first phase.
2382    Since we don't do .gots or .plts, we just need to consider the
2383    virtual table relocs for gc.  */
2384 
2385 static bfd_boolean
sh_elf64_check_relocs(bfd * abfd,struct bfd_link_info * info,asection * sec,const Elf_Internal_Rela * relocs)2386 sh_elf64_check_relocs (bfd *abfd, struct bfd_link_info *info,
2387 		       asection *sec, const Elf_Internal_Rela *relocs)
2388 {
2389   Elf_Internal_Shdr *symtab_hdr;
2390   struct elf_link_hash_entry **sym_hashes;
2391   const Elf_Internal_Rela *rel;
2392   const Elf_Internal_Rela *rel_end;
2393   bfd *dynobj;
2394   bfd_vma *local_got_offsets;
2395   asection *sgot;
2396   asection *srelgot;
2397   asection *sreloc;
2398 
2399   sgot = NULL;
2400   srelgot = NULL;
2401   sreloc = NULL;
2402 
2403   if (info->relocatable)
2404     return TRUE;
2405 
2406   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2407   sym_hashes = elf_sym_hashes (abfd);
2408 
2409   dynobj = elf_hash_table (info)->dynobj;
2410   local_got_offsets = elf_local_got_offsets (abfd);
2411 
2412   rel_end = relocs + sec->reloc_count;
2413   for (rel = relocs; rel < rel_end; rel++)
2414     {
2415       struct elf_link_hash_entry *h;
2416       unsigned long r_symndx;
2417 
2418       r_symndx = ELF64_R_SYM (rel->r_info);
2419       if (r_symndx < symtab_hdr->sh_info)
2420         h = NULL;
2421       else
2422 	{
2423 	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2424 	  while (h->root.type == bfd_link_hash_indirect
2425 		 || h->root.type == bfd_link_hash_warning)
2426 	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
2427 	}
2428 
2429       /* Some relocs require a global offset table.  */
2430       if (dynobj == NULL)
2431 	{
2432 	  switch (ELF64_R_TYPE (rel->r_info))
2433 	    {
2434 	    case R_SH_GOTPLT_LOW16:
2435 	    case R_SH_GOTPLT_MEDLOW16:
2436 	    case R_SH_GOTPLT_MEDHI16:
2437 	    case R_SH_GOTPLT_HI16:
2438 	    case R_SH_GOTPLT10BY4:
2439 	    case R_SH_GOTPLT10BY8:
2440 	    case R_SH_GOT_LOW16:
2441 	    case R_SH_GOT_MEDLOW16:
2442 	    case R_SH_GOT_MEDHI16:
2443 	    case R_SH_GOT_HI16:
2444 	    case R_SH_GOT10BY4:
2445 	    case R_SH_GOT10BY8:
2446 	    case R_SH_GOTOFF_LOW16:
2447 	    case R_SH_GOTOFF_MEDLOW16:
2448 	    case R_SH_GOTOFF_MEDHI16:
2449 	    case R_SH_GOTOFF_HI16:
2450 	    case R_SH_GOTPC_LOW16:
2451 	    case R_SH_GOTPC_MEDLOW16:
2452 	    case R_SH_GOTPC_MEDHI16:
2453 	    case R_SH_GOTPC_HI16:
2454 	      elf_hash_table (info)->dynobj = dynobj = abfd;
2455 	      if (! _bfd_elf_create_got_section (dynobj, info))
2456 		return FALSE;
2457 	      break;
2458 
2459 	    default:
2460 	      break;
2461 	    }
2462 	}
2463 
2464       switch (ELF64_R_TYPE (rel->r_info))
2465         {
2466 	  /* This relocation describes the C++ object vtable hierarchy.
2467 	     Reconstruct it for later use during GC.  */
2468         case R_SH_GNU_VTINHERIT:
2469           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2470             return FALSE;
2471           break;
2472 
2473 	  /* This relocation describes which C++ vtable entries are actually
2474 	     used.  Record for later use during GC.  */
2475         case R_SH_GNU_VTENTRY:
2476           BFD_ASSERT (h != NULL);
2477           if (h != NULL
2478               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2479             return FALSE;
2480           break;
2481 
2482 	force_got:
2483 	case R_SH_GOT_LOW16:
2484 	case R_SH_GOT_MEDLOW16:
2485 	case R_SH_GOT_MEDHI16:
2486 	case R_SH_GOT_HI16:
2487 	case R_SH_GOT10BY4:
2488 	case R_SH_GOT10BY8:
2489 	  /* This symbol requires a global offset table entry.  */
2490 
2491 	  if (sgot == NULL)
2492 	    {
2493 	      sgot = bfd_get_linker_section (dynobj, ".got");
2494 	      BFD_ASSERT (sgot != NULL);
2495 	    }
2496 
2497 	  if (srelgot == NULL
2498 	      && (h != NULL || info->shared))
2499 	    {
2500 	      srelgot = bfd_get_linker_section (dynobj, ".rela.got");
2501 	      if (srelgot == NULL)
2502 		{
2503 		  flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2504 				    | SEC_IN_MEMORY | SEC_LINKER_CREATED
2505 				    | SEC_READONLY);
2506 		  srelgot = bfd_make_section_anyway_with_flags (dynobj,
2507 								".rela.got",
2508 								flags);
2509 		  if (srelgot == NULL
2510 		      || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2511 		    return FALSE;
2512 		}
2513 	    }
2514 
2515 	  if (h != NULL)
2516 	    {
2517 	      if (h->type == STT_DATALABEL)
2518 		{
2519 		  struct elf_sh64_link_hash_entry *hsh;
2520 
2521 		  h = (struct elf_link_hash_entry *) h->root.u.i.link;
2522 		  hsh = (struct elf_sh64_link_hash_entry *)h;
2523 		  if (hsh->datalabel_got_offset != (bfd_vma) -1)
2524 		    break;
2525 
2526 		  hsh->datalabel_got_offset = sgot->size;
2527 		}
2528 	      else
2529 		{
2530 		  if (h->got.offset != (bfd_vma) -1)
2531 		    {
2532 		      /* We have already allocated space in the .got.  */
2533 		      break;
2534 		    }
2535 		  h->got.offset = sgot->size;
2536 		}
2537 
2538 	      /* Make sure this symbol is output as a dynamic symbol.  */
2539 	      if (h->dynindx == -1)
2540 		{
2541 		  if (! bfd_elf_link_record_dynamic_symbol (info, h))
2542 		    return FALSE;
2543 		}
2544 
2545 	      srelgot->size += sizeof (Elf64_External_Rela);
2546 	    }
2547 	  else
2548 	    {
2549      	      /* This is a global offset table entry for a local
2550 		 symbol.  */
2551 	      if (local_got_offsets == NULL)
2552 		{
2553 		  size_t size;
2554 		  register unsigned int i;
2555 
2556 		  size = symtab_hdr->sh_info * sizeof (bfd_vma);
2557 		  /* Reserve space for both the datalabel and
2558 		     codelabel local GOT offsets.  */
2559 		  size *= 2;
2560 		  local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2561 		  if (local_got_offsets == NULL)
2562 		    return FALSE;
2563 		  elf_local_got_offsets (abfd) = local_got_offsets;
2564 		  for (i = 0; i < symtab_hdr->sh_info; i++)
2565 		    local_got_offsets[i] = (bfd_vma) -1;
2566 		  for (; i < 2 * symtab_hdr->sh_info; i++)
2567 		    local_got_offsets[i] = (bfd_vma) -1;
2568 		}
2569 	      if ((rel->r_addend & 1) != 0)
2570 		{
2571 		  if (local_got_offsets[symtab_hdr->sh_info
2572 					+ r_symndx] != (bfd_vma) -1)
2573 		    {
2574 		      /* We have already allocated space in the .got.  */
2575 		      break;
2576 		    }
2577 		  local_got_offsets[symtab_hdr->sh_info
2578 				    + r_symndx] = sgot->size;
2579 		}
2580 	      else
2581 		{
2582 		  if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2583 		    {
2584 		      /* We have already allocated space in the .got.  */
2585 		      break;
2586 		    }
2587 		  local_got_offsets[r_symndx] = sgot->size;
2588 		}
2589 
2590 	      if (info->shared)
2591 		{
2592 		  /* If we are generating a shared object, we need to
2593 		     output a R_SH_RELATIVE reloc so that the dynamic
2594 		     linker can adjust this GOT entry.  */
2595 		  srelgot->size += sizeof (Elf64_External_Rela);
2596 		}
2597 	    }
2598 
2599 	  sgot->size += 8;
2600 
2601 	  break;
2602 
2603 	case R_SH_GOTPLT_LOW16:
2604 	case R_SH_GOTPLT_MEDLOW16:
2605 	case R_SH_GOTPLT_MEDHI16:
2606 	case R_SH_GOTPLT_HI16:
2607 	case R_SH_GOTPLT10BY4:
2608 	case R_SH_GOTPLT10BY8:
2609 	  /* If this is a local symbol, we resolve it directly without
2610 	     creating a procedure linkage table entry.  */
2611 
2612 	  if (h == NULL
2613 	      || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2614 	      || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2615 	      || ! info->shared
2616 	      || info->symbolic
2617 	      || h->dynindx == -1
2618 	      || h->got.offset != (bfd_vma) -1)
2619 	    goto force_got;
2620 
2621 	  /* Make sure this symbol is output as a dynamic symbol.  */
2622 	  if (h->dynindx == -1)
2623 	    {
2624 	      if (! bfd_elf_link_record_dynamic_symbol (info, h))
2625 		return FALSE;
2626 	    }
2627 
2628 	  h->needs_plt = 1;
2629 
2630 	  break;
2631 
2632 	case R_SH_PLT_LOW16:
2633 	case R_SH_PLT_MEDLOW16:
2634 	case R_SH_PLT_MEDHI16:
2635 	case R_SH_PLT_HI16:
2636 	  /* This symbol requires a procedure linkage table entry.  We
2637 	     actually build the entry in adjust_dynamic_symbol,
2638 	     because this might be a case of linking PIC code which is
2639 	     never referenced by a dynamic object, in which case we
2640 	     don't need to generate a procedure linkage table entry
2641 	     after all.  */
2642 
2643 	  /* If this is a local symbol, we resolve it directly without
2644 	     creating a procedure linkage table entry.  */
2645 	  if (h == NULL)
2646 	    continue;
2647 
2648 	  if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2649 	      || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
2650 	    break;
2651 
2652 	  h->needs_plt = 1;
2653 
2654 	  break;
2655 
2656 	case R_SH_64:
2657 	case R_SH_64_PCREL:
2658 	  if (h != NULL)
2659 	    h->non_got_ref = 1;
2660 
2661 	  /* If we are creating a shared library, and this is a reloc
2662 	     against a global symbol, or a non PC relative reloc
2663 	     against a local symbol, then we need to copy the reloc
2664 	     into the shared library.  However, if we are linking with
2665 	     -Bsymbolic, we do not need to copy a reloc against a
2666 	     global symbol which is defined in an object we are
2667 	     including in the link (i.e., DEF_REGULAR is set).  At
2668 	     this point we have not seen all the input files, so it is
2669 	     possible that DEF_REGULAR is not set now but will be set
2670 	     later (it is never cleared).  We account for that
2671 	     possibility below by storing information in the
2672 	     pcrel_relocs_copied field of the hash table entry.  */
2673 	  if (info->shared
2674 	      && (sec->flags & SEC_ALLOC) != 0
2675 	      && (ELF32_R_TYPE (rel->r_info) != R_SH_64_PCREL
2676 		  || (h != NULL
2677 		      && (! info->symbolic
2678 			  || !h->def_regular))))
2679 	    {
2680 	      /* When creating a shared object, we must copy these
2681 		 reloc types into the output file.  We create a reloc
2682 		 section in dynobj and make room for this reloc.  */
2683 	      if (sreloc == NULL)
2684 		{
2685 		  sreloc = _bfd_elf_make_dynamic_reloc_section
2686 		    (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
2687 
2688 		  if (sreloc == NULL)
2689 		    return FALSE;
2690 		}
2691 
2692 	      sreloc->size += sizeof (Elf64_External_Rela);
2693 
2694 	      /* If we are linking with -Bsymbolic, and this is a
2695 		 global symbol, we count the number of PC relative
2696 		 relocations we have entered for this symbol, so that
2697 		 we can discard them again if the symbol is later
2698 		 defined by a regular object.  Note that this function
2699 		 is only called if we are using an elf_sh linker
2700 		 hash table, which means that h is really a pointer to
2701 		 an elf_sh_link_hash_entry.  */
2702 	      if (h != NULL && info->symbolic
2703 		  && ELF64_R_TYPE (rel->r_info) == R_SH_64_PCREL)
2704 		{
2705 		  struct elf_sh64_link_hash_entry *eh;
2706 		  struct elf_sh64_pcrel_relocs_copied *p;
2707 
2708 		  eh = (struct elf_sh64_link_hash_entry *) h;
2709 
2710 		  for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2711 		    if (p->section == sreloc)
2712 		      break;
2713 
2714 		  if (p == NULL)
2715 		    {
2716 		      p = ((struct elf_sh64_pcrel_relocs_copied *)
2717 			   bfd_alloc (dynobj, sizeof *p));
2718 		      if (p == NULL)
2719 			return FALSE;
2720 		      p->next = eh->pcrel_relocs_copied;
2721 		      eh->pcrel_relocs_copied = p;
2722 		      p->section = sreloc;
2723 		      p->count = 0;
2724 		    }
2725 
2726 		  ++p->count;
2727 		}
2728 	    }
2729 
2730 	  break;
2731         }
2732     }
2733 
2734   return TRUE;
2735 }
2736 
2737 static int
sh64_elf64_get_symbol_type(Elf_Internal_Sym * elf_sym,int type)2738 sh64_elf64_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
2739 {
2740   if (ELF_ST_TYPE (elf_sym->st_info) == STT_DATALABEL)
2741     return STT_DATALABEL;
2742 
2743   return type;
2744 }
2745 
2746 /* FIXME: This is a copy of sh64_elf_add_symbol_hook in elf32-sh64.c.
2747    Either file can presumably exist without the other, but do not differ
2748    in elf-size-ness.  How to share?
2749 
2750    Hook called by the linker routine which adds symbols from an object
2751    file.  We must make indirect symbols for undefined symbols marked with
2752    STT_DATALABEL, so relocations passing them will pick up that attribute
2753    and neutralize STO_SH5_ISA32 found on the symbol definition.
2754 
2755    There is a problem, though: We want to fill in the hash-table entry for
2756    this symbol and signal to the caller that no further processing is
2757    needed.  But we don't have the index for this hash-table entry.  We
2758    rely here on that the current entry is the first hash-entry with NULL,
2759    which seems brittle.  Also, iterating over the hash-table to find that
2760    entry is a linear operation on the number of symbols in this input
2761    file, and this function should take constant time, so that's not good
2762    too.  Only comfort is that DataLabel references should only be found in
2763    hand-written assembly code and thus be rare.  FIXME: Talk maintainers
2764    into adding an option to elf_add_symbol_hook (preferably) for the index
2765    or the hash entry, alternatively adding the index to Elf_Internal_Sym
2766    (not so good).  */
2767 
2768 static bfd_boolean
sh64_elf64_add_symbol_hook(bfd * abfd,struct bfd_link_info * info,Elf_Internal_Sym * sym,const char ** namep,flagword * flagsp ATTRIBUTE_UNUSED,asection ** secp,bfd_vma * valp)2769 sh64_elf64_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
2770 			    Elf_Internal_Sym *sym, const char **namep,
2771 			    flagword *flagsp ATTRIBUTE_UNUSED,
2772 			    asection **secp, bfd_vma *valp)
2773 {
2774   /* We want to do this for relocatable as well as final linking.  */
2775   if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL
2776       && is_elf_hash_table (info->hash))
2777     {
2778       struct elf_link_hash_entry *h;
2779 
2780       /* For relocatable links, we register the DataLabel sym in its own
2781 	 right, and tweak the name when it's output.  Otherwise, we make
2782 	 an indirect symbol of it.  */
2783       flagword flags
2784 	= info->relocatable || info->emitrelocations
2785 	? BSF_GLOBAL : BSF_GLOBAL | BSF_INDIRECT;
2786 
2787       char *dl_name
2788 	= bfd_malloc (strlen (*namep) + sizeof (DATALABEL_SUFFIX));
2789       struct elf_link_hash_entry ** sym_hash = elf_sym_hashes (abfd);
2790 
2791       BFD_ASSERT (sym_hash != NULL);
2792 
2793       /* Allocation may fail.  */
2794       if (dl_name == NULL)
2795 	return FALSE;
2796 
2797       strcpy (dl_name, *namep);
2798       strcat (dl_name, DATALABEL_SUFFIX);
2799 
2800       h = (struct elf_link_hash_entry *)
2801 	bfd_link_hash_lookup (info->hash, dl_name, FALSE, FALSE, FALSE);
2802 
2803       if (h == NULL)
2804 	{
2805 	  /* No previous datalabel symbol.  Make one.  */
2806 	  struct bfd_link_hash_entry *bh = NULL;
2807 	  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2808 
2809 	  if (! _bfd_generic_link_add_one_symbol (info, abfd, dl_name,
2810 						  flags, *secp, *valp,
2811 						  *namep, FALSE,
2812 						  bed->collect, &bh))
2813 	    {
2814 	      free (dl_name);
2815 	      return FALSE;
2816 	    }
2817 
2818 	  h = (struct elf_link_hash_entry *) bh;
2819 	  h->non_elf = 0;
2820 	  h->type = STT_DATALABEL;
2821 	}
2822       else
2823 	/* If a new symbol was created, it holds the allocated name.
2824 	   Otherwise, we don't need it anymore and should deallocate it.  */
2825 	free (dl_name);
2826 
2827       if (h->type != STT_DATALABEL
2828 	  || ((info->relocatable || info->emitrelocations)
2829 	      && h->root.type != bfd_link_hash_undefined)
2830 	  || (! info->relocatable && !info->emitrelocations
2831 	      && h->root.type != bfd_link_hash_indirect))
2832 	{
2833 	  /* Make sure we don't get confused on invalid input.  */
2834 	  (*_bfd_error_handler)
2835 	    (_("%s: encountered datalabel symbol in input"),
2836 	     bfd_get_filename (abfd));
2837 	  bfd_set_error (bfd_error_bad_value);
2838 	  return FALSE;
2839 	}
2840 
2841       /* Now find the hash-table slot for this entry and fill it in.  */
2842       while (*sym_hash != NULL)
2843 	sym_hash++;
2844       *sym_hash = h;
2845 
2846       /* Signal to caller to skip this symbol - we've handled it.  */
2847       *namep = NULL;
2848     }
2849 
2850   return TRUE;
2851 }
2852 
2853 /* This hook function is called before the linker writes out a global
2854    symbol.  For relocatable links, DataLabel symbols will be present in
2855    linker output.  We cut off the special suffix on those symbols, so the
2856    right name appears in the output.
2857 
2858    When linking and emitting relocations, there can appear global symbols
2859    that are not referenced by relocs, but rather only implicitly through
2860    DataLabel references, a relation that is not visible to the linker.
2861    Since no stripping of global symbols in done when doing such linking,
2862    we don't need to look up and make sure to emit the main symbol for each
2863    DataLabel symbol.  */
2864 
2865 static int
sh64_elf64_link_output_symbol_hook(struct bfd_link_info * info,const char * cname,Elf_Internal_Sym * sym,asection * input_sec ATTRIBUTE_UNUSED,struct elf_link_hash_entry * h ATTRIBUTE_UNUSED)2866 sh64_elf64_link_output_symbol_hook (struct bfd_link_info *info,
2867 				    const char *cname,
2868 				    Elf_Internal_Sym *sym,
2869 				    asection *input_sec ATTRIBUTE_UNUSED,
2870 				    struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
2871 {
2872   char *name = (char *) cname;
2873 
2874   if (info->relocatable || info->emitrelocations)
2875     {
2876       if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL)
2877 	name[strlen (name) - strlen (DATALABEL_SUFFIX)] = 0;
2878     }
2879 
2880   return 1;
2881 }
2882 
2883 /* Set bit 0 on the entry address; it always points to SHmedia code.  This
2884    is mostly for symmetry with the 32-bit format, where code can be
2885    SHcompact and we need to make a distinction to make sure execution
2886    starts in the right ISA mode.  It is also convenient for a loader,
2887    which would otherwise have to set this bit when loading a TR register
2888    before jumping to the program entry.  */
2889 
2890 static void
sh64_elf64_final_write_processing(bfd * abfd,bfd_boolean linker ATTRIBUTE_UNUSED)2891 sh64_elf64_final_write_processing (bfd *abfd,
2892 				   bfd_boolean linker ATTRIBUTE_UNUSED)
2893 {
2894   /* FIXME: Perhaps we shouldn't do this if the entry address was supplied
2895      numerically, but we currently lack the infrastructure to recognize
2896      that: The entry symbol, and info whether it is numeric or a symbol
2897      name is kept private in the linker.  */
2898   if (elf_elfheader (abfd)->e_type == ET_EXEC)
2899     elf_elfheader (abfd)->e_entry |= 1;
2900 }
2901 
2902 /* First entry in an absolute procedure linkage table look like this.  */
2903 
2904 static const bfd_byte elf_sh64_plt0_entry_be[PLT_ENTRY_SIZE] =
2905 {
2906   0xcc, 0x00, 0x01, 0x10, /* movi  .got.plt >> 48, r17 */
2907   0xc8, 0x00, 0x01, 0x10, /* shori (.got.plt >> 32) & 65535, r17 */
2908   0xc8, 0x00, 0x01, 0x10, /* shori (.got.plt >> 16) & 65535, r17 */
2909   0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
2910   0x8d, 0x10, 0x09, 0x90, /* ld.q  r17, 16, r25 */
2911   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2912   0x8d, 0x10, 0x05, 0x10, /* ld.q  r17, 8, r17 */
2913   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2914   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2915   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2916   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2917   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2918   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2919   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2920   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2921   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2922 };
2923 
2924 static const bfd_byte elf_sh64_plt0_entry_le[PLT_ENTRY_SIZE] =
2925 {
2926   0x10, 0x01, 0x00, 0xcc, /* movi  .got.plt >> 16, r17 */
2927   0x10, 0x01, 0x00, 0xc8, /* shori (.got.plt >> 32) & 65535, r17 */
2928   0x10, 0x01, 0x00, 0xc8, /* shori (.got.plt >> 16) & 65535, r17 */
2929   0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
2930   0x90, 0x09, 0x10, 0x8d, /* ld.q  r17, 16, r25 */
2931   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
2932   0x10, 0x05, 0x10, 0x8d, /* ld.q  r17, 8, r17 */
2933   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2934   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2935   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2936   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2937   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2938   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2939   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2940   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2941   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2942 };
2943 
2944 /* Sebsequent entries in an absolute procedure linkage table look like
2945    this.  */
2946 
2947 static const bfd_byte elf_sh64_plt_entry_be[PLT_ENTRY_SIZE] =
2948 {
2949   0xcc, 0x00, 0x01, 0x90, /* movi  nameN-in-GOT >> 48, r25 */
2950   0xc8, 0x00, 0x01, 0x90, /* shori (nameN-in-GOT >> 32) & 65535, r25 */
2951   0xc8, 0x00, 0x01, 0x90, /* shori (nameN-in-GOT >> 16) & 65535, r25 */
2952   0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
2953   0x8d, 0x90, 0x01, 0x90, /* ld.q  r25, 0, r25 */
2954   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2955   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2956   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2957   0xcc, 0x00, 0x01, 0x90, /* movi  (.+8-.PLT0) >> 16, r25 */
2958   0xc8, 0x00, 0x01, 0x90, /* shori (.+4-.PLT0) & 65535, r25 */
2959   0x6b, 0xf5, 0x66, 0x00, /* ptrel r25, tr0 */
2960   0xcc, 0x00, 0x01, 0x50, /* movi  reloc-offset >> 16, r21 */
2961   0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
2962   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2963   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2964   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2965 };
2966 
2967 static const bfd_byte elf_sh64_plt_entry_le[PLT_ENTRY_SIZE] =
2968 {
2969   0x90, 0x01, 0x00, 0xcc, /* movi  nameN-in-GOT >> 16, r25 */
2970   0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2971   0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2972   0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2973   0x90, 0x01, 0x90, 0x8d, /* ld.q  r25, 0, r25 */
2974   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
2975   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2976   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2977   0x90, 0x01, 0x00, 0xcc, /* movi  (.+8-.PLT0) >> 16, r25 */
2978   0x90, 0x01, 0x00, 0xc8, /* shori (.+4-.PLT0) & 65535, r25 */
2979   0x00, 0x66, 0xf5, 0x6b, /* ptrel r25, tr0 */
2980   0x50, 0x01, 0x00, 0xcc, /* movi  reloc-offset >> 16, r21 */
2981   0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
2982   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2983   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2984   0xf0, 0xff, 0xf0, 0x6f, /* nop */
2985 };
2986 
2987 /* Entries in a PIC procedure linkage table look like this.  */
2988 
2989 static const bfd_byte elf_sh64_pic_plt_entry_be[PLT_ENTRY_SIZE] =
2990 {
2991   0xcc, 0x00, 0x01, 0x90, /* movi  nameN@GOT >> 16, r25 */
2992   0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
2993   0x40, 0xc3, 0x65, 0x90, /* ldx.q r12, r25, r25 */
2994   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2995   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2996   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2997   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2998   0x6f, 0xf0, 0xff, 0xf0, /* nop */
2999   0xce, 0x00, 0x01, 0x10, /* movi  -GOT_BIAS, r17 */
3000   0x00, 0xc9, 0x45, 0x10, /* add   r12, r17, r17 */
3001   0x8d, 0x10, 0x09, 0x90, /* ld.q  r17, 16, r25 */
3002   0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3003   0x8d, 0x10, 0x05, 0x10, /* ld.q  r17, 8, r17 */
3004   0xcc, 0x00, 0x01, 0x50, /* movi  reloc-offset >> 16, r21 */
3005   0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
3006   0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3007 };
3008 
3009 static const bfd_byte elf_sh64_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3010 {
3011   0x90, 0x01, 0x00, 0xcc, /* movi  nameN@GOT >> 16, r25 */
3012   0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
3013   0x90, 0x65, 0xc3, 0x40, /* ldx.q r12, r25, r25 */
3014   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3015   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3016   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3017   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3018   0xf0, 0xff, 0xf0, 0x6f, /* nop */
3019   0x10, 0x01, 0x00, 0xce, /* movi  -GOT_BIAS, r17 */
3020   0x10, 0x45, 0xc9, 0x00, /* add   r12, r17, r17 */
3021   0x90, 0x09, 0x10, 0x8d, /* ld.q  r17, 16, r25 */
3022   0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3023   0x10, 0x05, 0x10, 0x8d, /* ld.q  r17, 8, r17 */
3024   0x50, 0x01, 0x00, 0xcc, /* movi  reloc-offset >> 16, r21 */
3025   0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
3026   0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3027 };
3028 
3029 static const bfd_byte *elf_sh64_plt0_entry;
3030 static const bfd_byte *elf_sh64_plt_entry;
3031 static const bfd_byte *elf_sh64_pic_plt_entry;
3032 
3033 /* Create an entry in an sh ELF linker hash table.  */
3034 
3035 static struct bfd_hash_entry *
sh64_elf64_link_hash_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)3036 sh64_elf64_link_hash_newfunc (struct bfd_hash_entry *entry,
3037 			      struct bfd_hash_table *table,
3038 			      const char *string)
3039 {
3040   struct elf_sh64_link_hash_entry *ret =
3041     (struct elf_sh64_link_hash_entry *) entry;
3042 
3043   /* Allocate the structure if it has not already been allocated by a
3044      subclass.  */
3045   if (ret == (struct elf_sh64_link_hash_entry *) NULL)
3046     ret = ((struct elf_sh64_link_hash_entry *)
3047 	   bfd_hash_allocate (table,
3048 			      sizeof (struct elf_sh64_link_hash_entry)));
3049   if (ret == (struct elf_sh64_link_hash_entry *) NULL)
3050     return (struct bfd_hash_entry *) ret;
3051 
3052   /* Call the allocation method of the superclass.  */
3053   ret = ((struct elf_sh64_link_hash_entry *)
3054 	 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3055 				     table, string));
3056   if (ret != (struct elf_sh64_link_hash_entry *) NULL)
3057     {
3058       ret->pcrel_relocs_copied = NULL;
3059       ret->datalabel_got_offset = (bfd_vma) -1;
3060     }
3061 
3062   return (struct bfd_hash_entry *) ret;
3063 }
3064 
3065 /* Create an sh64 ELF linker hash table.  */
3066 
3067 static struct bfd_link_hash_table *
sh64_elf64_link_hash_table_create(bfd * abfd)3068 sh64_elf64_link_hash_table_create (bfd *abfd)
3069 {
3070   struct elf_link_hash_table *ret;
3071 
3072   ret = (struct elf_link_hash_table *) bfd_zmalloc (sizeof (* ret));
3073   if (ret == (struct elf_link_hash_table *) NULL)
3074     return NULL;
3075 
3076   if (!_bfd_elf_link_hash_table_init (ret, abfd,
3077 				      sh64_elf64_link_hash_newfunc,
3078 				      sizeof (struct elf_sh64_link_hash_entry),
3079 				      GENERIC_ELF_DATA))
3080     {
3081       free (ret);
3082       return NULL;
3083     }
3084 
3085   return &ret->root;
3086 }
3087 
3088 inline static void
movi_shori_putval(bfd * output_bfd,unsigned long value,bfd_byte * addr)3089 movi_shori_putval (bfd *output_bfd, unsigned long value, bfd_byte *addr)
3090 {
3091   bfd_put_32 (output_bfd,
3092 	      bfd_get_32 (output_bfd, addr)
3093 	      | ((value >> 6) & 0x3fffc00),
3094 	      addr);
3095   bfd_put_32 (output_bfd,
3096 	      bfd_get_32 (output_bfd, addr + 4)
3097 	      | ((value << 10) & 0x3fffc00),
3098 	      addr + 4);
3099 }
3100 
3101 inline static void
movi_3shori_putval(bfd * output_bfd,bfd_vma value,bfd_byte * addr)3102 movi_3shori_putval (bfd *output_bfd, bfd_vma value, bfd_byte *addr)
3103 {
3104   bfd_put_32 (output_bfd,
3105 	      bfd_get_32 (output_bfd, addr)
3106 	      | ((value >> 38) & 0x3fffc00),
3107 	      addr);
3108   bfd_put_32 (output_bfd,
3109 	      bfd_get_32 (output_bfd, addr + 4)
3110 	      | ((value >> 22) & 0x3fffc00),
3111 	      addr + 4);
3112   bfd_put_32 (output_bfd,
3113 	      bfd_get_32 (output_bfd, addr + 8)
3114 	      | ((value >> 6) & 0x3fffc00),
3115 	      addr + 8);
3116   bfd_put_32 (output_bfd,
3117 	      bfd_get_32 (output_bfd, addr + 12)
3118 	      | ((value << 10) & 0x3fffc00),
3119 	      addr + 12);
3120 }
3121 
3122 /* Create dynamic sections when linking against a dynamic object.  */
3123 
3124 static bfd_boolean
sh64_elf64_create_dynamic_sections(bfd * abfd,struct bfd_link_info * info)3125 sh64_elf64_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3126 {
3127   flagword flags, pltflags;
3128   register asection *s;
3129   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3130   int ptralign = 0;
3131 
3132   switch (bed->s->arch_size)
3133     {
3134     case 32:
3135       ptralign = 2;
3136       break;
3137 
3138     case 64:
3139       ptralign = 3;
3140       break;
3141 
3142     default:
3143       bfd_set_error (bfd_error_bad_value);
3144       return FALSE;
3145     }
3146 
3147   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3148      .rel[a].bss sections.  */
3149 
3150   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3151 	   | SEC_LINKER_CREATED);
3152 
3153   pltflags = flags;
3154   pltflags |= SEC_CODE;
3155   if (bed->plt_not_loaded)
3156     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
3157   if (bed->plt_readonly)
3158     pltflags |= SEC_READONLY;
3159 
3160   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
3161   if (s == NULL
3162       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3163     return FALSE;
3164 
3165   if (bed->want_plt_sym)
3166     {
3167       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3168 	 .plt section.  */
3169       struct elf_link_hash_entry *h;
3170       struct bfd_link_hash_entry *bh = NULL;
3171 
3172       if (! (_bfd_generic_link_add_one_symbol
3173 	     (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3174 	      (bfd_vma) 0, (const char *) NULL, FALSE, bed->collect, &bh)))
3175 	return FALSE;
3176 
3177       h = (struct elf_link_hash_entry *) bh;
3178       h->def_regular = 1;
3179       h->type = STT_OBJECT;
3180       elf_hash_table (info)->hplt = h;
3181 
3182       if (info->shared
3183 	  && ! bfd_elf_link_record_dynamic_symbol (info, h))
3184 	return FALSE;
3185     }
3186 
3187   s = bfd_make_section_anyway_with_flags (abfd,
3188 					  bed->default_use_rela_p
3189 					  ? ".rela.plt" : ".rel.plt",
3190 					  flags | SEC_READONLY);
3191   if (s == NULL
3192       || ! bfd_set_section_alignment (abfd, s, ptralign))
3193     return FALSE;
3194 
3195   if (! _bfd_elf_create_got_section (abfd, info))
3196     return FALSE;
3197 
3198   if (bed->want_dynbss)
3199     {
3200       /* The .dynbss section is a place to put symbols which are defined
3201 	 by dynamic objects, are referenced by regular objects, and are
3202 	 not functions.  We must allocate space for them in the process
3203 	 image and use a R_*_COPY reloc to tell the dynamic linker to
3204 	 initialize them at run time.  The linker script puts the .dynbss
3205 	 section into the .bss section of the final image.  */
3206       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
3207 					      SEC_ALLOC | SEC_LINKER_CREATED);
3208       if (s == NULL)
3209 	return FALSE;
3210 
3211       /* The .rel[a].bss section holds copy relocs.  This section is not
3212 	 normally needed.  We need to create it here, though, so that the
3213 	 linker will map it to an output section.  We can't just create it
3214 	 only if we need it, because we will not know whether we need it
3215 	 until we have seen all the input files, and the first time the
3216 	 main linker code calls BFD after examining all the input files
3217 	 (size_dynamic_sections) the input sections have already been
3218 	 mapped to the output sections.  If the section turns out not to
3219 	 be needed, we can discard it later.  We will never need this
3220 	 section when generating a shared object, since they do not use
3221 	 copy relocs.  */
3222       if (! info->shared)
3223 	{
3224 	  s = bfd_make_section_anyway_with_flags (abfd,
3225 						  (bed->default_use_rela_p
3226 						   ? ".rela.bss" : ".rel.bss"),
3227 						  flags | SEC_READONLY);
3228 	  if (s == NULL
3229 	      || ! bfd_set_section_alignment (abfd, s, ptralign))
3230 	    return FALSE;
3231 	}
3232     }
3233 
3234   return TRUE;
3235 }
3236 
3237 /* Adjust a symbol defined by a dynamic object and referenced by a
3238    regular object.  The current definition is in some section of the
3239    dynamic object, but we're not including those sections.  We have to
3240    change the definition to something the rest of the link can
3241    understand.  */
3242 
3243 static bfd_boolean
sh64_elf64_adjust_dynamic_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * h)3244 sh64_elf64_adjust_dynamic_symbol (struct bfd_link_info *info,
3245 				  struct elf_link_hash_entry *h)
3246 {
3247   bfd *dynobj;
3248   asection *s;
3249 
3250   dynobj = elf_hash_table (info)->dynobj;
3251 
3252   /* Make sure we know what is going on here.  */
3253   BFD_ASSERT (dynobj != NULL
3254 	      && (h->needs_plt
3255 		  || h->u.weakdef != NULL
3256 		  || (h->def_dynamic
3257 		      && h->ref_regular
3258 		      && !h->def_regular)));
3259 
3260   /* If this is a function, put it in the procedure linkage table.  We
3261      will fill in the contents of the procedure linkage table later,
3262      when we know the address of the .got section.  */
3263   if (h->type == STT_FUNC
3264       || h->needs_plt)
3265     {
3266       if (! info->shared
3267 	  && !h->def_dynamic
3268 	  && !h->ref_dynamic)
3269 	{
3270 	  /* This case can occur if we saw a PLT reloc in an input
3271 	     file, but the symbol was never referred to by a dynamic
3272 	     object.  In such a case, we don't actually need to build
3273 	     a procedure linkage table, and we can just do a REL64
3274 	     reloc instead.  */
3275 	  BFD_ASSERT (h->needs_plt);
3276 	  return TRUE;
3277 	}
3278 
3279       /* Make sure this symbol is output as a dynamic symbol.  */
3280       if (h->dynindx == -1)
3281 	{
3282 	  if (! bfd_elf_link_record_dynamic_symbol (info, h))
3283 	    return FALSE;
3284 	}
3285 
3286       s = bfd_get_linker_section (dynobj, ".plt");
3287       BFD_ASSERT (s != NULL);
3288 
3289       /* If this is the first .plt entry, make room for the special
3290 	 first entry.  */
3291       if (s->size == 0)
3292 	s->size += PLT_ENTRY_SIZE;
3293 
3294       /* If this symbol is not defined in a regular file, and we are
3295 	 not generating a shared library, then set the symbol to this
3296 	 location in the .plt.  This is required to make function
3297 	 pointers compare as equal between the normal executable and
3298 	 the shared library.  */
3299       if (! info->shared
3300 	  && !h->def_regular)
3301 	{
3302 	  h->root.u.def.section = s;
3303 	  h->root.u.def.value = s->size;
3304 	}
3305 
3306       h->plt.offset = s->size;
3307 
3308       /* Make room for this entry.  */
3309       s->size += elf_sh64_sizeof_plt (info);
3310 
3311       /* We also need to make an entry in the .got.plt section, which
3312 	 will be placed in the .got section by the linker script.  */
3313 
3314       s = bfd_get_linker_section (dynobj, ".got.plt");
3315       BFD_ASSERT (s != NULL);
3316       s->size += 8;
3317 
3318       /* We also need to make an entry in the .rela.plt section.  */
3319 
3320       s = bfd_get_linker_section (dynobj, ".rela.plt");
3321       BFD_ASSERT (s != NULL);
3322       s->size += sizeof (Elf64_External_Rela);
3323 
3324       return TRUE;
3325     }
3326 
3327   /* If this is a weak symbol, and there is a real definition, the
3328      processor independent code will have arranged for us to see the
3329      real definition first, and we can just use the same value.  */
3330   if (h->u.weakdef != NULL)
3331     {
3332       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3333 		  || h->u.weakdef->root.type == bfd_link_hash_defweak);
3334       h->root.u.def.section = h->u.weakdef->root.u.def.section;
3335       h->root.u.def.value = h->u.weakdef->root.u.def.value;
3336       return TRUE;
3337     }
3338 
3339   /* This is a reference to a symbol defined by a dynamic object which
3340      is not a function.  */
3341 
3342   /* If we are creating a shared library, we must presume that the
3343      only references to the symbol are via the global offset table.
3344      For such cases we need not do anything here; the relocations will
3345      be handled correctly by relocate_section.  */
3346   if (info->shared)
3347     return TRUE;
3348 
3349   /* If there are no references to this symbol that do not use the
3350      GOT, we don't need to generate a copy reloc.  */
3351   if (!h->non_got_ref)
3352     return TRUE;
3353 
3354   /* We must allocate the symbol in our .dynbss section, which will
3355      become part of the .bss section of the executable.  There will be
3356      an entry for this symbol in the .dynsym section.  The dynamic
3357      object will contain position independent code, so all references
3358      from the dynamic object to this symbol will go through the global
3359      offset table.  The dynamic linker will use the .dynsym entry to
3360      determine the address it must put in the global offset table, so
3361      both the dynamic object and the regular object will refer to the
3362      same memory location for the variable.  */
3363 
3364   s = bfd_get_linker_section (dynobj, ".dynbss");
3365   BFD_ASSERT (s != NULL);
3366 
3367   /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
3368      copy the initial value out of the dynamic object and into the
3369      runtime process image.  We need to remember the offset into the
3370      .rela.bss section we are going to use.  */
3371   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
3372     {
3373       asection *srel;
3374 
3375       srel = bfd_get_linker_section (dynobj, ".rela.bss");
3376       BFD_ASSERT (srel != NULL);
3377       srel->size += sizeof (Elf64_External_Rela);
3378       h->needs_copy = 1;
3379     }
3380 
3381   return _bfd_elf_adjust_dynamic_copy (h, s);
3382 }
3383 
3384 /* This function is called via sh_elf_link_hash_traverse if we are
3385    creating a shared object with -Bsymbolic.  It discards the space
3386    allocated to copy PC relative relocs against symbols which are
3387    defined in regular objects.  We allocated space for them in the
3388    check_relocs routine, but we won't fill them in in the
3389    relocate_section routine.  */
3390 
3391 static bfd_boolean
sh64_elf64_discard_copies(struct elf_sh64_link_hash_entry * h,void * ignore ATTRIBUTE_UNUSED)3392 sh64_elf64_discard_copies (struct elf_sh64_link_hash_entry *h,
3393 			   void *ignore ATTRIBUTE_UNUSED)
3394 {
3395   struct elf_sh64_pcrel_relocs_copied *s;
3396 
3397   /* We only discard relocs for symbols defined in a regular object.  */
3398   if (!h->root.def_regular)
3399     return TRUE;
3400 
3401   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3402     s->section->size -= s->count * sizeof (Elf64_External_Rela);
3403 
3404   return TRUE;
3405 }
3406 
3407 /* Set the sizes of the dynamic sections.  */
3408 
3409 static bfd_boolean
sh64_elf64_size_dynamic_sections(bfd * output_bfd,struct bfd_link_info * info)3410 sh64_elf64_size_dynamic_sections (bfd *output_bfd,
3411 				  struct bfd_link_info *info)
3412 {
3413   bfd *dynobj;
3414   asection *s;
3415   bfd_boolean plt;
3416   bfd_boolean relocs;
3417   bfd_boolean reltext;
3418 
3419   dynobj = elf_hash_table (info)->dynobj;
3420   BFD_ASSERT (dynobj != NULL);
3421 
3422   if (elf_hash_table (info)->dynamic_sections_created)
3423     {
3424       /* Set the contents of the .interp section to the interpreter.  */
3425       if (info->executable)
3426 	{
3427 	  s = bfd_get_linker_section (dynobj, ".interp");
3428 	  BFD_ASSERT (s != NULL);
3429 	  s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3430 	  s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3431 	}
3432     }
3433   else
3434     {
3435       /* We may have created entries in the .rela.got section.
3436 	 However, if we are not creating the dynamic sections, we will
3437 	 not actually use these entries.  Reset the size of .rela.got,
3438 	 which will cause it to get stripped from the output file
3439 	 below.  */
3440       s = bfd_get_linker_section (dynobj, ".rela.got");
3441       if (s != NULL)
3442 	s->size = 0;
3443     }
3444 
3445   /* If this is a -Bsymbolic shared link, then we need to discard all
3446      PC relative relocs against symbols defined in a regular object.
3447      We allocated space for them in the check_relocs routine, but we
3448      will not fill them in in the relocate_section routine.  */
3449   if (info->shared && info->symbolic)
3450     sh64_elf64_link_hash_traverse (elf_hash_table (info),
3451 				   sh64_elf64_discard_copies, NULL);
3452 
3453   /* The check_relocs and adjust_dynamic_symbol entry points have
3454      determined the sizes of the various dynamic sections.  Allocate
3455      memory for them.  */
3456   plt = FALSE;
3457   relocs = FALSE;
3458   reltext = FALSE;
3459   for (s = dynobj->sections; s != NULL; s = s->next)
3460     {
3461       const char *name;
3462 
3463       if ((s->flags & SEC_LINKER_CREATED) == 0)
3464 	continue;
3465 
3466       /* It's OK to base decisions on the section name, because none
3467 	 of the dynobj section names depend upon the input files.  */
3468       name = bfd_get_section_name (dynobj, s);
3469 
3470       if (strcmp (name, ".plt") == 0)
3471 	{
3472 	  /* Remember whether there is a PLT.  */
3473 	  plt = s->size != 0;
3474 	}
3475       else if (CONST_STRNEQ (name, ".rela"))
3476 	{
3477 	  if (s->size != 0)
3478 	    {
3479 	      asection *target;
3480 
3481 	      /* Remember whether there are any reloc sections other
3482 		 than .rela.plt.  */
3483 	      if (strcmp (name, ".rela.plt") != 0)
3484 		{
3485 		  const char *outname;
3486 
3487 		  relocs = TRUE;
3488 
3489 		  /* If this relocation section applies to a read only
3490 		     section, then we probably need a DT_TEXTREL
3491 		     entry.  The entries in the .rela.plt section
3492 		     really apply to the .got section, which we
3493 		     created ourselves and so know is not readonly.  */
3494 		  outname = bfd_get_section_name (output_bfd,
3495 						  s->output_section);
3496 		  target = bfd_get_section_by_name (output_bfd, outname + 5);
3497 		  if (target != NULL
3498 		      && (target->flags & SEC_READONLY) != 0
3499 		      && (target->flags & SEC_ALLOC) != 0)
3500 		    reltext = TRUE;
3501 		}
3502 
3503 	      /* We use the reloc_count field as a counter if we need
3504 		 to copy relocs into the output file.  */
3505 	      s->reloc_count = 0;
3506 	    }
3507 	}
3508       else if (! CONST_STRNEQ (name, ".got")
3509 	       && strcmp (name, ".dynbss") != 0)
3510 	{
3511 	  /* It's not one of our sections, so don't allocate space.  */
3512 	  continue;
3513 	}
3514 
3515       if (s->size == 0)
3516 	{
3517 	  /* If we don't need this section, strip it from the
3518 	     output file.  This is mostly to handle .rela.bss and
3519 	     .rela.plt.  We must create both sections in
3520 	     create_dynamic_sections, because they must be created
3521 	     before the linker maps input sections to output
3522 	     sections.  The linker does that before
3523 	     adjust_dynamic_symbol is called, and it is that
3524 	     function which decides whether anything needs to go
3525 	     into these sections.  */
3526 	  s->flags |= SEC_EXCLUDE;
3527 	  continue;
3528 	}
3529 
3530       if ((s->flags & SEC_HAS_CONTENTS) == 0)
3531 	continue;
3532 
3533       /* Allocate memory for the section contents.  */
3534       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3535       if (s->contents == NULL)
3536 	return FALSE;
3537     }
3538 
3539   if (elf_hash_table (info)->dynamic_sections_created)
3540     {
3541       /* Add some entries to the .dynamic section.  We fill in the
3542 	 values later, in sh64_elf64_finish_dynamic_sections, but we
3543 	 must add the entries now so that we get the correct size for
3544 	 the .dynamic section.  The DT_DEBUG entry is filled in by the
3545 	 dynamic linker and used by the debugger.  */
3546       if (info->executable)
3547 	{
3548 	  if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
3549 	    return FALSE;
3550 	}
3551 
3552       if (plt)
3553 	{
3554 	  if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
3555 	      || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3556 	      || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3557 	      || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
3558 	    return FALSE;
3559 	}
3560 
3561       if (relocs)
3562 	{
3563 	  if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
3564 	      || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
3565 	      || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
3566 					      sizeof (Elf64_External_Rela)))
3567 	    return FALSE;
3568 	}
3569 
3570       if (reltext)
3571 	{
3572 	  if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
3573 	    return FALSE;
3574 	}
3575     }
3576 
3577   return TRUE;
3578 }
3579 
3580 /* Finish up dynamic symbol handling.  We set the contents of various
3581    dynamic sections here.  */
3582 
3583 static bfd_boolean
sh64_elf64_finish_dynamic_symbol(bfd * output_bfd,struct bfd_link_info * info,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym)3584 sh64_elf64_finish_dynamic_symbol (bfd *output_bfd,
3585 				  struct bfd_link_info *info,
3586 				  struct elf_link_hash_entry *h,
3587 				  Elf_Internal_Sym *sym)
3588 {
3589   bfd *dynobj;
3590 
3591   dynobj = elf_hash_table (info)->dynobj;
3592 
3593   if (h->plt.offset != (bfd_vma) -1)
3594     {
3595       asection *splt;
3596       asection *sgot;
3597       asection *srel;
3598 
3599       bfd_vma plt_index;
3600       bfd_vma got_offset;
3601       Elf_Internal_Rela rel;
3602       bfd_byte *loc;
3603 
3604       /* This symbol has an entry in the procedure linkage table.  Set
3605 	 it up.  */
3606 
3607       BFD_ASSERT (h->dynindx != -1);
3608 
3609       splt = bfd_get_linker_section (dynobj, ".plt");
3610       sgot = bfd_get_linker_section (dynobj, ".got.plt");
3611       srel = bfd_get_linker_section (dynobj, ".rela.plt");
3612       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3613 
3614       /* Get the index in the procedure linkage table which
3615 	 corresponds to this symbol.  This is the index of this symbol
3616 	 in all the symbols for which we are making plt entries.  The
3617 	 first entry in the procedure linkage table is reserved.  */
3618       plt_index = h->plt.offset / elf_sh64_sizeof_plt (info) - 1;
3619 
3620       /* Get the offset into the .got table of the entry that
3621 	 corresponds to this function.  Each .got entry is 8 bytes.
3622 	 The first three are reserved.  */
3623       got_offset = (plt_index + 3) * 8;
3624 
3625       if (info->shared)
3626 	got_offset -= GOT_BIAS;
3627 
3628       /* Fill in the entry in the procedure linkage table.  */
3629       if (! info->shared)
3630 	{
3631 	  if (elf_sh64_plt_entry == NULL)
3632 	    {
3633 	      elf_sh64_plt_entry = (bfd_big_endian (output_bfd) ?
3634 				  elf_sh64_plt_entry_be : elf_sh64_plt_entry_le);
3635 	    }
3636 	  memcpy (splt->contents + h->plt.offset, elf_sh64_plt_entry,
3637 		  elf_sh64_sizeof_plt (info));
3638 	  movi_3shori_putval (output_bfd,
3639 			      (sgot->output_section->vma
3640 			       + sgot->output_offset
3641 			       + got_offset),
3642 			      (splt->contents + h->plt.offset
3643 			       + elf_sh64_plt_symbol_offset (info)));
3644 
3645 	  /* Set bottom bit because its for a branch to SHmedia */
3646 	  movi_shori_putval (output_bfd,
3647 			     -(h->plt.offset
3648 			      + elf_sh64_plt_plt0_offset (info) + 8)
3649 			     | 1,
3650 			     (splt->contents + h->plt.offset
3651 			      + elf_sh64_plt_plt0_offset (info)));
3652 	}
3653       else
3654 	{
3655 	  if (elf_sh64_pic_plt_entry == NULL)
3656 	    {
3657 	      elf_sh64_pic_plt_entry = (bfd_big_endian (output_bfd) ?
3658 				      elf_sh64_pic_plt_entry_be :
3659 				      elf_sh64_pic_plt_entry_le);
3660 	    }
3661 	  memcpy (splt->contents + h->plt.offset, elf_sh64_pic_plt_entry,
3662 		  elf_sh64_sizeof_plt (info));
3663 	  movi_shori_putval (output_bfd, got_offset,
3664 			     (splt->contents + h->plt.offset
3665 			      + elf_sh64_plt_symbol_offset (info)));
3666 	}
3667 
3668       if (info->shared)
3669 	got_offset += GOT_BIAS;
3670 
3671       movi_shori_putval (output_bfd,
3672 			 plt_index * sizeof (Elf64_External_Rela),
3673 			 (splt->contents + h->plt.offset
3674 			  + elf_sh64_plt_reloc_offset (info)));
3675 
3676       /* Fill in the entry in the global offset table.  */
3677       bfd_put_64 (output_bfd,
3678 		  (splt->output_section->vma
3679 		   + splt->output_offset
3680 		   + h->plt.offset
3681 		   + elf_sh64_plt_temp_offset (info)),
3682 		  sgot->contents + got_offset);
3683 
3684       /* Fill in the entry in the .rela.plt section.  */
3685       rel.r_offset = (sgot->output_section->vma
3686 		      + sgot->output_offset
3687 		      + got_offset);
3688       rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_JMP_SLOT64);
3689       rel.r_addend = 0;
3690       rel.r_addend = GOT_BIAS;
3691       loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
3692       bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3693 
3694       if (!h->def_regular)
3695 	{
3696 	  /* Mark the symbol as undefined, rather than as defined in
3697 	     the .plt section.  Leave the value alone.  */
3698 	  sym->st_shndx = SHN_UNDEF;
3699 	}
3700     }
3701 
3702   if (h->got.offset != (bfd_vma) -1)
3703     {
3704       asection *sgot;
3705       asection *srel;
3706       Elf_Internal_Rela rel;
3707       bfd_byte *loc;
3708 
3709       /* This symbol has an entry in the global offset table.  Set it
3710 	 up.  */
3711 
3712       sgot = bfd_get_linker_section (dynobj, ".got");
3713       srel = bfd_get_linker_section (dynobj, ".rela.got");
3714       BFD_ASSERT (sgot != NULL && srel != NULL);
3715 
3716       rel.r_offset = (sgot->output_section->vma
3717 		      + sgot->output_offset
3718 		      + (h->got.offset &~ 1));
3719 
3720       /* If this is a -Bsymbolic link, and the symbol is defined
3721 	 locally, we just want to emit a RELATIVE reloc.  Likewise if
3722 	 the symbol was forced to be local because of a version file.
3723 	 The entry in the global offset table will already have been
3724 	 initialized in the relocate_section function.  */
3725       if (info->shared
3726 	  && (info->symbolic || h->dynindx == -1)
3727 	  && h->def_regular)
3728 	{
3729 	  rel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
3730 	  rel.r_addend = (h->root.u.def.value
3731 			  + h->root.u.def.section->output_section->vma
3732 			  + h->root.u.def.section->output_offset);
3733 	}
3734       else
3735 	{
3736 	  bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3737 	  rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_GLOB_DAT64);
3738 	  rel.r_addend = 0;
3739 	}
3740 
3741       loc = srel->contents;
3742       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
3743       bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3744     }
3745 
3746   if (h->needs_copy)
3747     {
3748       asection *s;
3749       Elf_Internal_Rela rel;
3750       bfd_byte *loc;
3751 
3752       /* This symbol needs a copy reloc.  Set it up.  */
3753 
3754       BFD_ASSERT (h->dynindx != -1
3755 		  && (h->root.type == bfd_link_hash_defined
3756 		      || h->root.type == bfd_link_hash_defweak));
3757 
3758       s = bfd_get_linker_section (dynobj, ".rela.bss");
3759       BFD_ASSERT (s != NULL);
3760 
3761       rel.r_offset = (h->root.u.def.value
3762 		      + h->root.u.def.section->output_section->vma
3763 		      + h->root.u.def.section->output_offset);
3764       rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_COPY64);
3765       rel.r_addend = 0;
3766       loc = s->contents;
3767       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
3768       bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3769     }
3770 
3771   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3772   if (h == elf_hash_table (info)->hdynamic
3773       || h == elf_hash_table (info)->hgot)
3774     sym->st_shndx = SHN_ABS;
3775 
3776   return TRUE;
3777 }
3778 
3779 /* Finish up the dynamic sections.  */
3780 
3781 static bfd_boolean
sh64_elf64_finish_dynamic_sections(bfd * output_bfd,struct bfd_link_info * info)3782 sh64_elf64_finish_dynamic_sections (bfd *output_bfd,
3783 				    struct bfd_link_info *info)
3784 {
3785   bfd *dynobj;
3786   asection *sgot;
3787   asection *sdyn;
3788 
3789   dynobj = elf_hash_table (info)->dynobj;
3790 
3791   sgot = bfd_get_linker_section (dynobj, ".got.plt");
3792   BFD_ASSERT (sgot != NULL);
3793   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3794 
3795   if (elf_hash_table (info)->dynamic_sections_created)
3796     {
3797       asection *splt;
3798       Elf64_External_Dyn *dyncon, *dynconend;
3799 
3800       BFD_ASSERT (sdyn != NULL);
3801 
3802       dyncon = (Elf64_External_Dyn *) sdyn->contents;
3803       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3804       for (; dyncon < dynconend; dyncon++)
3805 	{
3806 	  Elf_Internal_Dyn dyn;
3807 	  const char *name;
3808 	  asection *s;
3809 	  struct elf_link_hash_entry *h;
3810 
3811 	  bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3812 
3813 	  switch (dyn.d_tag)
3814 	    {
3815 	    default:
3816 	      break;
3817 
3818 	    case DT_INIT:
3819 	      name = info->init_function;
3820 	      goto get_sym;
3821 
3822 	    case DT_FINI:
3823 	      name = info->fini_function;
3824 	    get_sym:
3825 	      if (dyn.d_un.d_val != 0)
3826 		{
3827 		  h = elf_link_hash_lookup (elf_hash_table (info), name,
3828 					    FALSE, FALSE, TRUE);
3829 		  if (h != NULL && (h->other & STO_SH5_ISA32))
3830 		    {
3831 		      dyn.d_un.d_val |= 1;
3832 		      bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3833 		    }
3834 		}
3835 	      break;
3836 
3837 	    case DT_PLTGOT:
3838 	      name = ".got";
3839 	      goto get_vma;
3840 
3841 	    case DT_JMPREL:
3842 	      name = ".rela.plt";
3843 	    get_vma:
3844 	      s = bfd_get_section_by_name (output_bfd, name);
3845 	      BFD_ASSERT (s != NULL);
3846 	      dyn.d_un.d_ptr = s->vma;
3847 	      bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3848 	      break;
3849 
3850 	    case DT_PLTRELSZ:
3851 	      s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3852 	      BFD_ASSERT (s != NULL);
3853 	      dyn.d_un.d_val = s->size;
3854 	      bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3855 	      break;
3856 
3857 	    case DT_RELASZ:
3858 	      /* My reading of the SVR4 ABI indicates that the
3859 		 procedure linkage table relocs (DT_JMPREL) should be
3860 		 included in the overall relocs (DT_RELA).  This is
3861 		 what Solaris does.  However, UnixWare can not handle
3862 		 that case.  Therefore, we override the DT_RELASZ entry
3863 		 here to make it not include the JMPREL relocs.  Since
3864 		 the linker script arranges for .rela.plt to follow all
3865 		 other relocation sections, we don't have to worry
3866 		 about changing the DT_RELA entry.  */
3867 	      s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3868 	      if (s != NULL)
3869 		dyn.d_un.d_val -= s->size;
3870 	      bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3871 	      break;
3872 	    }
3873 	}
3874 
3875       /* Fill in the first entry in the procedure linkage table.  */
3876       splt = bfd_get_linker_section (dynobj, ".plt");
3877       if (splt && splt->size > 0)
3878 	{
3879 	  if (info->shared)
3880 	    {
3881 	      if (elf_sh64_pic_plt_entry == NULL)
3882 		{
3883 		  elf_sh64_pic_plt_entry = (bfd_big_endian (output_bfd) ?
3884 					  elf_sh64_pic_plt_entry_be :
3885 					  elf_sh64_pic_plt_entry_le);
3886 		}
3887 	      memcpy (splt->contents, elf_sh64_pic_plt_entry,
3888 		      elf_sh64_sizeof_plt (info));
3889 	    }
3890 	  else
3891 	    {
3892 	      if (elf_sh64_plt0_entry == NULL)
3893 		{
3894 		  elf_sh64_plt0_entry = (bfd_big_endian (output_bfd) ?
3895 				       elf_sh64_plt0_entry_be :
3896 				       elf_sh64_plt0_entry_le);
3897 		}
3898 	      memcpy (splt->contents, elf_sh64_plt0_entry, PLT_ENTRY_SIZE);
3899 	      movi_3shori_putval (output_bfd,
3900 				  sgot->output_section->vma
3901 				  + sgot->output_offset,
3902 				  splt->contents
3903 				  + elf_sh64_plt0_gotplt_offset (info));
3904 	    }
3905 
3906 	  /* UnixWare sets the entsize of .plt to 8, although that doesn't
3907 	     really seem like the right value.  */
3908 	  elf_section_data (splt->output_section)->this_hdr.sh_entsize = 8;
3909 	}
3910     }
3911 
3912   /* Fill in the first three entries in the global offset table.  */
3913   if (sgot->size > 0)
3914     {
3915       if (sdyn == NULL)
3916 	bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
3917       else
3918 	bfd_put_64 (output_bfd,
3919 		    sdyn->output_section->vma + sdyn->output_offset,
3920 		    sgot->contents);
3921       bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3922       bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + 16);
3923     }
3924 
3925   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
3926 
3927   return TRUE;
3928 }
3929 
3930 /* Merge non visibility st_other attribute when the symbol comes from
3931    a dynamic object.  */
3932 static void
sh64_elf64_merge_symbol_attribute(struct elf_link_hash_entry * h,const Elf_Internal_Sym * isym,bfd_boolean definition,bfd_boolean dynamic ATTRIBUTE_UNUSED)3933 sh64_elf64_merge_symbol_attribute (struct elf_link_hash_entry *h,
3934 				   const Elf_Internal_Sym *isym,
3935 				   bfd_boolean definition,
3936 				   bfd_boolean dynamic ATTRIBUTE_UNUSED)
3937 {
3938   if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
3939     {
3940       unsigned char other;
3941 
3942       /* Take the balance of OTHER from the definition.  */
3943       other = (definition ? isym->st_other : h->other);
3944       other &= ~ ELF_ST_VISIBILITY (-1);
3945       h->other = other | ELF_ST_VISIBILITY (h->other);
3946     }
3947 
3948   return;
3949 }
3950 
3951 static const struct bfd_elf_special_section sh64_elf64_special_sections[]=
3952 {
3953   { STRING_COMMA_LEN (".cranges"), 0, SHT_PROGBITS, 0 },
3954   { NULL,                       0, 0, 0,            0 }
3955 };
3956 
3957 #define TARGET_BIG_SYM		bfd_elf64_sh64_vec
3958 #define TARGET_BIG_NAME		"elf64-sh64"
3959 #define TARGET_LITTLE_SYM	bfd_elf64_sh64l_vec
3960 #define TARGET_LITTLE_NAME	"elf64-sh64l"
3961 #define ELF_ARCH		bfd_arch_sh
3962 #define ELF_MACHINE_CODE	EM_SH
3963 #define ELF_MAXPAGESIZE		128
3964 
3965 #define elf_symbol_leading_char '_'
3966 
3967 #define bfd_elf64_bfd_reloc_type_lookup	sh_elf64_reloc_type_lookup
3968 #define bfd_elf64_bfd_reloc_name_lookup \
3969 					sh_elf64_reloc_name_lookup
3970 #define elf_info_to_howto		sh_elf64_info_to_howto
3971 
3972 /* Note: there's no relaxation at present.  */
3973 
3974 #define elf_backend_relocate_section	sh_elf64_relocate_section
3975 #define bfd_elf64_bfd_get_relocated_section_contents \
3976 					sh_elf64_get_relocated_section_contents
3977 #define elf_backend_object_p		sh_elf64_set_mach_from_flags
3978 #define bfd_elf64_bfd_set_private_flags \
3979 					sh_elf64_set_private_flags
3980 #define bfd_elf64_bfd_copy_private_bfd_data \
3981 					sh_elf64_copy_private_data
3982 #define bfd_elf64_bfd_merge_private_bfd_data \
3983 					sh_elf64_merge_private_data
3984 #define elf_backend_fake_sections	sh64_elf64_fake_sections
3985 
3986 #define elf_backend_gc_mark_hook        sh_elf64_gc_mark_hook
3987 #define elf_backend_check_relocs        sh_elf64_check_relocs
3988 
3989 #define elf_backend_can_gc_sections	1
3990 
3991 #define elf_backend_get_symbol_type	sh64_elf64_get_symbol_type
3992 
3993 #define elf_backend_add_symbol_hook	sh64_elf64_add_symbol_hook
3994 
3995 #define elf_backend_link_output_symbol_hook \
3996 	sh64_elf64_link_output_symbol_hook
3997 
3998 #define	elf_backend_merge_symbol_attribute \
3999 	sh64_elf64_merge_symbol_attribute
4000 
4001 #define elf_backend_final_write_processing \
4002  	sh64_elf64_final_write_processing
4003 
4004 #define elf_backend_create_dynamic_sections \
4005 					sh64_elf64_create_dynamic_sections
4006 #define bfd_elf64_bfd_link_hash_table_create \
4007 					sh64_elf64_link_hash_table_create
4008 #define elf_backend_adjust_dynamic_symbol \
4009 					sh64_elf64_adjust_dynamic_symbol
4010 #define elf_backend_size_dynamic_sections \
4011 					sh64_elf64_size_dynamic_sections
4012 #define elf_backend_omit_section_dynsym \
4013   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4014 #define elf_backend_finish_dynamic_symbol \
4015 					sh64_elf64_finish_dynamic_symbol
4016 #define elf_backend_finish_dynamic_sections \
4017 					sh64_elf64_finish_dynamic_sections
4018 #define elf_backend_special_sections	sh64_elf64_special_sections
4019 
4020 #define elf_backend_want_got_plt	1
4021 #define elf_backend_plt_readonly	1
4022 #define elf_backend_want_plt_sym	0
4023 #define elf_backend_got_header_size	24
4024 
4025 #include "elf64-target.h"
4026 
4027 /* NetBSD support.  */
4028 #undef	TARGET_BIG_SYM
4029 #define	TARGET_BIG_SYM			bfd_elf64_sh64nbsd_vec
4030 #undef	TARGET_BIG_NAME
4031 #define	TARGET_BIG_NAME			"elf64-sh64-nbsd"
4032 #undef	TARGET_LITTLE_SYM
4033 #define	TARGET_LITTLE_SYM		bfd_elf64_sh64lnbsd_vec
4034 #undef	TARGET_LITTLE_NAME
4035 #define	TARGET_LITTLE_NAME		"elf64-sh64l-nbsd"
4036 #undef	ELF_MAXPAGESIZE
4037 #define	ELF_MAXPAGESIZE			0x10000
4038 #undef	elf_symbol_leading_char
4039 #define	elf_symbol_leading_char		0
4040 
4041 #define	elf64_bed			elf64_sh64_nbsd_bed
4042 
4043 #include "elf64-target.h"
4044 
4045 /* Linux support.  */
4046 #undef	TARGET_BIG_SYM
4047 #define	TARGET_BIG_SYM			bfd_elf64_sh64blin_vec
4048 #undef	TARGET_BIG_NAME
4049 #define	TARGET_BIG_NAME			"elf64-sh64big-linux"
4050 #undef	TARGET_LITTLE_SYM
4051 #define	TARGET_LITTLE_SYM		bfd_elf64_sh64lin_vec
4052 #undef	TARGET_LITTLE_NAME
4053 #define	TARGET_LITTLE_NAME		"elf64-sh64-linux"
4054 #undef elf64_bed
4055 #define	elf64_bed			elf64_sh64_linux_bed
4056 
4057 #include "elf64-target.h"
4058