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