]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf64-sh64.c
projects / thirdparty / binutils-gdb.git / blob
? search:


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