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