?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2011-03-25 Tristan Gingold <gingold@adacore.com>
[binutils.git] / bfd / elf64-sh64.c
blob969230464129c86113b80210140a30d799e90465
1 /* SuperH SH64-specific support for 64-bit ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3 2010 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 && elf_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 {
1635 (*_bfd_error_handler)
1636 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1637 input_bfd,
1638 input_section,
1639 (long) rel->r_offset,
1640 howto->name,
1641 h->root.root.string);
1642 }
1643 }
1644 else if (h->root.type == bfd_link_hash_undefweak)
1645 ;
1646 else if (info->unresolved_syms_in_objects == RM_IGNORE
1647 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1648 ;
1649 else if (!info->relocatable)
1650 {
1651 if (! ((*info->callbacks->undefined_symbol)
1652 (info, h->root.root.string, input_bfd,
1653 input_section, rel->r_offset,
1654 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1655 || ELF_ST_VISIBILITY (h->other)))))
1656 return FALSE;
1657 }
1658 }
1659
1660 if (sec != NULL && elf_discarded_section (sec))
1661 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1662 rel, relend, howto, contents);
1663
1664 if (info->relocatable)
1665 continue;
1666
1667 disp = (relocation
1668 - input_section->output_section->vma
1669 - input_section->output_offset
1670 - rel->r_offset);
1671 dropped = 0;
1672 switch ((int)r_type)
1673 {
1674 case R_SH_PT_16: dropped = disp & 2; break;
1675 case R_SH_DIR10SW: dropped = disp & 1; break;
1676 case R_SH_DIR10SL: dropped = disp & 3; break;
1677 case R_SH_DIR10SQ: dropped = disp & 7; break;
1678 }
1679 if (dropped != 0)
1680 {
1681 (*_bfd_error_handler)
1682 (_("%s: error: unaligned relocation type %d at %08x reloc %08x\n"),
1683 bfd_get_filename (input_bfd), (int)r_type, (unsigned)rel->r_offset, (unsigned)relocation);
1684 bfd_set_error (bfd_error_bad_value);
1685 return FALSE;
1686 }
1687 switch ((int)r_type)
1688 {
1689 case R_SH_64:
1690 case R_SH_64_PCREL:
1691 if (info->shared
1692 && (input_section->flags & SEC_ALLOC) != 0
1693 && (r_type != R_SH_64_PCREL
1694 || (h != NULL
1695 && h->dynindx != -1
1696 && (! info->symbolic
1697 || !h->def_regular))))
1698 {
1699 Elf_Internal_Rela outrel;
1700 bfd_byte *loc;
1701 bfd_boolean skip, relocate;
1702
1703 /* When generating a shared object, these relocations
1704 are copied into the output file to be resolved at run
1705 time. */
1706
1707 if (sreloc == NULL)
1708 {
1709 sreloc = _bfd_elf_get_dynamic_reloc_section
1710 (input_bfd, input_section, /*rela?*/ TRUE);
1711 if (sreloc == NULL)
1712 return FALSE;
1713 }
1714
1715 skip = FALSE;
1716 relocate = FALSE;
1717
1718 outrel.r_offset
1719 = _bfd_elf_section_offset (output_bfd, info,
1720 input_section, rel->r_offset);
1721
1722 if (outrel.r_offset == (bfd_vma) -1)
1723 skip = TRUE;
1724 else if (outrel.r_offset == (bfd_vma) -2)
1725 skip = TRUE, relocate = TRUE;
1726
1727 outrel.r_offset += (input_section->output_section->vma
1728 + input_section->output_offset);
1729
1730 if (skip)
1731 memset (&outrel, 0, sizeof outrel);
1732 else if (r_type == R_SH_64_PCREL)
1733 {
1734 BFD_ASSERT (h != NULL && h->dynindx != -1);
1735 outrel.r_info = ELF64_R_INFO (h->dynindx, R_SH_64_PCREL);
1736 outrel.r_addend = rel->r_addend;
1737 }
1738 else
1739 {
1740 /* h->dynindx may be -1 if this symbol was marked to
1741 become local. */
1742 if (h == NULL
1743 || ((info->symbolic || h->dynindx == -1)
1744 && h->def_regular))
1745 {
1746 relocate = TRUE;
1747 outrel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
1748 outrel.r_addend = relocation + rel->r_addend;
1749 }
1750 else
1751 {
1752 BFD_ASSERT (h->dynindx != -1);
1753 outrel.r_info = ELF64_R_INFO (h->dynindx, R_SH_64);
1754 outrel.r_addend = relocation + rel->r_addend;
1755 }
1756 }
1757
1758 loc = sreloc->contents;
1759 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
1760 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1761
1762 /* If this reloc is against an external symbol, we do
1763 not want to fiddle with the addend. Otherwise, we
1764 need to include the symbol value so that it becomes
1765 an addend for the dynamic reloc. */
1766 if (! relocate)
1767 continue;
1768 }
1769 else if (r_type == R_SH_64)
1770 addend = rel->r_addend;
1771 goto final_link_relocate;
1772
1773 case R_SH_GOTPLT_LOW16:
1774 case R_SH_GOTPLT_MEDLOW16:
1775 case R_SH_GOTPLT_MEDHI16:
1776 case R_SH_GOTPLT_HI16:
1777 case R_SH_GOTPLT10BY4:
1778 case R_SH_GOTPLT10BY8:
1779 /* Relocation is to the entry for this symbol in the
1780 procedure linkage table. */
1781
1782 if (h == NULL
1783 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1784 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
1785 || ! info->shared
1786 || info->symbolic
1787 || h->dynindx == -1
1788 || h->plt.offset == (bfd_vma) -1
1789 || h->got.offset != (bfd_vma) -1)
1790 goto force_got;
1791
1792 /* Relocation is to the entry for this symbol in the global
1793 offset table extension for the procedure linkage table. */
1794 if (sgotplt == NULL)
1795 {
1796 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1797 BFD_ASSERT (sgotplt != NULL);
1798 }
1799
1800 relocation = (sgotplt->output_offset
1801 + ((h->plt.offset / elf_sh64_sizeof_plt (info)
1802 - 1 + 3) * 8));
1803
1804 relocation -= GOT_BIAS;
1805
1806 goto final_link_relocate;
1807
1808 force_got:
1809 case R_SH_GOT_LOW16:
1810 case R_SH_GOT_MEDLOW16:
1811 case R_SH_GOT_MEDHI16:
1812 case R_SH_GOT_HI16:
1813 case R_SH_GOT10BY4:
1814 case R_SH_GOT10BY8:
1815 /* Relocation is to the entry for this symbol in the global
1816 offset table. */
1817 if (sgot == NULL)
1818 {
1819 sgot = bfd_get_section_by_name (dynobj, ".got");
1820 BFD_ASSERT (sgot != NULL);
1821 }
1822
1823 if (h != NULL)
1824 {
1825 bfd_vma off;
1826
1827 off = h->got.offset;
1828 if (seen_stt_datalabel)
1829 {
1830 struct elf_sh64_link_hash_entry *hsh;
1831
1832 hsh = (struct elf_sh64_link_hash_entry *)h;
1833 off = hsh->datalabel_got_offset;
1834 }
1835 BFD_ASSERT (off != (bfd_vma) -1);
1836
1837 if (! elf_hash_table (info)->dynamic_sections_created
1838 || (info->shared
1839 && (info->symbolic || h->dynindx == -1
1840 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1841 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
1842 && h->def_regular))
1843 {
1844 /* This is actually a static link, or it is a
1845 -Bsymbolic link and the symbol is defined
1846 locally, or the symbol was forced to be local
1847 because of a version file. We must initialize
1848 this entry in the global offset table. Since the
1849 offset must always be a multiple of 4, we use the
1850 least significant bit to record whether we have
1851 initialized it already.
1852
1853 When doing a dynamic link, we create a .rela.got
1854 relocation entry to initialize the value. This
1855 is done in the finish_dynamic_symbol routine. */
1856 if ((off & 1) != 0)
1857 off &= ~1;
1858 else
1859 {
1860 bfd_put_64 (output_bfd, relocation,
1861 sgot->contents + off);
1862 if (seen_stt_datalabel)
1863 {
1864 struct elf_sh64_link_hash_entry *hsh;
1865
1866 hsh = (struct elf_sh64_link_hash_entry *)h;
1867 hsh->datalabel_got_offset |= 1;
1868 }
1869 else
1870 h->got.offset |= 1;
1871 }
1872 }
1873
1874 relocation = sgot->output_offset + off;
1875 }
1876 else
1877 {
1878 bfd_vma off;
1879
1880 if (rel->r_addend)
1881 {
1882 BFD_ASSERT (local_got_offsets != NULL
1883 && (local_got_offsets[symtab_hdr->sh_info
1884 + r_symndx]
1885 != (bfd_vma) -1));
1886
1887 off = local_got_offsets[symtab_hdr->sh_info
1888 + r_symndx];
1889 }
1890 else
1891 {
1892 BFD_ASSERT (local_got_offsets != NULL
1893 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1894
1895 off = local_got_offsets[r_symndx];
1896 }
1897
1898 /* The offset must always be a multiple of 8. We use
1899 the least significant bit to record whether we have
1900 already generated the necessary reloc. */
1901 if ((off & 1) != 0)
1902 off &= ~1;
1903 else
1904 {
1905 bfd_put_64 (output_bfd, relocation, sgot->contents + off);
1906
1907 if (info->shared)
1908 {
1909 asection *s;
1910 Elf_Internal_Rela outrel;
1911 bfd_byte *loc;
1912
1913 s = bfd_get_section_by_name (dynobj, ".rela.got");
1914 BFD_ASSERT (s != NULL);
1915
1916 outrel.r_offset = (sgot->output_section->vma
1917 + sgot->output_offset
1918 + off);
1919 outrel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
1920 outrel.r_addend = relocation;
1921 loc = s->contents;
1922 loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
1923 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1924 }
1925
1926 if (rel->r_addend)
1927 local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
1928 else
1929 local_got_offsets[r_symndx] |= 1;
1930 }
1931
1932 relocation = sgot->output_offset + off;
1933 }
1934
1935 relocation -= GOT_BIAS;
1936
1937 goto final_link_relocate;
1938
1939 case R_SH_GOTOFF_LOW16:
1940 case R_SH_GOTOFF_MEDLOW16:
1941 case R_SH_GOTOFF_MEDHI16:
1942 case R_SH_GOTOFF_HI16:
1943 /* Relocation is relative to the start of the global offset
1944 table. */
1945
1946 if (sgot == NULL)
1947 {
1948 sgot = bfd_get_section_by_name (dynobj, ".got");
1949 BFD_ASSERT (sgot != NULL);
1950 }
1951
1952 /* Note that sgot->output_offset is not involved in this
1953 calculation. We always want the start of .got. If we
1954 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1955 permitted by the ABI, we might have to change this
1956 calculation. */
1957 relocation -= sgot->output_section->vma;
1958
1959 relocation -= GOT_BIAS;
1960
1961 addend = rel->r_addend;
1962
1963 goto final_link_relocate;
1964
1965 case R_SH_GOTPC_LOW16:
1966 case R_SH_GOTPC_MEDLOW16:
1967 case R_SH_GOTPC_MEDHI16:
1968 case R_SH_GOTPC_HI16:
1969 /* Use global offset table as symbol value. */
1970
1971 if (sgot == NULL)
1972 {
1973 sgot = bfd_get_section_by_name (dynobj, ".got");
1974 BFD_ASSERT (sgot != NULL);
1975 }
1976
1977 relocation = sgot->output_section->vma;
1978
1979 relocation += GOT_BIAS;
1980
1981 addend = rel->r_addend;
1982
1983 goto final_link_relocate;
1984
1985 case R_SH_PLT_LOW16:
1986 case R_SH_PLT_MEDLOW16:
1987 case R_SH_PLT_MEDHI16:
1988 case R_SH_PLT_HI16:
1989 /* Relocation is to the entry for this symbol in the
1990 procedure linkage table. */
1991
1992 /* Resolve a PLT reloc against a local symbol directly,
1993 without using the procedure linkage table. */
1994 if (h == NULL)
1995 goto final_link_relocate;
1996
1997 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1998 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
1999 goto final_link_relocate;
2000
2001 if (h->plt.offset == (bfd_vma) -1)
2002 {
2003 /* We didn't make a PLT entry for this symbol. This
2004 happens when statically linking PIC code, or when
2005 using -Bsymbolic. */
2006 goto final_link_relocate;
2007 }
2008
2009 if (splt == NULL)
2010 {
2011 splt = bfd_get_section_by_name (dynobj, ".plt");
2012 BFD_ASSERT (splt != NULL);
2013 }
2014
2015 relocation = (splt->output_section->vma
2016 + splt->output_offset
2017 + h->plt.offset);
2018 relocation++;
2019
2020 addend = rel->r_addend;
2021
2022 goto final_link_relocate;
2023
2024 case R_SH_DIR32:
2025 case R_SH_SHMEDIA_CODE:
2026 case R_SH_PT_16:
2027 case R_SH_DIR5U:
2028 case R_SH_DIR6S:
2029 case R_SH_DIR6U:
2030 case R_SH_DIR10S:
2031 case R_SH_DIR10SW:
2032 case R_SH_DIR10SL:
2033 case R_SH_DIR10SQ:
2034 case R_SH_IMMS16:
2035 case R_SH_IMMU16:
2036 case R_SH_IMM_LOW16:
2037 case R_SH_IMM_LOW16_PCREL:
2038 case R_SH_IMM_MEDLOW16:
2039 case R_SH_IMM_MEDLOW16_PCREL:
2040 case R_SH_IMM_MEDHI16:
2041 case R_SH_IMM_MEDHI16_PCREL:
2042 case R_SH_IMM_HI16:
2043 case R_SH_IMM_HI16_PCREL:
2044 addend = rel->r_addend;
2045 /* Fall through. */
2046 case R_SH_REL32:
2047 final_link_relocate:
2048 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2049 contents, rel->r_offset,
2050 relocation, addend);
2051 break;
2052
2053 default:
2054 bfd_set_error (bfd_error_bad_value);
2055 return FALSE;
2056
2057 }
2058
2059 if (r != bfd_reloc_ok)
2060 {
2061 switch (r)
2062 {
2063 default:
2064 case bfd_reloc_outofrange:
2065 abort ();
2066 case bfd_reloc_overflow:
2067 {
2068 const char *name;
2069
2070 if (h != NULL)
2071 name = NULL;
2072 else
2073 {
2074 name = (bfd_elf_string_from_elf_section
2075 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2076 if (name == NULL)
2077 return FALSE;
2078 if (*name == '\0')
2079 name = bfd_section_name (input_bfd, sec);
2080 }
2081 if (! ((*info->callbacks->reloc_overflow)
2082 (info, (h ? &h->root : NULL), name, howto->name,
2083 (bfd_vma) 0, input_bfd, input_section,
2084 rel->r_offset)))
2085 return FALSE;
2086 }
2087 break;
2088 }
2089 }
2090 }
2091
2092 return TRUE;
2093 }
2094
2095 /* This is a version of bfd_generic_get_relocated_section_contents
2096 that uses sh_elf64_relocate_section.
2097
2098 See sh_elf_relocate_section in elf32-sh.c for the original. */
2099
2100 static bfd_byte *
2101 sh_elf64_get_relocated_section_contents (bfd *output_bfd,
2102 struct bfd_link_info *link_info,
2103 struct bfd_link_order *link_order,
2104 bfd_byte *data,
2105 bfd_boolean relocatable,
2106 asymbol **symbols)
2107 {
2108 Elf_Internal_Shdr *symtab_hdr;
2109 asection *input_section = link_order->u.indirect.section;
2110 bfd *input_bfd = input_section->owner;
2111 asection **sections = NULL;
2112 Elf_Internal_Rela *internal_relocs = NULL;
2113 Elf_Internal_Sym *isymbuf = NULL;
2114
2115 /* We only need to handle the case of relaxing, or of having a
2116 particular set of section contents, specially. */
2117 if (relocatable
2118 || elf_section_data (input_section)->this_hdr.contents == NULL)
2119 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2120 link_order, data,
2121 relocatable,
2122 symbols);
2123
2124 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2125
2126 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2127 input_section->size);
2128
2129 if ((input_section->flags & SEC_RELOC) != 0
2130 && input_section->reloc_count > 0)
2131 {
2132 Elf_Internal_Sym *isymp;
2133 Elf_Internal_Sym *isymend;
2134 asection **secpp;
2135
2136 /* Read this BFD's local symbols. */
2137 if (symtab_hdr->sh_info != 0)
2138 {
2139 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2140 if (isymbuf == NULL)
2141 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2142 symtab_hdr->sh_info, 0,
2143 NULL, NULL, NULL);
2144 if (isymbuf == NULL)
2145 goto error_return;
2146 }
2147
2148 internal_relocs = (_bfd_elf_link_read_relocs
2149 (input_bfd, input_section, NULL,
2150 (Elf_Internal_Rela *) NULL, FALSE));
2151 if (internal_relocs == NULL)
2152 goto error_return;
2153
2154 sections = (asection **) bfd_malloc (symtab_hdr->sh_info
2155 * sizeof (asection *));
2156 if (sections == NULL && symtab_hdr->sh_info > 0)
2157 goto error_return;
2158
2159 secpp = sections;
2160 isymend = isymbuf + symtab_hdr->sh_info;
2161 for (isymp = isymbuf; isymp < isymend; ++isymp, ++secpp)
2162 {
2163 asection *isec;
2164
2165 if (isymp->st_shndx == SHN_UNDEF)
2166 isec = bfd_und_section_ptr;
2167 else if (isymp->st_shndx == SHN_ABS)
2168 isec = bfd_abs_section_ptr;
2169 else if (isymp->st_shndx == SHN_COMMON)
2170 isec = bfd_com_section_ptr;
2171 else
2172 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
2173
2174 *secpp = isec;
2175 }
2176
2177 if (! sh_elf64_relocate_section (output_bfd, link_info, input_bfd,
2178 input_section, data, internal_relocs,
2179 isymbuf, sections))
2180 goto error_return;
2181
2182 if (sections != NULL)
2183 free (sections);
2184 if (internal_relocs != elf_section_data (input_section)->relocs)
2185 free (internal_relocs);
2186 if (isymbuf != NULL
2187 && (unsigned char *) isymbuf != symtab_hdr->contents)
2188 free (isymbuf);
2189 }
2190
2191 return data;
2192
2193 error_return:
2194 if (sections != NULL)
2195 free (sections);
2196 if (internal_relocs != NULL
2197 && internal_relocs != elf_section_data (input_section)->relocs)
2198 free (internal_relocs);
2199 if (isymbuf != NULL
2200 && (unsigned char *) isymbuf != symtab_hdr->contents)
2201 free (isymbuf);
2202 return NULL;
2203 }
2204
2205 /* Set the SHF_SH5_ISA32 flag for ISA SHmedia code sections. */
2206
2207 static bfd_boolean
2208 sh64_elf64_fake_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2209 Elf_Internal_Shdr *elf_section_hdr,
2210 asection *asect)
2211 {
2212 /* Code sections can only contain SH64 code, so mark them as such. */
2213 if (bfd_get_section_flags (output_bfd, asect) & SEC_CODE)
2214 elf_section_hdr->sh_flags |= SHF_SH5_ISA32;
2215
2216 return TRUE;
2217 }
2218
2219 static bfd_boolean
2220 sh_elf64_set_mach_from_flags (bfd *abfd)
2221 {
2222 flagword flags = elf_elfheader (abfd)->e_flags;
2223
2224 switch (flags & EF_SH_MACH_MASK)
2225 {
2226 case EF_SH5:
2227 /* Just one, but keep the switch construct to make additions easy. */
2228 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh5);
2229 break;
2230
2231 default:
2232 bfd_set_error (bfd_error_wrong_format);
2233 return FALSE;
2234 }
2235 return TRUE;
2236 }
2237
2238 /* Function to keep SH64 specific file flags.
2239
2240 See sh64_elf_set_private_flags in elf32-sh64.c for the original. */
2241
2242 static bfd_boolean
2243 sh_elf64_set_private_flags (bfd *abfd, flagword flags)
2244 {
2245 BFD_ASSERT (! elf_flags_init (abfd)
2246 || elf_elfheader (abfd)->e_flags == flags);
2247
2248 elf_elfheader (abfd)->e_flags = flags;
2249 elf_flags_init (abfd) = TRUE;
2250 return sh_elf64_set_mach_from_flags (abfd);
2251 }
2252
2253 /* Copy the SHF_SH5_ISA32 attribute that we keep on all sections with
2254 code, to keep attributes the same as for SHmedia in 32-bit ELF. */
2255
2256 static bfd_boolean
2257 sh_elf64_copy_private_data_internal (bfd *ibfd, bfd *obfd)
2258 {
2259 Elf_Internal_Shdr **o_shdrp;
2260 asection *isec;
2261 asection *osec;
2262
2263 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2264 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2265 return TRUE;
2266
2267 o_shdrp = elf_elfsections (obfd);
2268 for (osec = obfd->sections; osec; osec = osec->next)
2269 {
2270 int oIndex = ((struct bfd_elf_section_data *) elf_section_data (osec))->this_idx;
2271 for (isec = ibfd->sections; isec; isec = isec->next)
2272 {
2273 if (strcmp (osec->name, isec->name) == 0)
2274 {
2275 /* Note that we're not disallowing mixing data and code. */
2276 if ((elf_section_data (isec)->this_hdr.sh_flags
2277 & SHF_SH5_ISA32) != 0)
2278 o_shdrp[oIndex]->sh_flags |= SHF_SH5_ISA32;
2279 break;
2280 }
2281 }
2282 }
2283
2284 /* Copy object attributes. */
2285 _bfd_elf_copy_obj_attributes (ibfd, obfd);
2286
2287 return sh_elf64_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
2288 }
2289
2290 static bfd_boolean
2291 sh_elf64_copy_private_data (bfd *ibfd, bfd *obfd)
2292 {
2293 return sh_elf64_copy_private_data_internal (ibfd, obfd);
2294 }
2295
2296 static bfd_boolean
2297 sh_elf64_merge_private_data (bfd *ibfd, bfd *obfd)
2298 {
2299 flagword old_flags, new_flags;
2300
2301 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
2302 return FALSE;
2303
2304 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2305 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2306 return TRUE;
2307
2308 if (bfd_get_arch_size (ibfd) != bfd_get_arch_size (obfd))
2309 {
2310 const char *msg;
2311
2312 if (bfd_get_arch_size (ibfd) == 32
2313 && bfd_get_arch_size (obfd) == 64)
2314 msg = _("%s: compiled as 32-bit object and %s is 64-bit");
2315 else if (bfd_get_arch_size (ibfd) == 64
2316 && bfd_get_arch_size (obfd) == 32)
2317 msg = _("%s: compiled as 64-bit object and %s is 32-bit");
2318 else
2319 msg = _("%s: object size does not match that of target %s");
2320
2321 (*_bfd_error_handler) (msg, bfd_get_filename (ibfd),
2322 bfd_get_filename (obfd));
2323 bfd_set_error (bfd_error_wrong_format);
2324 return FALSE;
2325 }
2326
2327 old_flags = elf_elfheader (obfd)->e_flags;
2328 new_flags = elf_elfheader (ibfd)->e_flags;
2329 if (! elf_flags_init (obfd))
2330 {
2331 /* This happens when ld starts out with a 'blank' output file. */
2332 elf_flags_init (obfd) = TRUE;
2333 elf_elfheader (obfd)->e_flags = old_flags = new_flags;
2334 }
2335 /* We don't allow linking in anything else than SH64 code, and since
2336 this is a 64-bit ELF, we assume the 64-bit ABI is used. Add code
2337 here as things change. */
2338 else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
2339 {
2340 (*_bfd_error_handler)
2341 ("%s: does not use the SH64 64-bit ABI as previous modules do",
2342 bfd_get_filename (ibfd));
2343 bfd_set_error (bfd_error_bad_value);
2344 return FALSE;
2345 }
2346
2347 sh_elf64_copy_private_data_internal (ibfd, obfd);
2348
2349 /* I can't think of anything sane other than old_flags being EF_SH5 and
2350 that we need to preserve that. */
2351 elf_elfheader (obfd)->e_flags = old_flags;
2352
2353 return sh_elf64_set_mach_from_flags (obfd);
2354 }
2355
2356 /* Return the section that should be marked against GC for a given
2357 relocation. */
2358
2359 static asection *
2360 sh_elf64_gc_mark_hook (asection *sec,
2361 struct bfd_link_info *info,
2362 Elf_Internal_Rela *rel,
2363 struct elf_link_hash_entry *h,
2364 Elf_Internal_Sym *sym)
2365 {
2366 if (h != NULL)
2367 switch (ELF64_R_TYPE (rel->r_info))
2368 {
2369 case R_SH_GNU_VTINHERIT:
2370 case R_SH_GNU_VTENTRY:
2371 return NULL;
2372 }
2373
2374 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2375 }
2376
2377 /* Look through the relocs for a section during the first phase.
2378 Since we don't do .gots or .plts, we just need to consider the
2379 virtual table relocs for gc. */
2380
2381 static bfd_boolean
2382 sh_elf64_check_relocs (bfd *abfd, struct bfd_link_info *info,
2383 asection *sec, const Elf_Internal_Rela *relocs)
2384 {
2385 Elf_Internal_Shdr *symtab_hdr;
2386 struct elf_link_hash_entry **sym_hashes;
2387 const Elf_Internal_Rela *rel;
2388 const Elf_Internal_Rela *rel_end;
2389 bfd *dynobj;
2390 bfd_vma *local_got_offsets;
2391 asection *sgot;
2392 asection *srelgot;
2393 asection *sreloc;
2394
2395 sgot = NULL;
2396 srelgot = NULL;
2397 sreloc = NULL;
2398
2399 if (info->relocatable)
2400 return TRUE;
2401
2402 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2403 sym_hashes = elf_sym_hashes (abfd);
2404
2405 dynobj = elf_hash_table (info)->dynobj;
2406 local_got_offsets = elf_local_got_offsets (abfd);
2407
2408 rel_end = relocs + sec->reloc_count;
2409 for (rel = relocs; rel < rel_end; rel++)
2410 {
2411 struct elf_link_hash_entry *h;
2412 unsigned long r_symndx;
2413
2414 r_symndx = ELF64_R_SYM (rel->r_info);
2415 if (r_symndx < symtab_hdr->sh_info)
2416 h = NULL;
2417 else
2418 {
2419 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2420 while (h->root.type == bfd_link_hash_indirect
2421 || h->root.type == bfd_link_hash_warning)
2422 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2423 }
2424
2425 /* Some relocs require a global offset table. */
2426 if (dynobj == NULL)
2427 {
2428 switch (ELF64_R_TYPE (rel->r_info))
2429 {
2430 case R_SH_GOTPLT_LOW16:
2431 case R_SH_GOTPLT_MEDLOW16:
2432 case R_SH_GOTPLT_MEDHI16:
2433 case R_SH_GOTPLT_HI16:
2434 case R_SH_GOTPLT10BY4:
2435 case R_SH_GOTPLT10BY8:
2436 case R_SH_GOT_LOW16:
2437 case R_SH_GOT_MEDLOW16:
2438 case R_SH_GOT_MEDHI16:
2439 case R_SH_GOT_HI16:
2440 case R_SH_GOT10BY4:
2441 case R_SH_GOT10BY8:
2442 case R_SH_GOTOFF_LOW16:
2443 case R_SH_GOTOFF_MEDLOW16:
2444 case R_SH_GOTOFF_MEDHI16:
2445 case R_SH_GOTOFF_HI16:
2446 case R_SH_GOTPC_LOW16:
2447 case R_SH_GOTPC_MEDLOW16:
2448 case R_SH_GOTPC_MEDHI16:
2449 case R_SH_GOTPC_HI16:
2450 elf_hash_table (info)->dynobj = dynobj = abfd;
2451 if (! _bfd_elf_create_got_section (dynobj, info))
2452 return FALSE;
2453 break;
2454
2455 default:
2456 break;
2457 }
2458 }
2459
2460 switch (ELF64_R_TYPE (rel->r_info))
2461 {
2462 /* This relocation describes the C++ object vtable hierarchy.
2463 Reconstruct it for later use during GC. */
2464 case R_SH_GNU_VTINHERIT:
2465 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2466 return FALSE;
2467 break;
2468
2469 /* This relocation describes which C++ vtable entries are actually
2470 used. Record for later use during GC. */
2471 case R_SH_GNU_VTENTRY:
2472 BFD_ASSERT (h != NULL);
2473 if (h != NULL
2474 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2475 return FALSE;
2476 break;
2477
2478 force_got:
2479 case R_SH_GOT_LOW16:
2480 case R_SH_GOT_MEDLOW16:
2481 case R_SH_GOT_MEDHI16:
2482 case R_SH_GOT_HI16:
2483 case R_SH_GOT10BY4:
2484 case R_SH_GOT10BY8:
2485 /* This symbol requires a global offset table entry. */
2486
2487 if (sgot == NULL)
2488 {
2489 sgot = bfd_get_section_by_name (dynobj, ".got");
2490 BFD_ASSERT (sgot != NULL);
2491 }
2492
2493 if (srelgot == NULL
2494 && (h != NULL || info->shared))
2495 {
2496 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2497 if (srelgot == NULL)
2498 {
2499 srelgot = bfd_make_section_with_flags (dynobj,
2500 ".rela.got",
2501 (SEC_ALLOC
2502 | SEC_LOAD
2503 | SEC_HAS_CONTENTS
2504 | SEC_IN_MEMORY
2505 | SEC_LINKER_CREATED
2506 | SEC_READONLY));
2507 if (srelgot == NULL
2508 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2509 return FALSE;
2510 }
2511 }
2512
2513 if (h != NULL)
2514 {
2515 if (h->type == STT_DATALABEL)
2516 {
2517 struct elf_sh64_link_hash_entry *hsh;
2518
2519 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2520 hsh = (struct elf_sh64_link_hash_entry *)h;
2521 if (hsh->datalabel_got_offset != (bfd_vma) -1)
2522 break;
2523
2524 hsh->datalabel_got_offset = sgot->size;
2525 }
2526 else
2527 {
2528 if (h->got.offset != (bfd_vma) -1)
2529 {
2530 /* We have already allocated space in the .got. */
2531 break;
2532 }
2533 h->got.offset = sgot->size;
2534 }
2535
2536 /* Make sure this symbol is output as a dynamic symbol. */
2537 if (h->dynindx == -1)
2538 {
2539 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2540 return FALSE;
2541 }
2542
2543 srelgot->size += sizeof (Elf64_External_Rela);
2544 }
2545 else
2546 {
2547 /* This is a global offset table entry for a local
2548 symbol. */
2549 if (local_got_offsets == NULL)
2550 {
2551 size_t size;
2552 register unsigned int i;
2553
2554 size = symtab_hdr->sh_info * sizeof (bfd_vma);
2555 /* Reserve space for both the datalabel and
2556 codelabel local GOT offsets. */
2557 size *= 2;
2558 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2559 if (local_got_offsets == NULL)
2560 return FALSE;
2561 elf_local_got_offsets (abfd) = local_got_offsets;
2562 for (i = 0; i < symtab_hdr->sh_info; i++)
2563 local_got_offsets[i] = (bfd_vma) -1;
2564 for (; i < 2 * symtab_hdr->sh_info; i++)
2565 local_got_offsets[i] = (bfd_vma) -1;
2566 }
2567 if ((rel->r_addend & 1) != 0)
2568 {
2569 if (local_got_offsets[symtab_hdr->sh_info
2570 + r_symndx] != (bfd_vma) -1)
2571 {
2572 /* We have already allocated space in the .got. */
2573 break;
2574 }
2575 local_got_offsets[symtab_hdr->sh_info
2576 + r_symndx] = sgot->size;
2577 }
2578 else
2579 {
2580 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2581 {
2582 /* We have already allocated space in the .got. */
2583 break;
2584 }
2585 local_got_offsets[r_symndx] = sgot->size;
2586 }
2587
2588 if (info->shared)
2589 {
2590 /* If we are generating a shared object, we need to
2591 output a R_SH_RELATIVE reloc so that the dynamic
2592 linker can adjust this GOT entry. */
2593 srelgot->size += sizeof (Elf64_External_Rela);
2594 }
2595 }
2596
2597 sgot->size += 8;
2598
2599 break;
2600
2601 case R_SH_GOTPLT_LOW16:
2602 case R_SH_GOTPLT_MEDLOW16:
2603 case R_SH_GOTPLT_MEDHI16:
2604 case R_SH_GOTPLT_HI16:
2605 case R_SH_GOTPLT10BY4:
2606 case R_SH_GOTPLT10BY8:
2607 /* If this is a local symbol, we resolve it directly without
2608 creating a procedure linkage table entry. */
2609
2610 if (h == NULL
2611 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2612 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2613 || ! info->shared
2614 || info->symbolic
2615 || h->dynindx == -1
2616 || h->got.offset != (bfd_vma) -1)
2617 goto force_got;
2618
2619 /* Make sure this symbol is output as a dynamic symbol. */
2620 if (h->dynindx == -1)
2621 {
2622 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2623 return FALSE;
2624 }
2625
2626 h->needs_plt = 1;
2627
2628 break;
2629
2630 case R_SH_PLT_LOW16:
2631 case R_SH_PLT_MEDLOW16:
2632 case R_SH_PLT_MEDHI16:
2633 case R_SH_PLT_HI16:
2634 /* This symbol requires a procedure linkage table entry. We
2635 actually build the entry in adjust_dynamic_symbol,
2636 because this might be a case of linking PIC code which is
2637 never referenced by a dynamic object, in which case we
2638 don't need to generate a procedure linkage table entry
2639 after all. */
2640
2641 /* If this is a local symbol, we resolve it directly without
2642 creating a procedure linkage table entry. */
2643 if (h == NULL)
2644 continue;
2645
2646 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2647 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
2648 break;
2649
2650 h->needs_plt = 1;
2651
2652 break;
2653
2654 case R_SH_64:
2655 case R_SH_64_PCREL:
2656 if (h != NULL)
2657 h->non_got_ref = 1;
2658
2659 /* If we are creating a shared library, and this is a reloc
2660 against a global symbol, or a non PC relative reloc
2661 against a local symbol, then we need to copy the reloc
2662 into the shared library. However, if we are linking with
2663 -Bsymbolic, we do not need to copy a reloc against a
2664 global symbol which is defined in an object we are
2665 including in the link (i.e., DEF_REGULAR is set). At
2666 this point we have not seen all the input files, so it is
2667 possible that DEF_REGULAR is not set now but will be set
2668 later (it is never cleared). We account for that
2669 possibility below by storing information in the
2670 pcrel_relocs_copied field of the hash table entry. */
2671 if (info->shared
2672 && (sec->flags & SEC_ALLOC) != 0
2673 && (ELF32_R_TYPE (rel->r_info) != R_SH_64_PCREL
2674 || (h != NULL
2675 && (! info->symbolic
2676 || !h->def_regular))))
2677 {
2678 /* When creating a shared object, we must copy these
2679 reloc types into the output file. We create a reloc
2680 section in dynobj and make room for this reloc. */
2681 if (sreloc == NULL)
2682 {
2683 sreloc = _bfd_elf_make_dynamic_reloc_section
2684 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
2685
2686 if (sreloc == NULL)
2687 return FALSE;
2688 }
2689
2690 sreloc->size += sizeof (Elf64_External_Rela);
2691
2692 /* If we are linking with -Bsymbolic, and this is a
2693 global symbol, we count the number of PC relative
2694 relocations we have entered for this symbol, so that
2695 we can discard them again if the symbol is later
2696 defined by a regular object. Note that this function
2697 is only called if we are using an elf_sh linker
2698 hash table, which means that h is really a pointer to
2699 an elf_sh_link_hash_entry. */
2700 if (h != NULL && info->symbolic
2701 && ELF64_R_TYPE (rel->r_info) == R_SH_64_PCREL)
2702 {
2703 struct elf_sh64_link_hash_entry *eh;
2704 struct elf_sh64_pcrel_relocs_copied *p;
2705
2706 eh = (struct elf_sh64_link_hash_entry *) h;
2707
2708 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2709 if (p->section == sreloc)
2710 break;
2711
2712 if (p == NULL)
2713 {
2714 p = ((struct elf_sh64_pcrel_relocs_copied *)
2715 bfd_alloc (dynobj, sizeof *p));
2716 if (p == NULL)
2717 return FALSE;
2718 p->next = eh->pcrel_relocs_copied;
2719 eh->pcrel_relocs_copied = p;
2720 p->section = sreloc;
2721 p->count = 0;
2722 }
2723
2724 ++p->count;
2725 }
2726 }
2727
2728 break;
2729 }
2730 }
2731
2732 return TRUE;
2733 }
2734
2735 static int
2736 sh64_elf64_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
2737 {
2738 if (ELF_ST_TYPE (elf_sym->st_info) == STT_DATALABEL)
2739 return STT_DATALABEL;
2740
2741 return type;
2742 }
2743
2744 /* FIXME: This is a copy of sh64_elf_add_symbol_hook in elf32-sh64.c.
2745 Either file can presumably exist without the other, but do not differ
2746 in elf-size-ness. How to share?
2747
2748 Hook called by the linker routine which adds symbols from an object
2749 file. We must make indirect symbols for undefined symbols marked with
2750 STT_DATALABEL, so relocations passing them will pick up that attribute
2751 and neutralize STO_SH5_ISA32 found on the symbol definition.
2752
2753 There is a problem, though: We want to fill in the hash-table entry for
2754 this symbol and signal to the caller that no further processing is
2755 needed. But we don't have the index for this hash-table entry. We
2756 rely here on that the current entry is the first hash-entry with NULL,
2757 which seems brittle. Also, iterating over the hash-table to find that
2758 entry is a linear operation on the number of symbols in this input
2759 file, and this function should take constant time, so that's not good
2760 too. Only comfort is that DataLabel references should only be found in
2761 hand-written assembly code and thus be rare. FIXME: Talk maintainers
2762 into adding an option to elf_add_symbol_hook (preferably) for the index
2763 or the hash entry, alternatively adding the index to Elf_Internal_Sym
2764 (not so good). */
2765
2766 static bfd_boolean
2767 sh64_elf64_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
2768 Elf_Internal_Sym *sym, const char **namep,
2769 flagword *flagsp ATTRIBUTE_UNUSED,
2770 asection **secp, bfd_vma *valp)
2771 {
2772 /* We want to do this for relocatable as well as final linking. */
2773 if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL
2774 && is_elf_hash_table (info->hash))
2775 {
2776 struct elf_link_hash_entry *h;
2777
2778 /* For relocatable links, we register the DataLabel sym in its own
2779 right, and tweak the name when it's output. Otherwise, we make
2780 an indirect symbol of it. */
2781 flagword flags
2782 = info->relocatable || info->emitrelocations
2783 ? BSF_GLOBAL : BSF_GLOBAL | BSF_INDIRECT;
2784
2785 char *dl_name
2786 = bfd_malloc (strlen (*namep) + sizeof (DATALABEL_SUFFIX));
2787 struct elf_link_hash_entry ** sym_hash = elf_sym_hashes (abfd);
2788
2789 BFD_ASSERT (sym_hash != NULL);
2790
2791 /* Allocation may fail. */
2792 if (dl_name == NULL)
2793 return FALSE;
2794
2795 strcpy (dl_name, *namep);
2796 strcat (dl_name, DATALABEL_SUFFIX);
2797
2798 h = (struct elf_link_hash_entry *)
2799 bfd_link_hash_lookup (info->hash, dl_name, FALSE, FALSE, FALSE);
2800
2801 if (h == NULL)
2802 {
2803 /* No previous datalabel symbol. Make one. */
2804 struct bfd_link_hash_entry *bh = NULL;
2805 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2806
2807 if (! _bfd_generic_link_add_one_symbol (info, abfd, dl_name,
2808 flags, *secp, *valp,
2809 *namep, FALSE,
2810 bed->collect, &bh))
2811 {
2812 free (dl_name);
2813 return FALSE;
2814 }
2815
2816 h = (struct elf_link_hash_entry *) bh;
2817 h->non_elf = 0;
2818 h->type = STT_DATALABEL;
2819 }
2820 else
2821 /* If a new symbol was created, it holds the allocated name.
2822 Otherwise, we don't need it anymore and should deallocate it. */
2823 free (dl_name);
2824
2825 if (h->type != STT_DATALABEL
2826 || ((info->relocatable || info->emitrelocations)
2827 && h->root.type != bfd_link_hash_undefined)
2828 || (! info->relocatable && !info->emitrelocations
2829 && h->root.type != bfd_link_hash_indirect))
2830 {
2831 /* Make sure we don't get confused on invalid input. */
2832 (*_bfd_error_handler)
2833 (_("%s: encountered datalabel symbol in input"),
2834 bfd_get_filename (abfd));
2835 bfd_set_error (bfd_error_bad_value);
2836 return FALSE;
2837 }
2838
2839 /* Now find the hash-table slot for this entry and fill it in. */
2840 while (*sym_hash != NULL)
2841 sym_hash++;
2842 *sym_hash = h;
2843
2844 /* Signal to caller to skip this symbol - we've handled it. */
2845 *namep = NULL;
2846 }
2847
2848 return TRUE;
2849 }
2850
2851 /* This hook function is called before the linker writes out a global
2852 symbol. For relocatable links, DataLabel symbols will be present in
2853 linker output. We cut off the special suffix on those symbols, so the
2854 right name appears in the output.
2855
2856 When linking and emitting relocations, there can appear global symbols
2857 that are not referenced by relocs, but rather only implicitly through
2858 DataLabel references, a relation that is not visible to the linker.
2859 Since no stripping of global symbols in done when doing such linking,
2860 we don't need to look up and make sure to emit the main symbol for each
2861 DataLabel symbol. */
2862
2863 static int
2864 sh64_elf64_link_output_symbol_hook (struct bfd_link_info *info,
2865 const char *cname,
2866 Elf_Internal_Sym *sym,
2867 asection *input_sec ATTRIBUTE_UNUSED,
2868 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
2869 {
2870 char *name = (char *) cname;
2871
2872 if (info->relocatable || info->emitrelocations)
2873 {
2874 if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL)
2875 name[strlen (name) - strlen (DATALABEL_SUFFIX)] = 0;
2876 }
2877
2878 return 1;
2879 }
2880
2881 /* Set bit 0 on the entry address; it always points to SHmedia code. This
2882 is mostly for symmetry with the 32-bit format, where code can be
2883 SHcompact and we need to make a distinction to make sure execution
2884 starts in the right ISA mode. It is also convenient for a loader,
2885 which would otherwise have to set this bit when loading a TR register
2886 before jumping to the program entry. */
2887
2888 static void
2889 sh64_elf64_final_write_processing (bfd *abfd,
2890 bfd_boolean linker ATTRIBUTE_UNUSED)
2891 {
2892 /* FIXME: Perhaps we shouldn't do this if the entry address was supplied
2893 numerically, but we currently lack the infrastructure to recognize
2894 that: The entry symbol, and info whether it is numeric or a symbol
2895 name is kept private in the linker. */
2896 if (elf_elfheader (abfd)->e_type == ET_EXEC)
2897 elf_elfheader (abfd)->e_entry |= 1;
2898 }
2899
2900 /* First entry in an absolute procedure linkage table look like this. */
2901
2902 static const bfd_byte elf_sh64_plt0_entry_be[PLT_ENTRY_SIZE] =
2903 {
2904 0xcc, 0x00, 0x01, 0x10, /* movi .got.plt >> 48, r17 */
2905 0xc8, 0x00, 0x01, 0x10, /* shori (.got.plt >> 32) & 65535, r17 */
2906 0xc8, 0x00, 0x01, 0x10, /* shori (.got.plt >> 16) & 65535, r17 */
2907 0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
2908 0x8d, 0x10, 0x09, 0x90, /* ld.q r17, 16, r25 */
2909 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2910 0x8d, 0x10, 0x05, 0x10, /* ld.q r17, 8, r17 */
2911 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2912 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2913 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2914 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2915 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2916 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2917 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2918 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2919 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2920 };
2921
2922 static const bfd_byte elf_sh64_plt0_entry_le[PLT_ENTRY_SIZE] =
2923 {
2924 0x10, 0x01, 0x00, 0xcc, /* movi .got.plt >> 16, r17 */
2925 0x10, 0x01, 0x00, 0xc8, /* shori (.got.plt >> 32) & 65535, r17 */
2926 0x10, 0x01, 0x00, 0xc8, /* shori (.got.plt >> 16) & 65535, r17 */
2927 0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
2928 0x90, 0x09, 0x10, 0x8d, /* ld.q r17, 16, r25 */
2929 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
2930 0x10, 0x05, 0x10, 0x8d, /* ld.q r17, 8, r17 */
2931 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2932 0xf0, 0xff, 0xf0, 0x6f, /* nop */
2933 0xf0, 0xff, 0xf0, 0x6f, /* nop */
2934 0xf0, 0xff, 0xf0, 0x6f, /* nop */
2935 0xf0, 0xff, 0xf0, 0x6f, /* nop */
2936 0xf0, 0xff, 0xf0, 0x6f, /* nop */
2937 0xf0, 0xff, 0xf0, 0x6f, /* nop */
2938 0xf0, 0xff, 0xf0, 0x6f, /* nop */
2939 0xf0, 0xff, 0xf0, 0x6f, /* nop */
2940 };
2941
2942 /* Sebsequent entries in an absolute procedure linkage table look like
2943 this. */
2944
2945 static const bfd_byte elf_sh64_plt_entry_be[PLT_ENTRY_SIZE] =
2946 {
2947 0xcc, 0x00, 0x01, 0x90, /* movi nameN-in-GOT >> 48, r25 */
2948 0xc8, 0x00, 0x01, 0x90, /* shori (nameN-in-GOT >> 32) & 65535, r25 */
2949 0xc8, 0x00, 0x01, 0x90, /* shori (nameN-in-GOT >> 16) & 65535, r25 */
2950 0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
2951 0x8d, 0x90, 0x01, 0x90, /* ld.q r25, 0, r25 */
2952 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2953 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2954 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2955 0xcc, 0x00, 0x01, 0x90, /* movi (.+8-.PLT0) >> 16, r25 */
2956 0xc8, 0x00, 0x01, 0x90, /* shori (.+4-.PLT0) & 65535, r25 */
2957 0x6b, 0xf5, 0x66, 0x00, /* ptrel r25, tr0 */
2958 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
2959 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
2960 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2961 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2962 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2963 };
2964
2965 static const bfd_byte elf_sh64_plt_entry_le[PLT_ENTRY_SIZE] =
2966 {
2967 0x90, 0x01, 0x00, 0xcc, /* movi nameN-in-GOT >> 16, r25 */
2968 0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2969 0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2970 0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2971 0x90, 0x01, 0x90, 0x8d, /* ld.q r25, 0, r25 */
2972 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
2973 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2974 0xf0, 0xff, 0xf0, 0x6f, /* nop */
2975 0x90, 0x01, 0x00, 0xcc, /* movi (.+8-.PLT0) >> 16, r25 */
2976 0x90, 0x01, 0x00, 0xc8, /* shori (.+4-.PLT0) & 65535, r25 */
2977 0x00, 0x66, 0xf5, 0x6b, /* ptrel r25, tr0 */
2978 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
2979 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
2980 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2981 0xf0, 0xff, 0xf0, 0x6f, /* nop */
2982 0xf0, 0xff, 0xf0, 0x6f, /* nop */
2983 };
2984
2985 /* Entries in a PIC procedure linkage table look like this. */
2986
2987 static const bfd_byte elf_sh64_pic_plt_entry_be[PLT_ENTRY_SIZE] =
2988 {
2989 0xcc, 0x00, 0x01, 0x90, /* movi nameN@GOT >> 16, r25 */
2990 0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
2991 0x40, 0xc3, 0x65, 0x90, /* ldx.q r12, r25, r25 */
2992 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2993 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2994 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2995 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2996 0x6f, 0xf0, 0xff, 0xf0, /* nop */
2997 0xce, 0x00, 0x01, 0x10, /* movi -GOT_BIAS, r17 */
2998 0x00, 0xc9, 0x45, 0x10, /* add r12, r17, r17 */
2999 0x8d, 0x10, 0x09, 0x90, /* ld.q r17, 16, r25 */
3000 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3001 0x8d, 0x10, 0x05, 0x10, /* ld.q r17, 8, r17 */
3002 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
3003 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
3004 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3005 };
3006
3007 static const bfd_byte elf_sh64_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3008 {
3009 0x90, 0x01, 0x00, 0xcc, /* movi nameN@GOT >> 16, r25 */
3010 0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
3011 0x90, 0x65, 0xc3, 0x40, /* ldx.q r12, r25, r25 */
3012 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3013 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3014 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3015 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3016 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3017 0x10, 0x01, 0x00, 0xce, /* movi -GOT_BIAS, r17 */
3018 0x10, 0x45, 0xc9, 0x00, /* add r12, r17, r17 */
3019 0x90, 0x09, 0x10, 0x8d, /* ld.q r17, 16, r25 */
3020 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3021 0x10, 0x05, 0x10, 0x8d, /* ld.q r17, 8, r17 */
3022 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
3023 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
3024 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3025 };
3026
3027 static const bfd_byte *elf_sh64_plt0_entry;
3028 static const bfd_byte *elf_sh64_plt_entry;
3029 static const bfd_byte *elf_sh64_pic_plt_entry;
3030
3031 /* Create an entry in an sh ELF linker hash table. */
3032
3033 static struct bfd_hash_entry *
3034 sh64_elf64_link_hash_newfunc (struct bfd_hash_entry *entry,
3035 struct bfd_hash_table *table,
3036 const char *string)
3037 {
3038 struct elf_sh64_link_hash_entry *ret =
3039 (struct elf_sh64_link_hash_entry *) entry;
3040
3041 /* Allocate the structure if it has not already been allocated by a
3042 subclass. */
3043 if (ret == (struct elf_sh64_link_hash_entry *) NULL)
3044 ret = ((struct elf_sh64_link_hash_entry *)
3045 bfd_hash_allocate (table,
3046 sizeof (struct elf_sh64_link_hash_entry)));
3047 if (ret == (struct elf_sh64_link_hash_entry *) NULL)
3048 return (struct bfd_hash_entry *) ret;
3049
3050 /* Call the allocation method of the superclass. */
3051 ret = ((struct elf_sh64_link_hash_entry *)
3052 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3053 table, string));
3054 if (ret != (struct elf_sh64_link_hash_entry *) NULL)
3055 {
3056 ret->pcrel_relocs_copied = NULL;
3057 ret->datalabel_got_offset = (bfd_vma) -1;
3058 }
3059
3060 return (struct bfd_hash_entry *) ret;
3061 }
3062
3063 /* Create an sh64 ELF linker hash table. */
3064
3065 static struct bfd_link_hash_table *
3066 sh64_elf64_link_hash_table_create (bfd *abfd)
3067 {
3068 struct elf_link_hash_table *ret;
3069
3070 ret = (struct elf_link_hash_table *) bfd_malloc (sizeof (* ret));
3071 if (ret == (struct elf_link_hash_table *) NULL)
3072 return NULL;
3073
3074 if (!_bfd_elf_link_hash_table_init (ret, abfd,
3075 sh64_elf64_link_hash_newfunc,
3076 sizeof (struct elf_sh64_link_hash_entry),
3077 GENERIC_ELF_DATA))
3078 {
3079 free (ret);
3080 return NULL;
3081 }
3082
3083 return &ret->root;
3084 }
3085
3086 inline static void
3087 movi_shori_putval (bfd *output_bfd, unsigned long value, bfd_byte *addr)
3088 {
3089 bfd_put_32 (output_bfd,
3090 bfd_get_32 (output_bfd, addr)
3091 | ((value >> 6) & 0x3fffc00),
3092 addr);
3093 bfd_put_32 (output_bfd,
3094 bfd_get_32 (output_bfd, addr + 4)
3095 | ((value << 10) & 0x3fffc00),
3096 addr + 4);
3097 }
3098
3099 inline static void
3100 movi_3shori_putval (bfd *output_bfd, bfd_vma value, bfd_byte *addr)
3101 {
3102 bfd_put_32 (output_bfd,
3103 bfd_get_32 (output_bfd, addr)
3104 | ((value >> 38) & 0x3fffc00),
3105 addr);
3106 bfd_put_32 (output_bfd,
3107 bfd_get_32 (output_bfd, addr + 4)
3108 | ((value >> 22) & 0x3fffc00),
3109 addr + 4);
3110 bfd_put_32 (output_bfd,
3111 bfd_get_32 (output_bfd, addr + 8)
3112 | ((value >> 6) & 0x3fffc00),
3113 addr + 8);
3114 bfd_put_32 (output_bfd,
3115 bfd_get_32 (output_bfd, addr + 12)
3116 | ((value << 10) & 0x3fffc00),
3117 addr + 12);
3118 }
3119
3120 /* Create dynamic sections when linking against a dynamic object. */
3121
3122 static bfd_boolean
3123 sh64_elf64_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3124 {
3125 flagword flags, pltflags;
3126 register asection *s;
3127 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3128 int ptralign = 0;
3129
3130 switch (bed->s->arch_size)
3131 {
3132 case 32:
3133 ptralign = 2;
3134 break;
3135
3136 case 64:
3137 ptralign = 3;
3138 break;
3139
3140 default:
3141 bfd_set_error (bfd_error_bad_value);
3142 return FALSE;
3143 }
3144
3145 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3146 .rel[a].bss sections. */
3147
3148 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3149 | SEC_LINKER_CREATED);
3150
3151 pltflags = flags;
3152 pltflags |= SEC_CODE;
3153 if (bed->plt_not_loaded)
3154 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
3155 if (bed->plt_readonly)
3156 pltflags |= SEC_READONLY;
3157
3158 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
3159 if (s == NULL
3160 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3161 return FALSE;
3162
3163 if (bed->want_plt_sym)
3164 {
3165 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3166 .plt section. */
3167 struct elf_link_hash_entry *h;
3168 struct bfd_link_hash_entry *bh = NULL;
3169
3170 if (! (_bfd_generic_link_add_one_symbol
3171 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3172 (bfd_vma) 0, (const char *) NULL, FALSE, bed->collect, &bh)))
3173 return FALSE;
3174
3175 h = (struct elf_link_hash_entry *) bh;
3176 h->def_regular = 1;
3177 h->type = STT_OBJECT;
3178 elf_hash_table (info)->hplt = h;
3179
3180 if (info->shared
3181 && ! bfd_elf_link_record_dynamic_symbol (info, h))
3182 return FALSE;
3183 }
3184
3185 s = bfd_make_section_with_flags (abfd,
3186 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
3187 flags | SEC_READONLY);
3188 if (s == NULL
3189 || ! bfd_set_section_alignment (abfd, s, ptralign))
3190 return FALSE;
3191
3192 if (! _bfd_elf_create_got_section (abfd, info))
3193 return FALSE;
3194
3195 {
3196 const char *secname;
3197 char *relname;
3198 flagword secflags;
3199 asection *sec;
3200
3201 for (sec = abfd->sections; sec; sec = sec->next)
3202 {
3203 secflags = bfd_get_section_flags (abfd, sec);
3204 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3205 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3206 continue;
3207 secname = bfd_get_section_name (abfd, sec);
3208 relname = (char *) bfd_malloc (strlen (secname) + 6);
3209 strcpy (relname, ".rela");
3210 strcat (relname, secname);
3211 s = bfd_make_section_with_flags (abfd, relname,
3212 flags | SEC_READONLY);
3213 if (s == NULL
3214 || ! bfd_set_section_alignment (abfd, s, ptralign))
3215 return FALSE;
3216 }
3217 }
3218
3219 if (bed->want_dynbss)
3220 {
3221 /* The .dynbss section is a place to put symbols which are defined
3222 by dynamic objects, are referenced by regular objects, and are
3223 not functions. We must allocate space for them in the process
3224 image and use a R_*_COPY reloc to tell the dynamic linker to
3225 initialize them at run time. The linker script puts the .dynbss
3226 section into the .bss section of the final image. */
3227 s = bfd_make_section_with_flags (abfd, ".dynbss",
3228 SEC_ALLOC | SEC_LINKER_CREATED);
3229 if (s == NULL)
3230 return FALSE;
3231
3232 /* The .rel[a].bss section holds copy relocs. This section is not
3233 normally needed. We need to create it here, though, so that the
3234 linker will map it to an output section. We can't just create it
3235 only if we need it, because we will not know whether we need it
3236 until we have seen all the input files, and the first time the
3237 main linker code calls BFD after examining all the input files
3238 (size_dynamic_sections) the input sections have already been
3239 mapped to the output sections. If the section turns out not to
3240 be needed, we can discard it later. We will never need this
3241 section when generating a shared object, since they do not use
3242 copy relocs. */
3243 if (! info->shared)
3244 {
3245 s = bfd_make_section_with_flags (abfd,
3246 (bed->default_use_rela_p
3247 ? ".rela.bss" : ".rel.bss"),
3248 flags | SEC_READONLY);
3249 if (s == NULL
3250 || ! bfd_set_section_alignment (abfd, s, ptralign))
3251 return FALSE;
3252 }
3253 }
3254
3255 return TRUE;
3256 }
3257 \f
3258 /* Adjust a symbol defined by a dynamic object and referenced by a
3259 regular object. The current definition is in some section of the
3260 dynamic object, but we're not including those sections. We have to
3261 change the definition to something the rest of the link can
3262 understand. */
3263
3264 static bfd_boolean
3265 sh64_elf64_adjust_dynamic_symbol (struct bfd_link_info *info,
3266 struct elf_link_hash_entry *h)
3267 {
3268 bfd *dynobj;
3269 asection *s;
3270
3271 dynobj = elf_hash_table (info)->dynobj;
3272
3273 /* Make sure we know what is going on here. */
3274 BFD_ASSERT (dynobj != NULL
3275 && (h->needs_plt
3276 || h->u.weakdef != NULL
3277 || (h->def_dynamic
3278 && h->ref_regular
3279 && !h->def_regular)));
3280
3281 /* If this is a function, put it in the procedure linkage table. We
3282 will fill in the contents of the procedure linkage table later,
3283 when we know the address of the .got section. */
3284 if (h->type == STT_FUNC
3285 || h->needs_plt)
3286 {
3287 if (! info->shared
3288 && !h->def_dynamic
3289 && !h->ref_dynamic)
3290 {
3291 /* This case can occur if we saw a PLT reloc in an input
3292 file, but the symbol was never referred to by a dynamic
3293 object. In such a case, we don't actually need to build
3294 a procedure linkage table, and we can just do a REL64
3295 reloc instead. */
3296 BFD_ASSERT (h->needs_plt);
3297 return TRUE;
3298 }
3299
3300 /* Make sure this symbol is output as a dynamic symbol. */
3301 if (h->dynindx == -1)
3302 {
3303 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3304 return FALSE;
3305 }
3306
3307 s = bfd_get_section_by_name (dynobj, ".plt");
3308 BFD_ASSERT (s != NULL);
3309
3310 /* If this is the first .plt entry, make room for the special
3311 first entry. */
3312 if (s->size == 0)
3313 s->size += PLT_ENTRY_SIZE;
3314
3315 /* If this symbol is not defined in a regular file, and we are
3316 not generating a shared library, then set the symbol to this
3317 location in the .plt. This is required to make function
3318 pointers compare as equal between the normal executable and
3319 the shared library. */
3320 if (! info->shared
3321 && !h->def_regular)
3322 {
3323 h->root.u.def.section = s;
3324 h->root.u.def.value = s->size;
3325 }
3326
3327 h->plt.offset = s->size;
3328
3329 /* Make room for this entry. */
3330 s->size += elf_sh64_sizeof_plt (info);
3331
3332 /* We also need to make an entry in the .got.plt section, which
3333 will be placed in the .got section by the linker script. */
3334
3335 s = bfd_get_section_by_name (dynobj, ".got.plt");
3336 BFD_ASSERT (s != NULL);
3337 s->size += 8;
3338
3339 /* We also need to make an entry in the .rela.plt section. */
3340
3341 s = bfd_get_section_by_name (dynobj, ".rela.plt");
3342 BFD_ASSERT (s != NULL);
3343 s->size += sizeof (Elf64_External_Rela);
3344
3345 return TRUE;
3346 }
3347
3348 /* If this is a weak symbol, and there is a real definition, the
3349 processor independent code will have arranged for us to see the
3350 real definition first, and we can just use the same value. */
3351 if (h->u.weakdef != NULL)
3352 {
3353 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3354 || h->u.weakdef->root.type == bfd_link_hash_defweak);
3355 h->root.u.def.section = h->u.weakdef->root.u.def.section;
3356 h->root.u.def.value = h->u.weakdef->root.u.def.value;
3357 return TRUE;
3358 }
3359
3360 /* This is a reference to a symbol defined by a dynamic object which
3361 is not a function. */
3362
3363 /* If we are creating a shared library, we must presume that the
3364 only references to the symbol are via the global offset table.
3365 For such cases we need not do anything here; the relocations will
3366 be handled correctly by relocate_section. */
3367 if (info->shared)
3368 return TRUE;
3369
3370 /* If there are no references to this symbol that do not use the
3371 GOT, we don't need to generate a copy reloc. */
3372 if (!h->non_got_ref)
3373 return TRUE;
3374
3375 if (h->size == 0)
3376 {
3377 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
3378 h->root.root.string);
3379 return TRUE;
3380 }
3381
3382 /* We must allocate the symbol in our .dynbss section, which will
3383 become part of the .bss section of the executable. There will be
3384 an entry for this symbol in the .dynsym section. The dynamic
3385 object will contain position independent code, so all references
3386 from the dynamic object to this symbol will go through the global
3387 offset table. The dynamic linker will use the .dynsym entry to
3388 determine the address it must put in the global offset table, so
3389 both the dynamic object and the regular object will refer to the
3390 same memory location for the variable. */
3391
3392 s = bfd_get_section_by_name (dynobj, ".dynbss");
3393 BFD_ASSERT (s != NULL);
3394
3395 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
3396 copy the initial value out of the dynamic object and into the
3397 runtime process image. We need to remember the offset into the
3398 .rela.bss section we are going to use. */
3399 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3400 {
3401 asection *srel;
3402
3403 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
3404 BFD_ASSERT (srel != NULL);
3405 srel->size += sizeof (Elf64_External_Rela);
3406 h->needs_copy = 1;
3407 }
3408
3409 return _bfd_elf_adjust_dynamic_copy (h, s);
3410 }
3411
3412 /* This function is called via sh_elf_link_hash_traverse if we are
3413 creating a shared object with -Bsymbolic. It discards the space
3414 allocated to copy PC relative relocs against symbols which are
3415 defined in regular objects. We allocated space for them in the
3416 check_relocs routine, but we won't fill them in in the
3417 relocate_section routine. */
3418
3419 static bfd_boolean
3420 sh64_elf64_discard_copies (struct elf_sh64_link_hash_entry *h,
3421 void *ignore ATTRIBUTE_UNUSED)
3422 {
3423 struct elf_sh64_pcrel_relocs_copied *s;
3424
3425 if (h->root.root.type == bfd_link_hash_warning)
3426 h = (struct elf_sh64_link_hash_entry *) h->root.root.u.i.link;
3427
3428 /* We only discard relocs for symbols defined in a regular object. */
3429 if (!h->root.def_regular)
3430 return TRUE;
3431
3432 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3433 s->section->size -= s->count * sizeof (Elf64_External_Rela);
3434
3435 return TRUE;
3436 }
3437
3438 /* Set the sizes of the dynamic sections. */
3439
3440 static bfd_boolean
3441 sh64_elf64_size_dynamic_sections (bfd *output_bfd,
3442 struct bfd_link_info *info)
3443 {
3444 bfd *dynobj;
3445 asection *s;
3446 bfd_boolean plt;
3447 bfd_boolean relocs;
3448 bfd_boolean reltext;
3449
3450 dynobj = elf_hash_table (info)->dynobj;
3451 BFD_ASSERT (dynobj != NULL);
3452
3453 if (elf_hash_table (info)->dynamic_sections_created)
3454 {
3455 /* Set the contents of the .interp section to the interpreter. */
3456 if (info->executable)
3457 {
3458 s = bfd_get_section_by_name (dynobj, ".interp");
3459 BFD_ASSERT (s != NULL);
3460 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3461 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3462 }
3463 }
3464 else
3465 {
3466 /* We may have created entries in the .rela.got section.
3467 However, if we are not creating the dynamic sections, we will
3468 not actually use these entries. Reset the size of .rela.got,
3469 which will cause it to get stripped from the output file
3470 below. */
3471 s = bfd_get_section_by_name (dynobj, ".rela.got");
3472 if (s != NULL)
3473 s->size = 0;
3474 }
3475
3476 /* If this is a -Bsymbolic shared link, then we need to discard all
3477 PC relative relocs against symbols defined in a regular object.
3478 We allocated space for them in the check_relocs routine, but we
3479 will not fill them in in the relocate_section routine. */
3480 if (info->shared && info->symbolic)
3481 sh64_elf64_link_hash_traverse (elf_hash_table (info),
3482 sh64_elf64_discard_copies, NULL);
3483
3484 /* The check_relocs and adjust_dynamic_symbol entry points have
3485 determined the sizes of the various dynamic sections. Allocate
3486 memory for them. */
3487 plt = FALSE;
3488 relocs = FALSE;
3489 reltext = FALSE;
3490 for (s = dynobj->sections; s != NULL; s = s->next)
3491 {
3492 const char *name;
3493
3494 if ((s->flags & SEC_LINKER_CREATED) == 0)
3495 continue;
3496
3497 /* It's OK to base decisions on the section name, because none
3498 of the dynobj section names depend upon the input files. */
3499 name = bfd_get_section_name (dynobj, s);
3500
3501 if (strcmp (name, ".plt") == 0)
3502 {
3503 /* Remember whether there is a PLT. */
3504 plt = s->size != 0;
3505 }
3506 else if (CONST_STRNEQ (name, ".rela"))
3507 {
3508 if (s->size != 0)
3509 {
3510 asection *target;
3511
3512 /* Remember whether there are any reloc sections other
3513 than .rela.plt. */
3514 if (strcmp (name, ".rela.plt") != 0)
3515 {
3516 const char *outname;
3517
3518 relocs = TRUE;
3519
3520 /* If this relocation section applies to a read only
3521 section, then we probably need a DT_TEXTREL
3522 entry. The entries in the .rela.plt section
3523 really apply to the .got section, which we
3524 created ourselves and so know is not readonly. */
3525 outname = bfd_get_section_name (output_bfd,
3526 s->output_section);
3527 target = bfd_get_section_by_name (output_bfd, outname + 5);
3528 if (target != NULL
3529 && (target->flags & SEC_READONLY) != 0
3530 && (target->flags & SEC_ALLOC) != 0)
3531 reltext = TRUE;
3532 }
3533
3534 /* We use the reloc_count field as a counter if we need
3535 to copy relocs into the output file. */
3536 s->reloc_count = 0;
3537 }
3538 }
3539 else if (! CONST_STRNEQ (name, ".got")
3540 && strcmp (name, ".dynbss") != 0)
3541 {
3542 /* It's not one of our sections, so don't allocate space. */
3543 continue;
3544 }
3545
3546 if (s->size == 0)
3547 {
3548 /* If we don't need this section, strip it from the
3549 output file. This is mostly to handle .rela.bss and
3550 .rela.plt. We must create both sections in
3551 create_dynamic_sections, because they must be created
3552 before the linker maps input sections to output
3553 sections. The linker does that before
3554 adjust_dynamic_symbol is called, and it is that
3555 function which decides whether anything needs to go
3556 into these sections. */
3557 s->flags |= SEC_EXCLUDE;
3558 continue;
3559 }
3560
3561 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3562 continue;
3563
3564 /* Allocate memory for the section contents. */
3565 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3566 if (s->contents == NULL)
3567 return FALSE;
3568 }
3569
3570 if (elf_hash_table (info)->dynamic_sections_created)
3571 {
3572 /* Add some entries to the .dynamic section. We fill in the
3573 values later, in sh64_elf64_finish_dynamic_sections, but we
3574 must add the entries now so that we get the correct size for
3575 the .dynamic section. The DT_DEBUG entry is filled in by the
3576 dynamic linker and used by the debugger. */
3577 if (info->executable)
3578 {
3579 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
3580 return FALSE;
3581 }
3582
3583 if (plt)
3584 {
3585 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
3586 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3587 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3588 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
3589 return FALSE;
3590 }
3591
3592 if (relocs)
3593 {
3594 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
3595 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
3596 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
3597 sizeof (Elf64_External_Rela)))
3598 return FALSE;
3599 }
3600
3601 if (reltext)
3602 {
3603 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
3604 return FALSE;
3605 }
3606 }
3607
3608 return TRUE;
3609 }
3610
3611 /* Finish up dynamic symbol handling. We set the contents of various
3612 dynamic sections here. */
3613
3614 static bfd_boolean
3615 sh64_elf64_finish_dynamic_symbol (bfd *output_bfd,
3616 struct bfd_link_info *info,
3617 struct elf_link_hash_entry *h,
3618 Elf_Internal_Sym *sym)
3619 {
3620 bfd *dynobj;
3621
3622 dynobj = elf_hash_table (info)->dynobj;
3623
3624 if (h->plt.offset != (bfd_vma) -1)
3625 {
3626 asection *splt;
3627 asection *sgot;
3628 asection *srel;
3629
3630 bfd_vma plt_index;
3631 bfd_vma got_offset;
3632 Elf_Internal_Rela rel;
3633 bfd_byte *loc;
3634
3635 /* This symbol has an entry in the procedure linkage table. Set
3636 it up. */
3637
3638 BFD_ASSERT (h->dynindx != -1);
3639
3640 splt = bfd_get_section_by_name (dynobj, ".plt");
3641 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3642 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3643 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3644
3645 /* Get the index in the procedure linkage table which
3646 corresponds to this symbol. This is the index of this symbol
3647 in all the symbols for which we are making plt entries. The
3648 first entry in the procedure linkage table is reserved. */
3649 plt_index = h->plt.offset / elf_sh64_sizeof_plt (info) - 1;
3650
3651 /* Get the offset into the .got table of the entry that
3652 corresponds to this function. Each .got entry is 8 bytes.
3653 The first three are reserved. */
3654 got_offset = (plt_index + 3) * 8;
3655
3656 if (info->shared)
3657 got_offset -= GOT_BIAS;
3658
3659 /* Fill in the entry in the procedure linkage table. */
3660 if (! info->shared)
3661 {
3662 if (elf_sh64_plt_entry == NULL)
3663 {
3664 elf_sh64_plt_entry = (bfd_big_endian (output_bfd) ?
3665 elf_sh64_plt_entry_be : elf_sh64_plt_entry_le);
3666 }
3667 memcpy (splt->contents + h->plt.offset, elf_sh64_plt_entry,
3668 elf_sh64_sizeof_plt (info));
3669 movi_3shori_putval (output_bfd,
3670 (sgot->output_section->vma
3671 + sgot->output_offset
3672 + got_offset),
3673 (splt->contents + h->plt.offset
3674 + elf_sh64_plt_symbol_offset (info)));
3675
3676 /* Set bottom bit because its for a branch to SHmedia */
3677 movi_shori_putval (output_bfd,
3678 -(h->plt.offset
3679 + elf_sh64_plt_plt0_offset (info) + 8)
3680 | 1,
3681 (splt->contents + h->plt.offset
3682 + elf_sh64_plt_plt0_offset (info)));
3683 }
3684 else
3685 {
3686 if (elf_sh64_pic_plt_entry == NULL)
3687 {
3688 elf_sh64_pic_plt_entry = (bfd_big_endian (output_bfd) ?
3689 elf_sh64_pic_plt_entry_be :
3690 elf_sh64_pic_plt_entry_le);
3691 }
3692 memcpy (splt->contents + h->plt.offset, elf_sh64_pic_plt_entry,
3693 elf_sh64_sizeof_plt (info));
3694 movi_shori_putval (output_bfd, got_offset,
3695 (splt->contents + h->plt.offset
3696 + elf_sh64_plt_symbol_offset (info)));
3697 }
3698
3699 if (info->shared)
3700 got_offset += GOT_BIAS;
3701
3702 movi_shori_putval (output_bfd,
3703 plt_index * sizeof (Elf64_External_Rela),
3704 (splt->contents + h->plt.offset
3705 + elf_sh64_plt_reloc_offset (info)));
3706
3707 /* Fill in the entry in the global offset table. */
3708 bfd_put_64 (output_bfd,
3709 (splt->output_section->vma
3710 + splt->output_offset
3711 + h->plt.offset
3712 + elf_sh64_plt_temp_offset (info)),
3713 sgot->contents + got_offset);
3714
3715 /* Fill in the entry in the .rela.plt section. */
3716 rel.r_offset = (sgot->output_section->vma
3717 + sgot->output_offset
3718 + got_offset);
3719 rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_JMP_SLOT64);
3720 rel.r_addend = 0;
3721 rel.r_addend = GOT_BIAS;
3722 loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
3723 bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3724
3725 if (!h->def_regular)
3726 {
3727 /* Mark the symbol as undefined, rather than as defined in
3728 the .plt section. Leave the value alone. */
3729 sym->st_shndx = SHN_UNDEF;
3730 }
3731 }
3732
3733 if (h->got.offset != (bfd_vma) -1)
3734 {
3735 asection *sgot;
3736 asection *srel;
3737 Elf_Internal_Rela rel;
3738 bfd_byte *loc;
3739
3740 /* This symbol has an entry in the global offset table. Set it
3741 up. */
3742
3743 sgot = bfd_get_section_by_name (dynobj, ".got");
3744 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3745 BFD_ASSERT (sgot != NULL && srel != NULL);
3746
3747 rel.r_offset = (sgot->output_section->vma
3748 + sgot->output_offset
3749 + (h->got.offset &~ 1));
3750
3751 /* If this is a -Bsymbolic link, and the symbol is defined
3752 locally, we just want to emit a RELATIVE reloc. Likewise if
3753 the symbol was forced to be local because of a version file.
3754 The entry in the global offset table will already have been
3755 initialized in the relocate_section function. */
3756 if (info->shared
3757 && (info->symbolic || h->dynindx == -1)
3758 && h->def_regular)
3759 {
3760 rel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
3761 rel.r_addend = (h->root.u.def.value
3762 + h->root.u.def.section->output_section->vma
3763 + h->root.u.def.section->output_offset);
3764 }
3765 else
3766 {
3767 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3768 rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_GLOB_DAT64);
3769 rel.r_addend = 0;
3770 }
3771
3772 loc = srel->contents;
3773 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
3774 bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3775 }
3776
3777 if (h->needs_copy)
3778 {
3779 asection *s;
3780 Elf_Internal_Rela rel;
3781 bfd_byte *loc;
3782
3783 /* This symbol needs a copy reloc. Set it up. */
3784
3785 BFD_ASSERT (h->dynindx != -1
3786 && (h->root.type == bfd_link_hash_defined
3787 || h->root.type == bfd_link_hash_defweak));
3788
3789 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3790 ".rela.bss");
3791 BFD_ASSERT (s != NULL);
3792
3793 rel.r_offset = (h->root.u.def.value
3794 + h->root.u.def.section->output_section->vma
3795 + h->root.u.def.section->output_offset);
3796 rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_COPY64);
3797 rel.r_addend = 0;
3798 loc = s->contents;
3799 loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
3800 bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3801 }
3802
3803 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3804 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3805 || h == elf_hash_table (info)->hgot)
3806 sym->st_shndx = SHN_ABS;
3807
3808 return TRUE;
3809 }
3810
3811 /* Finish up the dynamic sections. */
3812
3813 static bfd_boolean
3814 sh64_elf64_finish_dynamic_sections (bfd *output_bfd,
3815 struct bfd_link_info *info)
3816 {
3817 bfd *dynobj;
3818 asection *sgot;
3819 asection *sdyn;
3820
3821 dynobj = elf_hash_table (info)->dynobj;
3822
3823 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3824 BFD_ASSERT (sgot != NULL);
3825 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3826
3827 if (elf_hash_table (info)->dynamic_sections_created)
3828 {
3829 asection *splt;
3830 Elf64_External_Dyn *dyncon, *dynconend;
3831
3832 BFD_ASSERT (sdyn != NULL);
3833
3834 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3835 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3836 for (; dyncon < dynconend; dyncon++)
3837 {
3838 Elf_Internal_Dyn dyn;
3839 const char *name;
3840 asection *s;
3841 struct elf_link_hash_entry *h;
3842
3843 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3844
3845 switch (dyn.d_tag)
3846 {
3847 default:
3848 break;
3849
3850 case DT_INIT:
3851 name = info->init_function;
3852 goto get_sym;
3853
3854 case DT_FINI:
3855 name = info->fini_function;
3856 get_sym:
3857 if (dyn.d_un.d_val != 0)
3858 {
3859 h = elf_link_hash_lookup (elf_hash_table (info), name,
3860 FALSE, FALSE, TRUE);
3861 if (h != NULL && (h->other & STO_SH5_ISA32))
3862 {
3863 dyn.d_un.d_val |= 1;
3864 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3865 }
3866 }
3867 break;
3868
3869 case DT_PLTGOT:
3870 name = ".got";
3871 goto get_vma;
3872
3873 case DT_JMPREL:
3874 name = ".rela.plt";
3875 get_vma:
3876 s = bfd_get_section_by_name (output_bfd, name);
3877 BFD_ASSERT (s != NULL);
3878 dyn.d_un.d_ptr = s->vma;
3879 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3880 break;
3881
3882 case DT_PLTRELSZ:
3883 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3884 BFD_ASSERT (s != NULL);
3885 dyn.d_un.d_val = s->size;
3886 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3887 break;
3888
3889 case DT_RELASZ:
3890 /* My reading of the SVR4 ABI indicates that the
3891 procedure linkage table relocs (DT_JMPREL) should be
3892 included in the overall relocs (DT_RELA). This is
3893 what Solaris does. However, UnixWare can not handle
3894 that case. Therefore, we override the DT_RELASZ entry
3895 here to make it not include the JMPREL relocs. Since
3896 the linker script arranges for .rela.plt to follow all
3897 other relocation sections, we don't have to worry
3898 about changing the DT_RELA entry. */
3899 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3900 if (s != NULL)
3901 dyn.d_un.d_val -= s->size;
3902 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3903 break;
3904 }
3905 }
3906
3907 /* Fill in the first entry in the procedure linkage table. */
3908 splt = bfd_get_section_by_name (dynobj, ".plt");
3909 if (splt && splt->size > 0)
3910 {
3911 if (info->shared)
3912 {
3913 if (elf_sh64_pic_plt_entry == NULL)
3914 {
3915 elf_sh64_pic_plt_entry = (bfd_big_endian (output_bfd) ?
3916 elf_sh64_pic_plt_entry_be :
3917 elf_sh64_pic_plt_entry_le);
3918 }
3919 memcpy (splt->contents, elf_sh64_pic_plt_entry,
3920 elf_sh64_sizeof_plt (info));
3921 }
3922 else
3923 {
3924 if (elf_sh64_plt0_entry == NULL)
3925 {
3926 elf_sh64_plt0_entry = (bfd_big_endian (output_bfd) ?
3927 elf_sh64_plt0_entry_be :
3928 elf_sh64_plt0_entry_le);
3929 }
3930 memcpy (splt->contents, elf_sh64_plt0_entry, PLT_ENTRY_SIZE);
3931 movi_3shori_putval (output_bfd,
3932 sgot->output_section->vma
3933 + sgot->output_offset,
3934 splt->contents
3935 + elf_sh64_plt0_gotplt_offset (info));
3936 }
3937
3938 /* UnixWare sets the entsize of .plt to 8, although that doesn't
3939 really seem like the right value. */
3940 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 8;
3941 }
3942 }
3943
3944 /* Fill in the first three entries in the global offset table. */
3945 if (sgot->size > 0)
3946 {
3947 if (sdyn == NULL)
3948 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
3949 else
3950 bfd_put_64 (output_bfd,
3951 sdyn->output_section->vma + sdyn->output_offset,
3952 sgot->contents);
3953 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3954 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + 16);
3955 }
3956
3957 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
3958
3959 return TRUE;
3960 }
3961
3962 /* Merge non visibility st_other attribute when the symbol comes from
3963 a dynamic object. */
3964 static void
3965 sh64_elf64_merge_symbol_attribute (struct elf_link_hash_entry *h,
3966 const Elf_Internal_Sym *isym,
3967 bfd_boolean definition,
3968 bfd_boolean dynamic ATTRIBUTE_UNUSED)
3969 {
3970 if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
3971 {
3972 unsigned char other;
3973
3974 /* Take the balance of OTHER from the definition. */
3975 other = (definition ? isym->st_other : h->other);
3976 other &= ~ ELF_ST_VISIBILITY (-1);
3977 h->other = other | ELF_ST_VISIBILITY (h->other);
3978 }
3979
3980 return;
3981 }
3982
3983 static const struct bfd_elf_special_section sh64_elf64_special_sections[]=
3984 {
3985 { STRING_COMMA_LEN (".cranges"), 0, SHT_PROGBITS, 0 },
3986 { NULL, 0, 0, 0, 0 }
3987 };
3988
3989 #define TARGET_BIG_SYM bfd_elf64_sh64_vec
3990 #define TARGET_BIG_NAME "elf64-sh64"
3991 #define TARGET_LITTLE_SYM bfd_elf64_sh64l_vec
3992 #define TARGET_LITTLE_NAME "elf64-sh64l"
3993 #define ELF_ARCH bfd_arch_sh
3994 #define ELF_MACHINE_CODE EM_SH
3995 #define ELF_MAXPAGESIZE 128
3996
3997 #define elf_symbol_leading_char '_'
3998
3999 #define bfd_elf64_bfd_reloc_type_lookup sh_elf64_reloc_type_lookup
4000 #define bfd_elf64_bfd_reloc_name_lookup \
4001 sh_elf64_reloc_name_lookup
4002 #define elf_info_to_howto sh_elf64_info_to_howto
4003
4004 /* Note: there's no relaxation at present. */
4005
4006 #define elf_backend_relocate_section sh_elf64_relocate_section
4007 #define bfd_elf64_bfd_get_relocated_section_contents \
4008 sh_elf64_get_relocated_section_contents
4009 #define elf_backend_object_p sh_elf64_set_mach_from_flags
4010 #define bfd_elf64_bfd_set_private_flags \
4011 sh_elf64_set_private_flags
4012 #define bfd_elf64_bfd_copy_private_bfd_data \
4013 sh_elf64_copy_private_data
4014 #define bfd_elf64_bfd_merge_private_bfd_data \
4015 sh_elf64_merge_private_data
4016 #define elf_backend_fake_sections sh64_elf64_fake_sections
4017
4018 #define elf_backend_gc_mark_hook sh_elf64_gc_mark_hook
4019 #define elf_backend_check_relocs sh_elf64_check_relocs
4020
4021 #define elf_backend_can_gc_sections 1
4022
4023 #define elf_backend_get_symbol_type sh64_elf64_get_symbol_type
4024
4025 #define elf_backend_add_symbol_hook sh64_elf64_add_symbol_hook
4026
4027 #define elf_backend_link_output_symbol_hook \
4028 sh64_elf64_link_output_symbol_hook
4029
4030 #define elf_backend_merge_symbol_attribute \
4031 sh64_elf64_merge_symbol_attribute
4032
4033 #define elf_backend_final_write_processing \
4034 sh64_elf64_final_write_processing
4035
4036 #define elf_backend_create_dynamic_sections \
4037 sh64_elf64_create_dynamic_sections
4038 #define bfd_elf64_bfd_link_hash_table_create \
4039 sh64_elf64_link_hash_table_create
4040 #define elf_backend_adjust_dynamic_symbol \
4041 sh64_elf64_adjust_dynamic_symbol
4042 #define elf_backend_size_dynamic_sections \
4043 sh64_elf64_size_dynamic_sections
4044 #define elf_backend_omit_section_dynsym \
4045 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4046 #define elf_backend_finish_dynamic_symbol \
4047 sh64_elf64_finish_dynamic_symbol
4048 #define elf_backend_finish_dynamic_sections \
4049 sh64_elf64_finish_dynamic_sections
4050 #define elf_backend_special_sections sh64_elf64_special_sections
4051
4052 #define elf_backend_want_got_plt 1
4053 #define elf_backend_plt_readonly 1
4054 #define elf_backend_want_plt_sym 0
4055 #define elf_backend_got_header_size 24
4056
4057 #include "elf64-target.h"
4058
4059 /* NetBSD support. */
4060 #undef TARGET_BIG_SYM
4061 #define TARGET_BIG_SYM bfd_elf64_sh64nbsd_vec
4062 #undef TARGET_BIG_NAME
4063 #define TARGET_BIG_NAME "elf64-sh64-nbsd"
4064 #undef TARGET_LITTLE_SYM
4065 #define TARGET_LITTLE_SYM bfd_elf64_sh64lnbsd_vec
4066 #undef TARGET_LITTLE_NAME
4067 #define TARGET_LITTLE_NAME "elf64-sh64l-nbsd"
4068 #undef ELF_MAXPAGESIZE
4069 #define ELF_MAXPAGESIZE 0x10000
4070 #undef elf_symbol_leading_char
4071 #define elf_symbol_leading_char 0
4072
4073 #define elf64_bed elf64_sh64_nbsd_bed
4074
4075 #include "elf64-target.h"
4076
4077 /* Linux support. */
4078 #undef TARGET_BIG_SYM
4079 #define TARGET_BIG_SYM bfd_elf64_sh64blin_vec
4080 #undef TARGET_BIG_NAME
4081 #define TARGET_BIG_NAME "elf64-sh64big-linux"
4082 #undef TARGET_LITTLE_SYM
4083 #define TARGET_LITTLE_SYM bfd_elf64_sh64lin_vec
4084 #undef TARGET_LITTLE_NAME
4085 #define TARGET_LITTLE_NAME "elf64-sh64-linux"
4086 #undef elf64_bed
4087 #define elf64_bed elf64_sh64_linux_bed
4088
4089 #include "elf64-target.h"
git-cvsimport of binutils cvsroot