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