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