bfd/
[deliverable/binutils-gdb.git] / bfd / elf64-sh64.c
CommitLineData
ef230218 1/* SuperH SH64-specific support for 64-bit ELF
4dfe6ac6
NC
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3 2010 Free Software Foundation, Inc.
fbca6ad9
AO
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
cd123cb7 9 the Free Software Foundation; either version 3 of the License, or
fbca6ad9
AO
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
cd123cb7
NC
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
fbca6ad9
AO
21
22#define SH64_ELF64
23
fbca6ad9 24#include "sysdep.h"
3db64b00 25#include "bfd.h"
fbca6ad9
AO
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
70struct 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
82struct 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. */
518313c3 89 struct elf_sh64_pcrel_relocs_copied *pcrel_relocs_copied;
fbca6ad9
AO
90};
91
fbca6ad9
AO
92/* Traverse an sh ELF linker hash table. */
93
4dfe6ac6
NC
94#define sh64_elf64_link_hash_traverse(table, func, info) \
95 (elf_link_hash_traverse \
96 ((table), \
09fd220b 97 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
fbca6ad9
AO
98 (info)))
99
fbca6ad9 100static bfd_reloc_status_type sh_elf64_ignore_reloc
09fd220b 101 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
fbca6ad9 102static bfd_reloc_status_type sh_elf64_reloc
09fd220b 103 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
fbca6ad9
AO
104
105static 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 */
b34976b6 111 FALSE, /* pc_relative */
fbca6ad9
AO
112 0, /* bitpos */
113 complain_overflow_dont, /* complain_on_overflow */
114 sh_elf64_ignore_reloc, /* special_function */
115 "R_SH_NONE", /* name */
b34976b6 116 FALSE, /* partial_inplace */
fbca6ad9
AO
117 0, /* src_mask */
118 0, /* dst_mask */
b34976b6 119 FALSE), /* pcrel_offset */
fbca6ad9 120
b34976b6 121 /* 32 bit absolute relocation. Setting partial_inplace to TRUE and
fbca6ad9
AO
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 */
b34976b6 127 FALSE, /* pc_relative */
fbca6ad9
AO
128 0, /* bitpos */
129 complain_overflow_bitfield, /* complain_on_overflow */
130 sh_elf64_reloc, /* special_function */
131 "R_SH_DIR32", /* name */
b34976b6 132 TRUE, /* partial_inplace */
fbca6ad9
AO
133 0xffffffff, /* src_mask */
134 0xffffffff, /* dst_mask */
b34976b6 135 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 142 TRUE, /* pc_relative */
fbca6ad9
AO
143 0, /* bitpos */
144 complain_overflow_signed, /* complain_on_overflow */
145 sh_elf64_ignore_reloc, /* special_function */
146 "R_SH_REL32", /* name */
b34976b6 147 FALSE, /* partial_inplace */
fbca6ad9
AO
148 0, /* src_mask */
149 0xffffffff, /* dst_mask */
b34976b6 150 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 201 FALSE, /* pc_relative */
fbca6ad9
AO
202 0, /* bitpos */
203 complain_overflow_unsigned, /* complain_on_overflow */
204 sh_elf64_ignore_reloc, /* special_function */
205 "R_SH_SWITCH16", /* name */
b34976b6 206 FALSE, /* partial_inplace */
fbca6ad9
AO
207 0, /* src_mask */
208 0, /* dst_mask */
b34976b6 209 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 218 FALSE, /* pc_relative */
fbca6ad9
AO
219 0, /* bitpos */
220 complain_overflow_unsigned, /* complain_on_overflow */
221 sh_elf64_ignore_reloc, /* special_function */
222 "R_SH_SWITCH32", /* name */
b34976b6 223 FALSE, /* partial_inplace */
fbca6ad9
AO
224 0, /* src_mask */
225 0, /* dst_mask */
b34976b6 226 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 261 FALSE, /* pc_relative */
fbca6ad9
AO
262 0, /* bitpos */
263 complain_overflow_unsigned, /* complain_on_overflow */
264 sh_elf64_ignore_reloc, /* special_function */
265 "R_SH_SWITCH8", /* name */
b34976b6 266 FALSE, /* partial_inplace */
fbca6ad9
AO
267 0, /* src_mask */
268 0, /* dst_mask */
b34976b6 269 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 276 FALSE, /* pc_relative */
fbca6ad9
AO
277 0, /* bitpos */
278 complain_overflow_dont, /* complain_on_overflow */
279 NULL, /* special_function */
280 "R_SH_GNU_VTINHERIT", /* name */
b34976b6 281 FALSE, /* partial_inplace */
fbca6ad9
AO
282 0, /* src_mask */
283 0, /* dst_mask */
b34976b6 284 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 291 FALSE, /* pc_relative */
fbca6ad9
AO
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 */
b34976b6 296 FALSE, /* partial_inplace */
fbca6ad9
AO
297 0, /* src_mask */
298 0, /* dst_mask */
b34976b6 299 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 320 FALSE, /* pc_relative */
fbca6ad9
AO
321 10, /* bitpos */
322 complain_overflow_unsigned, /* complain_on_overflow */
323 bfd_elf_generic_reloc, /* special_function */
324 "R_SH_DIR5U", /* name */
b34976b6 325 FALSE, /* partial_inplace */
fbca6ad9
AO
326 0, /* src_mask */
327 0xfc00, /* dst_mask */
b34976b6 328 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 335 FALSE, /* pc_relative */
fbca6ad9
AO
336 10, /* bitpos */
337 complain_overflow_unsigned, /* complain_on_overflow */
338 bfd_elf_generic_reloc, /* special_function */
339 "R_SH_DIR6U", /* name */
b34976b6 340 FALSE, /* partial_inplace */
fbca6ad9
AO
341 0, /* src_mask */
342 0xfc00, /* dst_mask */
b34976b6 343 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 350 FALSE, /* pc_relative */
fbca6ad9
AO
351 10, /* bitpos */
352 complain_overflow_signed, /* complain_on_overflow */
353 bfd_elf_generic_reloc, /* special_function */
354 "R_SH_DIR6S", /* name */
b34976b6 355 FALSE, /* partial_inplace */
fbca6ad9
AO
356 0, /* src_mask */
357 0xfc00, /* dst_mask */
b34976b6 358 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 365 FALSE, /* pc_relative */
fbca6ad9
AO
366 10, /* bitpos */
367 complain_overflow_signed, /* complain_on_overflow */
368 bfd_elf_generic_reloc, /* special_function */
369 "R_SH_DIR10S", /* name */
b34976b6 370 FALSE, /* partial_inplace */
fbca6ad9
AO
371 0, /* src_mask */
372 0xffc00, /* dst_mask */
b34976b6 373 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 380 FALSE, /* pc_relative */
fbca6ad9
AO
381 10, /* bitpos */
382 complain_overflow_signed, /* complain_on_overflow */
383 bfd_elf_generic_reloc, /* special_function */
384 "R_SH_DIR10SW", /* name */
b34976b6 385 FALSE, /* partial_inplace */
fbca6ad9
AO
386 0, /* src_mask */
387 0xffc00, /* dst_mask */
b34976b6 388 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 395 FALSE, /* pc_relative */
fbca6ad9
AO
396 10, /* bitpos */
397 complain_overflow_signed, /* complain_on_overflow */
398 bfd_elf_generic_reloc, /* special_function */
399 "R_SH_DIR10SL", /* name */
b34976b6 400 FALSE, /* partial_inplace */
fbca6ad9
AO
401 0, /* src_mask */
402 0xffc00, /* dst_mask */
b34976b6 403 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 410 FALSE, /* pc_relative */
fbca6ad9
AO
411 10, /* bitpos */
412 complain_overflow_signed, /* complain_on_overflow */
413 bfd_elf_generic_reloc, /* special_function */
414 "R_SH_DIR10SQ", /* name */
b34976b6 415 FALSE, /* partial_inplace */
fbca6ad9
AO
416 0, /* src_mask */
417 0xffc00, /* dst_mask */
b34976b6 418 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 548 FALSE, /* pc_relative */
fbca6ad9
AO
549 10, /* bitpos */
550 complain_overflow_dont, /* complain_on_overflow */
551 bfd_elf_generic_reloc, /* special_function */
552 "R_SH_GOT_LOW16", /* name */
b34976b6 553 FALSE, /* partial_inplace */
fbca6ad9
AO
554 0, /* src_mask */
555 0x3fffc00, /* dst_mask */
b34976b6 556 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 563 FALSE, /* pc_relative */
fbca6ad9
AO
564 10, /* bitpos */
565 complain_overflow_dont, /* complain_on_overflow */
566 bfd_elf_generic_reloc, /* special_function */
567 "R_SH_GOT_MEDLOW16", /* name */
b34976b6 568 FALSE, /* partial_inplace */
fbca6ad9
AO
569 0, /* src_mask */
570 0x3fffc00, /* dst_mask */
b34976b6 571 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 578 FALSE, /* pc_relative */
fbca6ad9
AO
579 10, /* bitpos */
580 complain_overflow_dont, /* complain_on_overflow */
581 bfd_elf_generic_reloc, /* special_function */
582 "R_SH_GOT_MEDHI16", /* name */
b34976b6 583 FALSE, /* partial_inplace */
fbca6ad9
AO
584 0, /* src_mask */
585 0x3fffc00, /* dst_mask */
b34976b6 586 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 593 FALSE, /* pc_relative */
fbca6ad9
AO
594 10, /* bitpos */
595 complain_overflow_dont, /* complain_on_overflow */
596 bfd_elf_generic_reloc, /* special_function */
597 "R_SH_GOT_HI16", /* name */
b34976b6 598 FALSE, /* partial_inplace */
fbca6ad9
AO
599 0, /* src_mask */
600 0x3fffc00, /* dst_mask */
b34976b6 601 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 608 FALSE, /* pc_relative */
fbca6ad9
AO
609 10, /* bitpos */
610 complain_overflow_dont, /* complain_on_overflow */
611 bfd_elf_generic_reloc, /* special_function */
612 "R_SH_GOTPLT_LOW16", /* name */
b34976b6 613 FALSE, /* partial_inplace */
fbca6ad9
AO
614 0, /* src_mask */
615 0x3fffc00, /* dst_mask */
b34976b6 616 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 623 FALSE, /* pc_relative */
fbca6ad9
AO
624 10, /* bitpos */
625 complain_overflow_dont, /* complain_on_overflow */
626 bfd_elf_generic_reloc, /* special_function */
627 "R_SH_GOTPLT_MEDLOW16", /* name */
b34976b6 628 FALSE, /* partial_inplace */
fbca6ad9
AO
629 0, /* src_mask */
630 0x3fffc00, /* dst_mask */
b34976b6 631 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 638 FALSE, /* pc_relative */
fbca6ad9
AO
639 10, /* bitpos */
640 complain_overflow_dont, /* complain_on_overflow */
641 bfd_elf_generic_reloc, /* special_function */
642 "R_SH_GOTPLT_MEDHI16", /* name */
b34976b6 643 FALSE, /* partial_inplace */
fbca6ad9
AO
644 0, /* src_mask */
645 0x3fffc00, /* dst_mask */
b34976b6 646 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 653 FALSE, /* pc_relative */
fbca6ad9
AO
654 10, /* bitpos */
655 complain_overflow_dont, /* complain_on_overflow */
656 bfd_elf_generic_reloc, /* special_function */
657 "R_SH_GOTPLT_HI16", /* name */
b34976b6 658 FALSE, /* partial_inplace */
fbca6ad9
AO
659 0, /* src_mask */
660 0x3fffc00, /* dst_mask */
b34976b6 661 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 668 TRUE, /* pc_relative */
fbca6ad9
AO
669 10, /* bitpos */
670 complain_overflow_dont, /* complain_on_overflow */
671 bfd_elf_generic_reloc, /* special_function */
672 "R_SH_PLT_LOW16", /* name */
b34976b6 673 FALSE, /* partial_inplace */
fbca6ad9
AO
674 0, /* src_mask */
675 0x3fffc00, /* dst_mask */
b34976b6 676 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 683 TRUE, /* pc_relative */
fbca6ad9
AO
684 10, /* bitpos */
685 complain_overflow_dont, /* complain_on_overflow */
686 bfd_elf_generic_reloc, /* special_function */
687 "R_SH_PLT_MEDLOW16", /* name */
b34976b6 688 FALSE, /* partial_inplace */
fbca6ad9
AO
689 0, /* src_mask */
690 0x3fffc00, /* dst_mask */
b34976b6 691 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 698 TRUE, /* pc_relative */
fbca6ad9
AO
699 10, /* bitpos */
700 complain_overflow_dont, /* complain_on_overflow */
701 bfd_elf_generic_reloc, /* special_function */
702 "R_SH_PLT_MEDHI16", /* name */
b34976b6 703 FALSE, /* partial_inplace */
fbca6ad9
AO
704 0, /* src_mask */
705 0x3fffc00, /* dst_mask */
b34976b6 706 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 713 TRUE, /* pc_relative */
fbca6ad9
AO
714 10, /* bitpos */
715 complain_overflow_dont, /* complain_on_overflow */
716 bfd_elf_generic_reloc, /* special_function */
717 "R_SH_PLT_HI16", /* name */
b34976b6 718 FALSE, /* partial_inplace */
fbca6ad9
AO
719 0, /* src_mask */
720 0x3fffc00, /* dst_mask */
b34976b6 721 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 728 FALSE, /* pc_relative */
fbca6ad9
AO
729 10, /* bitpos */
730 complain_overflow_dont, /* complain_on_overflow */
731 bfd_elf_generic_reloc, /* special_function */
732 "R_SH_GOTOFF_LOW16", /* name */
b34976b6 733 FALSE, /* partial_inplace */
fbca6ad9
AO
734 0, /* src_mask */
735 0x3fffc00, /* dst_mask */
b34976b6 736 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 743 FALSE, /* pc_relative */
fbca6ad9
AO
744 10, /* bitpos */
745 complain_overflow_dont, /* complain_on_overflow */
746 bfd_elf_generic_reloc, /* special_function */
747 "R_SH_GOTOFF_MEDLOW16", /* name */
b34976b6 748 FALSE, /* partial_inplace */
fbca6ad9
AO
749 0, /* src_mask */
750 0x3fffc00, /* dst_mask */
b34976b6 751 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 758 FALSE, /* pc_relative */
fbca6ad9
AO
759 10, /* bitpos */
760 complain_overflow_dont, /* complain_on_overflow */
761 bfd_elf_generic_reloc, /* special_function */
762 "R_SH_GOTOFF_MEDHI16", /* name */
b34976b6 763 FALSE, /* partial_inplace */
fbca6ad9
AO
764 0, /* src_mask */
765 0x3fffc00, /* dst_mask */
b34976b6 766 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 773 FALSE, /* pc_relative */
fbca6ad9
AO
774 10, /* bitpos */
775 complain_overflow_dont, /* complain_on_overflow */
776 bfd_elf_generic_reloc, /* special_function */
777 "R_SH_GOTOFF_HI16", /* name */
b34976b6 778 FALSE, /* partial_inplace */
fbca6ad9
AO
779 0, /* src_mask */
780 0x3fffc00, /* dst_mask */
b34976b6 781 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 788 TRUE, /* pc_relative */
fbca6ad9
AO
789 10, /* bitpos */
790 complain_overflow_dont, /* complain_on_overflow */
791 bfd_elf_generic_reloc, /* special_function */
792 "R_SH_GOTPC_LOW16", /* name */
b34976b6 793 FALSE, /* partial_inplace */
fbca6ad9
AO
794 0, /* src_mask */
795 0x3fffc00, /* dst_mask */
b34976b6 796 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 803 TRUE, /* pc_relative */
fbca6ad9
AO
804 10, /* bitpos */
805 complain_overflow_dont, /* complain_on_overflow */
806 bfd_elf_generic_reloc, /* special_function */
807 "R_SH_GOTPC_MEDLOW16", /* name */
b34976b6 808 FALSE, /* partial_inplace */
fbca6ad9
AO
809 0, /* src_mask */
810 0x3fffc00, /* dst_mask */
b34976b6 811 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 818 TRUE, /* pc_relative */
fbca6ad9
AO
819 10, /* bitpos */
820 complain_overflow_dont, /* complain_on_overflow */
821 bfd_elf_generic_reloc, /* special_function */
822 "R_SH_GOTPC_MEDHI16", /* name */
b34976b6 823 FALSE, /* partial_inplace */
fbca6ad9
AO
824 0, /* src_mask */
825 0x3fffc00, /* dst_mask */
b34976b6 826 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 833 TRUE, /* pc_relative */
fbca6ad9
AO
834 10, /* bitpos */
835 complain_overflow_dont, /* complain_on_overflow */
836 bfd_elf_generic_reloc, /* special_function */
837 "R_SH_GOTPC_HI16", /* name */
b34976b6 838 FALSE, /* partial_inplace */
fbca6ad9
AO
839 0, /* src_mask */
840 0x3fffc00, /* dst_mask */
b34976b6 841 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 848 FALSE, /* pc_relative */
fbca6ad9
AO
849 10, /* bitpos */
850 complain_overflow_signed, /* complain_on_overflow */
851 bfd_elf_generic_reloc, /* special_function */
852 "R_SH_GOT10BY4", /* name */
b34976b6 853 FALSE, /* partial_inplace */
fbca6ad9
AO
854 0, /* src_mask */
855 0xffc00, /* dst_mask */
b34976b6 856 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 863 FALSE, /* pc_relative */
fbca6ad9
AO
864 10, /* bitpos */
865 complain_overflow_signed, /* complain_on_overflow */
866 bfd_elf_generic_reloc, /* special_function */
867 "R_SH_GOTPLT10BY4", /* name */
b34976b6 868 FALSE, /* partial_inplace */
fbca6ad9
AO
869 0, /* src_mask */
870 0xffc00, /* dst_mask */
b34976b6 871 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 878 FALSE, /* pc_relative */
fbca6ad9
AO
879 10, /* bitpos */
880 complain_overflow_signed, /* complain_on_overflow */
881 bfd_elf_generic_reloc, /* special_function */
882 "R_SH_GOT10BY8", /* name */
b34976b6 883 FALSE, /* partial_inplace */
fbca6ad9
AO
884 0, /* src_mask */
885 0xffc00, /* dst_mask */
b34976b6 886 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 893 FALSE, /* pc_relative */
fbca6ad9
AO
894 10, /* bitpos */
895 complain_overflow_signed, /* complain_on_overflow */
896 bfd_elf_generic_reloc, /* special_function */
897 "R_SH_GOTPLT10BY8", /* name */
b34976b6 898 FALSE, /* partial_inplace */
fbca6ad9
AO
899 0, /* src_mask */
900 0xffc00, /* dst_mask */
b34976b6 901 FALSE), /* pcrel_offset */
fbca6ad9
AO
902
903 HOWTO (R_SH_COPY64, /* type */
904 0, /* rightshift */
905 4, /* size (0 = byte, 1 = short, 2 = long) */
906 64, /* bitsize */
b34976b6 907 FALSE, /* pc_relative */
fbca6ad9
AO
908 0, /* bitpos */
909 complain_overflow_dont, /* complain_on_overflow */
910 bfd_elf_generic_reloc, /* special_function */
911 "R_SH_COPY64", /* name */
b34976b6 912 FALSE, /* partial_inplace */
fbca6ad9
AO
913 0, /* src_mask */
914 ((bfd_vma) 0) - 1, /* dst_mask */
b34976b6 915 FALSE), /* pcrel_offset */
fbca6ad9
AO
916
917 HOWTO (R_SH_GLOB_DAT64, /* type */
918 0, /* rightshift */
919 4, /* size (0 = byte, 1 = short, 2 = long) */
920 64, /* bitsize */
b34976b6 921 FALSE, /* pc_relative */
fbca6ad9
AO
922 0, /* bitpos */
923 complain_overflow_dont, /* complain_on_overflow */
924 bfd_elf_generic_reloc, /* special_function */
925 "R_SH_GLOB_DAT64", /* name */
b34976b6 926 FALSE, /* partial_inplace */
fbca6ad9
AO
927 0, /* src_mask */
928 ((bfd_vma) 0) - 1, /* dst_mask */
b34976b6 929 FALSE), /* pcrel_offset */
fbca6ad9
AO
930
931 HOWTO (R_SH_JMP_SLOT64, /* type */
932 0, /* rightshift */
933 4, /* size (0 = byte, 1 = short, 2 = long) */
934 64, /* bitsize */
b34976b6 935 FALSE, /* pc_relative */
fbca6ad9
AO
936 0, /* bitpos */
937 complain_overflow_dont, /* complain_on_overflow */
938 bfd_elf_generic_reloc, /* special_function */
939 "R_SH_JMP_SLOT64", /* name */
b34976b6 940 FALSE, /* partial_inplace */
fbca6ad9
AO
941 0, /* src_mask */
942 ((bfd_vma) 0) - 1, /* dst_mask */
b34976b6 943 FALSE), /* pcrel_offset */
fbca6ad9
AO
944
945 HOWTO (R_SH_RELATIVE64, /* type */
946 0, /* rightshift */
947 4, /* size (0 = byte, 1 = short, 2 = long) */
948 64, /* bitsize */
b34976b6 949 FALSE, /* pc_relative */
fbca6ad9
AO
950 0, /* bitpos */
951 complain_overflow_dont, /* complain_on_overflow */
952 bfd_elf_generic_reloc, /* special_function */
953 "R_SH_RELATIVE64", /* name */
b34976b6 954 FALSE, /* partial_inplace */
fbca6ad9
AO
955 0, /* src_mask */
956 ((bfd_vma) 0) - 1, /* dst_mask */
b34976b6 957 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1018 FALSE, /* pc_relative */
fbca6ad9
AO
1019 0, /* bitpos */
1020 complain_overflow_unsigned, /* complain_on_overflow */
1021 sh_elf64_ignore_reloc, /* special_function */
1022 "R_SH_SHMEDIA_CODE", /* name */
b34976b6 1023 FALSE, /* partial_inplace */
fbca6ad9
AO
1024 0, /* src_mask */
1025 0, /* dst_mask */
b34976b6 1026 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1035 TRUE, /* pc_relative */
fbca6ad9
AO
1036 10, /* bitpos */
1037 complain_overflow_signed, /* complain_on_overflow */
1038 bfd_elf_generic_reloc, /* special_function */
1039 "R_SH_PT_16", /* name */
b34976b6 1040 FALSE, /* partial_inplace */
fbca6ad9
AO
1041 0, /* src_mask */
1042 0x3fffc00, /* dst_mask */
b34976b6 1043 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1050 FALSE, /* pc_relative */
fbca6ad9
AO
1051 10, /* bitpos */
1052 complain_overflow_signed, /* complain_on_overflow */
1053 bfd_elf_generic_reloc, /* special_function */
1054 "R_SH_IMMS16", /* name */
b34976b6 1055 FALSE, /* partial_inplace */
fbca6ad9
AO
1056 0, /* src_mask */
1057 0x3fffc00, /* dst_mask */
b34976b6 1058 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1065 FALSE, /* pc_relative */
fbca6ad9
AO
1066 10, /* bitpos */
1067 complain_overflow_unsigned, /* complain_on_overflow */
1068 bfd_elf_generic_reloc, /* special_function */
1069 "R_SH_IMMU16", /* name */
b34976b6 1070 FALSE, /* partial_inplace */
fbca6ad9
AO
1071 0, /* src_mask */
1072 0x3fffc00, /* dst_mask */
b34976b6 1073 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1080 FALSE, /* pc_relative */
fbca6ad9
AO
1081 10, /* bitpos */
1082 complain_overflow_dont, /* complain_on_overflow */
1083 bfd_elf_generic_reloc, /* special_function */
1084 "R_SH_IMM_LOW16", /* name */
b34976b6 1085 FALSE, /* partial_inplace */
fbca6ad9
AO
1086 0, /* src_mask */
1087 0x3fffc00, /* dst_mask */
b34976b6 1088 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1095 TRUE, /* pc_relative */
fbca6ad9
AO
1096 10, /* bitpos */
1097 complain_overflow_dont, /* complain_on_overflow */
1098 bfd_elf_generic_reloc, /* special_function */
1099 "R_SH_IMM_LOW16_PCREL", /* name */
b34976b6 1100 FALSE, /* partial_inplace */
fbca6ad9
AO
1101 0, /* src_mask */
1102 0x3fffc00, /* dst_mask */
b34976b6 1103 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1110 FALSE, /* pc_relative */
fbca6ad9
AO
1111 10, /* bitpos */
1112 complain_overflow_dont, /* complain_on_overflow */
1113 bfd_elf_generic_reloc, /* special_function */
1114 "R_SH_IMM_MEDLOW16", /* name */
b34976b6 1115 FALSE, /* partial_inplace */
fbca6ad9
AO
1116 0, /* src_mask */
1117 0x3fffc00, /* dst_mask */
b34976b6 1118 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1125 TRUE, /* pc_relative */
fbca6ad9
AO
1126 10, /* bitpos */
1127 complain_overflow_dont, /* complain_on_overflow */
1128 bfd_elf_generic_reloc, /* special_function */
1129 "R_SH_IMM_MEDLOW16_PCREL", /* name */
b34976b6 1130 FALSE, /* partial_inplace */
fbca6ad9
AO
1131 0, /* src_mask */
1132 0x3fffc00, /* dst_mask */
b34976b6 1133 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1140 FALSE, /* pc_relative */
fbca6ad9
AO
1141 10, /* bitpos */
1142 complain_overflow_dont, /* complain_on_overflow */
1143 bfd_elf_generic_reloc, /* special_function */
1144 "R_SH_IMM_MEDHI16", /* name */
b34976b6 1145 FALSE, /* partial_inplace */
fbca6ad9
AO
1146 0, /* src_mask */
1147 0x3fffc00, /* dst_mask */
b34976b6 1148 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1155 TRUE, /* pc_relative */
fbca6ad9
AO
1156 10, /* bitpos */
1157 complain_overflow_dont, /* complain_on_overflow */
1158 bfd_elf_generic_reloc, /* special_function */
1159 "R_SH_IMM_MEDHI16_PCREL", /* name */
b34976b6 1160 FALSE, /* partial_inplace */
fbca6ad9
AO
1161 0, /* src_mask */
1162 0x3fffc00, /* dst_mask */
b34976b6 1163 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1170 FALSE, /* pc_relative */
fbca6ad9
AO
1171 10, /* bitpos */
1172 complain_overflow_dont, /* complain_on_overflow */
1173 bfd_elf_generic_reloc, /* special_function */
1174 "R_SH_IMM_HI16", /* name */
b34976b6 1175 FALSE, /* partial_inplace */
fbca6ad9
AO
1176 0, /* src_mask */
1177 0x3fffc00, /* dst_mask */
b34976b6 1178 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1185 TRUE, /* pc_relative */
fbca6ad9
AO
1186 10, /* bitpos */
1187 complain_overflow_dont, /* complain_on_overflow */
1188 bfd_elf_generic_reloc, /* special_function */
1189 "R_SH_IMM_HI16_PCREL", /* name */
b34976b6 1190 FALSE, /* partial_inplace */
fbca6ad9
AO
1191 0, /* src_mask */
1192 0x3fffc00, /* dst_mask */
b34976b6 1193 TRUE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1200 FALSE, /* pc_relative */
fbca6ad9
AO
1201 0, /* bitpos */
1202 complain_overflow_dont, /* complain_on_overflow */
1203 bfd_elf_generic_reloc, /* special_function */
1204 "R_SH_64", /* name */
b34976b6 1205 FALSE, /* partial_inplace */
fbca6ad9
AO
1206 0, /* src_mask */
1207 ((bfd_vma) 0) - 1, /* dst_mask */
b34976b6 1208 FALSE), /* pcrel_offset */
fbca6ad9
AO
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 */
b34976b6 1215 TRUE, /* pc_relative */
fbca6ad9
AO
1216 10, /* bitpos */
1217 complain_overflow_dont, /* complain_on_overflow */
1218 bfd_elf_generic_reloc, /* special_function */
1219 "R_SH_64_PCREL", /* name */
b34976b6 1220 FALSE, /* partial_inplace */
fbca6ad9
AO
1221 0, /* src_mask */
1222 ((bfd_vma) 0) - 1, /* dst_mask */
b34976b6 1223 TRUE), /* pcrel_offset */
fbca6ad9
AO
1224
1225};
1226
1227/* This function is used for relocs which are only used for relaxing,
1228 which the linker should otherwise ignore. */
1229
1230static bfd_reloc_status_type
09fd220b
KK
1231sh_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)
fbca6ad9
AO
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
1247static bfd_reloc_status_type
09fd220b
KK
1248sh_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)
fbca6ad9
AO
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))
cedb70c5
KH
1272 sym_value = 0;
1273 else
fbca6ad9
AO
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
1296struct 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
1304static 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
1369static reloc_howto_type *
09fd220b
KK
1370sh_elf64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1371 bfd_reloc_code_real_type code)
fbca6ad9
AO
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
157090f7
AM
1384static reloc_howto_type *
1385sh_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
fbca6ad9
AO
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
1404static void
09fd220b
KK
1405sh_elf64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
1406 Elf_Internal_Rela *dst)
fbca6ad9
AO
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
b34976b6 1425static bfd_boolean
09fd220b
KK
1426sh_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)
fbca6ad9
AO
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
0c72ffe0
KK
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
fbca6ad9
AO
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);
b34976b6 1490 return FALSE;
fbca6ad9
AO
1491 }
1492
1493 howto = sh_elf64_howto_table + r_type;
1494
fbca6ad9
AO
1495 h = NULL;
1496 sym = NULL;
1497 sec = NULL;
ab96bf03 1498 relocation = 0;
fbca6ad9
AO
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
ab96bf03
AM
1517 if (sec != NULL && elf_discarded_section (sec))
1518 /* Handled below. */
1519 ;
1520 else if (info->relocatable)
fbca6ad9 1521 {
1049f94e 1522 /* This is a relocatable link. We don't have to change
fbca6ad9
AO
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. */
fbca6ad9
AO
1526 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1527 goto final_link_relocate;
1528
1529 continue;
1530 }
a0087177
JW
1531 else if (! howto->partial_inplace)
1532 {
8517fae7 1533 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
a0087177
JW
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)
d003868e
AM
1544 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
1545 input_bfd, input_section,
a0087177 1546 (long) rel->r_offset, howto->name);
b34976b6 1547 return FALSE;
a0087177
JW
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 }
fbca6ad9
AO
1559 }
1560 else
1561 {
560e09e9
NC
1562 /* ??? Could we use the RELOC_FOR_GLOBAL_SYMBOL macro here ? */
1563
fbca6ad9
AO
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
cedb70c5 1581 sec->output_section will be NULL. */
fbca6ad9
AO
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)
f5385ebf 1598 || !h->def_regular))
fbca6ad9
AO
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)
f5385ebf 1606 || !h->def_regular)
fbca6ad9
AO
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. */
1448fa32
KK
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
f5385ebf 1622 && h->def_dynamic)))
ab96bf03
AM
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)
fbca6ad9
AO
1634 {
1635 (*_bfd_error_handler)
843fe662
L
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);
fbca6ad9 1642 }
fbca6ad9
AO
1643 }
1644 else if (h->root.type == bfd_link_hash_undefweak)
ab96bf03 1645 ;
59c2e50f
L
1646 else if (info->unresolved_syms_in_objects == RM_IGNORE
1647 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
ab96bf03
AM
1648 ;
1649 else if (!info->relocatable)
fbca6ad9
AO
1650 {
1651 if (! ((*info->callbacks->undefined_symbol)
1652 (info, h->root.root.string, input_bfd,
59c2e50f
L
1653 input_section, rel->r_offset,
1654 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1655 || ELF_ST_VISIBILITY (h->other)))))
b34976b6 1656 return FALSE;
fbca6ad9
AO
1657 }
1658 }
1659
ab96bf03 1660 if (sec != NULL && elf_discarded_section (sec))
e4067dbb
DJ
1661 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1662 rel, relend, howto, contents);
ab96bf03
AM
1663
1664 if (info->relocatable)
1665 continue;
1666
fbca6ad9
AO
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);
b34976b6 1685 return FALSE;
fbca6ad9
AO
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
f5385ebf 1697 || !h->def_regular))))
fbca6ad9
AO
1698 {
1699 Elf_Internal_Rela outrel;
947216bf 1700 bfd_byte *loc;
b34976b6 1701 bfd_boolean skip, relocate;
fbca6ad9
AO
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 {
83bac4b0
NC
1709 sreloc = _bfd_elf_get_dynamic_reloc_section
1710 (input_bfd, input_section, /*rela?*/ TRUE);
1711 if (sreloc == NULL)
b34976b6 1712 return FALSE;
fbca6ad9
AO
1713 }
1714
b34976b6
AM
1715 skip = FALSE;
1716 relocate = FALSE;
fbca6ad9
AO
1717
1718 outrel.r_offset
518313c3
AO
1719 = _bfd_elf_section_offset (output_bfd, info,
1720 input_section, rel->r_offset);
fbca6ad9
AO
1721
1722 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 1723 skip = TRUE;
0fb19cbc 1724 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 1725 skip = TRUE, relocate = TRUE;
cedb70c5 1726
fbca6ad9
AO
1727 outrel.r_offset += (input_section->output_section->vma
1728 + input_section->output_offset);
1729
1730 if (skip)
0bb2d96a 1731 memset (&outrel, 0, sizeof outrel);
fbca6ad9
AO
1732 else if (r_type == R_SH_64_PCREL)
1733 {
1734 BFD_ASSERT (h != NULL && h->dynindx != -1);
fbca6ad9
AO
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)
f5385ebf 1744 && h->def_regular))
fbca6ad9 1745 {
b34976b6 1746 relocate = TRUE;
fbca6ad9
AO
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);
fbca6ad9
AO
1753 outrel.r_info = ELF64_R_INFO (h->dynindx, R_SH_64);
1754 outrel.r_addend = relocation + rel->r_addend;
1755 }
1756 }
1757
947216bf
AM
1758 loc = sreloc->contents;
1759 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
1760 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
fbca6ad9
AO
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)
f5385ebf 1842 && h->def_regular))
fbca6ad9
AO
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 {
947216bf 1909 asection *s;
fbca6ad9 1910 Elf_Internal_Rela outrel;
947216bf 1911 bfd_byte *loc;
fbca6ad9 1912
947216bf
AM
1913 s = bfd_get_section_by_name (dynobj, ".rela.got");
1914 BFD_ASSERT (s != NULL);
fbca6ad9
AO
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;
947216bf
AM
1921 loc = s->contents;
1922 loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
1923 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
fbca6ad9
AO
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);
b34976b6 2055 return FALSE;
fbca6ad9
AO
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)
dfeffb9f 2071 name = NULL;
fbca6ad9
AO
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)
b34976b6 2077 return FALSE;
fbca6ad9
AO
2078 if (*name == '\0')
2079 name = bfd_section_name (input_bfd, sec);
2080 }
2081 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L
2082 (info, (h ? &h->root : NULL), name, howto->name,
2083 (bfd_vma) 0, input_bfd, input_section,
2084 rel->r_offset)))
b34976b6 2085 return FALSE;
fbca6ad9
AO
2086 }
2087 break;
2088 }
2089 }
2090 }
2091
b34976b6 2092 return TRUE;
fbca6ad9
AO
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
2100static bfd_byte *
09fd220b
KK
2101sh_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)
fbca6ad9
AO
2107{
2108 Elf_Internal_Shdr *symtab_hdr;
fbca6ad9
AO
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;
6cdc0ccc 2113 Elf_Internal_Sym *isymbuf = NULL;
fbca6ad9
AO
2114
2115 /* We only need to handle the case of relaxing, or of having a
2116 particular set of section contents, specially. */
1049f94e 2117 if (relocatable
fbca6ad9
AO
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,
1049f94e 2121 relocatable,
fbca6ad9
AO
2122 symbols);
2123
2124 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
fbca6ad9
AO
2125
2126 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
eea6121a 2127 input_section->size);
fbca6ad9
AO
2128
2129 if ((input_section->flags & SEC_RELOC) != 0
2130 && input_section->reloc_count > 0)
2131 {
2132 Elf_Internal_Sym *isymp;
6cdc0ccc 2133 Elf_Internal_Sym *isymend;
fbca6ad9 2134 asection **secpp;
fbca6ad9 2135
6cdc0ccc
AM
2136 /* Read this BFD's local symbols. */
2137 if (symtab_hdr->sh_info != 0)
fbca6ad9 2138 {
6cdc0ccc
AM
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)
fbca6ad9
AO
2145 goto error_return;
2146 }
2147
45d6a902 2148 internal_relocs = (_bfd_elf_link_read_relocs
09fd220b 2149 (input_bfd, input_section, NULL,
b34976b6 2150 (Elf_Internal_Rela *) NULL, FALSE));
fbca6ad9
AO
2151 if (internal_relocs == NULL)
2152 goto error_return;
2153
fbca6ad9
AO
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
fbca6ad9 2159 secpp = sections;
6cdc0ccc
AM
2160 isymend = isymbuf + symtab_hdr->sh_info;
2161 for (isymp = isymbuf; isymp < isymend; ++isymp, ++secpp)
fbca6ad9
AO
2162 {
2163 asection *isec;
2164
fbca6ad9
AO
2165 if (isymp->st_shndx == SHN_UNDEF)
2166 isec = bfd_und_section_ptr;
fbca6ad9
AO
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
cb33740c 2172 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
fbca6ad9
AO
2173
2174 *secpp = isec;
2175 }
2176
2177 if (! sh_elf64_relocate_section (output_bfd, link_info, input_bfd,
2178 input_section, data, internal_relocs,
6cdc0ccc 2179 isymbuf, sections))
fbca6ad9
AO
2180 goto error_return;
2181
2182 if (sections != NULL)
2183 free (sections);
fbca6ad9
AO
2184 if (internal_relocs != elf_section_data (input_section)->relocs)
2185 free (internal_relocs);
6cdc0ccc
AM
2186 if (isymbuf != NULL
2187 && (unsigned char *) isymbuf != symtab_hdr->contents)
2188 free (isymbuf);
fbca6ad9
AO
2189 }
2190
2191 return data;
2192
2193 error_return:
6cdc0ccc
AM
2194 if (sections != NULL)
2195 free (sections);
fbca6ad9
AO
2196 if (internal_relocs != NULL
2197 && internal_relocs != elf_section_data (input_section)->relocs)
2198 free (internal_relocs);
6cdc0ccc
AM
2199 if (isymbuf != NULL
2200 && (unsigned char *) isymbuf != symtab_hdr->contents)
2201 free (isymbuf);
fbca6ad9
AO
2202 return NULL;
2203}
2204
2205/* Set the SHF_SH5_ISA32 flag for ISA SHmedia code sections. */
2206
f075ee0c 2207static bfd_boolean
09fd220b
KK
2208sh64_elf64_fake_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2209 Elf_Internal_Shdr *elf_section_hdr,
2210 asection *asect)
fbca6ad9
AO
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
b34976b6 2216 return TRUE;
fbca6ad9
AO
2217}
2218
b34976b6 2219static bfd_boolean
09fd220b 2220sh_elf64_set_mach_from_flags (bfd *abfd)
fbca6ad9
AO
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);
b34976b6 2233 return FALSE;
fbca6ad9 2234 }
b34976b6 2235 return TRUE;
fbca6ad9
AO
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
b34976b6 2242static bfd_boolean
09fd220b 2243sh_elf64_set_private_flags (bfd *abfd, flagword flags)
fbca6ad9
AO
2244{
2245 BFD_ASSERT (! elf_flags_init (abfd)
2246 || elf_elfheader (abfd)->e_flags == flags);
2247
2248 elf_elfheader (abfd)->e_flags = flags;
b34976b6 2249 elf_flags_init (abfd) = TRUE;
fbca6ad9
AO
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
b34976b6 2256static bfd_boolean
09fd220b 2257sh_elf64_copy_private_data_internal (bfd *ibfd, bfd *obfd)
fbca6ad9
AO
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)
b34976b6 2265 return TRUE;
fbca6ad9
AO
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
104d59d1
JM
2284 /* Copy object attributes. */
2285 _bfd_elf_copy_obj_attributes (ibfd, obfd);
2286
fbca6ad9
AO
2287 return sh_elf64_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
2288}
2289
b34976b6 2290static bfd_boolean
09fd220b 2291sh_elf64_copy_private_data (bfd *ibfd, bfd *obfd)
fbca6ad9
AO
2292{
2293 return sh_elf64_copy_private_data_internal (ibfd, obfd);
2294}
2295
b34976b6 2296static bfd_boolean
09fd220b 2297sh_elf64_merge_private_data (bfd *ibfd, bfd *obfd)
fbca6ad9
AO
2298{
2299 flagword old_flags, new_flags;
2300
82e51918 2301 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
b34976b6 2302 return FALSE;
fbca6ad9
AO
2303
2304 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2305 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 2306 return TRUE;
fbca6ad9
AO
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);
b34976b6 2324 return FALSE;
fbca6ad9
AO
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. */
b34976b6 2332 elf_flags_init (obfd) = TRUE;
fbca6ad9
AO
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);
b34976b6 2344 return FALSE;
fbca6ad9
AO
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
2359static asection *
09fd220b 2360sh_elf64_gc_mark_hook (asection *sec,
07adf181 2361 struct bfd_link_info *info,
09fd220b
KK
2362 Elf_Internal_Rela *rel,
2363 struct elf_link_hash_entry *h,
2364 Elf_Internal_Sym *sym)
fbca6ad9
AO
2365{
2366 if (h != NULL)
07adf181
AM
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 }
fbca6ad9 2373
07adf181 2374 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
fbca6ad9
AO
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. */
cedb70c5 2380
b34976b6 2381static bfd_boolean
09fd220b
KK
2382sh_elf64_check_relocs (bfd *abfd, struct bfd_link_info *info,
2383 asection *sec, const Elf_Internal_Rela *relocs)
fbca6ad9
AO
2384{
2385 Elf_Internal_Shdr *symtab_hdr;
5582a088 2386 struct elf_link_hash_entry **sym_hashes;
fbca6ad9
AO
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
1049f94e 2399 if (info->relocatable)
b34976b6 2400 return TRUE;
fbca6ad9
AO
2401
2402 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2403 sym_hashes = elf_sym_hashes (abfd);
cedb70c5 2404
fbca6ad9
AO
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;
cedb70c5 2413
fbca6ad9
AO
2414 r_symndx = ELF64_R_SYM (rel->r_info);
2415 if (r_symndx < symtab_hdr->sh_info)
2416 h = NULL;
2417 else
973a3492
L
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 }
cedb70c5 2424
fbca6ad9
AO
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))
b34976b6 2452 return FALSE;
fbca6ad9
AO
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:
c152c796 2465 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 2466 return FALSE;
fbca6ad9 2467 break;
cedb70c5 2468
fbca6ad9
AO
2469 /* This relocation describes which C++ vtable entries are actually
2470 used. Record for later use during GC. */
2471 case R_SH_GNU_VTENTRY:
d17e0c6e
JB
2472 BFD_ASSERT (h != NULL);
2473 if (h != NULL
2474 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b34976b6 2475 return FALSE;
fbca6ad9
AO
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 {
3496cb2a
L
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));
fbca6ad9 2507 if (srelgot == NULL
fbca6ad9 2508 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
b34976b6 2509 return FALSE;
fbca6ad9
AO
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
eea6121a 2524 hsh->datalabel_got_offset = sgot->size;
fbca6ad9
AO
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 }
eea6121a 2533 h->got.offset = sgot->size;
fbca6ad9
AO
2534 }
2535
2536 /* Make sure this symbol is output as a dynamic symbol. */
2537 if (h->dynindx == -1)
2538 {
c152c796 2539 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2540 return FALSE;
fbca6ad9
AO
2541 }
2542
eea6121a 2543 srelgot->size += sizeof (Elf64_External_Rela);
fbca6ad9
AO
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)
b34976b6 2560 return FALSE;
fbca6ad9
AO
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
eea6121a 2576 + r_symndx] = sgot->size;
fbca6ad9
AO
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 }
eea6121a 2585 local_got_offsets[r_symndx] = sgot->size;
fbca6ad9
AO
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. */
eea6121a 2593 srelgot->size += sizeof (Elf64_External_Rela);
fbca6ad9
AO
2594 }
2595 }
2596
eea6121a 2597 sgot->size += 8;
fbca6ad9
AO
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 {
c152c796 2622 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2623 return FALSE;
fbca6ad9
AO
2624 }
2625
f5385ebf 2626 h->needs_plt = 1;
fbca6ad9
AO
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
f5385ebf 2650 h->needs_plt = 1;
fbca6ad9
AO
2651
2652 break;
2653
2654 case R_SH_64:
2655 case R_SH_64_PCREL:
2656 if (h != NULL)
f5385ebf 2657 h->non_got_ref = 1;
fbca6ad9
AO
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
f5385ebf 2676 || !h->def_regular))))
fbca6ad9
AO
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 {
83bac4b0
NC
2683 sreloc = _bfd_elf_make_dynamic_reloc_section
2684 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
fbca6ad9 2685
fbca6ad9 2686 if (sreloc == NULL)
83bac4b0 2687 return FALSE;
fbca6ad9
AO
2688 }
2689
eea6121a 2690 sreloc->size += sizeof (Elf64_External_Rela);
fbca6ad9
AO
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)
b34976b6 2717 return FALSE;
fbca6ad9
AO
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 }
cedb70c5 2731
b34976b6 2732 return TRUE;
fbca6ad9
AO
2733}
2734
2735static int
09fd220b 2736sh64_elf64_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
fbca6ad9
AO
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
b34976b6 2766static bfd_boolean
09fd220b 2767sh64_elf64_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
555cd476 2768 Elf_Internal_Sym *sym, const char **namep,
09fd220b
KK
2769 flagword *flagsp ATTRIBUTE_UNUSED,
2770 asection **secp, bfd_vma *valp)
fbca6ad9
AO
2771{
2772 /* We want to do this for relocatable as well as final linking. */
4ab82700 2773 if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL
0eddce27 2774 && is_elf_hash_table (info->hash))
fbca6ad9
AO
2775 {
2776 struct elf_link_hash_entry *h;
2777
1049f94e 2778 /* For relocatable links, we register the DataLabel sym in its own
fbca6ad9
AO
2779 right, and tweak the name when it's output. Otherwise, we make
2780 an indirect symbol of it. */
2781 flagword flags
1049f94e 2782 = info->relocatable || info->emitrelocations
fbca6ad9
AO
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)
b34976b6 2793 return FALSE;
fbca6ad9
AO
2794
2795 strcpy (dl_name, *namep);
2796 strcat (dl_name, DATALABEL_SUFFIX);
2797
2798 h = (struct elf_link_hash_entry *)
b34976b6 2799 bfd_link_hash_lookup (info->hash, dl_name, FALSE, FALSE, FALSE);
fbca6ad9
AO
2800
2801 if (h == NULL)
2802 {
2803 /* No previous datalabel symbol. Make one. */
14a793b2 2804 struct bfd_link_hash_entry *bh = NULL;
9c5bfbb7 2805 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
14a793b2 2806
fbca6ad9
AO
2807 if (! _bfd_generic_link_add_one_symbol (info, abfd, dl_name,
2808 flags, *secp, *valp,
b34976b6 2809 *namep, FALSE,
14a793b2 2810 bed->collect, &bh))
fbca6ad9
AO
2811 {
2812 free (dl_name);
b34976b6 2813 return FALSE;
fbca6ad9
AO
2814 }
2815
14a793b2 2816 h = (struct elf_link_hash_entry *) bh;
f5385ebf 2817 h->non_elf = 0;
fbca6ad9
AO
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
1049f94e 2826 || ((info->relocatable || info->emitrelocations)
fbca6ad9 2827 && h->root.type != bfd_link_hash_undefined)
1049f94e 2828 || (! info->relocatable && !info->emitrelocations
fbca6ad9
AO
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);
b34976b6 2836 return FALSE;
fbca6ad9
AO
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
b34976b6 2848 return TRUE;
fbca6ad9
AO
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
6e0b88f1 2863static int
754021d0 2864sh64_elf64_link_output_symbol_hook (struct bfd_link_info *info,
09fd220b
KK
2865 const char *cname,
2866 Elf_Internal_Sym *sym,
754021d0
AM
2867 asection *input_sec ATTRIBUTE_UNUSED,
2868 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
fbca6ad9
AO
2869{
2870 char *name = (char *) cname;
2871
1049f94e 2872 if (info->relocatable || info->emitrelocations)
fbca6ad9
AO
2873 {
2874 if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL)
2875 name[strlen (name) - strlen (DATALABEL_SUFFIX)] = 0;
2876 }
2877
6e0b88f1 2878 return 1;
fbca6ad9
AO
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
2888static void
09fd220b
KK
2889sh64_elf64_final_write_processing (bfd *abfd,
2890 bfd_boolean linker ATTRIBUTE_UNUSED)
fbca6ad9
AO
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
2902static 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 */
c8614e8e 2909 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
fbca6ad9
AO
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
2922static 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 */
c8614e8e 2929 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
fbca6ad9
AO
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
2945static 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 */
c8614e8e
AM
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 */
fbca6ad9
AO
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
2965static 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 */
c8614e8e
AM
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 */
fbca6ad9
AO
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
2987static 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 */
0a4ef3f4 2998 0x00, 0xc9, 0x45, 0x10, /* add r12, r17, r17 */
fbca6ad9
AO
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
3007static 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 */
0a4ef3f4 3018 0x10, 0x45, 0xc9, 0x00, /* add r12, r17, r17 */
fbca6ad9
AO
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
3027static const bfd_byte *elf_sh64_plt0_entry;
3028static const bfd_byte *elf_sh64_plt_entry;
3029static const bfd_byte *elf_sh64_pic_plt_entry;
3030
3031/* Create an entry in an sh ELF linker hash table. */
3032
3033static struct bfd_hash_entry *
09fd220b
KK
3034sh64_elf64_link_hash_newfunc (struct bfd_hash_entry *entry,
3035 struct bfd_hash_table *table,
3036 const char *string)
fbca6ad9
AO
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
3065static struct bfd_link_hash_table *
09fd220b 3066sh64_elf64_link_hash_table_create (bfd *abfd)
fbca6ad9 3067{
4dfe6ac6 3068 struct elf_link_hash_table *ret;
fbca6ad9 3069
4dfe6ac6
NC
3070 ret = (struct elf_link_hash_table *) bfd_malloc (sizeof (* ret));
3071 if (ret == (struct elf_link_hash_table *) NULL)
fbca6ad9
AO
3072 return NULL;
3073
4dfe6ac6 3074 if (!_bfd_elf_link_hash_table_init (ret, abfd,
66eb6687 3075 sh64_elf64_link_hash_newfunc,
4dfe6ac6
NC
3076 sizeof (struct elf_sh64_link_hash_entry),
3077 GENERIC_ELF_DATA))
fbca6ad9 3078 {
e2d34d7d 3079 free (ret);
fbca6ad9
AO
3080 return NULL;
3081 }
3082
4dfe6ac6 3083 return &ret->root;
fbca6ad9
AO
3084}
3085
3086inline static void
f075ee0c 3087movi_shori_putval (bfd *output_bfd, unsigned long value, bfd_byte *addr)
fbca6ad9
AO
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
3099inline static void
f075ee0c 3100movi_3shori_putval (bfd *output_bfd, bfd_vma value, bfd_byte *addr)
fbca6ad9
AO
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
b34976b6 3122static bfd_boolean
09fd220b 3123sh64_elf64_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
fbca6ad9
AO
3124{
3125 flagword flags, pltflags;
3126 register asection *s;
9c5bfbb7 3127 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
fbca6ad9
AO
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);
b34976b6 3142 return FALSE;
fbca6ad9
AO
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
3496cb2a 3158 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
fbca6ad9 3159 if (s == NULL
fbca6ad9 3160 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
b34976b6 3161 return FALSE;
fbca6ad9
AO
3162
3163 if (bed->want_plt_sym)
3164 {
3165 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3166 .plt section. */
14a793b2
AM
3167 struct elf_link_hash_entry *h;
3168 struct bfd_link_hash_entry *bh = NULL;
3169
fbca6ad9
AO
3170 if (! (_bfd_generic_link_add_one_symbol
3171 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
b34976b6
AM
3172 (bfd_vma) 0, (const char *) NULL, FALSE, bed->collect, &bh)))
3173 return FALSE;
14a793b2
AM
3174
3175 h = (struct elf_link_hash_entry *) bh;
f5385ebf 3176 h->def_regular = 1;
fbca6ad9 3177 h->type = STT_OBJECT;
7325306f 3178 elf_hash_table (info)->hplt = h;
fbca6ad9
AO
3179
3180 if (info->shared
c152c796 3181 && ! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 3182 return FALSE;
fbca6ad9
AO
3183 }
3184
3496cb2a
L
3185 s = bfd_make_section_with_flags (abfd,
3186 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
3187 flags | SEC_READONLY);
fbca6ad9 3188 if (s == NULL
fbca6ad9 3189 || ! bfd_set_section_alignment (abfd, s, ptralign))
b34976b6 3190 return FALSE;
fbca6ad9
AO
3191
3192 if (! _bfd_elf_create_got_section (abfd, info))
b34976b6 3193 return FALSE;
fbca6ad9
AO
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);
3496cb2a
L
3211 s = bfd_make_section_with_flags (abfd, relname,
3212 flags | SEC_READONLY);
fbca6ad9 3213 if (s == NULL
fbca6ad9 3214 || ! bfd_set_section_alignment (abfd, s, ptralign))
b34976b6 3215 return FALSE;
fbca6ad9
AO
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. */
3496cb2a
L
3227 s = bfd_make_section_with_flags (abfd, ".dynbss",
3228 SEC_ALLOC | SEC_LINKER_CREATED);
3229 if (s == NULL)
b34976b6 3230 return FALSE;
fbca6ad9
AO
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 {
3496cb2a
L
3245 s = bfd_make_section_with_flags (abfd,
3246 (bed->default_use_rela_p
3247 ? ".rela.bss" : ".rel.bss"),
3248 flags | SEC_READONLY);
fbca6ad9 3249 if (s == NULL
fbca6ad9 3250 || ! bfd_set_section_alignment (abfd, s, ptralign))
b34976b6 3251 return FALSE;
fbca6ad9
AO
3252 }
3253 }
3254
b34976b6 3255 return TRUE;
fbca6ad9
AO
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
b34976b6 3264static bfd_boolean
09fd220b
KK
3265sh64_elf64_adjust_dynamic_symbol (struct bfd_link_info *info,
3266 struct elf_link_hash_entry *h)
fbca6ad9
AO
3267{
3268 bfd *dynobj;
3269 asection *s;
fbca6ad9
AO
3270
3271 dynobj = elf_hash_table (info)->dynobj;
3272
3273 /* Make sure we know what is going on here. */
3274 BFD_ASSERT (dynobj != NULL
f5385ebf 3275 && (h->needs_plt
f6e332e6 3276 || h->u.weakdef != NULL
f5385ebf
AM
3277 || (h->def_dynamic
3278 && h->ref_regular
3279 && !h->def_regular)));
fbca6ad9
AO
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
f5385ebf 3285 || h->needs_plt)
fbca6ad9
AO
3286 {
3287 if (! info->shared
f5385ebf
AM
3288 && !h->def_dynamic
3289 && !h->ref_dynamic)
fbca6ad9
AO
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. */
f5385ebf 3296 BFD_ASSERT (h->needs_plt);
b34976b6 3297 return TRUE;
fbca6ad9
AO
3298 }
3299
3300 /* Make sure this symbol is output as a dynamic symbol. */
3301 if (h->dynindx == -1)
3302 {
c152c796 3303 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 3304 return FALSE;
fbca6ad9
AO
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. */
eea6121a
AM
3312 if (s->size == 0)
3313 s->size += PLT_ENTRY_SIZE;
fbca6ad9
AO
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
f5385ebf 3321 && !h->def_regular)
fbca6ad9
AO
3322 {
3323 h->root.u.def.section = s;
eea6121a 3324 h->root.u.def.value = s->size;
fbca6ad9
AO
3325 }
3326
eea6121a 3327 h->plt.offset = s->size;
fbca6ad9
AO
3328
3329 /* Make room for this entry. */
eea6121a 3330 s->size += elf_sh64_sizeof_plt (info);
fbca6ad9
AO
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);
eea6121a 3337 s->size += 8;
fbca6ad9
AO
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);
eea6121a 3343 s->size += sizeof (Elf64_External_Rela);
fbca6ad9 3344
b34976b6 3345 return TRUE;
fbca6ad9
AO
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. */
f6e332e6 3351 if (h->u.weakdef != NULL)
fbca6ad9 3352 {
f6e332e6
AM
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;
b34976b6 3357 return TRUE;
fbca6ad9
AO
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)
b34976b6 3368 return TRUE;
fbca6ad9
AO
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. */
f5385ebf 3372 if (!h->non_got_ref)
b34976b6 3373 return TRUE;
fbca6ad9 3374
909272ee
AM
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
fbca6ad9
AO
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);
eea6121a 3405 srel->size += sizeof (Elf64_External_Rela);
f5385ebf 3406 h->needs_copy = 1;
fbca6ad9
AO
3407 }
3408
027297b7 3409 return _bfd_elf_adjust_dynamic_copy (h, s);
fbca6ad9
AO
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
b34976b6 3419static bfd_boolean
09fd220b
KK
3420sh64_elf64_discard_copies (struct elf_sh64_link_hash_entry *h,
3421 void *ignore ATTRIBUTE_UNUSED)
fbca6ad9
AO
3422{
3423 struct elf_sh64_pcrel_relocs_copied *s;
3424
e92d460e
AM
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
fbca6ad9 3428 /* We only discard relocs for symbols defined in a regular object. */
f5385ebf 3429 if (!h->root.def_regular)
b34976b6 3430 return TRUE;
fbca6ad9
AO
3431
3432 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
eea6121a 3433 s->section->size -= s->count * sizeof (Elf64_External_Rela);
fbca6ad9 3434
b34976b6 3435 return TRUE;
fbca6ad9
AO
3436}
3437
3438/* Set the sizes of the dynamic sections. */
3439
b34976b6 3440static bfd_boolean
09fd220b
KK
3441sh64_elf64_size_dynamic_sections (bfd *output_bfd,
3442 struct bfd_link_info *info)
fbca6ad9
AO
3443{
3444 bfd *dynobj;
3445 asection *s;
b34976b6
AM
3446 bfd_boolean plt;
3447 bfd_boolean relocs;
3448 bfd_boolean reltext;
fbca6ad9
AO
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. */
2558b9a9 3456 if (info->executable)
fbca6ad9
AO
3457 {
3458 s = bfd_get_section_by_name (dynobj, ".interp");
3459 BFD_ASSERT (s != NULL);
eea6121a 3460 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
fbca6ad9
AO
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)
eea6121a 3473 s->size = 0;
fbca6ad9
AO
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)
4dfe6ac6 3481 sh64_elf64_link_hash_traverse (elf_hash_table (info),
09fd220b 3482 sh64_elf64_discard_copies, NULL);
fbca6ad9
AO
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. */
b34976b6
AM
3487 plt = FALSE;
3488 relocs = FALSE;
3489 reltext = FALSE;
fbca6ad9
AO
3490 for (s = dynobj->sections; s != NULL; s = s->next)
3491 {
3492 const char *name;
fbca6ad9
AO
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
fbca6ad9
AO
3501 if (strcmp (name, ".plt") == 0)
3502 {
c456f082
AM
3503 /* Remember whether there is a PLT. */
3504 plt = s->size != 0;
fbca6ad9 3505 }
0112cd26 3506 else if (CONST_STRNEQ (name, ".rela"))
fbca6ad9 3507 {
c456f082 3508 if (s->size != 0)
fbca6ad9
AO
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
b34976b6 3518 relocs = TRUE;
fbca6ad9
AO
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)
b34976b6 3531 reltext = TRUE;
fbca6ad9
AO
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 }
0112cd26 3539 else if (! CONST_STRNEQ (name, ".got")
c456f082 3540 && strcmp (name, ".dynbss") != 0)
fbca6ad9
AO
3541 {
3542 /* It's not one of our sections, so don't allocate space. */
3543 continue;
3544 }
3545
c456f082 3546 if (s->size == 0)
fbca6ad9 3547 {
c456f082
AM
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. */
8423293d 3557 s->flags |= SEC_EXCLUDE;
fbca6ad9
AO
3558 continue;
3559 }
3560
c456f082
AM
3561 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3562 continue;
3563
fbca6ad9 3564 /* Allocate memory for the section contents. */
eea6121a 3565 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
c456f082 3566 if (s->contents == NULL)
b34976b6 3567 return FALSE;
fbca6ad9
AO
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. */
2558b9a9 3577 if (info->executable)
fbca6ad9 3578 {
5a580b3a 3579 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
b34976b6 3580 return FALSE;
fbca6ad9
AO
3581 }
3582
3583 if (plt)
3584 {
5a580b3a
AM
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))
b34976b6 3589 return FALSE;
fbca6ad9
AO
3590 }
3591
3592 if (relocs)
3593 {
5a580b3a
AM
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)))
b34976b6 3598 return FALSE;
fbca6ad9
AO
3599 }
3600
3601 if (reltext)
3602 {
5a580b3a 3603 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
b34976b6 3604 return FALSE;
fbca6ad9
AO
3605 }
3606 }
3607
b34976b6 3608 return TRUE;
fbca6ad9
AO
3609}
3610
3611/* Finish up dynamic symbol handling. We set the contents of various
3612 dynamic sections here. */
3613
b34976b6 3614static bfd_boolean
09fd220b
KK
3615sh64_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)
fbca6ad9
AO
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;
947216bf 3633 bfd_byte *loc;
fbca6ad9
AO
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
c8614e8e
AM
3656 if (info->shared)
3657 got_offset -= GOT_BIAS;
fbca6ad9
AO
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
c8614e8e 3676 /* Set bottom bit because its for a branch to SHmedia */
fbca6ad9 3677 movi_shori_putval (output_bfd,
c8614e8e
AM
3678 -(h->plt.offset
3679 + elf_sh64_plt_plt0_offset (info) + 8)
3680 | 1,
fbca6ad9
AO
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
c8614e8e
AM
3699 if (info->shared)
3700 got_offset += GOT_BIAS;
fbca6ad9
AO
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;
947216bf
AM
3722 loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
3723 bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
fbca6ad9 3724
f5385ebf 3725 if (!h->def_regular)
fbca6ad9
AO
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;
947216bf 3738 bfd_byte *loc;
fbca6ad9
AO
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)
f5385ebf 3758 && h->def_regular)
fbca6ad9
AO
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
947216bf
AM
3772 loc = srel->contents;
3773 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
3774 bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
fbca6ad9
AO
3775 }
3776
f5385ebf 3777 if (h->needs_copy)
fbca6ad9
AO
3778 {
3779 asection *s;
3780 Elf_Internal_Rela rel;
947216bf 3781 bfd_byte *loc;
fbca6ad9
AO
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;
947216bf
AM
3798 loc = s->contents;
3799 loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
3800 bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
fbca6ad9
AO
3801 }
3802
3803 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3804 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
22edb2f1 3805 || h == elf_hash_table (info)->hgot)
fbca6ad9
AO
3806 sym->st_shndx = SHN_ABS;
3807
b34976b6 3808 return TRUE;
fbca6ad9
AO
3809}
3810
3811/* Finish up the dynamic sections. */
3812
b34976b6 3813static bfd_boolean
09fd220b
KK
3814sh64_elf64_finish_dynamic_sections (bfd *output_bfd,
3815 struct bfd_link_info *info)
fbca6ad9
AO
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;
eea6121a 3835 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
fbca6ad9
AO
3836 for (; dyncon < dynconend; dyncon++)
3837 {
3838 Elf_Internal_Dyn dyn;
3839 const char *name;
3840 asection *s;
3b587c71 3841 struct elf_link_hash_entry *h;
fbca6ad9
AO
3842
3843 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3844
3845 switch (dyn.d_tag)
3846 {
3847 default:
3848 break;
3849
3b587c71
AM
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,
b34976b6 3860 FALSE, FALSE, TRUE);
3b587c71
AM
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
fbca6ad9
AO
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);
eea6121a 3885 dyn.d_un.d_val = s->size;
fbca6ad9
AO
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)
eea6121a 3901 dyn.d_un.d_val -= s->size;
fbca6ad9
AO
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");
eea6121a 3909 if (splt && splt->size > 0)
fbca6ad9
AO
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. */
eea6121a 3945 if (sgot->size > 0)
fbca6ad9
AO
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
b34976b6 3959 return TRUE;
fbca6ad9
AO
3960}
3961
46e993b9
KK
3962/* Merge non visibility st_other attribute when the symbol comes from
3963 a dynamic object. */
3964static void
3965sh64_elf64_merge_symbol_attribute (struct elf_link_hash_entry *h,
3966 const Elf_Internal_Sym *isym,
3967 bfd_boolean definition,
dc84ceef 3968 bfd_boolean dynamic ATTRIBUTE_UNUSED)
46e993b9 3969{
dc84ceef 3970 if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
46e993b9
KK
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
b35d266b 3983static const struct bfd_elf_special_section sh64_elf64_special_sections[]=
2f89ff8d 3984{
0112cd26
NC
3985 { STRING_COMMA_LEN (".cranges"), 0, SHT_PROGBITS, 0 },
3986 { NULL, 0, 0, 0, 0 }
7f4d3958
L
3987};
3988
fbca6ad9
AO
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 '_'
fbca6ad9
AO
3998
3999#define bfd_elf64_bfd_reloc_type_lookup sh_elf64_reloc_type_lookup
157090f7
AM
4000#define bfd_elf64_bfd_reloc_name_lookup \
4001 sh_elf64_reloc_name_lookup
fbca6ad9
AO
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
fbca6ad9
AO
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
46e993b9
KK
4030#define elf_backend_merge_symbol_attribute \
4031 sh64_elf64_merge_symbol_attribute
4032
fbca6ad9
AO
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
74541ad4
AM
4044#define elf_backend_omit_section_dynsym \
4045 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
fbca6ad9
AO
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
29ef7005 4050#define elf_backend_special_sections sh64_elf64_special_sections
fbca6ad9
AO
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
fbca6ad9
AO
4056
4057#include "elf64-target.h"
2bc3c89a
AM
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"
16cecee5
L
4086#undef elf64_bed
4087#define elf64_bed elf64_sh64_linux_bed
2bc3c89a 4088
2bc3c89a 4089#include "elf64-target.h"
This page took 0.657382 seconds and 4 git commands to generate.