source: trunk/binutils/bfd/elf32-sh.c@ 3193

Last change on this file since 3193 was 610, checked in by bird, 22 years ago

This commit was generated by cvs2svn to compensate for changes in r609,
which included commits to RCS files with non-trunk default branches.
  • Property cvs2svn:cvs-rev set to 1.1.1.2
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 215.3 KB
Line 
1/* Renesas / SuperH SH specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
4 Contributed by Ian Lance Taylor, Cygnus Support.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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
29static bfd_reloc_status_type sh_elf_reloc
30 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
31static bfd_reloc_status_type sh_elf_ignore_reloc
32 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
33static reloc_howto_type *sh_elf_reloc_type_lookup
34 PARAMS ((bfd *, bfd_reloc_code_real_type));
35static void sh_elf_info_to_howto
36 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
37static bfd_boolean sh_elf_set_private_flags
38 PARAMS ((bfd *, flagword));
39static bfd_boolean sh_elf_copy_private_data
40 PARAMS ((bfd *, bfd *));
41static bfd_boolean sh_elf_merge_private_data
42 PARAMS ((bfd *, bfd *));
43static bfd_boolean sh_elf_set_mach_from_flags
44 PARAMS ((bfd *));
45static bfd_boolean sh_elf_relax_section
46 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
47static bfd_boolean sh_elf_relax_delete_bytes
48 PARAMS ((bfd *, asection *, bfd_vma, int));
49static bfd_boolean sh_elf_align_loads
50 PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_boolean *));
51static bfd_boolean sh_elf_swap_insns
52 PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma));
53static bfd_boolean sh_elf_relocate_section
54 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
55 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
56static bfd_byte *sh_elf_get_relocated_section_contents
57 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
58 bfd_byte *, bfd_boolean, asymbol **));
59static void sh_elf_copy_indirect_symbol
60 PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
61 struct elf_link_hash_entry *));
62static int sh_elf_optimized_tls_reloc
63 PARAMS ((struct bfd_link_info *, int, int));
64static bfd_boolean sh_elf_mkobject
65 PARAMS ((bfd *));
66static bfd_boolean sh_elf_object_p
67 PARAMS ((bfd *));
68static bfd_boolean sh_elf_check_relocs
69 PARAMS ((bfd *, struct bfd_link_info *, asection *,
70 const Elf_Internal_Rela *));
71static struct bfd_hash_entry *sh_elf_link_hash_newfunc
72 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
73static struct bfd_link_hash_table *sh_elf_link_hash_table_create
74 PARAMS ((bfd *));
75static bfd_boolean sh_elf_adjust_dynamic_symbol
76 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
77static bfd_boolean sh_elf_size_dynamic_sections
78 PARAMS ((bfd *, struct bfd_link_info *));
79static bfd_boolean sh_elf_finish_dynamic_symbol
80 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
81 Elf_Internal_Sym *));
82static bfd_boolean sh_elf_finish_dynamic_sections
83 PARAMS ((bfd *, struct bfd_link_info *));
84static bfd_reloc_status_type sh_elf_reloc_loop
85 PARAMS ((int, bfd *, asection *, bfd_byte *, bfd_vma, asection *,
86 bfd_vma, bfd_vma));
87static bfd_boolean create_got_section
88 PARAMS ((bfd *, struct bfd_link_info *));
89static bfd_boolean sh_elf_create_dynamic_sections
90 PARAMS ((bfd *, struct bfd_link_info *));
91static bfd_vma dtpoff_base
92 PARAMS ((struct bfd_link_info *));
93static bfd_vma tpoff
94 PARAMS ((struct bfd_link_info *, bfd_vma));
95static asection * sh_elf_gc_mark_hook
96 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
97 struct elf_link_hash_entry *, Elf_Internal_Sym *));
98static bfd_boolean sh_elf_gc_sweep_hook
99 PARAMS ((bfd *, struct bfd_link_info *, asection *,
100 const Elf_Internal_Rela *));
101static bfd_boolean allocate_dynrelocs
102 PARAMS ((struct elf_link_hash_entry *, PTR));
103static bfd_boolean readonly_dynrelocs
104 PARAMS ((struct elf_link_hash_entry *, PTR));
105static enum elf_reloc_type_class sh_elf_reloc_type_class
106 PARAMS ((const Elf_Internal_Rela *));
107#ifdef INCLUDE_SHMEDIA
108inline static void movi_shori_putval PARAMS ((bfd *, unsigned long, char *));
109#endif
110static bfd_boolean elf32_shlin_grok_prstatus
111 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
112static bfd_boolean elf32_shlin_grok_psinfo
113 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
114
115/* The name of the dynamic interpreter. This is put in the .interp
116 section. */
117
118#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
119
120static reloc_howto_type sh_elf_howto_table[] =
121{
122 /* No relocation. */
123 HOWTO (R_SH_NONE, /* type */
124 0, /* rightshift */
125 0, /* size (0 = byte, 1 = short, 2 = long) */
126 0, /* bitsize */
127 FALSE, /* pc_relative */
128 0, /* bitpos */
129 complain_overflow_dont, /* complain_on_overflow */
130 sh_elf_ignore_reloc, /* special_function */
131 "R_SH_NONE", /* name */
132 FALSE, /* partial_inplace */
133 0, /* src_mask */
134 0, /* dst_mask */
135 FALSE), /* pcrel_offset */
136
137 /* 32 bit absolute relocation. Setting partial_inplace to TRUE and
138 src_mask to a non-zero value is similar to the COFF toolchain. */
139 HOWTO (R_SH_DIR32, /* type */
140 0, /* rightshift */
141 2, /* size (0 = byte, 1 = short, 2 = long) */
142 32, /* bitsize */
143 FALSE, /* pc_relative */
144 0, /* bitpos */
145 complain_overflow_bitfield, /* complain_on_overflow */
146 sh_elf_reloc, /* special_function */
147 "R_SH_DIR32", /* name */
148 TRUE, /* partial_inplace */
149 0xffffffff, /* src_mask */
150 0xffffffff, /* dst_mask */
151 FALSE), /* pcrel_offset */
152
153 /* 32 bit PC relative relocation. */
154 HOWTO (R_SH_REL32, /* type */
155 0, /* rightshift */
156 2, /* size (0 = byte, 1 = short, 2 = long) */
157 32, /* bitsize */
158 TRUE, /* pc_relative */
159 0, /* bitpos */
160 complain_overflow_signed, /* complain_on_overflow */
161 sh_elf_ignore_reloc, /* special_function */
162 "R_SH_REL32", /* name */
163 TRUE, /* partial_inplace */
164 0xffffffff, /* src_mask */
165 0xffffffff, /* dst_mask */
166 TRUE), /* pcrel_offset */
167
168 /* 8 bit PC relative branch divided by 2. */
169 HOWTO (R_SH_DIR8WPN, /* type */
170 1, /* rightshift */
171 1, /* size (0 = byte, 1 = short, 2 = long) */
172 8, /* bitsize */
173 TRUE, /* pc_relative */
174 0, /* bitpos */
175 complain_overflow_signed, /* complain_on_overflow */
176 sh_elf_ignore_reloc, /* special_function */
177 "R_SH_DIR8WPN", /* name */
178 TRUE, /* partial_inplace */
179 0xff, /* src_mask */
180 0xff, /* dst_mask */
181 TRUE), /* pcrel_offset */
182
183 /* 12 bit PC relative branch divided by 2. */
184 /* This cannot be partial_inplace because relaxation can't know the
185 eventual value of a symbol. */
186 HOWTO (R_SH_IND12W, /* type */
187 1, /* rightshift */
188 1, /* size (0 = byte, 1 = short, 2 = long) */
189 12, /* bitsize */
190 TRUE, /* pc_relative */
191 0, /* bitpos */
192 complain_overflow_signed, /* complain_on_overflow */
193 NULL, /* special_function */
194 "R_SH_IND12W", /* name */
195 FALSE, /* partial_inplace */
196 0x0, /* src_mask */
197 0xfff, /* dst_mask */
198 TRUE), /* pcrel_offset */
199
200 /* 8 bit unsigned PC relative divided by 4. */
201 HOWTO (R_SH_DIR8WPL, /* type */
202 2, /* rightshift */
203 1, /* size (0 = byte, 1 = short, 2 = long) */
204 8, /* bitsize */
205 TRUE, /* pc_relative */
206 0, /* bitpos */
207 complain_overflow_unsigned, /* complain_on_overflow */
208 sh_elf_ignore_reloc, /* special_function */
209 "R_SH_DIR8WPL", /* name */
210 TRUE, /* partial_inplace */
211 0xff, /* src_mask */
212 0xff, /* dst_mask */
213 TRUE), /* pcrel_offset */
214
215 /* 8 bit unsigned PC relative divided by 2. */
216 HOWTO (R_SH_DIR8WPZ, /* type */
217 1, /* rightshift */
218 1, /* size (0 = byte, 1 = short, 2 = long) */
219 8, /* bitsize */
220 TRUE, /* pc_relative */
221 0, /* bitpos */
222 complain_overflow_unsigned, /* complain_on_overflow */
223 sh_elf_ignore_reloc, /* special_function */
224 "R_SH_DIR8WPZ", /* name */
225 TRUE, /* partial_inplace */
226 0xff, /* src_mask */
227 0xff, /* dst_mask */
228 TRUE), /* pcrel_offset */
229
230 /* 8 bit GBR relative. FIXME: This only makes sense if we have some
231 special symbol for the GBR relative area, and that is not
232 implemented. */
233 HOWTO (R_SH_DIR8BP, /* type */
234 0, /* rightshift */
235 1, /* size (0 = byte, 1 = short, 2 = long) */
236 8, /* bitsize */
237 FALSE, /* pc_relative */
238 0, /* bitpos */
239 complain_overflow_unsigned, /* complain_on_overflow */
240 sh_elf_ignore_reloc, /* special_function */
241 "R_SH_DIR8BP", /* name */
242 FALSE, /* partial_inplace */
243 0, /* src_mask */
244 0xff, /* dst_mask */
245 TRUE), /* pcrel_offset */
246
247 /* 8 bit GBR relative divided by 2. FIXME: This only makes sense if
248 we have some special symbol for the GBR relative area, and that
249 is not implemented. */
250 HOWTO (R_SH_DIR8W, /* type */
251 1, /* rightshift */
252 1, /* size (0 = byte, 1 = short, 2 = long) */
253 8, /* bitsize */
254 FALSE, /* pc_relative */
255 0, /* bitpos */
256 complain_overflow_unsigned, /* complain_on_overflow */
257 sh_elf_ignore_reloc, /* special_function */
258 "R_SH_DIR8W", /* name */
259 FALSE, /* partial_inplace */
260 0, /* src_mask */
261 0xff, /* dst_mask */
262 TRUE), /* pcrel_offset */
263
264 /* 8 bit GBR relative divided by 4. FIXME: This only makes sense if
265 we have some special symbol for the GBR relative area, and that
266 is not implemented. */
267 HOWTO (R_SH_DIR8L, /* type */
268 2, /* rightshift */
269 1, /* size (0 = byte, 1 = short, 2 = long) */
270 8, /* bitsize */
271 FALSE, /* pc_relative */
272 0, /* bitpos */
273 complain_overflow_unsigned, /* complain_on_overflow */
274 sh_elf_ignore_reloc, /* special_function */
275 "R_SH_DIR8L", /* name */
276 FALSE, /* partial_inplace */
277 0, /* src_mask */
278 0xff, /* dst_mask */
279 TRUE), /* pcrel_offset */
280
281 EMPTY_HOWTO (10),
282 EMPTY_HOWTO (11),
283 EMPTY_HOWTO (12),
284 EMPTY_HOWTO (13),
285 EMPTY_HOWTO (14),
286 EMPTY_HOWTO (15),
287 EMPTY_HOWTO (16),
288 EMPTY_HOWTO (17),
289 EMPTY_HOWTO (18),
290 EMPTY_HOWTO (19),
291 EMPTY_HOWTO (20),
292 EMPTY_HOWTO (21),
293 EMPTY_HOWTO (22),
294 EMPTY_HOWTO (23),
295 EMPTY_HOWTO (24),
296
297 /* The remaining relocs are a GNU extension used for relaxing. The
298 final pass of the linker never needs to do anything with any of
299 these relocs. Any required operations are handled by the
300 relaxation code. */
301
302 /* A 16 bit switch table entry. This is generated for an expression
303 such as ``.word L1 - L2''. The offset holds the difference
304 between the reloc address and L2. */
305 HOWTO (R_SH_SWITCH16, /* type */
306 0, /* rightshift */
307 1, /* size (0 = byte, 1 = short, 2 = long) */
308 16, /* bitsize */
309 FALSE, /* pc_relative */
310 0, /* bitpos */
311 complain_overflow_unsigned, /* complain_on_overflow */
312 sh_elf_ignore_reloc, /* special_function */
313 "R_SH_SWITCH16", /* name */
314 FALSE, /* partial_inplace */
315 0, /* src_mask */
316 0, /* dst_mask */
317 TRUE), /* pcrel_offset */
318
319 /* A 32 bit switch table entry. This is generated for an expression
320 such as ``.long L1 - L2''. The offset holds the difference
321 between the reloc address and L2. */
322 HOWTO (R_SH_SWITCH32, /* type */
323 0, /* rightshift */
324 2, /* size (0 = byte, 1 = short, 2 = long) */
325 32, /* bitsize */
326 FALSE, /* pc_relative */
327 0, /* bitpos */
328 complain_overflow_unsigned, /* complain_on_overflow */
329 sh_elf_ignore_reloc, /* special_function */
330 "R_SH_SWITCH32", /* name */
331 FALSE, /* partial_inplace */
332 0, /* src_mask */
333 0, /* dst_mask */
334 TRUE), /* pcrel_offset */
335
336 /* Indicates a .uses pseudo-op. The compiler will generate .uses
337 pseudo-ops when it finds a function call which can be relaxed.
338 The offset field holds the PC relative offset to the instruction
339 which loads the register used in the function call. */
340 HOWTO (R_SH_USES, /* type */
341 0, /* rightshift */
342 1, /* size (0 = byte, 1 = short, 2 = long) */
343 0, /* bitsize */
344 FALSE, /* pc_relative */
345 0, /* bitpos */
346 complain_overflow_unsigned, /* complain_on_overflow */
347 sh_elf_ignore_reloc, /* special_function */
348 "R_SH_USES", /* name */
349 FALSE, /* partial_inplace */
350 0, /* src_mask */
351 0, /* dst_mask */
352 TRUE), /* pcrel_offset */
353
354 /* The assembler will generate this reloc for addresses referred to
355 by the register loads associated with USES relocs. The offset
356 field holds the number of times the address is referenced in the
357 object file. */
358 HOWTO (R_SH_COUNT, /* type */
359 0, /* rightshift */
360 1, /* size (0 = byte, 1 = short, 2 = long) */
361 0, /* bitsize */
362 FALSE, /* pc_relative */
363 0, /* bitpos */
364 complain_overflow_unsigned, /* complain_on_overflow */
365 sh_elf_ignore_reloc, /* special_function */
366 "R_SH_COUNT", /* name */
367 FALSE, /* partial_inplace */
368 0, /* src_mask */
369 0, /* dst_mask */
370 TRUE), /* pcrel_offset */
371
372 /* Indicates an alignment statement. The offset field is the power
373 of 2 to which subsequent portions of the object file must be
374 aligned. */
375 HOWTO (R_SH_ALIGN, /* type */
376 0, /* rightshift */
377 1, /* size (0 = byte, 1 = short, 2 = long) */
378 0, /* bitsize */
379 FALSE, /* pc_relative */
380 0, /* bitpos */
381 complain_overflow_unsigned, /* complain_on_overflow */
382 sh_elf_ignore_reloc, /* special_function */
383 "R_SH_ALIGN", /* name */
384 FALSE, /* partial_inplace */
385 0, /* src_mask */
386 0, /* dst_mask */
387 TRUE), /* pcrel_offset */
388
389 /* The assembler will generate this reloc before a block of
390 instructions. A section should be processed as assumining it
391 contains data, unless this reloc is seen. */
392 HOWTO (R_SH_CODE, /* type */
393 0, /* rightshift */
394 1, /* size (0 = byte, 1 = short, 2 = long) */
395 0, /* bitsize */
396 FALSE, /* pc_relative */
397 0, /* bitpos */
398 complain_overflow_unsigned, /* complain_on_overflow */
399 sh_elf_ignore_reloc, /* special_function */
400 "R_SH_CODE", /* name */
401 FALSE, /* partial_inplace */
402 0, /* src_mask */
403 0, /* dst_mask */
404 TRUE), /* pcrel_offset */
405
406 /* The assembler will generate this reloc after a block of
407 instructions when it sees data that is not instructions. */
408 HOWTO (R_SH_DATA, /* type */
409 0, /* rightshift */
410 1, /* size (0 = byte, 1 = short, 2 = long) */
411 0, /* bitsize */
412 FALSE, /* pc_relative */
413 0, /* bitpos */
414 complain_overflow_unsigned, /* complain_on_overflow */
415 sh_elf_ignore_reloc, /* special_function */
416 "R_SH_DATA", /* name */
417 FALSE, /* partial_inplace */
418 0, /* src_mask */
419 0, /* dst_mask */
420 TRUE), /* pcrel_offset */
421
422 /* The assembler generates this reloc for each label within a block
423 of instructions. This permits the linker to avoid swapping
424 instructions which are the targets of branches. */
425 HOWTO (R_SH_LABEL, /* type */
426 0, /* rightshift */
427 1, /* size (0 = byte, 1 = short, 2 = long) */
428 0, /* bitsize */
429 FALSE, /* pc_relative */
430 0, /* bitpos */
431 complain_overflow_unsigned, /* complain_on_overflow */
432 sh_elf_ignore_reloc, /* special_function */
433 "R_SH_LABEL", /* name */
434 FALSE, /* partial_inplace */
435 0, /* src_mask */
436 0, /* dst_mask */
437 TRUE), /* pcrel_offset */
438
439 /* An 8 bit switch table entry. This is generated for an expression
440 such as ``.word L1 - L2''. The offset holds the difference
441 between the reloc address and L2. */
442 HOWTO (R_SH_SWITCH8, /* type */
443 0, /* rightshift */
444 0, /* size (0 = byte, 1 = short, 2 = long) */
445 8, /* bitsize */
446 FALSE, /* pc_relative */
447 0, /* bitpos */
448 complain_overflow_unsigned, /* complain_on_overflow */
449 sh_elf_ignore_reloc, /* special_function */
450 "R_SH_SWITCH8", /* name */
451 FALSE, /* partial_inplace */
452 0, /* src_mask */
453 0, /* dst_mask */
454 TRUE), /* pcrel_offset */
455
456 /* GNU extension to record C++ vtable hierarchy */
457 HOWTO (R_SH_GNU_VTINHERIT, /* type */
458 0, /* rightshift */
459 2, /* size (0 = byte, 1 = short, 2 = long) */
460 0, /* bitsize */
461 FALSE, /* pc_relative */
462 0, /* bitpos */
463 complain_overflow_dont, /* complain_on_overflow */
464 NULL, /* special_function */
465 "R_SH_GNU_VTINHERIT", /* name */
466 FALSE, /* partial_inplace */
467 0, /* src_mask */
468 0, /* dst_mask */
469 FALSE), /* pcrel_offset */
470
471 /* GNU extension to record C++ vtable member usage */
472 HOWTO (R_SH_GNU_VTENTRY, /* type */
473 0, /* rightshift */
474 2, /* size (0 = byte, 1 = short, 2 = long) */
475 0, /* bitsize */
476 FALSE, /* pc_relative */
477 0, /* bitpos */
478 complain_overflow_dont, /* complain_on_overflow */
479 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
480 "R_SH_GNU_VTENTRY", /* name */
481 FALSE, /* partial_inplace */
482 0, /* src_mask */
483 0, /* dst_mask */
484 FALSE), /* pcrel_offset */
485
486 /* 8 bit PC relative divided by 2 - but specified in a very odd way. */
487 HOWTO (R_SH_LOOP_START, /* type */
488 1, /* rightshift */
489 1, /* size (0 = byte, 1 = short, 2 = long) */
490 8, /* bitsize */
491 FALSE, /* pc_relative */
492 0, /* bitpos */
493 complain_overflow_signed, /* complain_on_overflow */
494 sh_elf_ignore_reloc, /* special_function */
495 "R_SH_LOOP_START", /* name */
496 TRUE, /* partial_inplace */
497 0xff, /* src_mask */
498 0xff, /* dst_mask */
499 TRUE), /* pcrel_offset */
500
501 /* 8 bit PC relative divided by 2 - but specified in a very odd way. */
502 HOWTO (R_SH_LOOP_END, /* type */
503 1, /* rightshift */
504 1, /* size (0 = byte, 1 = short, 2 = long) */
505 8, /* bitsize */
506 FALSE, /* pc_relative */
507 0, /* bitpos */
508 complain_overflow_signed, /* complain_on_overflow */
509 sh_elf_ignore_reloc, /* special_function */
510 "R_SH_LOOP_END", /* name */
511 TRUE, /* partial_inplace */
512 0xff, /* src_mask */
513 0xff, /* dst_mask */
514 TRUE), /* pcrel_offset */
515
516 EMPTY_HOWTO (38),
517 EMPTY_HOWTO (39),
518 EMPTY_HOWTO (40),
519 EMPTY_HOWTO (41),
520 EMPTY_HOWTO (42),
521 EMPTY_HOWTO (43),
522 EMPTY_HOWTO (44),
523
524#ifdef INCLUDE_SHMEDIA
525 /* Used in SHLLI.L and SHLRI.L. */
526 HOWTO (R_SH_DIR5U, /* type */
527 0, /* rightshift */
528 2, /* size (0 = byte, 1 = short, 2 = long) */
529 5, /* bitsize */
530 FALSE, /* pc_relative */
531 10, /* bitpos */
532 complain_overflow_unsigned, /* complain_on_overflow */
533 bfd_elf_generic_reloc, /* special_function */
534 "R_SH_DIR5U", /* name */
535 FALSE, /* partial_inplace */
536 0, /* src_mask */
537 0xfc00, /* dst_mask */
538 FALSE), /* pcrel_offset */
539
540 /* Used in SHARI, SHLLI et al. */
541 HOWTO (R_SH_DIR6U, /* type */
542 0, /* rightshift */
543 2, /* size (0 = byte, 1 = short, 2 = long) */
544 6, /* bitsize */
545 FALSE, /* pc_relative */
546 10, /* bitpos */
547 complain_overflow_unsigned, /* complain_on_overflow */
548 bfd_elf_generic_reloc, /* special_function */
549 "R_SH_DIR6U", /* name */
550 FALSE, /* partial_inplace */
551 0, /* src_mask */
552 0xfc00, /* dst_mask */
553 FALSE), /* pcrel_offset */
554
555 /* Used in BxxI, LDHI.L et al. */
556 HOWTO (R_SH_DIR6S, /* type */
557 0, /* rightshift */
558 2, /* size (0 = byte, 1 = short, 2 = long) */
559 6, /* bitsize */
560 FALSE, /* pc_relative */
561 10, /* bitpos */
562 complain_overflow_signed, /* complain_on_overflow */
563 bfd_elf_generic_reloc, /* special_function */
564 "R_SH_DIR6S", /* name */
565 FALSE, /* partial_inplace */
566 0, /* src_mask */
567 0xfc00, /* dst_mask */
568 FALSE), /* pcrel_offset */
569
570 /* Used in ADDI, ANDI et al. */
571 HOWTO (R_SH_DIR10S, /* type */
572 0, /* rightshift */
573 2, /* size (0 = byte, 1 = short, 2 = long) */
574 10, /* bitsize */
575 FALSE, /* pc_relative */
576 10, /* bitpos */
577 complain_overflow_signed, /* complain_on_overflow */
578 bfd_elf_generic_reloc, /* special_function */
579 "R_SH_DIR10S", /* name */
580 FALSE, /* partial_inplace */
581 0, /* src_mask */
582 0xffc00, /* dst_mask */
583 FALSE), /* pcrel_offset */
584
585 /* Used in LD.UW, ST.W et al. */
586 HOWTO (R_SH_DIR10SW, /* type */
587 1, /* rightshift */
588 2, /* size (0 = byte, 1 = short, 2 = long) */
589 11, /* bitsize */
590 FALSE, /* pc_relative */
591 10, /* bitpos */
592 complain_overflow_signed, /* complain_on_overflow */
593 bfd_elf_generic_reloc, /* special_function */
594 "R_SH_DIR10SW", /* name */
595 FALSE, /* partial_inplace */
596 0, /* src_mask */
597 0xffc00, /* dst_mask */
598 FALSE), /* pcrel_offset */
599
600 /* Used in LD.L, FLD.S et al. */
601 HOWTO (R_SH_DIR10SL, /* type */
602 2, /* rightshift */
603 2, /* size (0 = byte, 1 = short, 2 = long) */
604 12, /* bitsize */
605 FALSE, /* pc_relative */
606 10, /* bitpos */
607 complain_overflow_signed, /* complain_on_overflow */
608 bfd_elf_generic_reloc, /* special_function */
609 "R_SH_DIR10SL", /* name */
610 FALSE, /* partial_inplace */
611 0, /* src_mask */
612 0xffc00, /* dst_mask */
613 FALSE), /* pcrel_offset */
614
615 /* Used in FLD.D, FST.P et al. */
616 HOWTO (R_SH_DIR10SQ, /* type */
617 3, /* rightshift */
618 2, /* size (0 = byte, 1 = short, 2 = long) */
619 13, /* bitsize */
620 FALSE, /* pc_relative */
621 10, /* bitpos */
622 complain_overflow_signed, /* complain_on_overflow */
623 bfd_elf_generic_reloc, /* special_function */
624 "R_SH_DIR10SQ", /* name */
625 FALSE, /* partial_inplace */
626 0, /* src_mask */
627 0xffc00, /* dst_mask */
628 FALSE), /* pcrel_offset */
629
630#else
631 EMPTY_HOWTO (45),
632 EMPTY_HOWTO (46),
633 EMPTY_HOWTO (47),
634 EMPTY_HOWTO (48),
635 EMPTY_HOWTO (49),
636 EMPTY_HOWTO (50),
637 EMPTY_HOWTO (51),
638#endif
639
640 EMPTY_HOWTO (52),
641 EMPTY_HOWTO (53),
642 EMPTY_HOWTO (54),
643 EMPTY_HOWTO (55),
644 EMPTY_HOWTO (56),
645 EMPTY_HOWTO (57),
646 EMPTY_HOWTO (58),
647 EMPTY_HOWTO (59),
648 EMPTY_HOWTO (60),
649 EMPTY_HOWTO (61),
650 EMPTY_HOWTO (62),
651 EMPTY_HOWTO (63),
652 EMPTY_HOWTO (64),
653 EMPTY_HOWTO (65),
654 EMPTY_HOWTO (66),
655 EMPTY_HOWTO (67),
656 EMPTY_HOWTO (68),
657 EMPTY_HOWTO (69),
658 EMPTY_HOWTO (70),
659 EMPTY_HOWTO (71),
660 EMPTY_HOWTO (72),
661 EMPTY_HOWTO (73),
662 EMPTY_HOWTO (74),
663 EMPTY_HOWTO (75),
664 EMPTY_HOWTO (76),
665 EMPTY_HOWTO (77),
666 EMPTY_HOWTO (78),
667 EMPTY_HOWTO (79),
668 EMPTY_HOWTO (80),
669 EMPTY_HOWTO (81),
670 EMPTY_HOWTO (82),
671 EMPTY_HOWTO (83),
672 EMPTY_HOWTO (84),
673 EMPTY_HOWTO (85),
674 EMPTY_HOWTO (86),
675 EMPTY_HOWTO (87),
676 EMPTY_HOWTO (88),
677 EMPTY_HOWTO (89),
678 EMPTY_HOWTO (90),
679 EMPTY_HOWTO (91),
680 EMPTY_HOWTO (92),
681 EMPTY_HOWTO (93),
682 EMPTY_HOWTO (94),
683 EMPTY_HOWTO (95),
684 EMPTY_HOWTO (96),
685 EMPTY_HOWTO (97),
686 EMPTY_HOWTO (98),
687 EMPTY_HOWTO (99),
688 EMPTY_HOWTO (100),
689 EMPTY_HOWTO (101),
690 EMPTY_HOWTO (102),
691 EMPTY_HOWTO (103),
692 EMPTY_HOWTO (104),
693 EMPTY_HOWTO (105),
694 EMPTY_HOWTO (106),
695 EMPTY_HOWTO (107),
696 EMPTY_HOWTO (108),
697 EMPTY_HOWTO (109),
698 EMPTY_HOWTO (110),
699 EMPTY_HOWTO (111),
700 EMPTY_HOWTO (112),
701 EMPTY_HOWTO (113),
702 EMPTY_HOWTO (114),
703 EMPTY_HOWTO (115),
704 EMPTY_HOWTO (116),
705 EMPTY_HOWTO (117),
706 EMPTY_HOWTO (118),
707 EMPTY_HOWTO (119),
708 EMPTY_HOWTO (120),
709 EMPTY_HOWTO (121),
710 EMPTY_HOWTO (122),
711 EMPTY_HOWTO (123),
712 EMPTY_HOWTO (124),
713 EMPTY_HOWTO (125),
714 EMPTY_HOWTO (126),
715 EMPTY_HOWTO (127),
716 EMPTY_HOWTO (128),
717 EMPTY_HOWTO (129),
718 EMPTY_HOWTO (130),
719 EMPTY_HOWTO (131),
720 EMPTY_HOWTO (132),
721 EMPTY_HOWTO (133),
722 EMPTY_HOWTO (134),
723 EMPTY_HOWTO (135),
724 EMPTY_HOWTO (136),
725 EMPTY_HOWTO (137),
726 EMPTY_HOWTO (138),
727 EMPTY_HOWTO (139),
728 EMPTY_HOWTO (140),
729 EMPTY_HOWTO (141),
730 EMPTY_HOWTO (142),
731 EMPTY_HOWTO (143),
732
733 HOWTO (R_SH_TLS_GD_32, /* type */
734 0, /* rightshift */
735 2, /* size (0 = byte, 1 = short, 2 = long) */
736 32, /* bitsize */
737 FALSE, /* pc_relative */
738 0, /* bitpos */
739 complain_overflow_bitfield, /* complain_on_overflow */
740 bfd_elf_generic_reloc, /* */
741 "R_SH_TLS_GD_32", /* name */
742 TRUE, /* partial_inplace */
743 0xffffffff, /* src_mask */
744 0xffffffff, /* dst_mask */
745 FALSE), /* pcrel_offset */
746
747 HOWTO (R_SH_TLS_LD_32, /* type */
748 0, /* rightshift */
749 2, /* size (0 = byte, 1 = short, 2 = long) */
750 32, /* bitsize */
751 FALSE, /* pc_relative */
752 0, /* bitpos */
753 complain_overflow_bitfield, /* complain_on_overflow */
754 bfd_elf_generic_reloc, /* */
755 "R_SH_TLS_LD_32", /* name */
756 TRUE, /* partial_inplace */
757 0xffffffff, /* src_mask */
758 0xffffffff, /* dst_mask */
759 FALSE), /* pcrel_offset */
760
761 HOWTO (R_SH_TLS_LDO_32, /* type */
762 0, /* rightshift */
763 2, /* size (0 = byte, 1 = short, 2 = long) */
764 32, /* bitsize */
765 FALSE, /* pc_relative */
766 0, /* bitpos */
767 complain_overflow_bitfield, /* complain_on_overflow */
768 bfd_elf_generic_reloc, /* */
769 "R_SH_TLS_LDO_32", /* name */
770 TRUE, /* partial_inplace */
771 0xffffffff, /* src_mask */
772 0xffffffff, /* dst_mask */
773 FALSE), /* pcrel_offset */
774
775 HOWTO (R_SH_TLS_IE_32, /* type */
776 0, /* rightshift */
777 2, /* size (0 = byte, 1 = short, 2 = long) */
778 32, /* bitsize */
779 FALSE, /* pc_relative */
780 0, /* bitpos */
781 complain_overflow_bitfield, /* complain_on_overflow */
782 bfd_elf_generic_reloc, /* */
783 "R_SH_TLS_IE_32", /* name */
784 TRUE, /* partial_inplace */
785 0xffffffff, /* src_mask */
786 0xffffffff, /* dst_mask */
787 FALSE), /* pcrel_offset */
788
789 HOWTO (R_SH_TLS_LE_32, /* type */
790 0, /* rightshift */
791 2, /* size (0 = byte, 1 = short, 2 = long) */
792 32, /* bitsize */
793 FALSE, /* pc_relative */
794 0, /* bitpos */
795 complain_overflow_bitfield, /* complain_on_overflow */
796 bfd_elf_generic_reloc, /* */
797 "R_SH_TLS_LE_32", /* name */
798 TRUE, /* partial_inplace */
799 0xffffffff, /* src_mask */
800 0xffffffff, /* dst_mask */
801 FALSE), /* pcrel_offset */
802
803 HOWTO (R_SH_TLS_DTPMOD32, /* type */
804 0, /* rightshift */
805 2, /* size (0 = byte, 1 = short, 2 = long) */
806 32, /* bitsize */
807 FALSE, /* pc_relative */
808 0, /* bitpos */
809 complain_overflow_bitfield, /* complain_on_overflow */
810 bfd_elf_generic_reloc, /* */
811 "R_SH_TLS_DTPMOD32", /* name */
812 TRUE, /* partial_inplace */
813 0xffffffff, /* src_mask */
814 0xffffffff, /* dst_mask */
815 FALSE), /* pcrel_offset */
816
817 HOWTO (R_SH_TLS_DTPOFF32, /* type */
818 0, /* rightshift */
819 2, /* size (0 = byte, 1 = short, 2 = long) */
820 32, /* bitsize */
821 FALSE, /* pc_relative */
822 0, /* bitpos */
823 complain_overflow_bitfield, /* complain_on_overflow */
824 bfd_elf_generic_reloc, /* */
825 "R_SH_TLS_DTPOFF32", /* name */
826 TRUE, /* partial_inplace */
827 0xffffffff, /* src_mask */
828 0xffffffff, /* dst_mask */
829 FALSE), /* pcrel_offset */
830
831 HOWTO (R_SH_TLS_TPOFF32, /* type */
832 0, /* rightshift */
833 2, /* size (0 = byte, 1 = short, 2 = long) */
834 32, /* bitsize */
835 FALSE, /* pc_relative */
836 0, /* bitpos */
837 complain_overflow_bitfield, /* complain_on_overflow */
838 bfd_elf_generic_reloc, /* */
839 "R_SH_TLS_TPOFF32", /* name */
840 TRUE, /* partial_inplace */
841 0xffffffff, /* src_mask */
842 0xffffffff, /* dst_mask */
843 FALSE), /* pcrel_offset */
844
845 EMPTY_HOWTO (152),
846 EMPTY_HOWTO (153),
847 EMPTY_HOWTO (154),
848 EMPTY_HOWTO (155),
849 EMPTY_HOWTO (156),
850 EMPTY_HOWTO (157),
851 EMPTY_HOWTO (158),
852 EMPTY_HOWTO (159),
853
854 HOWTO (R_SH_GOT32, /* type */
855 0, /* rightshift */
856 2, /* size (0 = byte, 1 = short, 2 = long) */
857 32, /* bitsize */
858 FALSE, /* pc_relative */
859 0, /* bitpos */
860 complain_overflow_bitfield, /* complain_on_overflow */
861 bfd_elf_generic_reloc, /* */
862 "R_SH_GOT32", /* name */
863 TRUE, /* partial_inplace */
864 0xffffffff, /* src_mask */
865 0xffffffff, /* dst_mask */
866 FALSE), /* pcrel_offset */
867
868 HOWTO (R_SH_PLT32, /* type */
869 0, /* rightshift */
870 2, /* size (0 = byte, 1 = short, 2 = long) */
871 32, /* bitsize */
872 TRUE, /* pc_relative */
873 0, /* bitpos */
874 complain_overflow_bitfield, /* complain_on_overflow */
875 bfd_elf_generic_reloc, /* */
876 "R_SH_PLT32", /* name */
877 TRUE, /* partial_inplace */
878 0xffffffff, /* src_mask */
879 0xffffffff, /* dst_mask */
880 TRUE), /* pcrel_offset */
881
882 HOWTO (R_SH_COPY, /* type */
883 0, /* rightshift */
884 2, /* size (0 = byte, 1 = short, 2 = long) */
885 32, /* bitsize */
886 FALSE, /* pc_relative */
887 0, /* bitpos */
888 complain_overflow_bitfield, /* complain_on_overflow */
889 bfd_elf_generic_reloc, /* */
890 "R_SH_COPY", /* name */
891 TRUE, /* partial_inplace */
892 0xffffffff, /* src_mask */
893 0xffffffff, /* dst_mask */
894 FALSE), /* pcrel_offset */
895
896 HOWTO (R_SH_GLOB_DAT, /* type */
897 0, /* rightshift */
898 2, /* size (0 = byte, 1 = short, 2 = long) */
899 32, /* bitsize */
900 FALSE, /* pc_relative */
901 0, /* bitpos */
902 complain_overflow_bitfield, /* complain_on_overflow */
903 bfd_elf_generic_reloc, /* */
904 "R_SH_GLOB_DAT", /* name */
905 TRUE, /* partial_inplace */
906 0xffffffff, /* src_mask */
907 0xffffffff, /* dst_mask */
908 FALSE), /* pcrel_offset */
909
910 HOWTO (R_SH_JMP_SLOT, /* type */
911 0, /* rightshift */
912 2, /* size (0 = byte, 1 = short, 2 = long) */
913 32, /* bitsize */
914 FALSE, /* pc_relative */
915 0, /* bitpos */
916 complain_overflow_bitfield, /* complain_on_overflow */
917 bfd_elf_generic_reloc, /* */
918 "R_SH_JMP_SLOT", /* name */
919 TRUE, /* partial_inplace */
920 0xffffffff, /* src_mask */
921 0xffffffff, /* dst_mask */
922 FALSE), /* pcrel_offset */
923
924 HOWTO (R_SH_RELATIVE, /* type */
925 0, /* rightshift */
926 2, /* size (0 = byte, 1 = short, 2 = long) */
927 32, /* bitsize */
928 FALSE, /* pc_relative */
929 0, /* bitpos */
930 complain_overflow_bitfield, /* complain_on_overflow */
931 bfd_elf_generic_reloc, /* */
932 "R_SH_RELATIVE", /* name */
933 TRUE, /* partial_inplace */
934 0xffffffff, /* src_mask */
935 0xffffffff, /* dst_mask */
936 FALSE), /* pcrel_offset */
937
938 HOWTO (R_SH_GOTOFF, /* type */
939 0, /* rightshift */
940 2, /* size (0 = byte, 1 = short, 2 = long) */
941 32, /* bitsize */
942 FALSE, /* pc_relative */
943 0, /* bitpos */
944 complain_overflow_bitfield, /* complain_on_overflow */
945 bfd_elf_generic_reloc, /* */
946 "R_SH_GOTOFF", /* name */
947 TRUE, /* partial_inplace */
948 0xffffffff, /* src_mask */
949 0xffffffff, /* dst_mask */
950 FALSE), /* pcrel_offset */
951
952 HOWTO (R_SH_GOTPC, /* type */
953 0, /* rightshift */
954 2, /* size (0 = byte, 1 = short, 2 = long) */
955 32, /* bitsize */
956 TRUE, /* pc_relative */
957 0, /* bitpos */
958 complain_overflow_bitfield, /* complain_on_overflow */
959 bfd_elf_generic_reloc, /* */
960 "R_SH_GOTPC", /* name */
961 TRUE, /* partial_inplace */
962 0xffffffff, /* src_mask */
963 0xffffffff, /* dst_mask */
964 TRUE), /* pcrel_offset */
965
966 HOWTO (R_SH_GOTPLT32, /* type */
967 0, /* rightshift */
968 2, /* size (0 = byte, 1 = short, 2 = long) */
969 32, /* bitsize */
970 FALSE, /* pc_relative */
971 0, /* bitpos */
972 complain_overflow_bitfield, /* complain_on_overflow */
973 bfd_elf_generic_reloc, /* */
974 "R_SH_GOTPLT32", /* name */
975 FALSE, /* partial_inplace */
976 0xffffffff, /* src_mask */
977 0xffffffff, /* dst_mask */
978 FALSE), /* pcrel_offset */
979
980#ifdef INCLUDE_SHMEDIA
981 /* Used in MOVI and SHORI (x & 65536). */
982 HOWTO (R_SH_GOT_LOW16, /* type */
983 0, /* rightshift */
984 2, /* size (0 = byte, 1 = short, 2 = long) */
985 64, /* bitsize */
986 FALSE, /* pc_relative */
987 10, /* bitpos */
988 complain_overflow_dont, /* complain_on_overflow */
989 bfd_elf_generic_reloc, /* special_function */
990 "R_SH_GOT_LOW16", /* name */
991 FALSE, /* partial_inplace */
992 0, /* src_mask */
993 0x3fffc00, /* dst_mask */
994 FALSE), /* pcrel_offset */
995
996 /* Used in MOVI and SHORI ((x >> 16) & 65536). */
997 HOWTO (R_SH_GOT_MEDLOW16, /* type */
998 16, /* rightshift */
999 2, /* size (0 = byte, 1 = short, 2 = long) */
1000 64, /* bitsize */
1001 FALSE, /* pc_relative */
1002 10, /* bitpos */
1003 complain_overflow_dont, /* complain_on_overflow */
1004 bfd_elf_generic_reloc, /* special_function */
1005 "R_SH_GOT_MEDLOW16", /* name */
1006 FALSE, /* partial_inplace */
1007 0, /* src_mask */
1008 0x3fffc00, /* dst_mask */
1009 FALSE), /* pcrel_offset */
1010
1011 /* Used in MOVI and SHORI ((x >> 32) & 65536). */
1012 HOWTO (R_SH_GOT_MEDHI16, /* type */
1013 32, /* rightshift */
1014 2, /* size (0 = byte, 1 = short, 2 = long) */
1015 64, /* bitsize */
1016 FALSE, /* pc_relative */
1017 10, /* bitpos */
1018 complain_overflow_dont, /* complain_on_overflow */
1019 bfd_elf_generic_reloc, /* special_function */
1020 "R_SH_GOT_MEDHI16", /* name */
1021 FALSE, /* partial_inplace */
1022 0, /* src_mask */
1023 0x3fffc00, /* dst_mask */
1024 FALSE), /* pcrel_offset */
1025
1026 /* Used in MOVI and SHORI ((x >> 48) & 65536). */
1027 HOWTO (R_SH_GOT_HI16, /* type */
1028 48, /* rightshift */
1029 2, /* size (0 = byte, 1 = short, 2 = long) */
1030 64, /* bitsize */
1031 FALSE, /* pc_relative */
1032 10, /* bitpos */
1033 complain_overflow_dont, /* complain_on_overflow */
1034 bfd_elf_generic_reloc, /* special_function */
1035 "R_SH_GOT_HI16", /* name */
1036 FALSE, /* partial_inplace */
1037 0, /* src_mask */
1038 0x3fffc00, /* dst_mask */
1039 FALSE), /* pcrel_offset */
1040
1041 /* Used in MOVI and SHORI (x & 65536). */
1042 HOWTO (R_SH_GOTPLT_LOW16, /* type */
1043 0, /* rightshift */
1044 2, /* size (0 = byte, 1 = short, 2 = long) */
1045 64, /* bitsize */
1046 FALSE, /* pc_relative */
1047 10, /* bitpos */
1048 complain_overflow_dont, /* complain_on_overflow */
1049 bfd_elf_generic_reloc, /* special_function */
1050 "R_SH_GOTPLT_LOW16", /* name */
1051 FALSE, /* partial_inplace */
1052 0, /* src_mask */
1053 0x3fffc00, /* dst_mask */
1054 FALSE), /* pcrel_offset */
1055
1056 /* Used in MOVI and SHORI ((x >> 16) & 65536). */
1057 HOWTO (R_SH_GOTPLT_MEDLOW16, /* type */
1058 16, /* rightshift */
1059 2, /* size (0 = byte, 1 = short, 2 = long) */
1060 64, /* bitsize */
1061 FALSE, /* pc_relative */
1062 10, /* bitpos */
1063 complain_overflow_dont, /* complain_on_overflow */
1064 bfd_elf_generic_reloc, /* special_function */
1065 "R_SH_GOTPLT_MEDLOW16", /* name */
1066 FALSE, /* partial_inplace */
1067 0, /* src_mask */
1068 0x3fffc00, /* dst_mask */
1069 FALSE), /* pcrel_offset */
1070
1071 /* Used in MOVI and SHORI ((x >> 32) & 65536). */
1072 HOWTO (R_SH_GOTPLT_MEDHI16, /* type */
1073 32, /* rightshift */
1074 2, /* size (0 = byte, 1 = short, 2 = long) */
1075 64, /* bitsize */
1076 FALSE, /* pc_relative */
1077 10, /* bitpos */
1078 complain_overflow_dont, /* complain_on_overflow */
1079 bfd_elf_generic_reloc, /* special_function */
1080 "R_SH_GOTPLT_MEDHI16", /* name */
1081 FALSE, /* partial_inplace */
1082 0, /* src_mask */
1083 0x3fffc00, /* dst_mask */
1084 FALSE), /* pcrel_offset */
1085
1086 /* Used in MOVI and SHORI ((x >> 48) & 65536). */
1087 HOWTO (R_SH_GOTPLT_HI16, /* type */
1088 48, /* rightshift */
1089 2, /* size (0 = byte, 1 = short, 2 = long) */
1090 64, /* bitsize */
1091 FALSE, /* pc_relative */
1092 10, /* bitpos */
1093 complain_overflow_dont, /* complain_on_overflow */
1094 bfd_elf_generic_reloc, /* special_function */
1095 "R_SH_GOTPLT_HI16", /* name */
1096 FALSE, /* partial_inplace */
1097 0, /* src_mask */
1098 0x3fffc00, /* dst_mask */
1099 FALSE), /* pcrel_offset */
1100
1101 /* Used in MOVI and SHORI (x & 65536). */
1102 HOWTO (R_SH_PLT_LOW16, /* type */
1103 0, /* rightshift */
1104 2, /* size (0 = byte, 1 = short, 2 = long) */
1105 64, /* bitsize */
1106 TRUE, /* pc_relative */
1107 10, /* bitpos */
1108 complain_overflow_dont, /* complain_on_overflow */
1109 bfd_elf_generic_reloc, /* special_function */
1110 "R_SH_PLT_LOW16", /* name */
1111 FALSE, /* partial_inplace */
1112 0, /* src_mask */
1113 0x3fffc00, /* dst_mask */
1114 TRUE), /* pcrel_offset */
1115
1116 /* Used in MOVI and SHORI ((x >> 16) & 65536). */
1117 HOWTO (R_SH_PLT_MEDLOW16, /* type */
1118 16, /* rightshift */
1119 2, /* size (0 = byte, 1 = short, 2 = long) */
1120 64, /* bitsize */
1121 TRUE, /* pc_relative */
1122 10, /* bitpos */
1123 complain_overflow_dont, /* complain_on_overflow */
1124 bfd_elf_generic_reloc, /* special_function */
1125 "R_SH_PLT_MEDLOW16", /* name */
1126 FALSE, /* partial_inplace */
1127 0, /* src_mask */
1128 0x3fffc00, /* dst_mask */
1129 TRUE), /* pcrel_offset */
1130
1131 /* Used in MOVI and SHORI ((x >> 32) & 65536). */
1132 HOWTO (R_SH_PLT_MEDHI16, /* type */
1133 32, /* rightshift */
1134 2, /* size (0 = byte, 1 = short, 2 = long) */
1135 64, /* bitsize */
1136 TRUE, /* pc_relative */
1137 10, /* bitpos */
1138 complain_overflow_dont, /* complain_on_overflow */
1139 bfd_elf_generic_reloc, /* special_function */
1140 "R_SH_PLT_MEDHI16", /* name */
1141 FALSE, /* partial_inplace */
1142 0, /* src_mask */
1143 0x3fffc00, /* dst_mask */
1144 TRUE), /* pcrel_offset */
1145
1146 /* Used in MOVI and SHORI ((x >> 48) & 65536). */
1147 HOWTO (R_SH_PLT_HI16, /* type */
1148 48, /* rightshift */
1149 2, /* size (0 = byte, 1 = short, 2 = long) */
1150 64, /* bitsize */
1151 TRUE, /* pc_relative */
1152 10, /* bitpos */
1153 complain_overflow_dont, /* complain_on_overflow */
1154 bfd_elf_generic_reloc, /* special_function */
1155 "R_SH_PLT_HI16", /* name */
1156 FALSE, /* partial_inplace */
1157 0, /* src_mask */
1158 0x3fffc00, /* dst_mask */
1159 TRUE), /* pcrel_offset */
1160
1161 /* Used in MOVI and SHORI (x & 65536). */
1162 HOWTO (R_SH_GOTOFF_LOW16, /* type */
1163 0, /* rightshift */
1164 2, /* size (0 = byte, 1 = short, 2 = long) */
1165 64, /* bitsize */
1166 FALSE, /* pc_relative */
1167 10, /* bitpos */
1168 complain_overflow_dont, /* complain_on_overflow */
1169 bfd_elf_generic_reloc, /* special_function */
1170 "R_SH_GOTOFF_LOW16", /* name */
1171 FALSE, /* partial_inplace */
1172 0, /* src_mask */
1173 0x3fffc00, /* dst_mask */
1174 FALSE), /* pcrel_offset */
1175
1176 /* Used in MOVI and SHORI ((x >> 16) & 65536). */
1177 HOWTO (R_SH_GOTOFF_MEDLOW16, /* type */
1178 16, /* rightshift */
1179 2, /* size (0 = byte, 1 = short, 2 = long) */
1180 64, /* bitsize */
1181 FALSE, /* pc_relative */
1182 10, /* bitpos */
1183 complain_overflow_dont, /* complain_on_overflow */
1184 bfd_elf_generic_reloc, /* special_function */
1185 "R_SH_GOTOFF_MEDLOW16", /* name */
1186 FALSE, /* partial_inplace */
1187 0, /* src_mask */
1188 0x3fffc00, /* dst_mask */
1189 FALSE), /* pcrel_offset */
1190
1191 /* Used in MOVI and SHORI ((x >> 32) & 65536). */
1192 HOWTO (R_SH_GOTOFF_MEDHI16, /* type */
1193 32, /* rightshift */
1194 2, /* size (0 = byte, 1 = short, 2 = long) */
1195 64, /* bitsize */
1196 FALSE, /* pc_relative */
1197 10, /* bitpos */
1198 complain_overflow_dont, /* complain_on_overflow */
1199 bfd_elf_generic_reloc, /* special_function */
1200 "R_SH_GOTOFF_MEDHI16", /* name */
1201 FALSE, /* partial_inplace */
1202 0, /* src_mask */
1203 0x3fffc00, /* dst_mask */
1204 FALSE), /* pcrel_offset */
1205
1206 /* Used in MOVI and SHORI ((x >> 48) & 65536). */
1207 HOWTO (R_SH_GOTOFF_HI16, /* type */
1208 48, /* rightshift */
1209 2, /* size (0 = byte, 1 = short, 2 = long) */
1210 64, /* bitsize */
1211 FALSE, /* pc_relative */
1212 10, /* bitpos */
1213 complain_overflow_dont, /* complain_on_overflow */
1214 bfd_elf_generic_reloc, /* special_function */
1215 "R_SH_GOTOFF_HI16", /* name */
1216 FALSE, /* partial_inplace */
1217 0, /* src_mask */
1218 0x3fffc00, /* dst_mask */
1219 FALSE), /* pcrel_offset */
1220
1221 /* Used in MOVI and SHORI (x & 65536). */
1222 HOWTO (R_SH_GOTPC_LOW16, /* type */
1223 0, /* rightshift */
1224 2, /* size (0 = byte, 1 = short, 2 = long) */
1225 64, /* bitsize */
1226 TRUE, /* pc_relative */
1227 10, /* bitpos */
1228 complain_overflow_dont, /* complain_on_overflow */
1229 bfd_elf_generic_reloc, /* special_function */
1230 "R_SH_GOTPC_LOW16", /* name */
1231 FALSE, /* partial_inplace */
1232 0, /* src_mask */
1233 0x3fffc00, /* dst_mask */
1234 TRUE), /* pcrel_offset */
1235
1236 /* Used in MOVI and SHORI ((x >> 16) & 65536). */
1237 HOWTO (R_SH_GOTPC_MEDLOW16, /* type */
1238 16, /* rightshift */
1239 2, /* size (0 = byte, 1 = short, 2 = long) */
1240 64, /* bitsize */
1241 TRUE, /* pc_relative */
1242 10, /* bitpos */
1243 complain_overflow_dont, /* complain_on_overflow */
1244 bfd_elf_generic_reloc, /* special_function */
1245 "R_SH_GOTPC_MEDLOW16", /* name */
1246 FALSE, /* partial_inplace */
1247 0, /* src_mask */
1248 0x3fffc00, /* dst_mask */
1249 TRUE), /* pcrel_offset */
1250
1251 /* Used in MOVI and SHORI ((x >> 32) & 65536). */
1252 HOWTO (R_SH_GOTPC_MEDHI16, /* type */
1253 32, /* rightshift */
1254 2, /* size (0 = byte, 1 = short, 2 = long) */
1255 64, /* bitsize */
1256 TRUE, /* pc_relative */
1257 10, /* bitpos */
1258 complain_overflow_dont, /* complain_on_overflow */
1259 bfd_elf_generic_reloc, /* special_function */
1260 "R_SH_GOTPC_MEDHI16", /* name */
1261 FALSE, /* partial_inplace */
1262 0, /* src_mask */
1263 0x3fffc00, /* dst_mask */
1264 TRUE), /* pcrel_offset */
1265
1266 /* Used in MOVI and SHORI ((x >> 48) & 65536). */
1267 HOWTO (R_SH_GOTPC_HI16, /* type */
1268 48, /* rightshift */
1269 2, /* size (0 = byte, 1 = short, 2 = long) */
1270 64, /* bitsize */
1271 TRUE, /* pc_relative */
1272 10, /* bitpos */
1273 complain_overflow_dont, /* complain_on_overflow */
1274 bfd_elf_generic_reloc, /* special_function */
1275 "R_SH_GOTPC_HI16", /* name */
1276 FALSE, /* partial_inplace */
1277 0, /* src_mask */
1278 0x3fffc00, /* dst_mask */
1279 TRUE), /* pcrel_offset */
1280
1281 /* Used in LD.L, FLD.S et al. */
1282 HOWTO (R_SH_GOT10BY4, /* type */
1283 2, /* rightshift */
1284 2, /* size (0 = byte, 1 = short, 2 = long) */
1285 12, /* bitsize */
1286 FALSE, /* pc_relative */
1287 10, /* bitpos */
1288 complain_overflow_signed, /* complain_on_overflow */
1289 bfd_elf_generic_reloc, /* special_function */
1290 "R_SH_GOT10BY4", /* name */
1291 FALSE, /* partial_inplace */
1292 0, /* src_mask */
1293 0xffc00, /* dst_mask */
1294 FALSE), /* pcrel_offset */
1295
1296 /* Used in LD.L, FLD.S et al. */
1297 HOWTO (R_SH_GOTPLT10BY4, /* type */
1298 2, /* rightshift */
1299 2, /* size (0 = byte, 1 = short, 2 = long) */
1300 12, /* bitsize */
1301 FALSE, /* pc_relative */
1302 10, /* bitpos */
1303 complain_overflow_signed, /* complain_on_overflow */
1304 bfd_elf_generic_reloc, /* special_function */
1305 "R_SH_GOTPLT10BY4", /* name */
1306 FALSE, /* partial_inplace */
1307 0, /* src_mask */
1308 0xffc00, /* dst_mask */
1309 FALSE), /* pcrel_offset */
1310
1311 /* Used in FLD.D, FST.P et al. */
1312 HOWTO (R_SH_GOT10BY8, /* type */
1313 3, /* rightshift */
1314 2, /* size (0 = byte, 1 = short, 2 = long) */
1315 13, /* bitsize */
1316 FALSE, /* pc_relative */
1317 10, /* bitpos */
1318 complain_overflow_signed, /* complain_on_overflow */
1319 bfd_elf_generic_reloc, /* special_function */
1320 "R_SH_GOT10BY8", /* name */
1321 FALSE, /* partial_inplace */
1322 0, /* src_mask */
1323 0xffc00, /* dst_mask */
1324 FALSE), /* pcrel_offset */
1325
1326 /* Used in FLD.D, FST.P et al. */
1327 HOWTO (R_SH_GOTPLT10BY8, /* type */
1328 3, /* rightshift */
1329 2, /* size (0 = byte, 1 = short, 2 = long) */
1330 13, /* bitsize */
1331 FALSE, /* pc_relative */
1332 10, /* bitpos */
1333 complain_overflow_signed, /* complain_on_overflow */
1334 bfd_elf_generic_reloc, /* special_function */
1335 "R_SH_GOTPLT10BY8", /* name */
1336 FALSE, /* partial_inplace */
1337 0, /* src_mask */
1338 0xffc00, /* dst_mask */
1339 FALSE), /* pcrel_offset */
1340
1341 HOWTO (R_SH_COPY64, /* type */
1342 0, /* rightshift */
1343 4, /* size (0 = byte, 1 = short, 2 = long) */
1344 64, /* bitsize */
1345 FALSE, /* pc_relative */
1346 0, /* bitpos */
1347 complain_overflow_dont, /* complain_on_overflow */
1348 bfd_elf_generic_reloc, /* special_function */
1349 "R_SH_COPY64", /* name */
1350 FALSE, /* partial_inplace */
1351 0, /* src_mask */
1352 ((bfd_vma) 0) - 1, /* dst_mask */
1353 FALSE), /* pcrel_offset */
1354
1355 HOWTO (R_SH_GLOB_DAT64, /* type */
1356 0, /* rightshift */
1357 4, /* size (0 = byte, 1 = short, 2 = long) */
1358 64, /* bitsize */
1359 FALSE, /* pc_relative */
1360 0, /* bitpos */
1361 complain_overflow_dont, /* complain_on_overflow */
1362 bfd_elf_generic_reloc, /* special_function */
1363 "R_SH_GLOB_DAT64", /* name */
1364 FALSE, /* partial_inplace */
1365 0, /* src_mask */
1366 ((bfd_vma) 0) - 1, /* dst_mask */
1367 FALSE), /* pcrel_offset */
1368
1369 HOWTO (R_SH_JMP_SLOT64, /* type */
1370 0, /* rightshift */
1371 4, /* size (0 = byte, 1 = short, 2 = long) */
1372 64, /* bitsize */
1373 FALSE, /* pc_relative */
1374 0, /* bitpos */
1375 complain_overflow_dont, /* complain_on_overflow */
1376 bfd_elf_generic_reloc, /* special_function */
1377 "R_SH_JMP_SLOT64", /* name */
1378 FALSE, /* partial_inplace */
1379 0, /* src_mask */
1380 ((bfd_vma) 0) - 1, /* dst_mask */
1381 FALSE), /* pcrel_offset */
1382
1383 HOWTO (R_SH_RELATIVE64, /* type */
1384 0, /* rightshift */
1385 4, /* size (0 = byte, 1 = short, 2 = long) */
1386 64, /* bitsize */
1387 FALSE, /* pc_relative */
1388 0, /* bitpos */
1389 complain_overflow_dont, /* complain_on_overflow */
1390 bfd_elf_generic_reloc, /* special_function */
1391 "R_SH_RELATIVE64", /* name */
1392 FALSE, /* partial_inplace */
1393 0, /* src_mask */
1394 ((bfd_vma) 0) - 1, /* dst_mask */
1395 FALSE), /* pcrel_offset */
1396
1397 EMPTY_HOWTO (197),
1398 EMPTY_HOWTO (198),
1399 EMPTY_HOWTO (199),
1400 EMPTY_HOWTO (200),
1401 EMPTY_HOWTO (201),
1402 EMPTY_HOWTO (202),
1403 EMPTY_HOWTO (203),
1404 EMPTY_HOWTO (204),
1405 EMPTY_HOWTO (205),
1406 EMPTY_HOWTO (206),
1407 EMPTY_HOWTO (207),
1408 EMPTY_HOWTO (208),
1409 EMPTY_HOWTO (209),
1410 EMPTY_HOWTO (210),
1411 EMPTY_HOWTO (211),
1412 EMPTY_HOWTO (212),
1413 EMPTY_HOWTO (213),
1414 EMPTY_HOWTO (214),
1415 EMPTY_HOWTO (215),
1416 EMPTY_HOWTO (216),
1417 EMPTY_HOWTO (217),
1418 EMPTY_HOWTO (218),
1419 EMPTY_HOWTO (219),
1420 EMPTY_HOWTO (220),
1421 EMPTY_HOWTO (221),
1422 EMPTY_HOWTO (222),
1423 EMPTY_HOWTO (223),
1424 EMPTY_HOWTO (224),
1425 EMPTY_HOWTO (225),
1426 EMPTY_HOWTO (226),
1427 EMPTY_HOWTO (227),
1428 EMPTY_HOWTO (228),
1429 EMPTY_HOWTO (229),
1430 EMPTY_HOWTO (230),
1431 EMPTY_HOWTO (231),
1432 EMPTY_HOWTO (232),
1433 EMPTY_HOWTO (233),
1434 EMPTY_HOWTO (234),
1435 EMPTY_HOWTO (235),
1436 EMPTY_HOWTO (236),
1437 EMPTY_HOWTO (237),
1438 EMPTY_HOWTO (238),
1439 EMPTY_HOWTO (239),
1440 EMPTY_HOWTO (240),
1441 EMPTY_HOWTO (241),
1442
1443 /* Relocations for SHmedia code. None of these are partial_inplace or
1444 use the field being relocated (except R_SH_PT_16). */
1445
1446 /* The assembler will generate this reloc before a block of SHmedia
1447 instructions. A section should be processed as assuming it contains
1448 data, unless this reloc is seen. Note that a block of SHcompact
1449 instructions are instead preceded by R_SH_CODE.
1450 This is currently not implemented, but should be used for SHmedia
1451 linker relaxation. */
1452 HOWTO (R_SH_SHMEDIA_CODE, /* type */
1453 0, /* rightshift */
1454 1, /* size (0 = byte, 1 = short, 2 = long) */
1455 0, /* bitsize */
1456 FALSE, /* pc_relative */
1457 0, /* bitpos */
1458 complain_overflow_unsigned, /* complain_on_overflow */
1459 sh_elf_ignore_reloc, /* special_function */
1460 "R_SH_SHMEDIA_CODE", /* name */
1461 FALSE, /* partial_inplace */
1462 0, /* src_mask */
1463 0, /* dst_mask */
1464 FALSE), /* pcrel_offset */
1465
1466 /* The assembler will generate this reloc at a PTA or PTB instruction,
1467 and the linker checks the right type of target, or changes a PTA to a
1468 PTB, if the original insn was PT. */
1469 HOWTO (R_SH_PT_16, /* type */
1470 2, /* rightshift */
1471 2, /* size (0 = byte, 1 = short, 2 = long) */
1472 18, /* bitsize */
1473 TRUE, /* pc_relative */
1474 10, /* bitpos */
1475 complain_overflow_signed, /* complain_on_overflow */
1476 bfd_elf_generic_reloc, /* special_function */
1477 "R_SH_PT_16", /* name */
1478 FALSE, /* partial_inplace */
1479 0, /* src_mask */
1480 0x3fffc00, /* dst_mask */
1481 TRUE), /* pcrel_offset */
1482
1483 /* Used in unexpanded MOVI. */
1484 HOWTO (R_SH_IMMS16, /* type */
1485 0, /* rightshift */
1486 2, /* size (0 = byte, 1 = short, 2 = long) */
1487 16, /* bitsize */
1488 FALSE, /* pc_relative */
1489 10, /* bitpos */
1490 complain_overflow_signed, /* complain_on_overflow */
1491 bfd_elf_generic_reloc, /* special_function */
1492 "R_SH_IMMS16", /* name */
1493 FALSE, /* partial_inplace */
1494 0, /* src_mask */
1495 0x3fffc00, /* dst_mask */
1496 FALSE), /* pcrel_offset */
1497
1498 /* Used in SHORI. */
1499 HOWTO (R_SH_IMMU16, /* type */
1500 0, /* rightshift */
1501 2, /* size (0 = byte, 1 = short, 2 = long) */
1502 16, /* bitsize */
1503 FALSE, /* pc_relative */
1504 10, /* bitpos */
1505 complain_overflow_unsigned, /* complain_on_overflow */
1506 bfd_elf_generic_reloc, /* special_function */
1507 "R_SH_IMMU16", /* name */
1508 FALSE, /* partial_inplace */
1509 0, /* src_mask */
1510 0x3fffc00, /* dst_mask */
1511 FALSE), /* pcrel_offset */
1512
1513 /* Used in MOVI and SHORI (x & 65536). */
1514 HOWTO (R_SH_IMM_LOW16, /* type */
1515 0, /* rightshift */
1516 2, /* size (0 = byte, 1 = short, 2 = long) */
1517 64, /* bitsize */
1518 FALSE, /* pc_relative */
1519 10, /* bitpos */
1520 complain_overflow_dont, /* complain_on_overflow */
1521 bfd_elf_generic_reloc, /* special_function */
1522 "R_SH_IMM_LOW16", /* name */
1523 FALSE, /* partial_inplace */
1524 0, /* src_mask */
1525 0x3fffc00, /* dst_mask */
1526 FALSE), /* pcrel_offset */
1527
1528 /* Used in MOVI and SHORI ((x - $) & 65536). */
1529 HOWTO (R_SH_IMM_LOW16_PCREL, /* type */
1530 0, /* rightshift */
1531 2, /* size (0 = byte, 1 = short, 2 = long) */
1532 64, /* bitsize */
1533 TRUE, /* pc_relative */
1534 10, /* bitpos */
1535 complain_overflow_dont, /* complain_on_overflow */
1536 bfd_elf_generic_reloc, /* special_function */
1537 "R_SH_IMM_LOW16_PCREL", /* name */
1538 FALSE, /* partial_inplace */
1539 0, /* src_mask */
1540 0x3fffc00, /* dst_mask */
1541 TRUE), /* pcrel_offset */
1542
1543 /* Used in MOVI and SHORI ((x >> 16) & 65536). */
1544 HOWTO (R_SH_IMM_MEDLOW16, /* type */
1545 16, /* rightshift */
1546 2, /* size (0 = byte, 1 = short, 2 = long) */
1547 64, /* bitsize */
1548 FALSE, /* pc_relative */
1549 10, /* bitpos */
1550 complain_overflow_dont, /* complain_on_overflow */
1551 bfd_elf_generic_reloc, /* special_function */
1552 "R_SH_IMM_MEDLOW16", /* name */
1553 FALSE, /* partial_inplace */
1554 0, /* src_mask */
1555 0x3fffc00, /* dst_mask */
1556 FALSE), /* pcrel_offset */
1557
1558 /* Used in MOVI and SHORI (((x - $) >> 16) & 65536). */
1559 HOWTO (R_SH_IMM_MEDLOW16_PCREL, /* type */
1560 16, /* rightshift */
1561 2, /* size (0 = byte, 1 = short, 2 = long) */
1562 64, /* bitsize */
1563 TRUE, /* pc_relative */
1564 10, /* bitpos */
1565 complain_overflow_dont, /* complain_on_overflow */
1566 bfd_elf_generic_reloc, /* special_function */
1567 "R_SH_IMM_MEDLOW16_PCREL", /* name */
1568 FALSE, /* partial_inplace */
1569 0, /* src_mask */
1570 0x3fffc00, /* dst_mask */
1571 TRUE), /* pcrel_offset */
1572
1573 /* Used in MOVI and SHORI ((x >> 32) & 65536). */
1574 HOWTO (R_SH_IMM_MEDHI16, /* type */
1575 32, /* rightshift */
1576 2, /* size (0 = byte, 1 = short, 2 = long) */
1577 64, /* bitsize */
1578 FALSE, /* pc_relative */
1579 10, /* bitpos */
1580 complain_overflow_dont, /* complain_on_overflow */
1581 bfd_elf_generic_reloc, /* special_function */
1582 "R_SH_IMM_MEDHI16", /* name */
1583 FALSE, /* partial_inplace */
1584 0, /* src_mask */
1585 0x3fffc00, /* dst_mask */
1586 FALSE), /* pcrel_offset */
1587
1588 /* Used in MOVI and SHORI (((x - $) >> 32) & 65536). */
1589 HOWTO (R_SH_IMM_MEDHI16_PCREL, /* type */
1590 32, /* rightshift */
1591 2, /* size (0 = byte, 1 = short, 2 = long) */
1592 64, /* bitsize */
1593 TRUE, /* pc_relative */
1594 10, /* bitpos */
1595 complain_overflow_dont, /* complain_on_overflow */
1596 bfd_elf_generic_reloc, /* special_function */
1597 "R_SH_IMM_MEDHI16_PCREL", /* name */
1598 FALSE, /* partial_inplace */
1599 0, /* src_mask */
1600 0x3fffc00, /* dst_mask */
1601 TRUE), /* pcrel_offset */
1602
1603 /* Used in MOVI and SHORI ((x >> 48) & 65536). */
1604 HOWTO (R_SH_IMM_HI16, /* type */
1605 48, /* rightshift */
1606 2, /* size (0 = byte, 1 = short, 2 = long) */
1607 64, /* bitsize */
1608 FALSE, /* pc_relative */
1609 10, /* bitpos */
1610 complain_overflow_dont, /* complain_on_overflow */
1611 bfd_elf_generic_reloc, /* special_function */
1612 "R_SH_IMM_HI16", /* name */
1613 FALSE, /* partial_inplace */
1614 0, /* src_mask */
1615 0x3fffc00, /* dst_mask */
1616 FALSE), /* pcrel_offset */
1617
1618 /* Used in MOVI and SHORI (((x - $) >> 48) & 65536). */
1619 HOWTO (R_SH_IMM_HI16_PCREL, /* type */
1620 48, /* rightshift */
1621 2, /* size (0 = byte, 1 = short, 2 = long) */
1622 64, /* bitsize */
1623 TRUE, /* pc_relative */
1624 10, /* bitpos */
1625 complain_overflow_dont, /* complain_on_overflow */
1626 bfd_elf_generic_reloc, /* special_function */
1627 "R_SH_IMM_HI16_PCREL", /* name */
1628 FALSE, /* partial_inplace */
1629 0, /* src_mask */
1630 0x3fffc00, /* dst_mask */
1631 TRUE), /* pcrel_offset */
1632
1633 /* For the .uaquad pseudo. */
1634 HOWTO (R_SH_64, /* type */
1635 0, /* rightshift */
1636 4, /* size (0 = byte, 1 = short, 2 = long) */
1637 64, /* bitsize */
1638 FALSE, /* pc_relative */
1639 0, /* bitpos */
1640 complain_overflow_dont, /* complain_on_overflow */
1641 bfd_elf_generic_reloc, /* special_function */
1642 "R_SH_64", /* name */
1643 FALSE, /* partial_inplace */
1644 0, /* src_mask */
1645 ((bfd_vma) 0) - 1, /* dst_mask */
1646 FALSE), /* pcrel_offset */
1647
1648 /* For the .uaquad pseudo, (x - $). */
1649 HOWTO (R_SH_64_PCREL, /* type */
1650 48, /* rightshift */
1651 2, /* size (0 = byte, 1 = short, 2 = long) */
1652 64, /* bitsize */
1653 TRUE, /* pc_relative */
1654 10, /* bitpos */
1655 complain_overflow_dont, /* complain_on_overflow */
1656 bfd_elf_generic_reloc, /* special_function */
1657 "R_SH_64_PCREL", /* name */
1658 FALSE, /* partial_inplace */
1659 0, /* src_mask */
1660 ((bfd_vma) 0) - 1, /* dst_mask */
1661 TRUE), /* pcrel_offset */
1662
1663#endif
1664};
1665
1666static bfd_reloc_status_type
1667sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, addr,
1668 symbol_section, start, end)
1669 int r_type ATTRIBUTE_UNUSED;
1670 bfd *input_bfd;
1671 asection *input_section;
1672 bfd_byte *contents;
1673 bfd_vma addr;
1674 asection *symbol_section;
1675 bfd_vma start, end;
1676{
1677 static bfd_vma last_addr;
1678 static asection *last_symbol_section;
1679 bfd_byte *start_ptr, *ptr, *last_ptr;
1680 int diff, cum_diff;
1681 bfd_signed_vma x;
1682 int insn;
1683
1684 /* Sanity check the address. */
1685 if (addr > input_section->_raw_size)
1686 return bfd_reloc_outofrange;
1687
1688 /* We require the start and end relocations to be processed consecutively -
1689 although we allow then to be processed forwards or backwards. */
1690 if (! last_addr)
1691 {
1692 last_addr = addr;
1693 last_symbol_section = symbol_section;
1694 return bfd_reloc_ok;
1695 }
1696 if (last_addr != addr)
1697 abort ();
1698 last_addr = 0;
1699
1700 if (! symbol_section || last_symbol_section != symbol_section || end < start)
1701 return bfd_reloc_outofrange;
1702
1703 /* Get the symbol_section contents. */
1704 if (symbol_section != input_section)
1705 {
1706 if (elf_section_data (symbol_section)->this_hdr.contents != NULL)
1707 contents = elf_section_data (symbol_section)->this_hdr.contents;
1708 else
1709 {
1710 contents = (bfd_byte *) bfd_malloc (symbol_section->_raw_size);
1711 if (contents == NULL)
1712 return bfd_reloc_outofrange;
1713 if (! bfd_get_section_contents (input_bfd, symbol_section, contents,
1714 (file_ptr) 0,
1715 symbol_section->_raw_size))
1716 {
1717 free (contents);
1718 return bfd_reloc_outofrange;
1719 }
1720 }
1721 }
1722#define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
1723 start_ptr = contents + start;
1724 for (cum_diff = -6, ptr = contents + end; cum_diff < 0 && ptr > start_ptr;)
1725 {
1726 for (last_ptr = ptr, ptr -= 4; ptr >= start_ptr && IS_PPI (ptr);)
1727 ptr -= 2;
1728 ptr += 2;
1729 diff = (last_ptr - ptr) >> 1;
1730 cum_diff += diff & 1;
1731 cum_diff += diff;
1732 }
1733 /* Calculate the start / end values to load into rs / re minus four -
1734 so that will cancel out the four we would otherwise have to add to
1735 addr to get the value to subtract in order to get relative addressing. */
1736 if (cum_diff >= 0)
1737 {
1738 start -= 4;
1739 end = (ptr + cum_diff * 2) - contents;
1740 }
1741 else
1742 {
1743 bfd_vma start0 = start - 4;
1744
1745 while (start0 && IS_PPI (contents + start0))
1746 start0 -= 2;
1747 start0 = start - 2 - ((start - start0) & 2);
1748 start = start0 - cum_diff - 2;
1749 end = start0;
1750 }
1751
1752 if (contents != NULL
1753 && elf_section_data (symbol_section)->this_hdr.contents != contents)
1754 free (contents);
1755
1756 insn = bfd_get_16 (input_bfd, contents + addr);
1757
1758 x = (insn & 0x200 ? end : start) - addr;
1759 if (input_section != symbol_section)
1760 x += ((symbol_section->output_section->vma + symbol_section->output_offset)
1761 - (input_section->output_section->vma
1762 + input_section->output_offset));
1763 x >>= 1;
1764 if (x < -128 || x > 127)
1765 return bfd_reloc_overflow;
1766
1767 x = (insn & ~0xff) | (x & 0xff);
1768 bfd_put_16 (input_bfd, (bfd_vma) x, contents + addr);
1769
1770 return bfd_reloc_ok;
1771}
1772
1773/* This function is used for normal relocs. This used to be like the COFF
1774 function, and is almost certainly incorrect for other ELF targets. */
1775
1776static bfd_reloc_status_type
1777sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
1778 error_message)
1779 bfd *abfd;
1780 arelent *reloc_entry;
1781 asymbol *symbol_in;
1782 PTR data;
1783 asection *input_section;
1784 bfd *output_bfd;
1785 char **error_message ATTRIBUTE_UNUSED;
1786{
1787 unsigned long insn;
1788 bfd_vma sym_value;
1789 enum elf_sh_reloc_type r_type;
1790 bfd_vma addr = reloc_entry->address;
1791 bfd_byte *hit_data = addr + (bfd_byte *) data;
1792
1793 r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
1794
1795 if (output_bfd != NULL)
1796 {
1797 /* Partial linking--do nothing. */
1798 reloc_entry->address += input_section->output_offset;
1799 return bfd_reloc_ok;
1800 }
1801
1802 /* Almost all relocs have to do with relaxing. If any work must be
1803 done for them, it has been done in sh_relax_section. */
1804 if (r_type == R_SH_IND12W && (symbol_in->flags & BSF_LOCAL) != 0)
1805 return bfd_reloc_ok;
1806
1807 if (symbol_in != NULL
1808 && bfd_is_und_section (symbol_in->section))
1809 return bfd_reloc_undefined;
1810
1811 if (bfd_is_com_section (symbol_in->section))
1812 sym_value = 0;
1813 else
1814 sym_value = (symbol_in->value +
1815 symbol_in->section->output_section->vma +
1816 symbol_in->section->output_offset);
1817
1818 switch (r_type)
1819 {
1820 case R_SH_DIR32:
1821 insn = bfd_get_32 (abfd, hit_data);
1822 insn += sym_value + reloc_entry->addend;
1823 bfd_put_32 (abfd, (bfd_vma) insn, hit_data);
1824 break;
1825 case R_SH_IND12W:
1826 insn = bfd_get_16 (abfd, hit_data);
1827 sym_value += reloc_entry->addend;
1828 sym_value -= (input_section->output_section->vma
1829 + input_section->output_offset
1830 + addr
1831 + 4);
1832 sym_value += (insn & 0xfff) << 1;
1833 if (insn & 0x800)
1834 sym_value -= 0x1000;
1835 insn = (insn & 0xf000) | (sym_value & 0xfff);
1836 bfd_put_16 (abfd, (bfd_vma) insn, hit_data);
1837 if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
1838 return bfd_reloc_overflow;
1839 break;
1840 default:
1841 abort ();
1842 break;
1843 }
1844
1845 return bfd_reloc_ok;
1846}
1847
1848/* This function is used for relocs which are only used for relaxing,
1849 which the linker should otherwise ignore. */
1850
1851static bfd_reloc_status_type
1852sh_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
1853 output_bfd, error_message)
1854 bfd *abfd ATTRIBUTE_UNUSED;
1855 arelent *reloc_entry;
1856 asymbol *symbol ATTRIBUTE_UNUSED;
1857 PTR data ATTRIBUTE_UNUSED;
1858 asection *input_section;
1859 bfd *output_bfd;
1860 char **error_message ATTRIBUTE_UNUSED;
1861{
1862 if (output_bfd != NULL)
1863 reloc_entry->address += input_section->output_offset;
1864 return bfd_reloc_ok;
1865}
1866
1867/* This structure is used to map BFD reloc codes to SH ELF relocs. */
1868
1869struct elf_reloc_map
1870{
1871 bfd_reloc_code_real_type bfd_reloc_val;
1872 unsigned char elf_reloc_val;
1873};
1874
1875/* An array mapping BFD reloc codes to SH ELF relocs. */
1876
1877static const struct elf_reloc_map sh_reloc_map[] =
1878{
1879 { BFD_RELOC_NONE, R_SH_NONE },
1880 { BFD_RELOC_32, R_SH_DIR32 },
1881 { BFD_RELOC_CTOR, R_SH_DIR32 },
1882 { BFD_RELOC_32_PCREL, R_SH_REL32 },
1883 { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
1884 { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
1885 { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
1886 { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
1887 { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
1888 { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
1889 { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
1890 { BFD_RELOC_SH_USES, R_SH_USES },
1891 { BFD_RELOC_SH_COUNT, R_SH_COUNT },
1892 { BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
1893 { BFD_RELOC_SH_CODE, R_SH_CODE },
1894 { BFD_RELOC_SH_DATA, R_SH_DATA },
1895 { BFD_RELOC_SH_LABEL, R_SH_LABEL },
1896 { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
1897 { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
1898 { BFD_RELOC_SH_LOOP_START, R_SH_LOOP_START },
1899 { BFD_RELOC_SH_LOOP_END, R_SH_LOOP_END },
1900 { BFD_RELOC_SH_TLS_GD_32, R_SH_TLS_GD_32 },
1901 { BFD_RELOC_SH_TLS_LD_32, R_SH_TLS_LD_32 },
1902 { BFD_RELOC_SH_TLS_LDO_32, R_SH_TLS_LDO_32 },
1903 { BFD_RELOC_SH_TLS_IE_32, R_SH_TLS_IE_32 },
1904 { BFD_RELOC_SH_TLS_LE_32, R_SH_TLS_LE_32 },
1905 { BFD_RELOC_SH_TLS_DTPMOD32, R_SH_TLS_DTPMOD32 },
1906 { BFD_RELOC_SH_TLS_DTPOFF32, R_SH_TLS_DTPOFF32 },
1907 { BFD_RELOC_SH_TLS_TPOFF32, R_SH_TLS_TPOFF32 },
1908 { BFD_RELOC_32_GOT_PCREL, R_SH_GOT32 },
1909 { BFD_RELOC_32_PLT_PCREL, R_SH_PLT32 },
1910 { BFD_RELOC_SH_COPY, R_SH_COPY },
1911 { BFD_RELOC_SH_GLOB_DAT, R_SH_GLOB_DAT },
1912 { BFD_RELOC_SH_JMP_SLOT, R_SH_JMP_SLOT },
1913 { BFD_RELOC_SH_RELATIVE, R_SH_RELATIVE },
1914 { BFD_RELOC_32_GOTOFF, R_SH_GOTOFF },
1915 { BFD_RELOC_SH_GOTPC, R_SH_GOTPC },
1916 { BFD_RELOC_SH_GOTPLT32, R_SH_GOTPLT32 },
1917#ifdef INCLUDE_SHMEDIA
1918 { BFD_RELOC_SH_GOT_LOW16, R_SH_GOT_LOW16 },
1919 { BFD_RELOC_SH_GOT_MEDLOW16, R_SH_GOT_MEDLOW16 },
1920 { BFD_RELOC_SH_GOT_MEDHI16, R_SH_GOT_MEDHI16 },
1921 { BFD_RELOC_SH_GOT_HI16, R_SH_GOT_HI16 },
1922 { BFD_RELOC_SH_GOTPLT_LOW16, R_SH_GOTPLT_LOW16 },
1923 { BFD_RELOC_SH_GOTPLT_MEDLOW16, R_SH_GOTPLT_MEDLOW16 },
1924 { BFD_RELOC_SH_GOTPLT_MEDHI16, R_SH_GOTPLT_MEDHI16 },
1925 { BFD_RELOC_SH_GOTPLT_HI16, R_SH_GOTPLT_HI16 },
1926 { BFD_RELOC_SH_PLT_LOW16, R_SH_PLT_LOW16 },
1927 { BFD_RELOC_SH_PLT_MEDLOW16, R_SH_PLT_MEDLOW16 },
1928 { BFD_RELOC_SH_PLT_MEDHI16, R_SH_PLT_MEDHI16 },
1929 { BFD_RELOC_SH_PLT_HI16, R_SH_PLT_HI16 },
1930 { BFD_RELOC_SH_GOTOFF_LOW16, R_SH_GOTOFF_LOW16 },
1931 { BFD_RELOC_SH_GOTOFF_MEDLOW16, R_SH_GOTOFF_MEDLOW16 },
1932 { BFD_RELOC_SH_GOTOFF_MEDHI16, R_SH_GOTOFF_MEDHI16 },
1933 { BFD_RELOC_SH_GOTOFF_HI16, R_SH_GOTOFF_HI16 },
1934 { BFD_RELOC_SH_GOTPC_LOW16, R_SH_GOTPC_LOW16 },
1935 { BFD_RELOC_SH_GOTPC_MEDLOW16, R_SH_GOTPC_MEDLOW16 },
1936 { BFD_RELOC_SH_GOTPC_MEDHI16, R_SH_GOTPC_MEDHI16 },
1937 { BFD_RELOC_SH_GOTPC_HI16, R_SH_GOTPC_HI16 },
1938 { BFD_RELOC_SH_COPY64, R_SH_COPY64 },
1939 { BFD_RELOC_SH_GLOB_DAT64, R_SH_GLOB_DAT64 },
1940 { BFD_RELOC_SH_JMP_SLOT64, R_SH_JMP_SLOT64 },
1941 { BFD_RELOC_SH_RELATIVE64, R_SH_RELATIVE64 },
1942 { BFD_RELOC_SH_GOT10BY4, R_SH_GOT10BY4 },
1943 { BFD_RELOC_SH_GOT10BY8, R_SH_GOT10BY8 },
1944 { BFD_RELOC_SH_GOTPLT10BY4, R_SH_GOTPLT10BY4 },
1945 { BFD_RELOC_SH_GOTPLT10BY8, R_SH_GOTPLT10BY8 },
1946 { BFD_RELOC_SH_PT_16, R_SH_PT_16 },
1947 { BFD_RELOC_SH_SHMEDIA_CODE, R_SH_SHMEDIA_CODE },
1948 { BFD_RELOC_SH_IMMU5, R_SH_DIR5U },
1949 { BFD_RELOC_SH_IMMS6, R_SH_DIR6S },
1950 { BFD_RELOC_SH_IMMU6, R_SH_DIR6U },
1951 { BFD_RELOC_SH_IMMS10, R_SH_DIR10S },
1952 { BFD_RELOC_SH_IMMS10BY2, R_SH_DIR10SW },
1953 { BFD_RELOC_SH_IMMS10BY4, R_SH_DIR10SL },
1954 { BFD_RELOC_SH_IMMS10BY8, R_SH_DIR10SQ },
1955 { BFD_RELOC_SH_IMMS16, R_SH_IMMS16 },
1956 { BFD_RELOC_SH_IMMU16, R_SH_IMMU16 },
1957 { BFD_RELOC_SH_IMM_LOW16, R_SH_IMM_LOW16 },
1958 { BFD_RELOC_SH_IMM_LOW16_PCREL, R_SH_IMM_LOW16_PCREL },
1959 { BFD_RELOC_SH_IMM_MEDLOW16, R_SH_IMM_MEDLOW16 },
1960 { BFD_RELOC_SH_IMM_MEDLOW16_PCREL, R_SH_IMM_MEDLOW16_PCREL },
1961 { BFD_RELOC_SH_IMM_MEDHI16, R_SH_IMM_MEDHI16 },
1962 { BFD_RELOC_SH_IMM_MEDHI16_PCREL, R_SH_IMM_MEDHI16_PCREL },
1963 { BFD_RELOC_SH_IMM_HI16, R_SH_IMM_HI16 },
1964 { BFD_RELOC_SH_IMM_HI16_PCREL, R_SH_IMM_HI16_PCREL },
1965 { BFD_RELOC_64, R_SH_64 },
1966 { BFD_RELOC_64_PCREL, R_SH_64_PCREL },
1967#endif /* not INCLUDE_SHMEDIA */
1968};
1969
1970/* Given a BFD reloc code, return the howto structure for the
1971 corresponding SH ELf reloc. */
1972
1973static reloc_howto_type *
1974sh_elf_reloc_type_lookup (abfd, code)
1975 bfd *abfd ATTRIBUTE_UNUSED;
1976 bfd_reloc_code_real_type code;
1977{
1978 unsigned int i;
1979
1980 for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
1981 {
1982 if (sh_reloc_map[i].bfd_reloc_val == code)
1983 return &sh_elf_howto_table[(int) sh_reloc_map[i].elf_reloc_val];
1984 }
1985
1986 return NULL;
1987}
1988
1989/* Given an ELF reloc, fill in the howto field of a relent. */
1990
1991static void
1992sh_elf_info_to_howto (abfd, cache_ptr, dst)
1993 bfd *abfd ATTRIBUTE_UNUSED;
1994 arelent *cache_ptr;
1995 Elf_Internal_Rela *dst;
1996{
1997 unsigned int r;
1998
1999 r = ELF32_R_TYPE (dst->r_info);
2000
2001 BFD_ASSERT (r < (unsigned int) R_SH_max);
2002 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
2003 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_2 || r > R_SH_LAST_INVALID_RELOC_2);
2004 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_3 || r > R_SH_LAST_INVALID_RELOC_3);
2005 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_4 || r > R_SH_LAST_INVALID_RELOC_4);
2006 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_5 || r > R_SH_LAST_INVALID_RELOC_5);
2007
2008 cache_ptr->howto = &sh_elf_howto_table[r];
2009}
2010
2011
2012/* This function handles relaxing for SH ELF. See the corresponding
2013 function in coff-sh.c for a description of what this does. FIXME:
2014 There is a lot of duplication here between this code and the COFF
2015 specific code. The format of relocs and symbols is wound deeply
2016 into this code, but it would still be better if the duplication
2017 could be eliminated somehow. Note in particular that although both
2018 functions use symbols like R_SH_CODE, those symbols have different
2019 values; in coff-sh.c they come from include/coff/sh.h, whereas here
2020 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
2021
2022static bfd_boolean
2023sh_elf_relax_section (abfd, sec, link_info, again)
2024 bfd *abfd;
2025 asection *sec;
2026 struct bfd_link_info *link_info;
2027 bfd_boolean *again;
2028{
2029 Elf_Internal_Shdr *symtab_hdr;
2030 Elf_Internal_Rela *internal_relocs;
2031 bfd_boolean have_code;
2032 Elf_Internal_Rela *irel, *irelend;
2033 bfd_byte *contents = NULL;
2034 Elf_Internal_Sym *isymbuf = NULL;
2035
2036 *again = FALSE;
2037
2038 if (link_info->relocateable
2039 || (sec->flags & SEC_RELOC) == 0
2040 || sec->reloc_count == 0)
2041 return TRUE;
2042
2043#ifdef INCLUDE_SHMEDIA
2044 if (elf_section_data (sec)->this_hdr.sh_flags
2045 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED))
2046 {
2047 return TRUE;
2048 }
2049#endif
2050
2051 /* If this is the first time we have been called for this section,
2052 initialize the cooked size. */
2053 if (sec->_cooked_size == 0)
2054 sec->_cooked_size = sec->_raw_size;
2055
2056 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2057
2058 internal_relocs = (_bfd_elf32_link_read_relocs
2059 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2060 link_info->keep_memory));
2061 if (internal_relocs == NULL)
2062 goto error_return;
2063
2064 have_code = FALSE;
2065
2066 irelend = internal_relocs + sec->reloc_count;
2067 for (irel = internal_relocs; irel < irelend; irel++)
2068 {
2069 bfd_vma laddr, paddr, symval;
2070 unsigned short insn;
2071 Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
2072 bfd_signed_vma foff;
2073
2074 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
2075 have_code = TRUE;
2076
2077 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
2078 continue;
2079
2080 /* Get the section contents. */
2081 if (contents == NULL)
2082 {
2083 if (elf_section_data (sec)->this_hdr.contents != NULL)
2084 contents = elf_section_data (sec)->this_hdr.contents;
2085 else
2086 {
2087 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
2088 if (contents == NULL)
2089 goto error_return;
2090
2091 if (! bfd_get_section_contents (abfd, sec, contents,
2092 (file_ptr) 0, sec->_raw_size))
2093 goto error_return;
2094 }
2095 }
2096
2097 /* The r_addend field of the R_SH_USES reloc will point us to
2098 the register load. The 4 is because the r_addend field is
2099 computed as though it were a jump offset, which are based
2100 from 4 bytes after the jump instruction. */
2101 laddr = irel->r_offset + 4 + irel->r_addend;
2102 if (laddr >= sec->_raw_size)
2103 {
2104 (*_bfd_error_handler) (_("%s: 0x%lx: warning: bad R_SH_USES offset"),
2105 bfd_archive_filename (abfd),
2106 (unsigned long) irel->r_offset);
2107 continue;
2108 }
2109 insn = bfd_get_16 (abfd, contents + laddr);
2110
2111 /* If the instruction is not mov.l NN,rN, we don't know what to
2112 do. */
2113 if ((insn & 0xf000) != 0xd000)
2114 {
2115 ((*_bfd_error_handler)
2116 (_("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
2117 bfd_archive_filename (abfd), (unsigned long) irel->r_offset, insn));
2118 continue;
2119 }
2120
2121 /* Get the address from which the register is being loaded. The
2122 displacement in the mov.l instruction is quadrupled. It is a
2123 displacement from four bytes after the movl instruction, but,
2124 before adding in the PC address, two least significant bits
2125 of the PC are cleared. We assume that the section is aligned
2126 on a four byte boundary. */
2127 paddr = insn & 0xff;
2128 paddr *= 4;
2129 paddr += (laddr + 4) &~ (bfd_vma) 3;
2130 if (paddr >= sec->_raw_size)
2131 {
2132 ((*_bfd_error_handler)
2133 (_("%s: 0x%lx: warning: bad R_SH_USES load offset"),
2134 bfd_archive_filename (abfd), (unsigned long) irel->r_offset));
2135 continue;
2136 }
2137
2138 /* Get the reloc for the address from which the register is
2139 being loaded. This reloc will tell us which function is
2140 actually being called. */
2141 for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
2142 if (irelfn->r_offset == paddr
2143 && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
2144 break;
2145 if (irelfn >= irelend)
2146 {
2147 ((*_bfd_error_handler)
2148 (_("%s: 0x%lx: warning: could not find expected reloc"),
2149 bfd_archive_filename (abfd), (unsigned long) paddr));
2150 continue;
2151 }
2152
2153 /* Read this BFD's symbols if we haven't done so already. */
2154 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2155 {
2156 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2157 if (isymbuf == NULL)
2158 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2159 symtab_hdr->sh_info, 0,
2160 NULL, NULL, NULL);
2161 if (isymbuf == NULL)
2162 goto error_return;
2163 }
2164
2165 /* Get the value of the symbol referred to by the reloc. */
2166 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
2167 {
2168 /* A local symbol. */
2169 Elf_Internal_Sym *isym;
2170
2171 isym = isymbuf + ELF32_R_SYM (irelfn->r_info);
2172 if (isym->st_shndx
2173 != (unsigned int) _bfd_elf_section_from_bfd_section (abfd, sec))
2174 {
2175 ((*_bfd_error_handler)
2176 (_("%s: 0x%lx: warning: symbol in unexpected section"),
2177 bfd_archive_filename (abfd), (unsigned long) paddr));
2178 continue;
2179 }
2180
2181 symval = (isym->st_value
2182 + sec->output_section->vma
2183 + sec->output_offset);
2184 }
2185 else
2186 {
2187 unsigned long indx;
2188 struct elf_link_hash_entry *h;
2189
2190 indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
2191 h = elf_sym_hashes (abfd)[indx];
2192 BFD_ASSERT (h != NULL);
2193 if (h->root.type != bfd_link_hash_defined
2194 && h->root.type != bfd_link_hash_defweak)
2195 {
2196 /* This appears to be a reference to an undefined
2197 symbol. Just ignore it--it will be caught by the
2198 regular reloc processing. */
2199 continue;
2200 }
2201
2202 symval = (h->root.u.def.value
2203 + h->root.u.def.section->output_section->vma
2204 + h->root.u.def.section->output_offset);
2205 }
2206
2207 symval += bfd_get_32 (abfd, contents + paddr);
2208
2209 /* See if this function call can be shortened. */
2210 foff = (symval
2211 - (irel->r_offset
2212 + sec->output_section->vma
2213 + sec->output_offset
2214 + 4));
2215 if (foff < -0x1000 || foff >= 0x1000)
2216 {
2217 /* After all that work, we can't shorten this function call. */
2218 continue;
2219 }
2220
2221 /* Shorten the function call. */
2222
2223 /* For simplicity of coding, we are going to modify the section
2224 contents, the section relocs, and the BFD symbol table. We
2225 must tell the rest of the code not to free up this
2226 information. It would be possible to instead create a table
2227 of changes which have to be made, as is done in coff-mips.c;
2228 that would be more work, but would require less memory when
2229 the linker is run. */
2230
2231 elf_section_data (sec)->relocs = internal_relocs;
2232 elf_section_data (sec)->this_hdr.contents = contents;
2233 symtab_hdr->contents = (unsigned char *) isymbuf;
2234
2235 /* Replace the jsr with a bsr. */
2236
2237 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
2238 replace the jsr with a bsr. */
2239 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
2240 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
2241 here, but that only checks if the symbol is an external symbol,
2242 not if the symbol is in a different section. Besides, we need
2243 a consistent meaning for the relocation, so we just assume here that
2244 the value of the symbol is not available. */
2245#if 0
2246 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
2247 {
2248 /* If this needs to be changed because of future relaxing,
2249 it will be handled here like other internal IND12W
2250 relocs. */
2251 bfd_put_16 (abfd,
2252 (bfd_vma) 0xb000 | ((foff >> 1) & 0xfff),
2253 contents + irel->r_offset);
2254 }
2255 else
2256#endif
2257 {
2258 /* We can't fully resolve this yet, because the external
2259 symbol value may be changed by future relaxing. We let
2260 the final link phase handle it. */
2261 bfd_put_16 (abfd, (bfd_vma) 0xb000, contents + irel->r_offset);
2262 }
2263 irel->r_addend = -4;
2264
2265 /* See if there is another R_SH_USES reloc referring to the same
2266 register load. */
2267 for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
2268 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
2269 && laddr == irelscan->r_offset + 4 + irelscan->r_addend)
2270 break;
2271 if (irelscan < irelend)
2272 {
2273 /* Some other function call depends upon this register load,
2274 and we have not yet converted that function call.
2275 Indeed, we may never be able to convert it. There is
2276 nothing else we can do at this point. */
2277 continue;
2278 }
2279
2280 /* Look for a R_SH_COUNT reloc on the location where the
2281 function address is stored. Do this before deleting any
2282 bytes, to avoid confusion about the address. */
2283 for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
2284 if (irelcount->r_offset == paddr
2285 && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
2286 break;
2287
2288 /* Delete the register load. */
2289 if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
2290 goto error_return;
2291
2292 /* That will change things, so, just in case it permits some
2293 other function call to come within range, we should relax
2294 again. Note that this is not required, and it may be slow. */
2295 *again = TRUE;
2296
2297 /* Now check whether we got a COUNT reloc. */
2298 if (irelcount >= irelend)
2299 {
2300 ((*_bfd_error_handler)
2301 (_("%s: 0x%lx: warning: could not find expected COUNT reloc"),
2302 bfd_archive_filename (abfd), (unsigned long) paddr));
2303 continue;
2304 }
2305
2306 /* The number of uses is stored in the r_addend field. We've
2307 just deleted one. */
2308 if (irelcount->r_addend == 0)
2309 {
2310 ((*_bfd_error_handler) (_("%s: 0x%lx: warning: bad count"),
2311 bfd_archive_filename (abfd),
2312 (unsigned long) paddr));
2313 continue;
2314 }
2315
2316 --irelcount->r_addend;
2317
2318 /* If there are no more uses, we can delete the address. Reload
2319 the address from irelfn, in case it was changed by the
2320 previous call to sh_elf_relax_delete_bytes. */
2321 if (irelcount->r_addend == 0)
2322 {
2323 if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
2324 goto error_return;
2325 }
2326
2327 /* We've done all we can with that function call. */
2328 }
2329
2330 /* Look for load and store instructions that we can align on four
2331 byte boundaries. */
2332 if ((elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK) != EF_SH4
2333 && have_code)
2334 {
2335 bfd_boolean swapped;
2336
2337 /* Get the section contents. */
2338 if (contents == NULL)
2339 {
2340 if (elf_section_data (sec)->this_hdr.contents != NULL)
2341 contents = elf_section_data (sec)->this_hdr.contents;
2342 else
2343 {
2344 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
2345 if (contents == NULL)
2346 goto error_return;
2347
2348 if (! bfd_get_section_contents (abfd, sec, contents,
2349 (file_ptr) 0, sec->_raw_size))
2350 goto error_return;
2351 }
2352 }
2353
2354 if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
2355 &swapped))
2356 goto error_return;
2357
2358 if (swapped)
2359 {
2360 elf_section_data (sec)->relocs = internal_relocs;
2361 elf_section_data (sec)->this_hdr.contents = contents;
2362 symtab_hdr->contents = (unsigned char *) isymbuf;
2363 }
2364 }
2365
2366 if (isymbuf != NULL
2367 && symtab_hdr->contents != (unsigned char *) isymbuf)
2368 {
2369 if (! link_info->keep_memory)
2370 free (isymbuf);
2371 else
2372 {
2373 /* Cache the symbols for elf_link_input_bfd. */
2374 symtab_hdr->contents = (unsigned char *) isymbuf;
2375 }
2376 }
2377
2378 if (contents != NULL
2379 && elf_section_data (sec)->this_hdr.contents != contents)
2380 {
2381 if (! link_info->keep_memory)
2382 free (contents);
2383 else
2384 {
2385 /* Cache the section contents for elf_link_input_bfd. */
2386 elf_section_data (sec)->this_hdr.contents = contents;
2387 }
2388 }
2389
2390 if (internal_relocs != NULL
2391 && elf_section_data (sec)->relocs != internal_relocs)
2392 free (internal_relocs);
2393
2394 return TRUE;
2395
2396 error_return:
2397 if (isymbuf != NULL
2398 && symtab_hdr->contents != (unsigned char *) isymbuf)
2399 free (isymbuf);
2400 if (contents != NULL
2401 && elf_section_data (sec)->this_hdr.contents != contents)
2402 free (contents);
2403 if (internal_relocs != NULL
2404 && elf_section_data (sec)->relocs != internal_relocs)
2405 free (internal_relocs);
2406
2407 return FALSE;
2408}
2409
2410/* Delete some bytes from a section while relaxing. FIXME: There is a
2411 lot of duplication between this function and sh_relax_delete_bytes
2412 in coff-sh.c. */
2413
2414static bfd_boolean
2415sh_elf_relax_delete_bytes (abfd, sec, addr, count)
2416 bfd *abfd;
2417 asection *sec;
2418 bfd_vma addr;
2419 int count;
2420{
2421 Elf_Internal_Shdr *symtab_hdr;
2422 unsigned int sec_shndx;
2423 bfd_byte *contents;
2424 Elf_Internal_Rela *irel, *irelend;
2425 Elf_Internal_Rela *irelalign;
2426 bfd_vma toaddr;
2427 Elf_Internal_Sym *isymbuf, *isym, *isymend;
2428 struct elf_link_hash_entry **sym_hashes;
2429 struct elf_link_hash_entry **end_hashes;
2430 unsigned int symcount;
2431 asection *o;
2432
2433 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2434 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2435
2436 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2437
2438 contents = elf_section_data (sec)->this_hdr.contents;
2439
2440 /* The deletion must stop at the next ALIGN reloc for an aligment
2441 power larger than the number of bytes we are deleting. */
2442
2443 irelalign = NULL;
2444 toaddr = sec->_cooked_size;
2445
2446 irel = elf_section_data (sec)->relocs;
2447 irelend = irel + sec->reloc_count;
2448 for (; irel < irelend; irel++)
2449 {
2450 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
2451 && irel->r_offset > addr
2452 && count < (1 << irel->r_addend))
2453 {
2454 irelalign = irel;
2455 toaddr = irel->r_offset;
2456 break;
2457 }
2458 }
2459
2460 /* Actually delete the bytes. */
2461 memmove (contents + addr, contents + addr + count,
2462 (size_t) (toaddr - addr - count));
2463 if (irelalign == NULL)
2464 sec->_cooked_size -= count;
2465 else
2466 {
2467 int i;
2468
2469#define NOP_OPCODE (0x0009)
2470
2471 BFD_ASSERT ((count & 1) == 0);
2472 for (i = 0; i < count; i += 2)
2473 bfd_put_16 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
2474 }
2475
2476 /* Adjust all the relocs. */
2477 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2478 {
2479 bfd_vma nraddr, stop;
2480 bfd_vma start = 0;
2481 int insn = 0;
2482 int off, adjust, oinsn;
2483 bfd_signed_vma voff = 0;
2484 bfd_boolean overflow;
2485
2486 /* Get the new reloc address. */
2487 nraddr = irel->r_offset;
2488 if ((irel->r_offset > addr
2489 && irel->r_offset < toaddr)
2490 || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
2491 && irel->r_offset == toaddr))
2492 nraddr -= count;
2493
2494 /* See if this reloc was for the bytes we have deleted, in which
2495 case we no longer care about it. Don't delete relocs which
2496 represent addresses, though. */
2497 if (irel->r_offset >= addr
2498 && irel->r_offset < addr + count
2499 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
2500 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
2501 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
2502 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
2503 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2504 (int) R_SH_NONE);
2505
2506 /* If this is a PC relative reloc, see if the range it covers
2507 includes the bytes we have deleted. */
2508 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
2509 {
2510 default:
2511 break;
2512
2513 case R_SH_DIR8WPN:
2514 case R_SH_IND12W:
2515 case R_SH_DIR8WPZ:
2516 case R_SH_DIR8WPL:
2517 start = irel->r_offset;
2518 insn = bfd_get_16 (abfd, contents + nraddr);
2519 break;
2520 }
2521
2522 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
2523 {
2524 default:
2525 start = stop = addr;
2526 break;
2527
2528 case R_SH_DIR32:
2529 /* If this reloc is against a symbol defined in this
2530 section, and the symbol will not be adjusted below, we
2531 must check the addend to see it will put the value in
2532 range to be adjusted, and hence must be changed. */
2533 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2534 {
2535 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2536 if (isym->st_shndx == sec_shndx
2537 && (isym->st_value <= addr
2538 || isym->st_value >= toaddr))
2539 {
2540 bfd_vma val;
2541
2542 val = bfd_get_32 (abfd, contents + nraddr);
2543 val += isym->st_value;
2544 if (val > addr && val < toaddr)
2545 bfd_put_32 (abfd, val - count, contents + nraddr);
2546 }
2547 }
2548 start = stop = addr;
2549 break;
2550
2551 case R_SH_DIR8WPN:
2552 off = insn & 0xff;
2553 if (off & 0x80)
2554 off -= 0x100;
2555 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
2556 break;
2557
2558 case R_SH_IND12W:
2559 off = insn & 0xfff;
2560 if (! off)
2561 {
2562 /* This has been made by previous relaxation. Since the
2563 relocation will be against an external symbol, the
2564 final relocation will just do the right thing. */
2565 start = stop = addr;
2566 }
2567 else
2568 {
2569 if (off & 0x800)
2570 off -= 0x1000;
2571 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
2572
2573 /* The addend will be against the section symbol, thus
2574 for adjusting the addend, the relevant start is the
2575 start of the section.
2576 N.B. If we want to abandom in-place changes here and
2577 test directly using symbol + addend, we have to take into
2578 account that the addend has already been adjusted by -4. */
2579 if (stop > addr && stop < toaddr)
2580 irel->r_addend -= count;
2581 }
2582 break;
2583
2584 case R_SH_DIR8WPZ:
2585 off = insn & 0xff;
2586 stop = start + 4 + off * 2;
2587 break;
2588
2589 case R_SH_DIR8WPL:
2590 off = insn & 0xff;
2591 stop = (start & ~(bfd_vma) 3) + 4 + off * 4;
2592 break;
2593
2594 case R_SH_SWITCH8:
2595 case R_SH_SWITCH16:
2596 case R_SH_SWITCH32:
2597 /* These relocs types represent
2598 .word L2-L1
2599 The r_addend field holds the difference between the reloc
2600 address and L1. That is the start of the reloc, and
2601 adding in the contents gives us the top. We must adjust
2602 both the r_offset field and the section contents.
2603 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
2604 and the elf bfd r_offset is called r_vaddr. */
2605
2606 stop = irel->r_offset;
2607 start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
2608
2609 if (start > addr
2610 && start < toaddr
2611 && (stop <= addr || stop >= toaddr))
2612 irel->r_addend += count;
2613 else if (stop > addr
2614 && stop < toaddr
2615 && (start <= addr || start >= toaddr))
2616 irel->r_addend -= count;
2617
2618 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
2619 voff = bfd_get_signed_16 (abfd, contents + nraddr);
2620 else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
2621 voff = bfd_get_8 (abfd, contents + nraddr);
2622 else
2623 voff = bfd_get_signed_32 (abfd, contents + nraddr);
2624 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
2625
2626 break;
2627
2628 case R_SH_USES:
2629 start = irel->r_offset;
2630 stop = (bfd_vma) ((bfd_signed_vma) start
2631 + (long) irel->r_addend
2632 + 4);
2633 break;
2634 }
2635
2636 if (start > addr
2637 && start < toaddr
2638 && (stop <= addr || stop >= toaddr))
2639 adjust = count;
2640 else if (stop > addr
2641 && stop < toaddr
2642 && (start <= addr || start >= toaddr))
2643 adjust = - count;
2644 else
2645 adjust = 0;
2646
2647 if (adjust != 0)
2648 {
2649 oinsn = insn;
2650 overflow = FALSE;
2651 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
2652 {
2653 default:
2654 abort ();
2655 break;
2656
2657 case R_SH_DIR8WPN:
2658 case R_SH_DIR8WPZ:
2659 insn += adjust / 2;
2660 if ((oinsn & 0xff00) != (insn & 0xff00))
2661 overflow = TRUE;
2662 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
2663 break;
2664
2665 case R_SH_IND12W:
2666 insn += adjust / 2;
2667 if ((oinsn & 0xf000) != (insn & 0xf000))
2668 overflow = TRUE;
2669 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
2670 break;
2671
2672 case R_SH_DIR8WPL:
2673 BFD_ASSERT (adjust == count || count >= 4);
2674 if (count >= 4)
2675 insn += adjust / 4;
2676 else
2677 {
2678 if ((irel->r_offset & 3) == 0)
2679 ++insn;
2680 }
2681 if ((oinsn & 0xff00) != (insn & 0xff00))
2682 overflow = TRUE;
2683 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
2684 break;
2685
2686 case R_SH_SWITCH8:
2687 voff += adjust;
2688 if (voff < 0 || voff >= 0xff)
2689 overflow = TRUE;
2690 bfd_put_8 (abfd, voff, contents + nraddr);
2691 break;
2692
2693 case R_SH_SWITCH16:
2694 voff += adjust;
2695 if (voff < - 0x8000 || voff >= 0x8000)
2696 overflow = TRUE;
2697 bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr);
2698 break;
2699
2700 case R_SH_SWITCH32:
2701 voff += adjust;
2702 bfd_put_signed_32 (abfd, (bfd_vma) voff, contents + nraddr);
2703 break;
2704
2705 case R_SH_USES:
2706 irel->r_addend += adjust;
2707 break;
2708 }
2709
2710 if (overflow)
2711 {
2712 ((*_bfd_error_handler)
2713 (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
2714 bfd_archive_filename (abfd), (unsigned long) irel->r_offset));
2715 bfd_set_error (bfd_error_bad_value);
2716 return FALSE;
2717 }
2718 }
2719
2720 irel->r_offset = nraddr;
2721 }
2722
2723 /* Look through all the other sections. If there contain any IMM32
2724 relocs against internal symbols which we are not going to adjust
2725 below, we may need to adjust the addends. */
2726 for (o = abfd->sections; o != NULL; o = o->next)
2727 {
2728 Elf_Internal_Rela *internal_relocs;
2729 Elf_Internal_Rela *irelscan, *irelscanend;
2730 bfd_byte *ocontents;
2731
2732 if (o == sec
2733 || (o->flags & SEC_RELOC) == 0
2734 || o->reloc_count == 0)
2735 continue;
2736
2737 /* We always cache the relocs. Perhaps, if info->keep_memory is
2738 FALSE, we should free them, if we are permitted to, when we
2739 leave sh_coff_relax_section. */
2740 internal_relocs = (_bfd_elf32_link_read_relocs
2741 (abfd, o, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2742 TRUE));
2743 if (internal_relocs == NULL)
2744 return FALSE;
2745
2746 ocontents = NULL;
2747 irelscanend = internal_relocs + o->reloc_count;
2748 for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
2749 {
2750 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
2751 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
2752 {
2753 bfd_vma start, stop;
2754 bfd_signed_vma voff;
2755
2756 if (ocontents == NULL)
2757 {
2758 if (elf_section_data (o)->this_hdr.contents != NULL)
2759 ocontents = elf_section_data (o)->this_hdr.contents;
2760 else
2761 {
2762 /* We always cache the section contents.
2763 Perhaps, if info->keep_memory is FALSE, we
2764 should free them, if we are permitted to,
2765 when we leave sh_coff_relax_section. */
2766 ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
2767 if (ocontents == NULL)
2768 return FALSE;
2769 if (! bfd_get_section_contents (abfd, o, ocontents,
2770 (file_ptr) 0,
2771 o->_raw_size))
2772 return FALSE;
2773 elf_section_data (o)->this_hdr.contents = ocontents;
2774 }
2775 }
2776
2777 stop = irelscan->r_offset;
2778 start
2779 = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
2780
2781 /* STOP is in a different section, so it won't change. */
2782 if (start > addr && start < toaddr)
2783 irelscan->r_addend += count;
2784
2785 voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
2786 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
2787
2788 if (start > addr
2789 && start < toaddr
2790 && (stop <= addr || stop >= toaddr))
2791 bfd_put_signed_32 (abfd, (bfd_vma) voff + count,
2792 ocontents + irelscan->r_offset);
2793 else if (stop > addr
2794 && stop < toaddr
2795 && (start <= addr || start >= toaddr))
2796 bfd_put_signed_32 (abfd, (bfd_vma) voff - count,
2797 ocontents + irelscan->r_offset);
2798 }
2799
2800 if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
2801 continue;
2802
2803 if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
2804 continue;
2805
2806
2807 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
2808 if (isym->st_shndx == sec_shndx
2809 && (isym->st_value <= addr
2810 || isym->st_value >= toaddr))
2811 {
2812 bfd_vma val;
2813
2814 if (ocontents == NULL)
2815 {
2816 if (elf_section_data (o)->this_hdr.contents != NULL)
2817 ocontents = elf_section_data (o)->this_hdr.contents;
2818 else
2819 {
2820 /* We always cache the section contents.
2821 Perhaps, if info->keep_memory is FALSE, we
2822 should free them, if we are permitted to,
2823 when we leave sh_coff_relax_section. */
2824 ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
2825 if (ocontents == NULL)
2826 return FALSE;
2827 if (! bfd_get_section_contents (abfd, o, ocontents,
2828 (file_ptr) 0,
2829 o->_raw_size))
2830 return FALSE;
2831 elf_section_data (o)->this_hdr.contents = ocontents;
2832 }
2833 }
2834
2835 val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
2836 val += isym->st_value;
2837 if (val > addr && val < toaddr)
2838 bfd_put_32 (abfd, val - count,
2839 ocontents + irelscan->r_offset);
2840 }
2841 }
2842 }
2843
2844 /* Adjust the local symbols defined in this section. */
2845 isymend = isymbuf + symtab_hdr->sh_info;
2846 for (isym = isymbuf; isym < isymend; isym++)
2847 {
2848 if (isym->st_shndx == sec_shndx
2849 && isym->st_value > addr
2850 && isym->st_value < toaddr)
2851 isym->st_value -= count;
2852 }
2853
2854 /* Now adjust the global symbols defined in this section. */
2855 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2856 - symtab_hdr->sh_info);
2857 sym_hashes = elf_sym_hashes (abfd);
2858 end_hashes = sym_hashes + symcount;
2859 for (; sym_hashes < end_hashes; sym_hashes++)
2860 {
2861 struct elf_link_hash_entry *sym_hash = *sym_hashes;
2862 if ((sym_hash->root.type == bfd_link_hash_defined
2863 || sym_hash->root.type == bfd_link_hash_defweak)
2864 && sym_hash->root.u.def.section == sec
2865 && sym_hash->root.u.def.value > addr
2866 && sym_hash->root.u.def.value < toaddr)
2867 {
2868 sym_hash->root.u.def.value -= count;
2869 }
2870 }
2871
2872 /* See if we can move the ALIGN reloc forward. We have adjusted
2873 r_offset for it already. */
2874 if (irelalign != NULL)
2875 {
2876 bfd_vma alignto, alignaddr;
2877
2878 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
2879 alignaddr = BFD_ALIGN (irelalign->r_offset,
2880 1 << irelalign->r_addend);
2881 if (alignto != alignaddr)
2882 {
2883 /* Tail recursion. */
2884 return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
2885 (int) (alignto - alignaddr));
2886 }
2887 }
2888
2889 return TRUE;
2890}
2891
2892/* Look for loads and stores which we can align to four byte
2893 boundaries. This is like sh_align_loads in coff-sh.c. */
2894
2895static bfd_boolean
2896sh_elf_align_loads (abfd, sec, internal_relocs, contents, pswapped)
2897 bfd *abfd ATTRIBUTE_UNUSED;
2898 asection *sec;
2899 Elf_Internal_Rela *internal_relocs;
2900 bfd_byte *contents ATTRIBUTE_UNUSED;
2901 bfd_boolean *pswapped;
2902{
2903 Elf_Internal_Rela *irel, *irelend;
2904 bfd_vma *labels = NULL;
2905 bfd_vma *label, *label_end;
2906 bfd_size_type amt;
2907
2908 *pswapped = FALSE;
2909
2910 irelend = internal_relocs + sec->reloc_count;
2911
2912 /* Get all the addresses with labels on them. */
2913 amt = sec->reloc_count;
2914 amt *= sizeof (bfd_vma);
2915 labels = (bfd_vma *) bfd_malloc (amt);
2916 if (labels == NULL)
2917 goto error_return;
2918 label_end = labels;
2919 for (irel = internal_relocs; irel < irelend; irel++)
2920 {
2921 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
2922 {
2923 *label_end = irel->r_offset;
2924 ++label_end;
2925 }
2926 }
2927
2928 /* Note that the assembler currently always outputs relocs in
2929 address order. If that ever changes, this code will need to sort
2930 the label values and the relocs. */
2931
2932 label = labels;
2933
2934 for (irel = internal_relocs; irel < irelend; irel++)
2935 {
2936 bfd_vma start, stop;
2937
2938 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
2939 continue;
2940
2941 start = irel->r_offset;
2942
2943 for (irel++; irel < irelend; irel++)
2944 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
2945 break;
2946 if (irel < irelend)
2947 stop = irel->r_offset;
2948 else
2949 stop = sec->_cooked_size;
2950
2951 if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
2952 (PTR) internal_relocs, &label,
2953 label_end, start, stop, pswapped))
2954 goto error_return;
2955 }
2956
2957 free (labels);
2958
2959 return TRUE;
2960
2961 error_return:
2962 if (labels != NULL)
2963 free (labels);
2964 return FALSE;
2965}
2966
2967/* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
2968
2969static bfd_boolean
2970sh_elf_swap_insns (abfd, sec, relocs, contents, addr)
2971 bfd *abfd;
2972 asection *sec;
2973 PTR relocs;
2974 bfd_byte *contents;
2975 bfd_vma addr;
2976{
2977 Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
2978 unsigned short i1, i2;
2979 Elf_Internal_Rela *irel, *irelend;
2980
2981 /* Swap the instructions themselves. */
2982 i1 = bfd_get_16 (abfd, contents + addr);
2983 i2 = bfd_get_16 (abfd, contents + addr + 2);
2984 bfd_put_16 (abfd, (bfd_vma) i2, contents + addr);
2985 bfd_put_16 (abfd, (bfd_vma) i1, contents + addr + 2);
2986
2987 /* Adjust all reloc addresses. */
2988 irelend = internal_relocs + sec->reloc_count;
2989 for (irel = internal_relocs; irel < irelend; irel++)
2990 {
2991 enum elf_sh_reloc_type type;
2992 int add;
2993
2994 /* There are a few special types of relocs that we don't want to
2995 adjust. These relocs do not apply to the instruction itself,
2996 but are only associated with the address. */
2997 type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
2998 if (type == R_SH_ALIGN
2999 || type == R_SH_CODE
3000 || type == R_SH_DATA
3001 || type == R_SH_LABEL)
3002 continue;
3003
3004 /* If an R_SH_USES reloc points to one of the addresses being
3005 swapped, we must adjust it. It would be incorrect to do this
3006 for a jump, though, since we want to execute both
3007 instructions after the jump. (We have avoided swapping
3008 around a label, so the jump will not wind up executing an
3009 instruction it shouldn't). */
3010 if (type == R_SH_USES)
3011 {
3012 bfd_vma off;
3013
3014 off = irel->r_offset + 4 + irel->r_addend;
3015 if (off == addr)
3016 irel->r_offset += 2;
3017 else if (off == addr + 2)
3018 irel->r_offset -= 2;
3019 }
3020
3021 if (irel->r_offset == addr)
3022 {
3023 irel->r_offset += 2;
3024 add = -2;
3025 }
3026 else if (irel->r_offset == addr + 2)
3027 {
3028 irel->r_offset -= 2;
3029 add = 2;
3030 }
3031 else
3032 add = 0;
3033
3034 if (add != 0)
3035 {
3036 bfd_byte *loc;
3037 unsigned short insn, oinsn;
3038 bfd_boolean overflow;
3039
3040 loc = contents + irel->r_offset;
3041 overflow = FALSE;
3042 switch (type)
3043 {
3044 default:
3045 break;
3046
3047 case R_SH_DIR8WPN:
3048 case R_SH_DIR8WPZ:
3049 insn = bfd_get_16 (abfd, loc);
3050 oinsn = insn;
3051 insn += add / 2;
3052 if ((oinsn & 0xff00) != (insn & 0xff00))
3053 overflow = TRUE;
3054 bfd_put_16 (abfd, (bfd_vma) insn, loc);
3055 break;
3056
3057 case R_SH_IND12W:
3058 insn = bfd_get_16 (abfd, loc);
3059 oinsn = insn;
3060 insn += add / 2;
3061 if ((oinsn & 0xf000) != (insn & 0xf000))
3062 overflow = TRUE;
3063 bfd_put_16 (abfd, (bfd_vma) insn, loc);
3064 break;
3065
3066 case R_SH_DIR8WPL:
3067 /* This reloc ignores the least significant 3 bits of
3068 the program counter before adding in the offset.
3069 This means that if ADDR is at an even address, the
3070 swap will not affect the offset. If ADDR is an at an
3071 odd address, then the instruction will be crossing a
3072 four byte boundary, and must be adjusted. */
3073 if ((addr & 3) != 0)
3074 {
3075 insn = bfd_get_16 (abfd, loc);
3076 oinsn = insn;
3077 insn += add / 2;
3078 if ((oinsn & 0xff00) != (insn & 0xff00))
3079 overflow = TRUE;
3080 bfd_put_16 (abfd, (bfd_vma) insn, loc);
3081 }
3082
3083 break;
3084 }
3085
3086 if (overflow)
3087 {
3088 ((*_bfd_error_handler)
3089 (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
3090 bfd_archive_filename (abfd), (unsigned long) irel->r_offset));
3091 bfd_set_error (bfd_error_bad_value);
3092 return FALSE;
3093 }
3094 }
3095 }
3096
3097 return TRUE;
3098}
3099
3100
3101#ifdef INCLUDE_SHMEDIA
3102
3103/* The size in bytes of an entry in the procedure linkage table. */
3104
3105#define PLT_ENTRY_SIZE 64
3106
3107/* First entry in an absolute procedure linkage table look like this. */
3108
3109static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
3110{
3111 0xcc, 0x00, 0x01, 0x10, /* movi .got.plt >> 16, r17 */
3112 0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
3113 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
3114 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3115 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
3116 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3117 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3118 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3119 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3120 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3121 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3122 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3123 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3124 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3125 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3126 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3127};
3128
3129static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
3130{
3131 0x10, 0x01, 0x00, 0xcc, /* movi .got.plt >> 16, r17 */
3132 0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
3133 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
3134 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3135 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
3136 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3137 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3138 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3139 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3140 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3141 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3142 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3143 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3144 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3145 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3146 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3147};
3148
3149/* Sebsequent entries in an absolute procedure linkage table look like
3150 this. */
3151
3152static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
3153{
3154 0xcc, 0x00, 0x01, 0x90, /* movi nameN-in-GOT >> 16, r25 */
3155 0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
3156 0x89, 0x90, 0x01, 0x90, /* ld.l r25, 0, r25 */
3157 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3158 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3159 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3160 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3161 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3162 0xcc, 0x00, 0x01, 0x90, /* movi .PLT0 >> 16, r25 */
3163 0xc8, 0x00, 0x01, 0x90, /* shori .PLT0 & 65535, r25 */
3164 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3165 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
3166 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
3167 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3168 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3169 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3170};
3171
3172static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
3173{
3174 0x90, 0x01, 0x00, 0xcc, /* movi nameN-in-GOT >> 16, r25 */
3175 0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
3176 0x90, 0x01, 0x90, 0x89, /* ld.l r25, 0, r25 */
3177 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3178 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3179 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3180 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3181 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3182 0x90, 0x01, 0x00, 0xcc, /* movi .PLT0 >> 16, r25 */
3183 0x90, 0x01, 0x00, 0xc8, /* shori .PLT0 & 65535, r25 */
3184 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3185 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
3186 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
3187 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3188 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3189 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3190};
3191
3192/* Entries in a PIC procedure linkage table look like this. */
3193
3194static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
3195{
3196 0xcc, 0x00, 0x01, 0x90, /* movi nameN@GOT >> 16, r25 */
3197 0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
3198 0x40, 0xc2, 0x65, 0x90, /* ldx.l r12, r25, r25 */
3199 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3200 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3201 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3202 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3203 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3204 0xce, 0x00, 0x01, 0x10, /* movi -GOT_BIAS, r17 */
3205 0x00, 0xc8, 0x45, 0x10, /* add.l r12, r17, r17 */
3206 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
3207 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3208 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
3209 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
3210 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
3211 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3212};
3213
3214static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3215{
3216 0x90, 0x01, 0x00, 0xcc, /* movi nameN@GOT >> 16, r25 */
3217 0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
3218 0x90, 0x65, 0xc2, 0x40, /* ldx.l r12, r25, r25 */
3219 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3220 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3221 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3222 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3223 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3224 0x10, 0x01, 0x00, 0xce, /* movi -GOT_BIAS, r17 */
3225 0x10, 0x45, 0xc8, 0x00, /* add.l r12, r17, r17 */
3226 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
3227 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3228 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
3229 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
3230 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
3231 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3232};
3233
3234static const bfd_byte *elf_sh_plt0_entry;
3235static const bfd_byte *elf_sh_plt_entry;
3236static const bfd_byte *elf_sh_pic_plt_entry;
3237
3238/* Return size of a PLT entry. */
3239#define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE
3240
3241/* Return offset of the PLT0 address in an absolute PLT entry. */
3242#define elf_sh_plt_plt0_offset(info) 32
3243
3244/* Return offset of the linker in PLT0 entry. */
3245#define elf_sh_plt0_gotplt_offset(info) 0
3246
3247/* Return offset of the trampoline in PLT entry */
3248#define elf_sh_plt_temp_offset(info) 33 /* Add one because it's SHmedia. */
3249
3250/* Return offset of the symbol in PLT entry. */
3251#define elf_sh_plt_symbol_offset(info) 0
3252
3253/* Return offset of the relocation in PLT entry. */
3254#define elf_sh_plt_reloc_offset(info) (info->shared ? 52 : 44)
3255
3256inline static void
3257movi_shori_putval (output_bfd, value, addr)
3258 bfd *output_bfd;
3259 unsigned long value;
3260 char *addr;
3261{
3262 bfd_put_32 (output_bfd,
3263 bfd_get_32 (output_bfd, addr)
3264 | ((value >> 6) & 0x3fffc00),
3265 addr);
3266 bfd_put_32 (output_bfd,
3267 bfd_get_32 (output_bfd, addr + 4)
3268 | ((value << 10) & 0x3fffc00),
3269 addr + 4);
3270}
3271
3272#else
3273/* The size in bytes of an entry in the procedure linkage table. */
3274
3275#define PLT_ENTRY_SIZE 28
3276
3277/* First entry in an absolute procedure linkage table look like this. */
3278
3279#if 1
3280/* Note - this code has been "optimised" not to use r2. r2 is used by
3281 GCC to return the address of large strutcures, so it should not be
3282 corrupted here. This does mean however, that this PLT does not conform
3283 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
3284 and r2 contains the GOT id. This version stores the GOT id in r0 and
3285 ignores the type. Loaders can easily detect this difference however,
3286 since the type will always be 0 or 8, and the GOT ids will always be
3287 greater than or equal to 12. */
3288static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
3289{
3290 0xd0, 0x05, /* mov.l 2f,r0 */
3291 0x60, 0x02, /* mov.l @r0,r0 */
3292 0x2f, 0x06, /* mov.l r0,@-r15 */
3293 0xd0, 0x03, /* mov.l 1f,r0 */
3294 0x60, 0x02, /* mov.l @r0,r0 */
3295 0x40, 0x2b, /* jmp @r0 */
3296 0x60, 0xf6, /* mov.l @r15+,r0 */
3297 0x00, 0x09, /* nop */
3298 0x00, 0x09, /* nop */
3299 0x00, 0x09, /* nop */
3300 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
3301 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
3302};
3303
3304static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
3305{
3306 0x05, 0xd0, /* mov.l 2f,r0 */
3307 0x02, 0x60, /* mov.l @r0,r0 */
3308 0x06, 0x2f, /* mov.l r0,@-r15 */
3309 0x03, 0xd0, /* mov.l 1f,r0 */
3310 0x02, 0x60, /* mov.l @r0,r0 */
3311 0x2b, 0x40, /* jmp @r0 */
3312 0xf6, 0x60, /* mov.l @r15+,r0 */
3313 0x09, 0x00, /* nop */
3314 0x09, 0x00, /* nop */
3315 0x09, 0x00, /* nop */
3316 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
3317 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
3318};
3319
3320/* Sebsequent entries in an absolute procedure linkage table look like
3321 this. */
3322
3323static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
3324{
3325 0xd0, 0x04, /* mov.l 1f,r0 */
3326 0x60, 0x02, /* mov.l @r0,r0 */
3327 0xd1, 0x02, /* mov.l 0f,r1 */
3328 0x40, 0x2b, /* jmp @r0 */
3329 0x60, 0x13, /* mov r1,r0 */
3330 0xd1, 0x03, /* mov.l 2f,r1 */
3331 0x40, 0x2b, /* jmp @r0 */
3332 0x00, 0x09, /* nop */
3333 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
3334 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3335 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
3336};
3337
3338static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
3339{
3340 0x04, 0xd0, /* mov.l 1f,r0 */
3341 0x02, 0x60, /* mov.l @r0,r0 */
3342 0x02, 0xd1, /* mov.l 0f,r1 */
3343 0x2b, 0x40, /* jmp @r0 */
3344 0x13, 0x60, /* mov r1,r0 */
3345 0x03, 0xd1, /* mov.l 2f,r1 */
3346 0x2b, 0x40, /* jmp @r0 */
3347 0x09, 0x00, /* nop */
3348 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
3349 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3350 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
3351};
3352
3353/* Entries in a PIC procedure linkage table look like this. */
3354
3355static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
3356{
3357 0xd0, 0x04, /* mov.l 1f,r0 */
3358 0x00, 0xce, /* mov.l @(r0,r12),r0 */
3359 0x40, 0x2b, /* jmp @r0 */
3360 0x00, 0x09, /* nop */
3361 0x50, 0xc2, /* mov.l @(8,r12),r0 */
3362 0xd1, 0x03, /* mov.l 2f,r1 */
3363 0x40, 0x2b, /* jmp @r0 */
3364 0x50, 0xc1, /* mov.l @(4,r12),r0 */
3365 0x00, 0x09, /* nop */
3366 0x00, 0x09, /* nop */
3367 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3368 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
3369};
3370
3371static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3372{
3373 0x04, 0xd0, /* mov.l 1f,r0 */
3374 0xce, 0x00, /* mov.l @(r0,r12),r0 */
3375 0x2b, 0x40, /* jmp @r0 */
3376 0x09, 0x00, /* nop */
3377 0xc2, 0x50, /* mov.l @(8,r12),r0 */
3378 0x03, 0xd1, /* mov.l 2f,r1 */
3379 0x2b, 0x40, /* jmp @r0 */
3380 0xc1, 0x50, /* mov.l @(4,r12),r0 */
3381 0x09, 0x00, /* nop */
3382 0x09, 0x00, /* nop */
3383 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3384 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
3385};
3386
3387#else /* These are the old style PLT entries. */
3388static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
3389{
3390 0xd0, 0x04, /* mov.l 1f,r0 */
3391 0xd2, 0x05, /* mov.l 2f,r2 */
3392 0x60, 0x02, /* mov.l @r0,r0 */
3393 0x62, 0x22, /* mov.l @r2,r2 */
3394 0x40, 0x2b, /* jmp @r0 */
3395 0xe0, 0x00, /* mov #0,r0 */
3396 0x00, 0x09, /* nop */
3397 0x00, 0x09, /* nop */
3398 0x00, 0x09, /* nop */
3399 0x00, 0x09, /* nop */
3400 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
3401 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
3402};
3403
3404static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
3405{
3406 0x04, 0xd0, /* mov.l 1f,r0 */
3407 0x05, 0xd2, /* mov.l 2f,r2 */
3408 0x02, 0x60, /* mov.l @r0,r0 */
3409 0x22, 0x62, /* mov.l @r2,r2 */
3410 0x2b, 0x40, /* jmp @r0 */
3411 0x00, 0xe0, /* mov #0,r0 */
3412 0x09, 0x00, /* nop */
3413 0x09, 0x00, /* nop */
3414 0x09, 0x00, /* nop */
3415 0x09, 0x00, /* nop */
3416 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
3417 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
3418};
3419
3420/* Sebsequent entries in an absolute procedure linkage table look like
3421 this. */
3422
3423static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
3424{
3425 0xd0, 0x04, /* mov.l 1f,r0 */
3426 0x60, 0x02, /* mov.l @r0,r0 */
3427 0xd2, 0x02, /* mov.l 0f,r2 */
3428 0x40, 0x2b, /* jmp @r0 */
3429 0x60, 0x23, /* mov r2,r0 */
3430 0xd1, 0x03, /* mov.l 2f,r1 */
3431 0x40, 0x2b, /* jmp @r0 */
3432 0x00, 0x09, /* nop */
3433 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
3434 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3435 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
3436};
3437
3438static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
3439{
3440 0x04, 0xd0, /* mov.l 1f,r0 */
3441 0x02, 0x60, /* mov.l @r0,r0 */
3442 0x02, 0xd2, /* mov.l 0f,r2 */
3443 0x2b, 0x40, /* jmp @r0 */
3444 0x23, 0x60, /* mov r2,r0 */
3445 0x03, 0xd1, /* mov.l 2f,r1 */
3446 0x2b, 0x40, /* jmp @r0 */
3447 0x09, 0x00, /* nop */
3448 0, 0, 0, 0, /* 0: replaced with address of .PLT. */
3449 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3450 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
3451};
3452
3453/* Entries in a PIC procedure linkage table look like this. */
3454
3455static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
3456{
3457 0xd0, 0x04, /* mov.l 1f,r0 */
3458 0x00, 0xce, /* mov.l @(r0,r12),r0 */
3459 0x40, 0x2b, /* jmp @r0 */
3460 0x00, 0x09, /* nop */
3461 0x50, 0xc2, /* 0: mov.l @(8,r12),r0 */
3462 0x52, 0xc1, /* 1: mov.l @(4,r12),r2 */
3463 0xd1, 0x02, /* mov.l 2f,r1 */
3464 0x40, 0x2b, /* jmp @r0 */
3465 0xe0, 0x00, /* mov #0,r0 ! shows the type of PLT. */
3466 0x00, 0x09, /* nop */
3467 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3468 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
3469};
3470
3471static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3472{
3473 0x04, 0xd0, /* mov.l 1f,r0 */
3474 0xce, 0x00, /* mov.l @(r0,r12),r0 */
3475 0x2b, 0x40, /* jmp @r0 */
3476 0x09, 0x00, /* nop */
3477 0xc2, 0x50, /* 0: mov.l @(8,r12),r0 */
3478 0xc1, 0x52, /* 1: mov.l @(4,r12),r2 */
3479 0x02, 0xd1, /* mov.l 2f,r1 */
3480 0x2b, 0x40, /* jmp @r0 */
3481 0x00, 0xe0, /* mov #0,r0 ! shows the type of PLT. */
3482 0x09, 0x00, /* nop */
3483 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3484 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
3485};
3486#endif /* old style PLT entries. */
3487
3488static const bfd_byte *elf_sh_plt0_entry;
3489static const bfd_byte *elf_sh_plt_entry;
3490static const bfd_byte *elf_sh_pic_plt_entry;
3491
3492/* Return size of a PLT entry. */
3493#define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE
3494
3495/* Return offset of the PLT0 address in an absolute PLT entry. */
3496#define elf_sh_plt_plt0_offset(info) 16
3497
3498/* Return offset of the linker in PLT0 entry. */
3499#define elf_sh_plt0_linker_offset(info) 20
3500
3501/* Return offset of the GOT id in PLT0 entry. */
3502#define elf_sh_plt0_gotid_offset(info) 24
3503
3504/* Return offset of the tempoline in PLT entry */
3505#define elf_sh_plt_temp_offset(info) 8
3506
3507/* Return offset of the symbol in PLT entry. */
3508#define elf_sh_plt_symbol_offset(info) 20
3509
3510/* Return offset of the relocation in PLT entry. */
3511#define elf_sh_plt_reloc_offset(info) 24
3512#endif
3513
3514/* The sh linker needs to keep track of the number of relocs that it
3515 decides to copy as dynamic relocs in check_relocs for each symbol.
3516 This is so that it can later discard them if they are found to be
3517 unnecessary. We store the information in a field extending the
3518 regular ELF linker hash table. */
3519
3520struct elf_sh_dyn_relocs
3521{
3522 struct elf_sh_dyn_relocs *next;
3523
3524 /* The input section of the reloc. */
3525 asection *sec;
3526
3527 /* Total number of relocs copied for the input section. */
3528 bfd_size_type count;
3529
3530 /* Number of pc-relative relocs copied for the input section. */
3531 bfd_size_type pc_count;
3532};
3533
3534/* sh ELF linker hash entry. */
3535
3536struct elf_sh_link_hash_entry
3537{
3538 struct elf_link_hash_entry root;
3539
3540#ifdef INCLUDE_SHMEDIA
3541 union
3542 {
3543 bfd_signed_vma refcount;
3544 bfd_vma offset;
3545 } datalabel_got;
3546#endif
3547
3548 /* Track dynamic relocs copied for this symbol. */
3549 struct elf_sh_dyn_relocs *dyn_relocs;
3550
3551 bfd_signed_vma gotplt_refcount;
3552
3553 enum {
3554 GOT_UNKNOWN = 0, GOT_NORMAL, GOT_TLS_GD, GOT_TLS_IE
3555 } tls_type;
3556};
3557
3558#define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
3559
3560struct sh_elf_obj_tdata
3561{
3562 struct elf_obj_tdata root;
3563
3564 /* tls_type for each local got entry. */
3565 char *local_got_tls_type;
3566};
3567
3568#define sh_elf_tdata(abfd) \
3569 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
3570
3571#define sh_elf_local_got_tls_type(abfd) \
3572 (sh_elf_tdata (abfd)->local_got_tls_type)
3573
3574/* Override the generic function because we need to store sh_elf_obj_tdata
3575 as the specific tdata. */
3576
3577static bfd_boolean
3578sh_elf_mkobject (abfd)
3579 bfd *abfd;
3580{
3581 bfd_size_type amt = sizeof (struct sh_elf_obj_tdata);
3582 abfd->tdata.any = bfd_zalloc (abfd, amt);
3583 if (abfd->tdata.any == NULL)
3584 return FALSE;
3585 return TRUE;
3586}
3587
3588/* sh ELF linker hash table. */
3589
3590struct elf_sh_link_hash_table
3591{
3592 struct elf_link_hash_table root;
3593
3594 /* Short-cuts to get to dynamic linker sections. */
3595 asection *sgot;
3596 asection *sgotplt;
3597 asection *srelgot;
3598 asection *splt;
3599 asection *srelplt;
3600 asection *sdynbss;
3601 asection *srelbss;
3602
3603 /* Small local sym to section mapping cache. */
3604 struct sym_sec_cache sym_sec;
3605
3606 /* A counter or offset to track a TLS got entry. */
3607 union
3608 {
3609 bfd_signed_vma refcount;
3610 bfd_vma offset;
3611 } tls_ldm_got;
3612};
3613
3614/* Traverse an sh ELF linker hash table. */
3615
3616#define sh_elf_link_hash_traverse(table, func, info) \
3617 (elf_link_hash_traverse \
3618 (&(table)->root, \
3619 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
3620 (info)))
3621
3622/* Get the sh ELF linker hash table from a link_info structure. */
3623
3624#define sh_elf_hash_table(p) \
3625 ((struct elf_sh_link_hash_table *) ((p)->hash))
3626
3627/* Create an entry in an sh ELF linker hash table. */
3628
3629static struct bfd_hash_entry *
3630sh_elf_link_hash_newfunc (entry, table, string)
3631 struct bfd_hash_entry *entry;
3632 struct bfd_hash_table *table;
3633 const char *string;
3634{
3635 struct elf_sh_link_hash_entry *ret =
3636 (struct elf_sh_link_hash_entry *) entry;
3637
3638 /* Allocate the structure if it has not already been allocated by a
3639 subclass. */
3640 if (ret == (struct elf_sh_link_hash_entry *) NULL)
3641 ret = ((struct elf_sh_link_hash_entry *)
3642 bfd_hash_allocate (table,
3643 sizeof (struct elf_sh_link_hash_entry)));
3644 if (ret == (struct elf_sh_link_hash_entry *) NULL)
3645 return (struct bfd_hash_entry *) ret;
3646
3647 /* Call the allocation method of the superclass. */
3648 ret = ((struct elf_sh_link_hash_entry *)
3649 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3650 table, string));
3651 if (ret != (struct elf_sh_link_hash_entry *) NULL)
3652 {
3653 ret->dyn_relocs = NULL;
3654 ret->gotplt_refcount = 0;
3655#ifdef INCLUDE_SHMEDIA
3656 ret->datalabel_got.refcount = ret->root.got.refcount;
3657#endif
3658 ret->tls_type = GOT_UNKNOWN;
3659 }
3660
3661 return (struct bfd_hash_entry *) ret;
3662}
3663
3664/* Create an sh ELF linker hash table. */
3665
3666static struct bfd_link_hash_table *
3667sh_elf_link_hash_table_create (abfd)
3668 bfd *abfd;
3669{
3670 struct elf_sh_link_hash_table *ret;
3671 bfd_size_type amt = sizeof (struct elf_sh_link_hash_table);
3672
3673 ret = (struct elf_sh_link_hash_table *) bfd_malloc (amt);
3674 if (ret == (struct elf_sh_link_hash_table *) NULL)
3675 return NULL;
3676
3677 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
3678 sh_elf_link_hash_newfunc))
3679 {
3680 free (ret);
3681 return NULL;
3682 }
3683
3684 ret->sgot = NULL;
3685 ret->sgotplt = NULL;
3686 ret->srelgot = NULL;
3687 ret->splt = NULL;
3688 ret->srelplt = NULL;
3689 ret->sdynbss = NULL;
3690 ret->srelbss = NULL;
3691 ret->sym_sec.abfd = NULL;
3692 ret->tls_ldm_got.refcount = 0;
3693
3694 return &ret->root.root;
3695}
3696
3697/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3698 shortcuts to them in our hash table. */
3699
3700static bfd_boolean
3701create_got_section (dynobj, info)
3702 bfd *dynobj;
3703 struct bfd_link_info *info;
3704{
3705 struct elf_sh_link_hash_table *htab;
3706
3707 if (! _bfd_elf_create_got_section (dynobj, info))
3708 return FALSE;
3709
3710 htab = sh_elf_hash_table (info);
3711 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
3712 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3713 if (! htab->sgot || ! htab->sgotplt)
3714 abort ();
3715
3716 htab->srelgot = bfd_make_section (dynobj, ".rela.got");
3717 if (htab->srelgot == NULL
3718 || ! bfd_set_section_flags (dynobj, htab->srelgot,
3719 (SEC_ALLOC
3720 | SEC_LOAD
3721 | SEC_HAS_CONTENTS
3722 | SEC_IN_MEMORY
3723 | SEC_LINKER_CREATED
3724 | SEC_READONLY))
3725 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
3726 return FALSE;
3727 return TRUE;
3728}
3729
3730/* Create dynamic sections when linking against a dynamic object. */
3731
3732static bfd_boolean
3733sh_elf_create_dynamic_sections (abfd, info)
3734 bfd *abfd;
3735 struct bfd_link_info *info;
3736{
3737 struct elf_sh_link_hash_table *htab;
3738 flagword flags, pltflags;
3739 register asection *s;
3740 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3741 int ptralign = 0;
3742
3743 switch (bed->s->arch_size)
3744 {
3745 case 32:
3746 ptralign = 2;
3747 break;
3748
3749 case 64:
3750 ptralign = 3;
3751 break;
3752
3753 default:
3754 bfd_set_error (bfd_error_bad_value);
3755 return FALSE;
3756 }
3757
3758 htab = sh_elf_hash_table (info);
3759
3760 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3761 .rel[a].bss sections. */
3762
3763 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3764 | SEC_LINKER_CREATED);
3765
3766 pltflags = flags;
3767 pltflags |= SEC_CODE;
3768 if (bed->plt_not_loaded)
3769 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
3770 if (bed->plt_readonly)
3771 pltflags |= SEC_READONLY;
3772
3773 s = bfd_make_section (abfd, ".plt");
3774 htab->splt = s;
3775 if (s == NULL
3776 || ! bfd_set_section_flags (abfd, s, pltflags)
3777 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3778 return FALSE;
3779
3780 if (bed->want_plt_sym)
3781 {
3782 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3783 .plt section. */
3784 struct elf_link_hash_entry *h;
3785 struct bfd_link_hash_entry *bh = NULL;
3786
3787 if (! (_bfd_generic_link_add_one_symbol
3788 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3789 (bfd_vma) 0, (const char *) NULL, FALSE,
3790 get_elf_backend_data (abfd)->collect, &bh)))
3791 return FALSE;
3792
3793 h = (struct elf_link_hash_entry *) bh;
3794 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3795 h->type = STT_OBJECT;
3796
3797 if (info->shared
3798 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
3799 return FALSE;
3800 }
3801
3802 s = bfd_make_section (abfd,
3803 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3804 htab->srelplt = s;
3805 if (s == NULL
3806 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3807 || ! bfd_set_section_alignment (abfd, s, ptralign))
3808 return FALSE;
3809
3810 if (! create_got_section (abfd, info))
3811 return FALSE;
3812
3813 {
3814 const char *secname;
3815 char *relname;
3816 flagword secflags;
3817 asection *sec;
3818
3819 for (sec = abfd->sections; sec; sec = sec->next)
3820 {
3821 secflags = bfd_get_section_flags (abfd, sec);
3822 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3823 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3824 continue;
3825 secname = bfd_get_section_name (abfd, sec);
3826 relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3827 strcpy (relname, ".rela");
3828 strcat (relname, secname);
3829 s = bfd_make_section (abfd, relname);
3830 if (s == NULL
3831 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3832 || ! bfd_set_section_alignment (abfd, s, ptralign))
3833 return FALSE;
3834 }
3835 }
3836
3837 if (bed->want_dynbss)
3838 {
3839 /* The .dynbss section is a place to put symbols which are defined
3840 by dynamic objects, are referenced by regular objects, and are
3841 not functions. We must allocate space for them in the process
3842 image and use a R_*_COPY reloc to tell the dynamic linker to
3843 initialize them at run time. The linker script puts the .dynbss
3844 section into the .bss section of the final image. */
3845 s = bfd_make_section (abfd, ".dynbss");
3846 htab->sdynbss = s;
3847 if (s == NULL
3848 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
3849 return FALSE;
3850
3851 /* The .rel[a].bss section holds copy relocs. This section is not
3852 normally needed. We need to create it here, though, so that the
3853 linker will map it to an output section. We can't just create it
3854 only if we need it, because we will not know whether we need it
3855 until we have seen all the input files, and the first time the
3856 main linker code calls BFD after examining all the input files
3857 (size_dynamic_sections) the input sections have already been
3858 mapped to the output sections. If the section turns out not to
3859 be needed, we can discard it later. We will never need this
3860 section when generating a shared object, since they do not use
3861 copy relocs. */
3862 if (! info->shared)
3863 {
3864 s = bfd_make_section (abfd,
3865 (bed->default_use_rela_p
3866 ? ".rela.bss" : ".rel.bss"));
3867 htab->srelbss = s;
3868 if (s == NULL
3869 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3870 || ! bfd_set_section_alignment (abfd, s, ptralign))
3871 return FALSE;
3872 }
3873 }
3874
3875 return TRUE;
3876}
3877
3878
3879/* Adjust a symbol defined by a dynamic object and referenced by a
3880 regular object. The current definition is in some section of the
3881 dynamic object, but we're not including those sections. We have to
3882 change the definition to something the rest of the link can
3883 understand. */
3884
3885static bfd_boolean
3886sh_elf_adjust_dynamic_symbol (info, h)
3887 struct bfd_link_info *info;
3888 struct elf_link_hash_entry *h;
3889{
3890 struct elf_sh_link_hash_table *htab;
3891 struct elf_sh_link_hash_entry *eh;
3892 struct elf_sh_dyn_relocs *p;
3893 bfd *dynobj;
3894 asection *s;
3895 unsigned int power_of_two;
3896
3897 dynobj = elf_hash_table (info)->dynobj;
3898
3899 /* Make sure we know what is going on here. */
3900 BFD_ASSERT (dynobj != NULL
3901 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
3902 || h->weakdef != NULL
3903 || ((h->elf_link_hash_flags
3904 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3905 && (h->elf_link_hash_flags
3906 & ELF_LINK_HASH_REF_REGULAR) != 0
3907 && (h->elf_link_hash_flags
3908 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
3909
3910 /* If this is a function, put it in the procedure linkage table. We
3911 will fill in the contents of the procedure linkage table later,
3912 when we know the address of the .got section. */
3913 if (h->type == STT_FUNC
3914 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
3915 {
3916 if (h->plt.refcount <= 0
3917 || (! info->shared
3918 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3919 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
3920 && h->root.type != bfd_link_hash_undefweak
3921 && h->root.type != bfd_link_hash_undefined))
3922 {
3923 /* This case can occur if we saw a PLT reloc in an input
3924 file, but the symbol was never referred to by a dynamic
3925 object. In such a case, we don't actually need to build
3926 a procedure linkage table, and we can just do a REL32
3927 reloc instead. */
3928 h->plt.offset = (bfd_vma) -1;
3929 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3930 }
3931
3932 return TRUE;
3933 }
3934 else
3935 h->plt.offset = (bfd_vma) -1;
3936
3937 /* If this is a weak symbol, and there is a real definition, the
3938 processor independent code will have arranged for us to see the
3939 real definition first, and we can just use the same value. */
3940 if (h->weakdef != NULL)
3941 {
3942 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3943 || h->weakdef->root.type == bfd_link_hash_defweak);
3944 h->root.u.def.section = h->weakdef->root.u.def.section;
3945 h->root.u.def.value = h->weakdef->root.u.def.value;
3946 return TRUE;
3947 }
3948
3949 /* This is a reference to a symbol defined by a dynamic object which
3950 is not a function. */
3951
3952 /* If we are creating a shared library, we must presume that the
3953 only references to the symbol are via the global offset table.
3954 For such cases we need not do anything here; the relocations will
3955 be handled correctly by relocate_section. */
3956 if (info->shared)
3957 return TRUE;
3958
3959 /* If there are no references to this symbol that do not use the
3960 GOT, we don't need to generate a copy reloc. */
3961 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
3962 return TRUE;
3963
3964 /* If -z nocopyreloc was given, we won't generate them either. */
3965 if (info->nocopyreloc)
3966 {
3967 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
3968 return TRUE;
3969 }
3970
3971 eh = (struct elf_sh_link_hash_entry *) h;
3972 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3973 {
3974 s = p->sec->output_section;
3975 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
3976 break;
3977 }
3978
3979 /* If we didn't find any dynamic relocs in sections which needs the
3980 copy reloc, then we'll be keeping the dynamic relocs and avoiding
3981 the copy reloc. */
3982 if (p == NULL)
3983 {
3984 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
3985 return TRUE;
3986 }
3987
3988 /* We must allocate the symbol in our .dynbss section, which will
3989 become part of the .bss section of the executable. There will be
3990 an entry for this symbol in the .dynsym section. The dynamic
3991 object will contain position independent code, so all references
3992 from the dynamic object to this symbol will go through the global
3993 offset table. The dynamic linker will use the .dynsym entry to
3994 determine the address it must put in the global offset table, so
3995 both the dynamic object and the regular object will refer to the
3996 same memory location for the variable. */
3997
3998 htab = sh_elf_hash_table (info);
3999 s = htab->sdynbss;
4000 BFD_ASSERT (s != NULL);
4001
4002 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
4003 copy the initial value out of the dynamic object and into the
4004 runtime process image. We need to remember the offset into the
4005 .rela.bss section we are going to use. */
4006 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4007 {
4008 asection *srel;
4009
4010 srel = htab->srelbss;
4011 BFD_ASSERT (srel != NULL);
4012 srel->_raw_size += sizeof (Elf32_External_Rela);
4013 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
4014 }
4015
4016 /* We need to figure out the alignment required for this symbol. I
4017 have no idea how ELF linkers handle this. */
4018 power_of_two = bfd_log2 (h->size);
4019 if (power_of_two > 3)
4020 power_of_two = 3;
4021
4022 /* Apply the required alignment. */
4023 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
4024 if (power_of_two > bfd_get_section_alignment (dynobj, s))
4025 {
4026 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
4027 return FALSE;
4028 }
4029
4030 /* Define the symbol as being at this point in the section. */
4031 h->root.u.def.section = s;
4032 h->root.u.def.value = s->_raw_size;
4033
4034 /* Increment the section size to make room for the symbol. */
4035 s->_raw_size += h->size;
4036
4037 return TRUE;
4038}
4039
4040/* This is the condition under which sh_elf_finish_dynamic_symbol
4041 will be called from elflink.h. If elflink.h doesn't call our
4042 finish_dynamic_symbol routine, we'll need to do something about
4043 initializing any .plt and .got entries in sh_elf_relocate_section. */
4044#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
4045 ((DYN) \
4046 && ((SHARED) \
4047 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
4048 && ((H)->dynindx != -1 \
4049 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
4050
4051/* Allocate space in .plt, .got and associated reloc sections for
4052 dynamic relocs. */
4053
4054static bfd_boolean
4055allocate_dynrelocs (h, inf)
4056 struct elf_link_hash_entry *h;
4057 PTR inf;
4058{
4059 struct bfd_link_info *info;
4060 struct elf_sh_link_hash_table *htab;
4061 struct elf_sh_link_hash_entry *eh;
4062 struct elf_sh_dyn_relocs *p;
4063
4064 if (h->root.type == bfd_link_hash_indirect)
4065 return TRUE;
4066
4067 if (h->root.type == bfd_link_hash_warning)
4068 /* When warning symbols are created, they **replace** the "real"
4069 entry in the hash table, thus we never get to see the real
4070 symbol in a hash traversal. So look at it now. */
4071 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4072
4073 info = (struct bfd_link_info *) inf;
4074 htab = sh_elf_hash_table (info);
4075
4076 eh = (struct elf_sh_link_hash_entry *) h;
4077 if ((h->got.refcount > 0
4078 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
4079 && eh->gotplt_refcount > 0)
4080 {
4081 /* The symbol has been forced local, or we have some direct got refs,
4082 so treat all the gotplt refs as got refs. */
4083 h->got.refcount += eh->gotplt_refcount;
4084 if (h->plt.refcount >= eh->gotplt_refcount)
4085 h->plt.refcount -= eh->gotplt_refcount;
4086 }
4087
4088 if (htab->root.dynamic_sections_created
4089 && h->plt.refcount > 0)
4090 {
4091 /* Make sure this symbol is output as a dynamic symbol.
4092 Undefined weak syms won't yet be marked as dynamic. */
4093 if (h->dynindx == -1
4094 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4095 {
4096 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4097 return FALSE;
4098 }
4099
4100 if (info->shared
4101 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
4102 {
4103 asection *s = htab->splt;
4104
4105 /* If this is the first .plt entry, make room for the special
4106 first entry. */
4107 if (s->_raw_size == 0)
4108 s->_raw_size += PLT_ENTRY_SIZE;
4109
4110 h->plt.offset = s->_raw_size;
4111
4112 /* If this symbol is not defined in a regular file, and we are
4113 not generating a shared library, then set the symbol to this
4114 location in the .plt. This is required to make function
4115 pointers compare as equal between the normal executable and
4116 the shared library. */
4117 if (! info->shared
4118 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4119 {
4120 h->root.u.def.section = s;
4121 h->root.u.def.value = h->plt.offset;
4122 }
4123
4124 /* Make room for this entry. */
4125 s->_raw_size += PLT_ENTRY_SIZE;
4126
4127 /* We also need to make an entry in the .got.plt section, which
4128 will be placed in the .got section by the linker script. */
4129 htab->sgotplt->_raw_size += 4;
4130
4131 /* We also need to make an entry in the .rel.plt section. */
4132 htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
4133 }
4134 else
4135 {
4136 h->plt.offset = (bfd_vma) -1;
4137 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
4138 }
4139 }
4140 else
4141 {
4142 h->plt.offset = (bfd_vma) -1;
4143 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
4144 }
4145
4146 if (h->got.refcount > 0)
4147 {
4148 asection *s;
4149 bfd_boolean dyn;
4150 int tls_type = sh_elf_hash_entry (h)->tls_type;
4151
4152 /* Make sure this symbol is output as a dynamic symbol.
4153 Undefined weak syms won't yet be marked as dynamic. */
4154 if (h->dynindx == -1
4155 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4156 {
4157 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4158 return FALSE;
4159 }
4160
4161 s = htab->sgot;
4162 h->got.offset = s->_raw_size;
4163 s->_raw_size += 4;
4164 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
4165 if (tls_type == GOT_TLS_GD)
4166 s->_raw_size += 4;
4167 dyn = htab->root.dynamic_sections_created;
4168 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
4169 R_SH_TLS_GD needs one if local symbol and two if global. */
4170 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
4171 || (tls_type == GOT_TLS_IE && dyn))
4172 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4173 else if (tls_type == GOT_TLS_GD)
4174 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela);
4175 else if (info->shared ||
4176 WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
4177 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4178 }
4179 else
4180 h->got.offset = (bfd_vma) -1;
4181
4182#ifdef INCLUDE_SHMEDIA
4183 if (eh->datalabel_got.refcount > 0)
4184 {
4185 asection *s;
4186 bfd_boolean dyn;
4187
4188 /* Make sure this symbol is output as a dynamic symbol.
4189 Undefined weak syms won't yet be marked as dynamic. */
4190 if (h->dynindx == -1
4191 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4192 {
4193 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4194 return FALSE;
4195 }
4196
4197 s = htab->sgot;
4198 eh->datalabel_got.offset = s->_raw_size;
4199 s->_raw_size += 4;
4200 dyn = htab->root.dynamic_sections_created;
4201 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
4202 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4203 }
4204 else
4205 eh->datalabel_got.offset = (bfd_vma) -1;
4206#endif
4207
4208 if (eh->dyn_relocs == NULL)
4209 return TRUE;
4210
4211 /* In the shared -Bsymbolic case, discard space allocated for
4212 dynamic pc-relative relocs against symbols which turn out to be
4213 defined in regular objects. For the normal shared case, discard
4214 space for pc-relative relocs that have become local due to symbol
4215 visibility changes. */
4216
4217 if (info->shared)
4218 {
4219 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
4220 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
4221 || info->symbolic))
4222 {
4223 struct elf_sh_dyn_relocs **pp;
4224
4225 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
4226 {
4227 p->count -= p->pc_count;
4228 p->pc_count = 0;
4229 if (p->count == 0)
4230 *pp = p->next;
4231 else
4232 pp = &p->next;
4233 }
4234 }
4235 }
4236 else
4237 {
4238 /* For the non-shared case, discard space for relocs against
4239 symbols which turn out to need copy relocs or are not
4240 dynamic. */
4241
4242 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
4243 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4244 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4245 || (htab->root.dynamic_sections_created
4246 && (h->root.type == bfd_link_hash_undefweak
4247 || h->root.type == bfd_link_hash_undefined))))
4248 {
4249 /* Make sure this symbol is output as a dynamic symbol.
4250 Undefined weak syms won't yet be marked as dynamic. */
4251 if (h->dynindx == -1
4252 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4253 {
4254 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4255 return FALSE;
4256 }
4257
4258 /* If that succeeded, we know we'll be keeping all the
4259 relocs. */
4260 if (h->dynindx != -1)
4261 goto keep;
4262 }
4263
4264 eh->dyn_relocs = NULL;
4265
4266 keep: ;
4267 }
4268
4269 /* Finally, allocate space. */
4270 for (p = eh->dyn_relocs; p != NULL; p = p->next)
4271 {
4272 asection *sreloc = elf_section_data (p->sec)->sreloc;
4273 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
4274 }
4275
4276 return TRUE;
4277}
4278
4279/* Find any dynamic relocs that apply to read-only sections. */
4280
4281static bfd_boolean
4282readonly_dynrelocs (h, inf)
4283 struct elf_link_hash_entry *h;
4284 PTR inf;
4285{
4286 struct elf_sh_link_hash_entry *eh;
4287 struct elf_sh_dyn_relocs *p;
4288
4289 if (h->root.type == bfd_link_hash_warning)
4290 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4291
4292 eh = (struct elf_sh_link_hash_entry *) h;
4293 for (p = eh->dyn_relocs; p != NULL; p = p->next)
4294 {
4295 asection *s = p->sec->output_section;
4296
4297 if (s != NULL && (s->flags & SEC_READONLY) != 0)
4298 {
4299 struct bfd_link_info *info = (struct bfd_link_info *) inf;
4300
4301 info->flags |= DF_TEXTREL;
4302
4303 /* Not an error, just cut short the traversal. */
4304 return FALSE;
4305 }
4306 }
4307 return TRUE;
4308}
4309
4310/* Set the sizes of the dynamic sections. */
4311
4312static bfd_boolean
4313sh_elf_size_dynamic_sections (output_bfd, info)
4314 bfd *output_bfd ATTRIBUTE_UNUSED;
4315 struct bfd_link_info *info;
4316{
4317 struct elf_sh_link_hash_table *htab;
4318 bfd *dynobj;
4319 asection *s;
4320 bfd_boolean relocs;
4321 bfd *ibfd;
4322
4323 htab = sh_elf_hash_table (info);
4324 dynobj = htab->root.dynobj;
4325 BFD_ASSERT (dynobj != NULL);
4326
4327 if (htab->root.dynamic_sections_created)
4328 {
4329 /* Set the contents of the .interp section to the interpreter. */
4330 if (! info->shared)
4331 {
4332 s = bfd_get_section_by_name (dynobj, ".interp");
4333 BFD_ASSERT (s != NULL);
4334 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
4335 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4336 }
4337 }
4338
4339 /* Set up .got offsets for local syms, and space for local dynamic
4340 relocs. */
4341 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4342 {
4343 bfd_signed_vma *local_got;
4344 bfd_signed_vma *end_local_got;
4345 char *local_tls_type;
4346 bfd_size_type locsymcount;
4347 Elf_Internal_Shdr *symtab_hdr;
4348 asection *srel;
4349
4350 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
4351 continue;
4352
4353 for (s = ibfd->sections; s != NULL; s = s->next)
4354 {
4355 struct elf_sh_dyn_relocs *p;
4356
4357 for (p = ((struct elf_sh_dyn_relocs *)
4358 elf_section_data (s)->local_dynrel);
4359 p != NULL;
4360 p = p->next)
4361 {
4362 if (! bfd_is_abs_section (p->sec)
4363 && bfd_is_abs_section (p->sec->output_section))
4364 {
4365 /* Input section has been discarded, either because
4366 it is a copy of a linkonce section or due to
4367 linker script /DISCARD/, so we'll be discarding
4368 the relocs too. */
4369 }
4370 else if (p->count != 0)
4371 {
4372 srel = elf_section_data (p->sec)->sreloc;
4373 srel->_raw_size += p->count * sizeof (Elf32_External_Rela);
4374 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
4375 info->flags |= DF_TEXTREL;
4376 }
4377 }
4378 }
4379
4380 local_got = elf_local_got_refcounts (ibfd);
4381 if (!local_got)
4382 continue;
4383
4384 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4385 locsymcount = symtab_hdr->sh_info;
4386#ifdef INCLUDE_SHMEDIA
4387 /* Count datalabel local GOT. */
4388 locsymcount *= 2;
4389#endif
4390 end_local_got = local_got + locsymcount;
4391 local_tls_type = sh_elf_local_got_tls_type (ibfd);
4392 s = htab->sgot;
4393 srel = htab->srelgot;
4394 for (; local_got < end_local_got; ++local_got)
4395 {
4396 if (*local_got > 0)
4397 {
4398 *local_got = s->_raw_size;
4399 s->_raw_size += 4;
4400 if (*local_tls_type == GOT_TLS_GD)
4401 s->_raw_size += 4;
4402 if (info->shared)
4403 srel->_raw_size += sizeof (Elf32_External_Rela);
4404 }
4405 else
4406 *local_got = (bfd_vma) -1;
4407 ++local_tls_type;
4408 }
4409 }
4410
4411 if (htab->tls_ldm_got.refcount > 0)
4412 {
4413 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
4414 relocs. */
4415 htab->tls_ldm_got.offset = htab->sgot->_raw_size;
4416 htab->sgot->_raw_size += 8;
4417 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4418 }
4419 else
4420 htab->tls_ldm_got.offset = -1;
4421
4422 /* Allocate global sym .plt and .got entries, and space for global
4423 sym dynamic relocs. */
4424 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (PTR) info);
4425
4426 /* We now have determined the sizes of the various dynamic sections.
4427 Allocate memory for them. */
4428 relocs = FALSE;
4429 for (s = dynobj->sections; s != NULL; s = s->next)
4430 {
4431 if ((s->flags & SEC_LINKER_CREATED) == 0)
4432 continue;
4433
4434 if (s == htab->splt
4435 || s == htab->sgot
4436 || s == htab->sgotplt)
4437 {
4438 /* Strip this section if we don't need it; see the
4439 comment below. */
4440 }
4441 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
4442 {
4443 if (s->_raw_size != 0 && s != htab->srelplt)
4444 relocs = TRUE;
4445
4446 /* We use the reloc_count field as a counter if we need
4447 to copy relocs into the output file. */
4448 s->reloc_count = 0;
4449 }
4450 else
4451 {
4452 /* It's not one of our sections, so don't allocate space. */
4453 continue;
4454 }
4455
4456 if (s->_raw_size == 0)
4457 {
4458 /* If we don't need this section, strip it from the
4459 output file. This is mostly to handle .rela.bss and
4460 .rela.plt. We must create both sections in
4461 create_dynamic_sections, because they must be created
4462 before the linker maps input sections to output
4463 sections. The linker does that before
4464 adjust_dynamic_symbol is called, and it is that
4465 function which decides whether anything needs to go
4466 into these sections. */
4467
4468 _bfd_strip_section_from_output (info, s);
4469 continue;
4470 }
4471
4472 /* Allocate memory for the section contents. We use bfd_zalloc
4473 here in case unused entries are not reclaimed before the
4474 section's contents are written out. This should not happen,
4475 but this way if it does, we get a R_SH_NONE reloc instead
4476 of garbage. */
4477 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
4478 if (s->contents == NULL)
4479 return FALSE;
4480 }
4481
4482 if (htab->root.dynamic_sections_created)
4483 {
4484 /* Add some entries to the .dynamic section. We fill in the
4485 values later, in sh_elf_finish_dynamic_sections, but we
4486 must add the entries now so that we get the correct size for
4487 the .dynamic section. The DT_DEBUG entry is filled in by the
4488 dynamic linker and used by the debugger. */
4489#define add_dynamic_entry(TAG, VAL) \
4490 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
4491
4492 if (! info->shared)
4493 {
4494 if (! add_dynamic_entry (DT_DEBUG, 0))
4495 return FALSE;
4496 }
4497
4498 if (htab->splt->_raw_size != 0)
4499 {
4500 if (! add_dynamic_entry (DT_PLTGOT, 0)
4501 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
4502 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
4503 || ! add_dynamic_entry (DT_JMPREL, 0))
4504 return FALSE;
4505 }
4506
4507 if (relocs)
4508 {
4509 if (! add_dynamic_entry (DT_RELA, 0)
4510 || ! add_dynamic_entry (DT_RELASZ, 0)
4511 || ! add_dynamic_entry (DT_RELAENT,
4512 sizeof (Elf32_External_Rela)))
4513 return FALSE;
4514
4515 /* If any dynamic relocs apply to a read-only section,
4516 then we need a DT_TEXTREL entry. */
4517 if ((info->flags & DF_TEXTREL) == 0)
4518 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
4519 (PTR) info);
4520
4521 if ((info->flags & DF_TEXTREL) != 0)
4522 {
4523 if (! add_dynamic_entry (DT_TEXTREL, 0))
4524 return FALSE;
4525 }
4526 }
4527 }
4528#undef add_dynamic_entry
4529
4530 return TRUE;
4531}
4532
4533
4534/* Relocate an SH ELF section. */
4535
4536static bfd_boolean
4537sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
4538 contents, relocs, local_syms, local_sections)
4539 bfd *output_bfd;
4540 struct bfd_link_info *info;
4541 bfd *input_bfd;
4542 asection *input_section;
4543 bfd_byte *contents;
4544 Elf_Internal_Rela *relocs;
4545 Elf_Internal_Sym *local_syms;
4546 asection **local_sections;
4547{
4548 struct elf_sh_link_hash_table *htab;
4549 Elf_Internal_Shdr *symtab_hdr;
4550 struct elf_link_hash_entry **sym_hashes;
4551 Elf_Internal_Rela *rel, *relend;
4552 bfd *dynobj;
4553 bfd_vma *local_got_offsets;
4554 asection *sgot;
4555 asection *sgotplt;
4556 asection *splt;
4557 asection *sreloc;
4558 asection *srelgot;
4559
4560 htab = sh_elf_hash_table (info);
4561 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4562 sym_hashes = elf_sym_hashes (input_bfd);
4563 dynobj = htab->root.dynobj;
4564 local_got_offsets = elf_local_got_offsets (input_bfd);
4565
4566 sgot = htab->sgot;
4567 sgotplt = htab->sgotplt;
4568 splt = htab->splt;
4569 sreloc = NULL;
4570 srelgot = NULL;
4571
4572 rel = relocs;
4573 relend = relocs + input_section->reloc_count;
4574 for (; rel < relend; rel++)
4575 {
4576 int r_type;
4577 reloc_howto_type *howto;
4578 unsigned long r_symndx;
4579 Elf_Internal_Sym *sym;
4580 asection *sec;
4581 struct elf_link_hash_entry *h;
4582 bfd_vma relocation;
4583 bfd_vma addend = (bfd_vma) 0;
4584 bfd_reloc_status_type r;
4585 int seen_stt_datalabel = 0;
4586 bfd_vma off;
4587 int tls_type;
4588
4589 r_symndx = ELF32_R_SYM (rel->r_info);
4590
4591 r_type = ELF32_R_TYPE (rel->r_info);
4592
4593 /* Many of the relocs are only used for relaxing, and are
4594 handled entirely by the relaxation code. */
4595 if (r_type > (int) R_SH_LAST_INVALID_RELOC
4596 && r_type < (int) R_SH_LOOP_START)
4597 continue;
4598 if (r_type == (int) R_SH_NONE)
4599 continue;
4600
4601 if (r_type < 0
4602 || r_type >= R_SH_max
4603 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
4604 && r_type <= (int) R_SH_LAST_INVALID_RELOC)
4605 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_3
4606 && r_type <= (int) R_SH_LAST_INVALID_RELOC_3)
4607 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_4
4608 && r_type <= (int) R_SH_LAST_INVALID_RELOC_4)
4609 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_5
4610 && r_type <= (int) R_SH_LAST_INVALID_RELOC_5)
4611 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
4612 && r_type <= (int) R_SH_LAST_INVALID_RELOC_2))
4613 {
4614 bfd_set_error (bfd_error_bad_value);
4615 return FALSE;
4616 }
4617
4618 howto = sh_elf_howto_table + r_type;
4619
4620 /* For relocs that aren't partial_inplace, we get the addend from
4621 the relocation. */
4622 if (! howto->partial_inplace)
4623 addend = rel->r_addend;
4624
4625 h = NULL;
4626 sym = NULL;
4627 sec = NULL;
4628 if (r_symndx < symtab_hdr->sh_info)
4629 {
4630 sym = local_syms + r_symndx;
4631 sec = local_sections[r_symndx];
4632 relocation = (sec->output_section->vma
4633 + sec->output_offset
4634 + sym->st_value);
4635 /* A local symbol never has STO_SH5_ISA32, so we don't need
4636 datalabel processing here. Make sure this does not change
4637 without notice. */
4638 if ((sym->st_other & STO_SH5_ISA32) != 0)
4639 ((*info->callbacks->reloc_dangerous)
4640 (info,
4641 _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
4642 input_bfd, input_section, rel->r_offset));
4643 if (info->relocateable)
4644 {
4645 /* This is a relocateable link. We don't have to change
4646 anything, unless the reloc is against a section symbol,
4647 in which case we have to adjust according to where the
4648 section symbol winds up in the output section. */
4649 sym = local_syms + r_symndx;
4650 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4651 {
4652 if (! howto->partial_inplace)
4653 {
4654 /* For relocations with the addend in the
4655 relocation, we need just to update the addend.
4656 All real relocs are of type partial_inplace; this
4657 code is mostly for completeness. */
4658 rel->r_addend += sec->output_offset + sym->st_value;
4659
4660 continue;
4661 }
4662
4663 /* Relocs of type partial_inplace need to pick up the
4664 contents in the contents and add the offset resulting
4665 from the changed location of the section symbol.
4666 Using _bfd_final_link_relocate (e.g. goto
4667 final_link_relocate) here would be wrong, because
4668 relocations marked pc_relative would get the current
4669 location subtracted, and we must only do that at the
4670 final link. */
4671 r = _bfd_relocate_contents (howto, input_bfd,
4672 sec->output_offset
4673 + sym->st_value,
4674 contents + rel->r_offset);
4675 goto relocation_done;
4676 }
4677
4678 continue;
4679 }
4680 else if (! howto->partial_inplace)
4681 {
4682 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
4683 addend = rel->r_addend;
4684 }
4685 else if ((sec->flags & SEC_MERGE)
4686 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4687 {
4688 asection *msec;
4689
4690 if (howto->rightshift || howto->src_mask != 0xffffffff)
4691 {
4692 (*_bfd_error_handler)
4693 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
4694 bfd_archive_filename (input_bfd),
4695 bfd_get_section_name (input_bfd, input_section),
4696 (long) rel->r_offset, howto->name);
4697 return FALSE;
4698 }
4699
4700 addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
4701 msec = sec;
4702 addend =
4703 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
4704 - relocation;
4705 addend += msec->output_section->vma + msec->output_offset;
4706 bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
4707 addend = 0;
4708 }
4709 }
4710 else
4711 {
4712 /* Section symbol are never (?) placed in the hash table, so
4713 we can just ignore hash relocations when creating a
4714 relocateable object file. */
4715 if (info->relocateable)
4716 continue;
4717
4718 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4719 while (h->root.type == bfd_link_hash_indirect
4720 || h->root.type == bfd_link_hash_warning)
4721 {
4722#ifdef INCLUDE_SHMEDIA
4723 /* If the reference passes a symbol marked with
4724 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
4725 doesn't count. */
4726 seen_stt_datalabel |= h->type == STT_DATALABEL;
4727#endif
4728 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4729 }
4730 if (h->root.type == bfd_link_hash_defined
4731 || h->root.type == bfd_link_hash_defweak)
4732 {
4733 bfd_boolean dyn;
4734
4735 dyn = htab->root.dynamic_sections_created;
4736 sec = h->root.u.def.section;
4737 /* In these cases, we don't need the relocation value.
4738 We check specially because in some obscure cases
4739 sec->output_section will be NULL. */
4740 if (r_type == R_SH_GOTPC
4741 || r_type == R_SH_GOTPC_LOW16
4742 || r_type == R_SH_GOTPC_MEDLOW16
4743 || r_type == R_SH_GOTPC_MEDHI16
4744 || r_type == R_SH_GOTPC_HI16
4745 || ((r_type == R_SH_PLT32
4746 || r_type == R_SH_PLT_LOW16
4747 || r_type == R_SH_PLT_MEDLOW16
4748 || r_type == R_SH_PLT_MEDHI16
4749 || r_type == R_SH_PLT_HI16)
4750 && h->plt.offset != (bfd_vma) -1)
4751 || ((r_type == R_SH_GOT32
4752 || r_type == R_SH_GOT_LOW16
4753 || r_type == R_SH_GOT_MEDLOW16
4754 || r_type == R_SH_GOT_MEDHI16
4755 || r_type == R_SH_GOT_HI16)
4756 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
4757 && (! info->shared
4758 || (! info->symbolic && h->dynindx != -1)
4759 || (h->elf_link_hash_flags
4760 & ELF_LINK_HASH_DEF_REGULAR) == 0))
4761 /* The cases above are those in which relocation is
4762 overwritten in the switch block below. The cases
4763 below are those in which we must defer relocation
4764 to run-time, because we can't resolve absolute
4765 addresses when creating a shared library. */
4766 || (info->shared
4767 && ((! info->symbolic && h->dynindx != -1)
4768 || (h->elf_link_hash_flags
4769 & ELF_LINK_HASH_DEF_REGULAR) == 0)
4770 && ((r_type == R_SH_DIR32
4771 && (h->elf_link_hash_flags
4772 & ELF_LINK_FORCED_LOCAL) == 0)
4773 || r_type == R_SH_REL32)
4774 && ((input_section->flags & SEC_ALLOC) != 0
4775 /* DWARF will emit R_SH_DIR32 relocations in its
4776 sections against symbols defined externally
4777 in shared libraries. We can't do anything
4778 with them here. */
4779 || ((input_section->flags & SEC_DEBUGGING) != 0
4780 && (h->elf_link_hash_flags
4781 & ELF_LINK_HASH_DEF_DYNAMIC) != 0)))
4782 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4783 sections because such sections are not SEC_ALLOC and
4784 thus ld.so will not process them. */
4785 || (sec->output_section == NULL
4786 && ((input_section->flags & SEC_DEBUGGING) != 0
4787 && (h->elf_link_hash_flags
4788 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
4789 || (sec->output_section == NULL
4790 && (sh_elf_hash_entry (h)->tls_type == GOT_TLS_IE
4791 || sh_elf_hash_entry (h)->tls_type == GOT_TLS_GD)))
4792 relocation = 0;
4793 else if (sec->output_section == NULL)
4794 {
4795 (*_bfd_error_handler)
4796 (_("%s: unresolvable relocation against symbol `%s' from %s section"),
4797 bfd_archive_filename (input_bfd), h->root.root.string,
4798 bfd_get_section_name (input_bfd, input_section));
4799 return FALSE;
4800 }
4801 else
4802 relocation = ((h->root.u.def.value
4803 + sec->output_section->vma
4804 + sec->output_offset)
4805 /* A STO_SH5_ISA32 causes a "bitor 1" to the
4806 symbol value, unless we've seen
4807 STT_DATALABEL on the way to it. */
4808 | ((h->other & STO_SH5_ISA32) != 0
4809 && ! seen_stt_datalabel));
4810 }
4811 else if (h->root.type == bfd_link_hash_undefweak)
4812 relocation = 0;
4813 else if (info->shared
4814 && ! info->no_undefined
4815 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4816 relocation = 0;
4817 else
4818 {
4819 if (! ((*info->callbacks->undefined_symbol)
4820 (info, h->root.root.string, input_bfd,
4821 input_section, rel->r_offset,
4822 (!info->shared || info->no_undefined
4823 || ELF_ST_VISIBILITY (h->other)))))
4824 return FALSE;
4825 relocation = 0;
4826 }
4827 }
4828
4829 switch ((int) r_type)
4830 {
4831 final_link_relocate:
4832 /* COFF relocs don't use the addend. The addend is used for
4833 R_SH_DIR32 to be compatible with other compilers. */
4834 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4835 contents, rel->r_offset,
4836 relocation, addend);
4837 break;
4838
4839 case R_SH_IND12W:
4840 goto final_link_relocate;
4841
4842 case R_SH_DIR8WPN:
4843 case R_SH_DIR8WPZ:
4844 case R_SH_DIR8WPL:
4845 /* If the reloc is against the start of this section, then
4846 the assembler has already taken care of it and the reloc
4847 is here only to assist in relaxing. If the reloc is not
4848 against the start of this section, then it's against an
4849 external symbol and we must deal with it ourselves. */
4850 if (input_section->output_section->vma + input_section->output_offset
4851 != relocation)
4852 {
4853 int disp = (relocation
4854 - input_section->output_section->vma
4855 - input_section->output_offset
4856 - rel->r_offset);
4857 int mask = 0;
4858 switch (r_type)
4859 {
4860 case R_SH_DIR8WPN:
4861 case R_SH_DIR8WPZ: mask = 1; break;
4862 case R_SH_DIR8WPL: mask = 3; break;
4863 default: mask = 0; break;
4864 }
4865 if (disp & mask)
4866 {
4867 ((*_bfd_error_handler)
4868 (_("%s: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
4869 bfd_archive_filename (input_section->owner),
4870 (unsigned long) rel->r_offset));
4871 bfd_set_error (bfd_error_bad_value);
4872 return FALSE;
4873 }
4874 relocation -= 4;
4875 goto final_link_relocate;
4876 }
4877 r = bfd_reloc_ok;
4878 break;
4879
4880 default:
4881#ifdef INCLUDE_SHMEDIA
4882 if (shmedia_prepare_reloc (info, input_bfd, input_section,
4883 contents, rel, &relocation))
4884 goto final_link_relocate;
4885#endif
4886 bfd_set_error (bfd_error_bad_value);
4887 return FALSE;
4888
4889 case R_SH_DIR32:
4890 case R_SH_REL32:
4891 if (info->shared
4892 && r_symndx != 0
4893 && (input_section->flags & SEC_ALLOC) != 0
4894 && (r_type != R_SH_REL32
4895 || (h != NULL
4896 && h->dynindx != -1
4897 && (! info->symbolic
4898 || (h->elf_link_hash_flags
4899 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
4900 {
4901 Elf_Internal_Rela outrel;
4902 bfd_byte *loc;
4903 bfd_boolean skip, relocate;
4904
4905 /* When generating a shared object, these relocations
4906 are copied into the output file to be resolved at run
4907 time. */
4908
4909 if (sreloc == NULL)
4910 {
4911 const char *name;
4912
4913 name = (bfd_elf_string_from_elf_section
4914 (input_bfd,
4915 elf_elfheader (input_bfd)->e_shstrndx,
4916 elf_section_data (input_section)->rel_hdr.sh_name));
4917 if (name == NULL)
4918 return FALSE;
4919
4920 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
4921 && strcmp (bfd_get_section_name (input_bfd,
4922 input_section),
4923 name + 5) == 0);
4924
4925 sreloc = bfd_get_section_by_name (dynobj, name);
4926 BFD_ASSERT (sreloc != NULL);
4927 }
4928
4929 skip = FALSE;
4930 relocate = FALSE;
4931
4932 outrel.r_offset =
4933 _bfd_elf_section_offset (output_bfd, info, input_section,
4934 rel->r_offset);
4935 if (outrel.r_offset == (bfd_vma) -1)
4936 skip = TRUE;
4937 else if (outrel.r_offset == (bfd_vma) -2)
4938 skip = TRUE, relocate = TRUE;
4939 outrel.r_offset += (input_section->output_section->vma
4940 + input_section->output_offset);
4941
4942 if (skip)
4943 memset (&outrel, 0, sizeof outrel);
4944 else if (r_type == R_SH_REL32)
4945 {
4946 BFD_ASSERT (h != NULL && h->dynindx != -1);
4947 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
4948 outrel.r_addend
4949 = bfd_get_32 (input_bfd, contents + rel->r_offset);
4950 }
4951 else
4952 {
4953 /* h->dynindx may be -1 if this symbol was marked to
4954 become local. */
4955 if (h == NULL
4956 || ((info->symbolic || h->dynindx == -1)
4957 && (h->elf_link_hash_flags
4958 & ELF_LINK_HASH_DEF_REGULAR) != 0))
4959 {
4960 relocate = TRUE;
4961 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4962 outrel.r_addend
4963 = relocation + bfd_get_32 (input_bfd,
4964 contents + rel->r_offset);
4965 }
4966 else
4967 {
4968 BFD_ASSERT (h->dynindx != -1);
4969 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
4970 outrel.r_addend
4971 = relocation + bfd_get_32 (input_bfd,
4972 contents + rel->r_offset);
4973 }
4974 }
4975
4976 loc = sreloc->contents;
4977 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4978 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4979
4980 /* If this reloc is against an external symbol, we do
4981 not want to fiddle with the addend. Otherwise, we
4982 need to include the symbol value so that it becomes
4983 an addend for the dynamic reloc. */
4984 if (! relocate)
4985 continue;
4986 }
4987 goto final_link_relocate;
4988
4989 case R_SH_GOTPLT32:
4990#ifdef INCLUDE_SHMEDIA
4991 case R_SH_GOTPLT_LOW16:
4992 case R_SH_GOTPLT_MEDLOW16:
4993 case R_SH_GOTPLT_MEDHI16:
4994 case R_SH_GOTPLT_HI16:
4995 case R_SH_GOTPLT10BY4:
4996 case R_SH_GOTPLT10BY8:
4997#endif
4998 /* Relocation is to the entry for this symbol in the
4999 procedure linkage table. */
5000
5001 if (h == NULL
5002 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
5003 || ! info->shared
5004 || info->symbolic
5005 || h->dynindx == -1
5006 || h->plt.offset == (bfd_vma) -1
5007 || h->got.offset != (bfd_vma) -1)
5008 goto force_got;
5009
5010 /* Relocation is to the entry for this symbol in the global
5011 offset table extension for the procedure linkage table. */
5012
5013 BFD_ASSERT (sgotplt != NULL);
5014 relocation = (sgotplt->output_offset
5015 + ((h->plt.offset / elf_sh_sizeof_plt (info)
5016 - 1 + 3) * 4));
5017
5018#ifdef GOT_BIAS
5019 relocation -= GOT_BIAS;
5020#endif
5021
5022 goto final_link_relocate;
5023
5024 force_got:
5025 case R_SH_GOT32:
5026#ifdef INCLUDE_SHMEDIA
5027 case R_SH_GOT_LOW16:
5028 case R_SH_GOT_MEDLOW16:
5029 case R_SH_GOT_MEDHI16:
5030 case R_SH_GOT_HI16:
5031 case R_SH_GOT10BY4:
5032 case R_SH_GOT10BY8:
5033#endif
5034 /* Relocation is to the entry for this symbol in the global
5035 offset table. */
5036
5037 BFD_ASSERT (sgot != NULL);
5038
5039 if (h != NULL)
5040 {
5041 bfd_boolean dyn;
5042
5043 off = h->got.offset;
5044#ifdef INCLUDE_SHMEDIA
5045 if (seen_stt_datalabel)
5046 {
5047 struct elf_sh_link_hash_entry *hsh;
5048
5049 hsh = (struct elf_sh_link_hash_entry *)h;
5050 off = hsh->datalabel_got.offset;
5051 }
5052#endif
5053 BFD_ASSERT (off != (bfd_vma) -1);
5054
5055 dyn = htab->root.dynamic_sections_created;
5056 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
5057 || (info->shared
5058 && (info->symbolic || h->dynindx == -1
5059 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
5060 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
5061 {
5062 /* This is actually a static link, or it is a
5063 -Bsymbolic link and the symbol is defined
5064 locally, or the symbol was forced to be local
5065 because of a version file. We must initialize
5066 this entry in the global offset table. Since the
5067 offset must always be a multiple of 4, we use the
5068 least significant bit to record whether we have
5069 initialized it already.
5070
5071 When doing a dynamic link, we create a .rela.got
5072 relocation entry to initialize the value. This
5073 is done in the finish_dynamic_symbol routine. */
5074 if ((off & 1) != 0)
5075 off &= ~1;
5076 else
5077 {
5078 bfd_put_32 (output_bfd, relocation,
5079 sgot->contents + off);
5080#ifdef INCLUDE_SHMEDIA
5081 if (seen_stt_datalabel)
5082 {
5083 struct elf_sh_link_hash_entry *hsh;
5084
5085 hsh = (struct elf_sh_link_hash_entry *)h;
5086 hsh->datalabel_got.offset |= 1;
5087 }
5088 else
5089#endif
5090 h->got.offset |= 1;
5091 }
5092 }
5093
5094 relocation = sgot->output_offset + off;
5095 }
5096 else
5097 {
5098#ifdef INCLUDE_SHMEDIA
5099 if (rel->r_addend)
5100 {
5101 BFD_ASSERT (local_got_offsets != NULL
5102 && (local_got_offsets[symtab_hdr->sh_info
5103 + r_symndx]
5104 != (bfd_vma) -1));
5105
5106 off = local_got_offsets[symtab_hdr->sh_info
5107 + r_symndx];
5108 }
5109 else
5110 {
5111#endif
5112 BFD_ASSERT (local_got_offsets != NULL
5113 && local_got_offsets[r_symndx] != (bfd_vma) -1);
5114
5115 off = local_got_offsets[r_symndx];
5116#ifdef INCLUDE_SHMEDIA
5117 }
5118#endif
5119
5120 /* The offset must always be a multiple of 4. We use
5121 the least significant bit to record whether we have
5122 already generated the necessary reloc. */
5123 if ((off & 1) != 0)
5124 off &= ~1;
5125 else
5126 {
5127 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5128
5129 if (info->shared)
5130 {
5131 Elf_Internal_Rela outrel;
5132 bfd_byte *loc;
5133
5134 if (srelgot == NULL)
5135 {
5136 srelgot = bfd_get_section_by_name (dynobj,
5137 ".rela.got");
5138 BFD_ASSERT (srelgot != NULL);
5139 }
5140
5141 outrel.r_offset = (sgot->output_section->vma
5142 + sgot->output_offset
5143 + off);
5144 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
5145 outrel.r_addend = relocation;
5146 loc = srelgot->contents;
5147 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5148 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5149 }
5150
5151#ifdef INCLUDE_SHMEDIA
5152 if (rel->r_addend)
5153 local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
5154 else
5155#endif
5156 local_got_offsets[r_symndx] |= 1;
5157 }
5158
5159 relocation = sgot->output_offset + off;
5160 }
5161
5162#ifdef GOT_BIAS
5163 relocation -= GOT_BIAS;
5164#endif
5165
5166 goto final_link_relocate;
5167
5168 case R_SH_GOTOFF:
5169#ifdef INCLUDE_SHMEDIA
5170 case R_SH_GOTOFF_LOW16:
5171 case R_SH_GOTOFF_MEDLOW16:
5172 case R_SH_GOTOFF_MEDHI16:
5173 case R_SH_GOTOFF_HI16:
5174#endif
5175 /* Relocation is relative to the start of the global offset
5176 table. */
5177
5178 BFD_ASSERT (sgot != NULL);
5179
5180 /* Note that sgot->output_offset is not involved in this
5181 calculation. We always want the start of .got. If we
5182 defined _GLOBAL_OFFSET_TABLE in a different way, as is
5183 permitted by the ABI, we might have to change this
5184 calculation. */
5185 relocation -= sgot->output_section->vma;
5186
5187#ifdef GOT_BIAS
5188 relocation -= GOT_BIAS;
5189#endif
5190
5191 addend = rel->r_addend;
5192
5193 goto final_link_relocate;
5194
5195 case R_SH_GOTPC:
5196#ifdef INCLUDE_SHMEDIA
5197 case R_SH_GOTPC_LOW16:
5198 case R_SH_GOTPC_MEDLOW16:
5199 case R_SH_GOTPC_MEDHI16:
5200 case R_SH_GOTPC_HI16:
5201#endif
5202 /* Use global offset table as symbol value. */
5203
5204 BFD_ASSERT (sgot != NULL);
5205 relocation = sgot->output_section->vma;
5206
5207#ifdef GOT_BIAS
5208 relocation += GOT_BIAS;
5209#endif
5210
5211 addend = rel->r_addend;
5212
5213 goto final_link_relocate;
5214
5215 case R_SH_PLT32:
5216#ifdef INCLUDE_SHMEDIA
5217 case R_SH_PLT_LOW16:
5218 case R_SH_PLT_MEDLOW16:
5219 case R_SH_PLT_MEDHI16:
5220 case R_SH_PLT_HI16:
5221#endif
5222 /* Relocation is to the entry for this symbol in the
5223 procedure linkage table. */
5224
5225 /* Resolve a PLT reloc against a local symbol directly,
5226 without using the procedure linkage table. */
5227 if (h == NULL)
5228 goto final_link_relocate;
5229
5230 if (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
5231 goto final_link_relocate;
5232
5233 if (h->plt.offset == (bfd_vma) -1)
5234 {
5235 /* We didn't make a PLT entry for this symbol. This
5236 happens when statically linking PIC code, or when
5237 using -Bsymbolic. */
5238 goto final_link_relocate;
5239 }
5240
5241 BFD_ASSERT (splt != NULL);
5242 relocation = (splt->output_section->vma
5243 + splt->output_offset
5244 + h->plt.offset);
5245
5246#ifdef INCLUDE_SHMEDIA
5247 relocation++;
5248#endif
5249
5250 addend = rel->r_addend;
5251
5252 goto final_link_relocate;
5253
5254 case R_SH_LOOP_START:
5255 {
5256 static bfd_vma start, end;
5257
5258 start = (relocation + rel->r_addend
5259 - (sec->output_section->vma + sec->output_offset));
5260 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5261 rel->r_offset, sec, start, end);
5262 break;
5263
5264 case R_SH_LOOP_END:
5265 end = (relocation + rel->r_addend
5266 - (sec->output_section->vma + sec->output_offset));
5267 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5268 rel->r_offset, sec, start, end);
5269 break;
5270 }
5271
5272 case R_SH_TLS_GD_32:
5273 case R_SH_TLS_IE_32:
5274 r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
5275 tls_type = GOT_UNKNOWN;
5276 if (h == NULL && local_got_offsets)
5277 tls_type = sh_elf_local_got_tls_type (input_bfd) [r_symndx];
5278 else if (h != NULL)
5279 {
5280 tls_type = sh_elf_hash_entry (h)->tls_type;
5281 if (! info->shared
5282 && (h->dynindx == -1
5283 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
5284 r_type = R_SH_TLS_LE_32;
5285 }
5286
5287 if (r_type == R_SH_TLS_GD_32 && tls_type == GOT_TLS_IE)
5288 r_type = R_SH_TLS_IE_32;
5289
5290 if (r_type == R_SH_TLS_LE_32)
5291 {
5292 bfd_vma offset;
5293 unsigned short insn;
5294
5295 if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_GD_32)
5296 {
5297 /* GD->LE transition:
5298 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5299 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5300 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5301 We change it into:
5302 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5303 nop; nop; ...
5304 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
5305
5306 offset = rel->r_offset;
5307 BFD_ASSERT (offset >= 16);
5308 /* Size of GD instructions is 16 or 18. */
5309 offset -= 16;
5310 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5311 if ((insn & 0xff00) == 0xc700)
5312 {
5313 BFD_ASSERT (offset >= 2);
5314 offset -= 2;
5315 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5316 }
5317
5318 BFD_ASSERT ((insn & 0xff00) == 0xd400);
5319 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5320 BFD_ASSERT ((insn & 0xff00) == 0xc700);
5321 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5322 BFD_ASSERT ((insn & 0xff00) == 0xd100);
5323 insn = bfd_get_16 (input_bfd, contents + offset + 6);
5324 BFD_ASSERT (insn == 0x310c);
5325 insn = bfd_get_16 (input_bfd, contents + offset + 8);
5326 BFD_ASSERT (insn == 0x410b);
5327 insn = bfd_get_16 (input_bfd, contents + offset + 10);
5328 BFD_ASSERT (insn == 0x34cc);
5329
5330 bfd_put_16 (output_bfd, 0x0012, contents + offset + 2);
5331 bfd_put_16 (output_bfd, 0x304c, contents + offset + 4);
5332 bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5333 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5334 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5335 }
5336 else
5337 {
5338 int index;
5339
5340 /* IE->LE transition:
5341 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5342 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5343 We change it into:
5344 mov.l .Ln,rM; stc gbr,rN; nop; ...;
5345 1: x@TPOFF; 2:. */
5346
5347 offset = rel->r_offset;
5348 BFD_ASSERT (offset >= 16);
5349 /* Size of IE instructions is 10 or 12. */
5350 offset -= 10;
5351 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5352 if ((insn & 0xf0ff) == 0x0012)
5353 {
5354 BFD_ASSERT (offset >= 2);
5355 offset -= 2;
5356 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5357 }
5358
5359 BFD_ASSERT ((insn & 0xff00) == 0xd000);
5360 index = insn & 0x00ff;
5361 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5362 BFD_ASSERT ((insn & 0xf0ff) == 0x0012);
5363 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5364 BFD_ASSERT ((insn & 0xf0ff) == 0x00ce);
5365 insn = 0xd000 | (insn & 0x0f00) | index;
5366 bfd_put_16 (output_bfd, insn, contents + offset + 0);
5367 bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5368 }
5369
5370 bfd_put_32 (output_bfd, tpoff (info, relocation),
5371 contents + rel->r_offset);
5372 continue;
5373 }
5374
5375 sgot = htab->sgot;
5376 if (sgot == NULL)
5377 abort ();
5378
5379 if (h != NULL)
5380 off = h->got.offset;
5381 else
5382 {
5383 if (local_got_offsets == NULL)
5384 abort ();
5385
5386 off = local_got_offsets[r_symndx];
5387 }
5388
5389 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
5390 if (r_type == R_SH_TLS_IE_32
5391 && ! htab->root.dynamic_sections_created)
5392 {
5393 off &= ~1;
5394 bfd_put_32 (output_bfd, tpoff (info, relocation),
5395 sgot->contents + off);
5396 bfd_put_32 (output_bfd, sgot->output_offset + off,
5397 contents + rel->r_offset);
5398 continue;
5399 }
5400
5401 if ((off & 1) != 0)
5402 off &= ~1;
5403 else
5404 {
5405 Elf_Internal_Rela outrel;
5406 bfd_byte *loc;
5407 int dr_type, indx;
5408
5409 if (srelgot == NULL)
5410 {
5411 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5412 BFD_ASSERT (srelgot != NULL);
5413 }
5414
5415 outrel.r_offset = (sgot->output_section->vma
5416 + sgot->output_offset + off);
5417
5418 if (h == NULL || h->dynindx == -1)
5419 indx = 0;
5420 else
5421 indx = h->dynindx;
5422
5423 dr_type = (r_type == R_SH_TLS_GD_32 ? R_SH_TLS_DTPMOD32 :
5424 R_SH_TLS_TPOFF32);
5425 if (dr_type == R_SH_TLS_TPOFF32 && indx == 0)
5426 outrel.r_addend = relocation - dtpoff_base (info);
5427 else
5428 outrel.r_addend = 0;
5429 outrel.r_info = ELF32_R_INFO (indx, dr_type);
5430 loc = srelgot->contents;
5431 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5432 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5433
5434 if (r_type == R_SH_TLS_GD_32)
5435 {
5436 if (indx == 0)
5437 {
5438 bfd_put_32 (output_bfd,
5439 relocation - dtpoff_base (info),
5440 sgot->contents + off + 4);
5441 }
5442 else
5443 {
5444 outrel.r_info = ELF32_R_INFO (indx,
5445 R_SH_TLS_DTPOFF32);
5446 outrel.r_offset += 4;
5447 outrel.r_addend = 0;
5448 srelgot->reloc_count++;
5449 loc += sizeof (Elf32_External_Rela);
5450 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5451 }
5452 }
5453
5454 if (h != NULL)
5455 h->got.offset |= 1;
5456 else
5457 local_got_offsets[r_symndx] |= 1;
5458 }
5459
5460 if (off >= (bfd_vma) -2)
5461 abort ();
5462
5463 if (r_type == (int) ELF32_R_TYPE (rel->r_info))
5464 relocation = sgot->output_offset + off;
5465 else
5466 {
5467 bfd_vma offset;
5468 unsigned short insn;
5469
5470 /* GD->IE transition:
5471 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5472 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5473 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5474 We change it into:
5475 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5476 nop; nop; bra 3f; nop; .align 2;
5477 1: .long x@TPOFF; 2:...; 3:. */
5478
5479 offset = rel->r_offset;
5480 BFD_ASSERT (offset >= 16);
5481 /* Size of GD instructions is 16 or 18. */
5482 offset -= 16;
5483 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5484 if ((insn & 0xff00) == 0xc700)
5485 {
5486 BFD_ASSERT (offset >= 2);
5487 offset -= 2;
5488 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5489 }
5490
5491 BFD_ASSERT ((insn & 0xff00) == 0xd400);
5492
5493 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
5494 bfd_put_16 (output_bfd, insn & 0xf0ff, contents + offset);
5495
5496 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5497 BFD_ASSERT ((insn & 0xff00) == 0xc700);
5498 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5499 BFD_ASSERT ((insn & 0xff00) == 0xd100);
5500 insn = bfd_get_16 (input_bfd, contents + offset + 6);
5501 BFD_ASSERT (insn == 0x310c);
5502 insn = bfd_get_16 (input_bfd, contents + offset + 8);
5503 BFD_ASSERT (insn == 0x410b);
5504 insn = bfd_get_16 (input_bfd, contents + offset + 10);
5505 BFD_ASSERT (insn == 0x34cc);
5506
5507 bfd_put_16 (output_bfd, 0x0412, contents + offset + 2);
5508 bfd_put_16 (output_bfd, 0x00ce, contents + offset + 4);
5509 bfd_put_16 (output_bfd, 0x304c, contents + offset + 6);
5510 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5511 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5512
5513 bfd_put_32 (output_bfd, sgot->output_offset + off,
5514 contents + rel->r_offset);
5515
5516 continue;
5517 }
5518
5519 addend = rel->r_addend;
5520
5521 goto final_link_relocate;
5522
5523 case R_SH_TLS_LD_32:
5524 if (! info->shared)
5525 {
5526 bfd_vma offset;
5527 unsigned short insn;
5528
5529 /* LD->LE transition:
5530 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5531 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5532 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5533 We change it into:
5534 stc gbr,r0; nop; nop; nop;
5535 nop; nop; bra 3f; ...; 3:. */
5536
5537 offset = rel->r_offset;
5538 BFD_ASSERT (offset >= 16);
5539 /* Size of LD instructions is 16 or 18. */
5540 offset -= 16;
5541 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5542 if ((insn & 0xff00) == 0xc700)
5543 {
5544 BFD_ASSERT (offset >= 2);
5545 offset -= 2;
5546 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5547 }
5548
5549 BFD_ASSERT ((insn & 0xff00) == 0xd400);
5550 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5551 BFD_ASSERT ((insn & 0xff00) == 0xc700);
5552 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5553 BFD_ASSERT ((insn & 0xff00) == 0xd100);
5554 insn = bfd_get_16 (input_bfd, contents + offset + 6);
5555 BFD_ASSERT (insn == 0x310c);
5556 insn = bfd_get_16 (input_bfd, contents + offset + 8);
5557 BFD_ASSERT (insn == 0x410b);
5558 insn = bfd_get_16 (input_bfd, contents + offset + 10);
5559 BFD_ASSERT (insn == 0x34cc);
5560
5561 bfd_put_16 (output_bfd, 0x0012, contents + offset + 0);
5562 bfd_put_16 (output_bfd, 0x0009, contents + offset + 2);
5563 bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5564 bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5565 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5566 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5567
5568 continue;
5569 }
5570
5571 sgot = htab->sgot;
5572 if (sgot == NULL)
5573 abort ();
5574
5575 off = htab->tls_ldm_got.offset;
5576 if (off & 1)
5577 off &= ~1;
5578 else
5579 {
5580 Elf_Internal_Rela outrel;
5581 bfd_byte *loc;
5582
5583 srelgot = htab->srelgot;
5584 if (srelgot == NULL)
5585 abort ();
5586
5587 outrel.r_offset = (sgot->output_section->vma
5588 + sgot->output_offset + off);
5589 outrel.r_addend = 0;
5590 outrel.r_info = ELF32_R_INFO (0, R_SH_TLS_DTPMOD32);
5591 loc = srelgot->contents;
5592 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5593 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5594 htab->tls_ldm_got.offset |= 1;
5595 }
5596
5597 relocation = sgot->output_offset + off;
5598 addend = rel->r_addend;
5599
5600 goto final_link_relocate;
5601
5602 case R_SH_TLS_LDO_32:
5603 if (! info->shared)
5604 relocation = tpoff (info, relocation);
5605 else
5606 relocation -= dtpoff_base (info);
5607
5608 addend = rel->r_addend;
5609 goto final_link_relocate;
5610
5611 case R_SH_TLS_LE_32:
5612 {
5613 int indx;
5614 Elf_Internal_Rela outrel;
5615 bfd_byte *loc;
5616
5617 if (! info->shared)
5618 {
5619 relocation = tpoff (info, relocation);
5620 addend = rel->r_addend;
5621 goto final_link_relocate;
5622 }
5623
5624 if (sreloc == NULL)
5625 {
5626 const char *name;
5627
5628 name = (bfd_elf_string_from_elf_section
5629 (input_bfd,
5630 elf_elfheader (input_bfd)->e_shstrndx,
5631 elf_section_data (input_section)->rel_hdr.sh_name));
5632 if (name == NULL)
5633 return FALSE;
5634
5635 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5636 && strcmp (bfd_get_section_name (input_bfd,
5637 input_section),
5638 name + 5) == 0);
5639
5640 sreloc = bfd_get_section_by_name (dynobj, name);
5641 BFD_ASSERT (sreloc != NULL);
5642 }
5643
5644 if (h == NULL || h->dynindx == -1)
5645 indx = 0;
5646 else
5647 indx = h->dynindx;
5648
5649 outrel.r_offset = (input_section->output_section->vma
5650 + input_section->output_offset
5651 + rel->r_offset);
5652 outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5653 if (indx == 0)
5654 outrel.r_addend = relocation - dtpoff_base (info);
5655 else
5656 outrel.r_addend = 0;
5657
5658 loc = sreloc->contents;
5659 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5660 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5661 continue;
5662 }
5663 }
5664
5665 relocation_done:
5666 if (r != bfd_reloc_ok)
5667 {
5668 switch (r)
5669 {
5670 default:
5671 case bfd_reloc_outofrange:
5672 abort ();
5673 case bfd_reloc_overflow:
5674 {
5675 const char *name;
5676
5677 if (h != NULL)
5678 name = h->root.root.string;
5679 else
5680 {
5681 name = (bfd_elf_string_from_elf_section
5682 (input_bfd, symtab_hdr->sh_link, sym->st_name));
5683 if (name == NULL)
5684 return FALSE;
5685 if (*name == '\0')
5686 name = bfd_section_name (input_bfd, sec);
5687 }
5688 if (! ((*info->callbacks->reloc_overflow)
5689 (info, name, howto->name, (bfd_vma) 0,
5690 input_bfd, input_section, rel->r_offset)))
5691 return FALSE;
5692 }
5693 break;
5694 }
5695 }
5696 }
5697
5698 return TRUE;
5699}
5700
5701/* This is a version of bfd_generic_get_relocated_section_contents
5702 which uses sh_elf_relocate_section. */
5703
5704static bfd_byte *
5705sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
5706 data, relocateable, symbols)
5707 bfd *output_bfd;
5708 struct bfd_link_info *link_info;
5709 struct bfd_link_order *link_order;
5710 bfd_byte *data;
5711 bfd_boolean relocateable;
5712 asymbol **symbols;
5713{
5714 Elf_Internal_Shdr *symtab_hdr;
5715 asection *input_section = link_order->u.indirect.section;
5716 bfd *input_bfd = input_section->owner;
5717 asection **sections = NULL;
5718 Elf_Internal_Rela *internal_relocs = NULL;
5719 Elf_Internal_Sym *isymbuf = NULL;
5720
5721 /* We only need to handle the case of relaxing, or of having a
5722 particular set of section contents, specially. */
5723 if (relocateable
5724 || elf_section_data (input_section)->this_hdr.contents == NULL)
5725 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
5726 link_order, data,
5727 relocateable,
5728 symbols);
5729
5730 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5731
5732 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
5733 (size_t) input_section->_raw_size);
5734
5735 if ((input_section->flags & SEC_RELOC) != 0
5736 && input_section->reloc_count > 0)
5737 {
5738 asection **secpp;
5739 Elf_Internal_Sym *isym, *isymend;
5740 bfd_size_type amt;
5741
5742 internal_relocs = (_bfd_elf32_link_read_relocs
5743 (input_bfd, input_section, (PTR) NULL,
5744 (Elf_Internal_Rela *) NULL, FALSE));
5745 if (internal_relocs == NULL)
5746 goto error_return;
5747
5748 if (symtab_hdr->sh_info != 0)
5749 {
5750 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5751 if (isymbuf == NULL)
5752 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
5753 symtab_hdr->sh_info, 0,
5754 NULL, NULL, NULL);
5755 if (isymbuf == NULL)
5756 goto error_return;
5757 }
5758
5759 amt = symtab_hdr->sh_info;
5760 amt *= sizeof (asection *);
5761 sections = (asection **) bfd_malloc (amt);
5762 if (sections == NULL && amt != 0)
5763 goto error_return;
5764
5765 isymend = isymbuf + symtab_hdr->sh_info;
5766 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
5767 {
5768 asection *isec;
5769
5770 if (isym->st_shndx == SHN_UNDEF)
5771 isec = bfd_und_section_ptr;
5772 else if (isym->st_shndx == SHN_ABS)
5773 isec = bfd_abs_section_ptr;
5774 else if (isym->st_shndx == SHN_COMMON)
5775 isec = bfd_com_section_ptr;
5776 else
5777 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
5778
5779 *secpp = isec;
5780 }
5781
5782 if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
5783 input_section, data, internal_relocs,
5784 isymbuf, sections))
5785 goto error_return;
5786
5787 if (sections != NULL)
5788 free (sections);
5789 if (isymbuf != NULL
5790 && symtab_hdr->contents != (unsigned char *) isymbuf)
5791 free (isymbuf);
5792 if (elf_section_data (input_section)->relocs != internal_relocs)
5793 free (internal_relocs);
5794 }
5795
5796 return data;
5797
5798 error_return:
5799 if (sections != NULL)
5800 free (sections);
5801 if (isymbuf != NULL
5802 && symtab_hdr->contents != (unsigned char *) isymbuf)
5803 free (isymbuf);
5804 if (internal_relocs != NULL
5805 && elf_section_data (input_section)->relocs != internal_relocs)
5806 free (internal_relocs);
5807 return NULL;
5808}
5809
5810/* Return the base VMA address which should be subtracted from real addresses
5811 when resolving @dtpoff relocation.
5812 This is PT_TLS segment p_vaddr. */
5813
5814static bfd_vma
5815dtpoff_base (info)
5816 struct bfd_link_info *info;
5817{
5818 /* If tls_segment is NULL, we should have signalled an error already. */
5819 if (elf_hash_table (info)->tls_segment == NULL)
5820 return 0;
5821 return elf_hash_table (info)->tls_segment->start;
5822}
5823
5824/* Return the relocation value for R_SH_TLS_TPOFF32.. */
5825
5826static bfd_vma
5827tpoff (info, address)
5828 struct bfd_link_info *info;
5829 bfd_vma address;
5830{
5831 /* If tls_segment is NULL, we should have signalled an error already. */
5832 if (elf_hash_table (info)->tls_segment == NULL)
5833 return 0;
5834 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5835 structure which has 2 pointer fields. */
5836 return (address - dtpoff_base (info) + 8);
5837}
5838
5839static asection *
5840sh_elf_gc_mark_hook (sec, info, rel, h, sym)
5841 asection *sec;
5842 struct bfd_link_info *info ATTRIBUTE_UNUSED;
5843 Elf_Internal_Rela *rel;
5844 struct elf_link_hash_entry *h;
5845 Elf_Internal_Sym *sym;
5846{
5847 if (h != NULL)
5848 {
5849 switch (ELF32_R_TYPE (rel->r_info))
5850 {
5851 case R_SH_GNU_VTINHERIT:
5852 case R_SH_GNU_VTENTRY:
5853 break;
5854
5855 default:
5856#ifdef INCLUDE_SHMEDIA
5857 while (h->root.type == bfd_link_hash_indirect
5858 && h->root.u.i.link)
5859 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5860#endif
5861 switch (h->root.type)
5862 {
5863 case bfd_link_hash_defined:
5864 case bfd_link_hash_defweak:
5865 return h->root.u.def.section;
5866
5867 case bfd_link_hash_common:
5868 return h->root.u.c.p->section;
5869
5870 default:
5871 break;
5872 }
5873 }
5874 }
5875 else
5876 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5877
5878 return NULL;
5879}
5880
5881/* Update the got entry reference counts for the section being removed. */
5882
5883static bfd_boolean
5884sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
5885 bfd *abfd;
5886 struct bfd_link_info *info;
5887 asection *sec;
5888 const Elf_Internal_Rela *relocs;
5889{
5890 Elf_Internal_Shdr *symtab_hdr;
5891 struct elf_link_hash_entry **sym_hashes;
5892 bfd_signed_vma *local_got_refcounts;
5893 const Elf_Internal_Rela *rel, *relend;
5894
5895 elf_section_data (sec)->local_dynrel = NULL;
5896
5897 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5898 sym_hashes = elf_sym_hashes (abfd);
5899 local_got_refcounts = elf_local_got_refcounts (abfd);
5900
5901 relend = relocs + sec->reloc_count;
5902 for (rel = relocs; rel < relend; rel++)
5903 {
5904 unsigned long r_symndx;
5905 unsigned int r_type;
5906 struct elf_link_hash_entry *h = NULL;
5907#ifdef INCLUDE_SHMEDIA
5908 int seen_stt_datalabel = 0;
5909#endif
5910
5911 r_symndx = ELF32_R_SYM (rel->r_info);
5912 if (r_symndx >= symtab_hdr->sh_info)
5913 {
5914 struct elf_sh_link_hash_entry *eh;
5915 struct elf_sh_dyn_relocs **pp;
5916 struct elf_sh_dyn_relocs *p;
5917
5918 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5919#ifdef INCLUDE_SHMEDIA
5920 while (h->root.type == bfd_link_hash_indirect
5921 || h->root.type == bfd_link_hash_warning)
5922 {
5923 seen_stt_datalabel |= h->type == STT_DATALABEL;
5924 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5925 }
5926#endif
5927 eh = (struct elf_sh_link_hash_entry *) h;
5928 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5929 if (p->sec == sec)
5930 {
5931 /* Everything must go for SEC. */
5932 *pp = p->next;
5933 break;
5934 }
5935 }
5936
5937 r_type = ELF32_R_TYPE (rel->r_info);
5938 switch (sh_elf_optimized_tls_reloc (info, r_type, h != NULL))
5939 {
5940 case R_SH_TLS_LD_32:
5941 if (sh_elf_hash_table (info)->tls_ldm_got.refcount > 0)
5942 sh_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
5943 break;
5944
5945 case R_SH_GOT32:
5946 case R_SH_GOTOFF:
5947 case R_SH_GOTPC:
5948#ifdef INCLUDE_SHMEDIA
5949 case R_SH_GOT_LOW16:
5950 case R_SH_GOT_MEDLOW16:
5951 case R_SH_GOT_MEDHI16:
5952 case R_SH_GOT_HI16:
5953 case R_SH_GOT10BY4:
5954 case R_SH_GOT10BY8:
5955 case R_SH_GOTOFF_LOW16:
5956 case R_SH_GOTOFF_MEDLOW16:
5957 case R_SH_GOTOFF_MEDHI16:
5958 case R_SH_GOTOFF_HI16:
5959 case R_SH_GOTPC_LOW16:
5960 case R_SH_GOTPC_MEDLOW16:
5961 case R_SH_GOTPC_MEDHI16:
5962 case R_SH_GOTPC_HI16:
5963#endif
5964 case R_SH_TLS_GD_32:
5965 case R_SH_TLS_IE_32:
5966 if (h != NULL)
5967 {
5968#ifdef INCLUDE_SHMEDIA
5969 if (seen_stt_datalabel)
5970 {
5971 struct elf_sh_link_hash_entry *eh;
5972 eh = (struct elf_sh_link_hash_entry *) h;
5973 if (eh->datalabel_got.refcount > 0)
5974 eh->datalabel_got.refcount -= 1;
5975 }
5976 else
5977#endif
5978 if (h->got.refcount > 0)
5979 h->got.refcount -= 1;
5980 }
5981 else if (local_got_refcounts != NULL)
5982 {
5983#ifdef INCLUDE_SHMEDIA
5984 if (rel->r_addend & 1)
5985 {
5986 if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
5987 local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
5988 }
5989 else
5990#endif
5991 if (local_got_refcounts[r_symndx] > 0)
5992 local_got_refcounts[r_symndx] -= 1;
5993 }
5994 break;
5995
5996 case R_SH_DIR32:
5997 case R_SH_REL32:
5998 if (info->shared)
5999 break;
6000 /* Fall thru */
6001
6002 case R_SH_PLT32:
6003#ifdef INCLUDE_SHMEDIA
6004 case R_SH_PLT_LOW16:
6005 case R_SH_PLT_MEDLOW16:
6006 case R_SH_PLT_MEDHI16:
6007 case R_SH_PLT_HI16:
6008#endif
6009 if (h != NULL)
6010 {
6011 if (h->plt.refcount > 0)
6012 h->plt.refcount -= 1;
6013 }
6014 break;
6015
6016 case R_SH_GOTPLT32:
6017#ifdef INCLUDE_SHMEDIA
6018 case R_SH_GOTPLT_LOW16:
6019 case R_SH_GOTPLT_MEDLOW16:
6020 case R_SH_GOTPLT_MEDHI16:
6021 case R_SH_GOTPLT_HI16:
6022 case R_SH_GOTPLT10BY4:
6023 case R_SH_GOTPLT10BY8:
6024#endif
6025 if (h != NULL)
6026 {
6027 struct elf_sh_link_hash_entry *eh;
6028 eh = (struct elf_sh_link_hash_entry *) h;
6029 if (eh->gotplt_refcount > 0)
6030 {
6031 eh->gotplt_refcount -= 1;
6032 if (h->plt.refcount > 0)
6033 h->plt.refcount -= 1;
6034 }
6035#ifdef INCLUDE_SHMEDIA
6036 else if (seen_stt_datalabel)
6037 {
6038 if (eh->datalabel_got.refcount > 0)
6039 eh->datalabel_got.refcount -= 1;
6040 }
6041#endif
6042 else if (h->got.refcount > 0)
6043 h->got.refcount -= 1;
6044 }
6045 else if (local_got_refcounts != NULL)
6046 {
6047#ifdef INCLUDE_SHMEDIA
6048 if (rel->r_addend & 1)
6049 {
6050 if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
6051 local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
6052 }
6053 else
6054#endif
6055 if (local_got_refcounts[r_symndx] > 0)
6056 local_got_refcounts[r_symndx] -= 1;
6057 }
6058 break;
6059
6060 default:
6061 break;
6062 }
6063 }
6064
6065 return TRUE;
6066}
6067
6068/* Copy the extra info we tack onto an elf_link_hash_entry. */
6069
6070static void
6071sh_elf_copy_indirect_symbol (bed, dir, ind)
6072 struct elf_backend_data *bed;
6073 struct elf_link_hash_entry *dir, *ind;
6074{
6075 struct elf_sh_link_hash_entry *edir, *eind;
6076#ifdef INCLUDE_SHMEDIA
6077 bfd_signed_vma tmp;
6078#endif
6079
6080 edir = (struct elf_sh_link_hash_entry *) dir;
6081 eind = (struct elf_sh_link_hash_entry *) ind;
6082
6083 if (eind->dyn_relocs != NULL)
6084 {
6085 if (edir->dyn_relocs != NULL)
6086 {
6087 struct elf_sh_dyn_relocs **pp;
6088 struct elf_sh_dyn_relocs *p;
6089
6090 BFD_ASSERT (ind->root.type != bfd_link_hash_indirect);
6091
6092 /* Add reloc counts against the weak sym to the strong sym
6093 list. Merge any entries against the same section. */
6094 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
6095 {
6096 struct elf_sh_dyn_relocs *q;
6097
6098 for (q = edir->dyn_relocs; q != NULL; q = q->next)
6099 if (q->sec == p->sec)
6100 {
6101 q->pc_count += p->pc_count;
6102 q->count += p->count;
6103 *pp = p->next;
6104 break;
6105 }
6106 if (q == NULL)
6107 pp = &p->next;
6108 }
6109 *pp = edir->dyn_relocs;
6110 }
6111
6112 edir->dyn_relocs = eind->dyn_relocs;
6113 eind->dyn_relocs = NULL;
6114 }
6115 edir->gotplt_refcount = eind->gotplt_refcount;
6116 eind->gotplt_refcount = 0;
6117#ifdef INCLUDE_SHMEDIA
6118 tmp = edir->datalabel_got.refcount;
6119 if (tmp < 1)
6120 {
6121 edir->datalabel_got.refcount = eind->datalabel_got.refcount;
6122 eind->datalabel_got.refcount = tmp;
6123 }
6124 else
6125 BFD_ASSERT (eind->datalabel_got.refcount < 1);
6126#endif
6127
6128 if (ind->root.type == bfd_link_hash_indirect
6129 && dir->got.refcount <= 0)
6130 {
6131 edir->tls_type = eind->tls_type;
6132 eind->tls_type = GOT_UNKNOWN;
6133 }
6134
6135 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
6136}
6137
6138static int
6139sh_elf_optimized_tls_reloc (info, r_type, is_local)
6140 struct bfd_link_info *info;
6141 int r_type;
6142 int is_local;
6143{
6144 if (info->shared)
6145 return r_type;
6146
6147 switch (r_type)
6148 {
6149 case R_SH_TLS_GD_32:
6150 case R_SH_TLS_IE_32:
6151 if (is_local)
6152 return R_SH_TLS_LE_32;
6153 return R_SH_TLS_IE_32;
6154 case R_SH_TLS_LD_32:
6155 return R_SH_TLS_LE_32;
6156 }
6157
6158 return r_type;
6159}
6160
6161/* Look through the relocs for a section during the first phase.
6162 Since we don't do .gots or .plts, we just need to consider the
6163 virtual table relocs for gc. */
6164
6165static bfd_boolean
6166sh_elf_check_relocs (abfd, info, sec, relocs)
6167 bfd *abfd;
6168 struct bfd_link_info *info;
6169 asection *sec;
6170 const Elf_Internal_Rela *relocs;
6171{
6172 Elf_Internal_Shdr *symtab_hdr;
6173 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6174 struct elf_sh_link_hash_table *htab;
6175 const Elf_Internal_Rela *rel;
6176 const Elf_Internal_Rela *rel_end;
6177 bfd *dynobj;
6178 bfd_vma *local_got_offsets;
6179 asection *sgot;
6180 asection *srelgot;
6181 asection *sreloc;
6182 unsigned int r_type;
6183 int tls_type, old_tls_type;
6184
6185 sgot = NULL;
6186 srelgot = NULL;
6187 sreloc = NULL;
6188
6189 if (info->relocateable)
6190 return TRUE;
6191
6192 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6193 sym_hashes = elf_sym_hashes (abfd);
6194 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
6195 if (!elf_bad_symtab (abfd))
6196 sym_hashes_end -= symtab_hdr->sh_info;
6197
6198 htab = sh_elf_hash_table (info);
6199 dynobj = htab->root.dynobj;
6200 local_got_offsets = elf_local_got_offsets (abfd);
6201
6202 rel_end = relocs + sec->reloc_count;
6203 for (rel = relocs; rel < rel_end; rel++)
6204 {
6205 struct elf_link_hash_entry *h;
6206 unsigned long r_symndx;
6207#ifdef INCLUDE_SHMEDIA
6208 int seen_stt_datalabel = 0;
6209#endif
6210
6211 r_symndx = ELF32_R_SYM (rel->r_info);
6212 r_type = ELF32_R_TYPE (rel->r_info);
6213
6214 if (r_symndx < symtab_hdr->sh_info)
6215 h = NULL;
6216 else
6217 {
6218 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6219#ifdef INCLUDE_SHMEDIA
6220 while (h->root.type == bfd_link_hash_indirect
6221 || h->root.type == bfd_link_hash_warning)
6222 {
6223 seen_stt_datalabel |= h->type == STT_DATALABEL;
6224 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6225 }
6226#endif
6227 }
6228
6229 r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
6230 if (! info->shared
6231 && r_type == R_SH_TLS_IE_32
6232 && h != NULL
6233 && h->root.type != bfd_link_hash_undefined
6234 && h->root.type != bfd_link_hash_undefweak
6235 && (h->dynindx == -1
6236 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
6237 r_type = R_SH_TLS_LE_32;
6238
6239 /* Some relocs require a global offset table. */
6240 if (htab->sgot == NULL)
6241 {
6242 switch (r_type)
6243 {
6244 case R_SH_GOTPLT32:
6245 case R_SH_GOT32:
6246 case R_SH_GOTOFF:
6247 case R_SH_GOTPC:
6248#ifdef INCLUDE_SHMEDIA
6249 case R_SH_GOTPLT_LOW16:
6250 case R_SH_GOTPLT_MEDLOW16:
6251 case R_SH_GOTPLT_MEDHI16:
6252 case R_SH_GOTPLT_HI16:
6253 case R_SH_GOTPLT10BY4:
6254 case R_SH_GOTPLT10BY8:
6255 case R_SH_GOT_LOW16:
6256 case R_SH_GOT_MEDLOW16:
6257 case R_SH_GOT_MEDHI16:
6258 case R_SH_GOT_HI16:
6259 case R_SH_GOT10BY4:
6260 case R_SH_GOT10BY8:
6261 case R_SH_GOTOFF_LOW16:
6262 case R_SH_GOTOFF_MEDLOW16:
6263 case R_SH_GOTOFF_MEDHI16:
6264 case R_SH_GOTOFF_HI16:
6265 case R_SH_GOTPC_LOW16:
6266 case R_SH_GOTPC_MEDLOW16:
6267 case R_SH_GOTPC_MEDHI16:
6268 case R_SH_GOTPC_HI16:
6269#endif
6270 case R_SH_TLS_GD_32:
6271 case R_SH_TLS_LD_32:
6272 case R_SH_TLS_IE_32:
6273 if (dynobj == NULL)
6274 htab->root.dynobj = dynobj = abfd;
6275 if (! create_got_section (dynobj, info))
6276 return FALSE;
6277 break;
6278
6279 default:
6280 break;
6281 }
6282 }
6283
6284 switch (r_type)
6285 {
6286 /* This relocation describes the C++ object vtable hierarchy.
6287 Reconstruct it for later use during GC. */
6288 case R_SH_GNU_VTINHERIT:
6289 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6290 return FALSE;
6291 break;
6292
6293 /* This relocation describes which C++ vtable entries are actually
6294 used. Record for later use during GC. */
6295 case R_SH_GNU_VTENTRY:
6296 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6297 return FALSE;
6298 break;
6299
6300 case R_SH_TLS_IE_32:
6301 if (info->shared)
6302 info->flags |= DF_STATIC_TLS;
6303
6304 /* FALLTHROUGH */
6305 force_got:
6306 case R_SH_TLS_GD_32:
6307 case R_SH_GOT32:
6308#ifdef INCLUDE_SHMEDIA
6309 case R_SH_GOT_LOW16:
6310 case R_SH_GOT_MEDLOW16:
6311 case R_SH_GOT_MEDHI16:
6312 case R_SH_GOT_HI16:
6313 case R_SH_GOT10BY4:
6314 case R_SH_GOT10BY8:
6315#endif
6316 switch (r_type)
6317 {
6318 default:
6319 tls_type = GOT_NORMAL;
6320 break;
6321 case R_SH_TLS_GD_32:
6322 tls_type = GOT_TLS_GD;
6323 break;
6324 case R_SH_TLS_IE_32:
6325 tls_type = GOT_TLS_IE;
6326 break;
6327 }
6328
6329 if (h != NULL)
6330 {
6331#ifdef INCLUDE_SHMEDIA
6332 if (seen_stt_datalabel)
6333 {
6334 struct elf_sh_link_hash_entry *eh
6335 = (struct elf_sh_link_hash_entry *) h;
6336
6337 eh->datalabel_got.refcount += 1;
6338 }
6339 else
6340#endif
6341 h->got.refcount += 1;
6342 old_tls_type = sh_elf_hash_entry (h)->tls_type;
6343 }
6344 else
6345 {
6346 bfd_signed_vma *local_got_refcounts;
6347
6348 /* This is a global offset table entry for a local
6349 symbol. */
6350 local_got_refcounts = elf_local_got_refcounts (abfd);
6351 if (local_got_refcounts == NULL)
6352 {
6353 bfd_size_type size;
6354
6355 size = symtab_hdr->sh_info;
6356 size *= sizeof (bfd_signed_vma);
6357#ifdef INCLUDE_SHMEDIA
6358 /* Reserve space for both the datalabel and
6359 codelabel local GOT offsets. */
6360 size *= 2;
6361#endif
6362 size += symtab_hdr->sh_info;
6363 local_got_refcounts = ((bfd_signed_vma *)
6364 bfd_zalloc (abfd, size));
6365 if (local_got_refcounts == NULL)
6366 return FALSE;
6367 elf_local_got_refcounts (abfd) = local_got_refcounts;
6368#ifdef INCLUDE_SHMEDIA
6369 /* Take care of both the datalabel and codelabel local
6370 GOT offsets. */
6371 sh_elf_local_got_tls_type (abfd)
6372 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
6373#else
6374 sh_elf_local_got_tls_type (abfd)
6375 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
6376#endif
6377 }
6378#ifdef INCLUDE_SHMEDIA
6379 if (rel->r_addend & 1)
6380 local_got_refcounts[symtab_hdr->sh_info + r_symndx] += 1;
6381 else
6382#endif
6383 local_got_refcounts[r_symndx] += 1;
6384 old_tls_type = sh_elf_local_got_tls_type (abfd) [r_symndx];
6385 }
6386
6387 /* If a TLS symbol is accessed using IE at least once,
6388 there is no point to use dynamic model for it. */
6389 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
6390 && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE))
6391 {
6392 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
6393 tls_type = GOT_TLS_IE;
6394 else
6395 {
6396 (*_bfd_error_handler)
6397 (_("%s: `%s' accessed both as normal and thread local symbol"),
6398 bfd_archive_filename (abfd), h->root.root.string);
6399 return FALSE;
6400 }
6401 }
6402
6403 if (old_tls_type != tls_type)
6404 {
6405 if (h != NULL)
6406 sh_elf_hash_entry (h)->tls_type = tls_type;
6407 else
6408 sh_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
6409 }
6410
6411 break;
6412
6413 case R_SH_TLS_LD_32:
6414 sh_elf_hash_table(info)->tls_ldm_got.refcount += 1;
6415 break;
6416
6417 case R_SH_GOTPLT32:
6418#ifdef INCLUDE_SHMEDIA
6419 case R_SH_GOTPLT_LOW16:
6420 case R_SH_GOTPLT_MEDLOW16:
6421 case R_SH_GOTPLT_MEDHI16:
6422 case R_SH_GOTPLT_HI16:
6423 case R_SH_GOTPLT10BY4:
6424 case R_SH_GOTPLT10BY8:
6425#endif
6426 /* If this is a local symbol, we resolve it directly without
6427 creating a procedure linkage table entry. */
6428
6429 if (h == NULL
6430 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
6431 || ! info->shared
6432 || info->symbolic
6433 || h->dynindx == -1)
6434 goto force_got;
6435
6436 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
6437 h->plt.refcount += 1;
6438 ((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1;
6439
6440 break;
6441
6442 case R_SH_PLT32:
6443#ifdef INCLUDE_SHMEDIA
6444 case R_SH_PLT_LOW16:
6445 case R_SH_PLT_MEDLOW16:
6446 case R_SH_PLT_MEDHI16:
6447 case R_SH_PLT_HI16:
6448#endif
6449 /* This symbol requires a procedure linkage table entry. We
6450 actually build the entry in adjust_dynamic_symbol,
6451 because this might be a case of linking PIC code which is
6452 never referenced by a dynamic object, in which case we
6453 don't need to generate a procedure linkage table entry
6454 after all. */
6455
6456 /* If this is a local symbol, we resolve it directly without
6457 creating a procedure linkage table entry. */
6458 if (h == NULL)
6459 continue;
6460
6461 if (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
6462 break;
6463
6464 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
6465 h->plt.refcount += 1;
6466 break;
6467
6468 case R_SH_DIR32:
6469 case R_SH_REL32:
6470 if (h != NULL && ! info->shared)
6471 {
6472 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
6473 h->plt.refcount += 1;
6474 }
6475
6476 /* If we are creating a shared library, and this is a reloc
6477 against a global symbol, or a non PC relative reloc
6478 against a local symbol, then we need to copy the reloc
6479 into the shared library. However, if we are linking with
6480 -Bsymbolic, we do not need to copy a reloc against a
6481 global symbol which is defined in an object we are
6482 including in the link (i.e., DEF_REGULAR is set). At
6483 this point we have not seen all the input files, so it is
6484 possible that DEF_REGULAR is not set now but will be set
6485 later (it is never cleared). We account for that
6486 possibility below by storing information in the
6487 dyn_relocs field of the hash table entry. A similar
6488 situation occurs when creating shared libraries and symbol
6489 visibility changes render the symbol local.
6490
6491 If on the other hand, we are creating an executable, we
6492 may need to keep relocations for symbols satisfied by a
6493 dynamic library if we manage to avoid copy relocs for the
6494 symbol. */
6495 if ((info->shared
6496 && (sec->flags & SEC_ALLOC) != 0
6497 && (r_type != R_SH_REL32
6498 || (h != NULL
6499 && (! info->symbolic
6500 || h->root.type == bfd_link_hash_defweak
6501 || (h->elf_link_hash_flags
6502 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
6503 || (! info->shared
6504 && (sec->flags & SEC_ALLOC) != 0
6505 && h != NULL
6506 && (h->root.type == bfd_link_hash_defweak
6507 || (h->elf_link_hash_flags
6508 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
6509 {
6510 struct elf_sh_dyn_relocs *p;
6511 struct elf_sh_dyn_relocs **head;
6512
6513 if (dynobj == NULL)
6514 htab->root.dynobj = dynobj = abfd;
6515
6516 /* When creating a shared object, we must copy these
6517 reloc types into the output file. We create a reloc
6518 section in dynobj and make room for this reloc. */
6519 if (sreloc == NULL)
6520 {
6521 const char *name;
6522
6523 name = (bfd_elf_string_from_elf_section
6524 (abfd,
6525 elf_elfheader (abfd)->e_shstrndx,
6526 elf_section_data (sec)->rel_hdr.sh_name));
6527 if (name == NULL)
6528 return FALSE;
6529
6530 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6531 && strcmp (bfd_get_section_name (abfd, sec),
6532 name + 5) == 0);
6533
6534 sreloc = bfd_get_section_by_name (dynobj, name);
6535 if (sreloc == NULL)
6536 {
6537 flagword flags;
6538
6539 sreloc = bfd_make_section (dynobj, name);
6540 flags = (SEC_HAS_CONTENTS | SEC_READONLY
6541 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6542 if ((sec->flags & SEC_ALLOC) != 0)
6543 flags |= SEC_ALLOC | SEC_LOAD;
6544 if (sreloc == NULL
6545 || ! bfd_set_section_flags (dynobj, sreloc, flags)
6546 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
6547 return FALSE;
6548 }
6549 if (sec->flags & SEC_READONLY)
6550 info->flags |= DF_TEXTREL;
6551 elf_section_data (sec)->sreloc = sreloc;
6552 }
6553
6554 /* If this is a global symbol, we count the number of
6555 relocations we need for this symbol. */
6556 if (h != NULL)
6557 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
6558 else
6559 {
6560 asection *s;
6561
6562 /* Track dynamic relocs needed for local syms too. */
6563 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
6564 sec, r_symndx);
6565 if (s == NULL)
6566 return FALSE;
6567
6568 head = ((struct elf_sh_dyn_relocs **)
6569 &elf_section_data (s)->local_dynrel);
6570 }
6571
6572 p = *head;
6573 if (p == NULL || p->sec != sec)
6574 {
6575 bfd_size_type amt = sizeof (*p);
6576 p = ((struct elf_sh_dyn_relocs *) bfd_alloc (dynobj, amt));
6577 if (p == NULL)
6578 return FALSE;
6579 p->next = *head;
6580 *head = p;
6581 p->sec = sec;
6582 p->count = 0;
6583 p->pc_count = 0;
6584 }
6585
6586 p->count += 1;
6587 if (r_type == R_SH_REL32)
6588 p->pc_count += 1;
6589 }
6590
6591 break;
6592
6593 case R_SH_TLS_LE_32:
6594 if (info->shared)
6595 {
6596 (*_bfd_error_handler) (_("%s: TLS local exec code cannot be linked into shared objects"),
6597 bfd_archive_filename (abfd));
6598 return FALSE;
6599 }
6600
6601 break;
6602
6603 case R_SH_TLS_LDO_32:
6604 /* Nothing to do. */
6605 break;
6606
6607 default:
6608 break;
6609 }
6610 }
6611
6612 return TRUE;
6613}
6614
6615#ifndef sh_elf_set_mach_from_flags
6616static bfd_boolean
6617sh_elf_set_mach_from_flags (abfd)
6618 bfd *abfd;
6619{
6620 flagword flags = elf_elfheader (abfd)->e_flags;
6621
6622 switch (flags & EF_SH_MACH_MASK)
6623 {
6624 case EF_SH1:
6625 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh);
6626 break;
6627 case EF_SH2:
6628 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2);
6629 break;
6630 case EF_SH2E:
6631 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2e);
6632 break;
6633 case EF_SH_DSP:
6634 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp);
6635 break;
6636 case EF_SH3:
6637 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3);
6638 break;
6639 case EF_SH3_DSP:
6640 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp);
6641 break;
6642 case EF_SH3E:
6643 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e);
6644 break;
6645 case EF_SH_UNKNOWN:
6646 case EF_SH4:
6647 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4);
6648 break;
6649 default:
6650 return FALSE;
6651 }
6652 return TRUE;
6653}
6654#endif /* not sh_elf_set_mach_from_flags */
6655
6656#ifndef sh_elf_set_private_flags
6657/* Function to keep SH specific file flags. */
6658
6659static bfd_boolean
6660sh_elf_set_private_flags (abfd, flags)
6661 bfd *abfd;
6662 flagword flags;
6663{
6664 BFD_ASSERT (! elf_flags_init (abfd)
6665 || elf_elfheader (abfd)->e_flags == flags);
6666
6667 elf_elfheader (abfd)->e_flags = flags;
6668 elf_flags_init (abfd) = TRUE;
6669 return sh_elf_set_mach_from_flags (abfd);
6670}
6671#endif /* not sh_elf_set_private_flags */
6672
6673#ifndef sh_elf_copy_private_data
6674/* Copy backend specific data from one object module to another */
6675
6676static bfd_boolean
6677sh_elf_copy_private_data (ibfd, obfd)
6678 bfd * ibfd;
6679 bfd * obfd;
6680{
6681 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6682 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6683 return TRUE;
6684
6685 return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
6686}
6687#endif /* not sh_elf_copy_private_data */
6688
6689#ifndef sh_elf_merge_private_data
6690/* This routine checks for linking big and little endian objects
6691 together, and for linking sh-dsp with sh3e / sh4 objects. */
6692
6693static bfd_boolean
6694sh_elf_merge_private_data (ibfd, obfd)
6695 bfd *ibfd;
6696 bfd *obfd;
6697{
6698 flagword old_flags, new_flags;
6699
6700 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
6701 return FALSE;
6702
6703 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6704 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6705 return TRUE;
6706
6707 if (! elf_flags_init (obfd))
6708 {
6709 /* This happens when ld starts out with a 'blank' output file. */
6710 elf_flags_init (obfd) = TRUE;
6711 elf_elfheader (obfd)->e_flags = EF_SH1;
6712 }
6713 old_flags = elf_elfheader (obfd)->e_flags;
6714 new_flags = elf_elfheader (ibfd)->e_flags;
6715 if ((EF_SH_HAS_DSP (old_flags) && EF_SH_HAS_FP (new_flags))
6716 || (EF_SH_HAS_DSP (new_flags) && EF_SH_HAS_FP (old_flags)))
6717 {
6718 (*_bfd_error_handler)
6719 ("%s: uses %s instructions while previous modules use %s instructions",
6720 bfd_archive_filename (ibfd),
6721 EF_SH_HAS_DSP (new_flags) ? "dsp" : "floating point",
6722 EF_SH_HAS_DSP (new_flags) ? "floating point" : "dsp");
6723 bfd_set_error (bfd_error_bad_value);
6724 return FALSE;
6725 }
6726 elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags);
6727
6728 return sh_elf_set_mach_from_flags (obfd);
6729}
6730#endif /* not sh_elf_merge_private_data */
6731
6732/* Override the generic function because we need to store sh_elf_obj_tdata
6733 as the specific tdata. We set also the machine architecture from flags
6734 here. */
6735
6736static bfd_boolean
6737sh_elf_object_p (abfd)
6738 bfd *abfd;
6739{
6740 struct sh_elf_obj_tdata *new_tdata;
6741 bfd_size_type amt = sizeof (struct sh_elf_obj_tdata);
6742
6743 if (!sh_elf_set_mach_from_flags (abfd))
6744 return FALSE;
6745
6746 /* Allocate our special target data. */
6747 new_tdata = bfd_zalloc (abfd, amt);
6748 if (new_tdata == NULL)
6749 return FALSE;
6750 new_tdata->root = *abfd->tdata.elf_obj_data;
6751 abfd->tdata.any = new_tdata;
6752 return TRUE;
6753}
6754
6755/* Finish up dynamic symbol handling. We set the contents of various
6756 dynamic sections here. */
6757
6758static bfd_boolean
6759sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
6760 bfd *output_bfd;
6761 struct bfd_link_info *info;
6762 struct elf_link_hash_entry *h;
6763 Elf_Internal_Sym *sym;
6764{
6765 struct elf_sh_link_hash_table *htab;
6766 bfd *dynobj;
6767
6768 htab = sh_elf_hash_table (info);
6769 dynobj = htab->root.dynobj;
6770
6771 if (h->plt.offset != (bfd_vma) -1)
6772 {
6773 asection *splt;
6774 asection *sgot;
6775 asection *srel;
6776
6777 bfd_vma plt_index;
6778 bfd_vma got_offset;
6779 Elf_Internal_Rela rel;
6780 bfd_byte *loc;
6781
6782 /* This symbol has an entry in the procedure linkage table. Set
6783 it up. */
6784
6785 BFD_ASSERT (h->dynindx != -1);
6786
6787 splt = htab->splt;
6788 sgot = htab->sgotplt;
6789 srel = htab->srelplt;
6790 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
6791
6792 /* Get the index in the procedure linkage table which
6793 corresponds to this symbol. This is the index of this symbol
6794 in all the symbols for which we are making plt entries. The
6795 first entry in the procedure linkage table is reserved. */
6796 plt_index = h->plt.offset / elf_sh_sizeof_plt (info) - 1;
6797
6798 /* Get the offset into the .got table of the entry that
6799 corresponds to this function. Each .got entry is 4 bytes.
6800 The first three are reserved. */
6801 got_offset = (plt_index + 3) * 4;
6802
6803#ifdef GOT_BIAS
6804 if (info->shared)
6805 got_offset -= GOT_BIAS;
6806#endif
6807
6808 /* Fill in the entry in the procedure linkage table. */
6809 if (! info->shared)
6810 {
6811 if (elf_sh_plt_entry == NULL)
6812 {
6813 elf_sh_plt_entry = (bfd_big_endian (output_bfd) ?
6814 elf_sh_plt_entry_be : elf_sh_plt_entry_le);
6815 }
6816 memcpy (splt->contents + h->plt.offset, elf_sh_plt_entry,
6817 elf_sh_sizeof_plt (info));
6818#ifdef INCLUDE_SHMEDIA
6819 movi_shori_putval (output_bfd,
6820 (sgot->output_section->vma
6821 + sgot->output_offset
6822 + got_offset),
6823 (splt->contents + h->plt.offset
6824 + elf_sh_plt_symbol_offset (info)));
6825
6826 /* Set bottom bit because its for a branch to SHmedia */
6827 movi_shori_putval (output_bfd,
6828 (splt->output_section->vma + splt->output_offset)
6829 | 1,
6830 (splt->contents + h->plt.offset
6831 + elf_sh_plt_plt0_offset (info)));
6832#else
6833 bfd_put_32 (output_bfd,
6834 (sgot->output_section->vma
6835 + sgot->output_offset
6836 + got_offset),
6837 (splt->contents + h->plt.offset
6838 + elf_sh_plt_symbol_offset (info)));
6839
6840 bfd_put_32 (output_bfd,
6841 (splt->output_section->vma + splt->output_offset),
6842 (splt->contents + h->plt.offset
6843 + elf_sh_plt_plt0_offset (info)));
6844#endif
6845 }
6846 else
6847 {
6848 if (elf_sh_pic_plt_entry == NULL)
6849 {
6850 elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
6851 elf_sh_pic_plt_entry_be :
6852 elf_sh_pic_plt_entry_le);
6853 }
6854 memcpy (splt->contents + h->plt.offset, elf_sh_pic_plt_entry,
6855 elf_sh_sizeof_plt (info));
6856#ifdef INCLUDE_SHMEDIA
6857 movi_shori_putval (output_bfd, got_offset,
6858 (splt->contents + h->plt.offset
6859 + elf_sh_plt_symbol_offset (info)));
6860#else
6861 bfd_put_32 (output_bfd, got_offset,
6862 (splt->contents + h->plt.offset
6863 + elf_sh_plt_symbol_offset (info)));
6864#endif
6865 }
6866
6867#ifdef GOT_BIAS
6868 if (info->shared)
6869 got_offset += GOT_BIAS;
6870#endif
6871
6872#ifdef INCLUDE_SHMEDIA
6873 movi_shori_putval (output_bfd,
6874 plt_index * sizeof (Elf32_External_Rela),
6875 (splt->contents + h->plt.offset
6876 + elf_sh_plt_reloc_offset (info)));
6877#else
6878 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
6879 (splt->contents + h->plt.offset
6880 + elf_sh_plt_reloc_offset (info)));
6881#endif
6882
6883 /* Fill in the entry in the global offset table. */
6884 bfd_put_32 (output_bfd,
6885 (splt->output_section->vma
6886 + splt->output_offset
6887 + h->plt.offset
6888 + elf_sh_plt_temp_offset (info)),
6889 sgot->contents + got_offset);
6890
6891 /* Fill in the entry in the .rela.plt section. */
6892 rel.r_offset = (sgot->output_section->vma
6893 + sgot->output_offset
6894 + got_offset);
6895 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
6896 rel.r_addend = 0;
6897#ifdef GOT_BIAS
6898 rel.r_addend = GOT_BIAS;
6899#endif
6900 loc = srel->contents + plt_index * sizeof (Elf32_External_Rela);
6901 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6902
6903 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
6904 {
6905 /* Mark the symbol as undefined, rather than as defined in
6906 the .plt section. Leave the value alone. */
6907 sym->st_shndx = SHN_UNDEF;
6908 }
6909 }
6910
6911 if (h->got.offset != (bfd_vma) -1
6912 && sh_elf_hash_entry (h)->tls_type != GOT_TLS_GD
6913 && sh_elf_hash_entry (h)->tls_type != GOT_TLS_IE)
6914 {
6915 asection *sgot;
6916 asection *srel;
6917 Elf_Internal_Rela rel;
6918 bfd_byte *loc;
6919
6920 /* This symbol has an entry in the global offset table. Set it
6921 up. */
6922
6923 sgot = htab->sgot;
6924 srel = htab->srelgot;
6925 BFD_ASSERT (sgot != NULL && srel != NULL);
6926
6927 rel.r_offset = (sgot->output_section->vma
6928 + sgot->output_offset
6929 + (h->got.offset &~ (bfd_vma) 1));
6930
6931 /* If this is a static link, or it is a -Bsymbolic link and the
6932 symbol is defined locally or was forced to be local because
6933 of a version file, we just want to emit a RELATIVE reloc.
6934 The entry in the global offset table will already have been
6935 initialized in the relocate_section function. */
6936 if (info->shared
6937 && (info->symbolic
6938 || h->dynindx == -1
6939 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
6940 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
6941 {
6942 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
6943 rel.r_addend = (h->root.u.def.value
6944 + h->root.u.def.section->output_section->vma
6945 + h->root.u.def.section->output_offset);
6946 }
6947 else
6948 {
6949 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
6950 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
6951 rel.r_addend = 0;
6952 }
6953
6954 loc = srel->contents;
6955 loc += srel->reloc_count++ * sizeof (Elf32_External_Rela);
6956 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
6957 }
6958
6959#ifdef INCLUDE_SHMEDIA
6960 {
6961 struct elf_sh_link_hash_entry *eh;
6962
6963 eh = (struct elf_sh_link_hash_entry *) h;
6964 if (eh->datalabel_got.offset != (bfd_vma) -1)
6965 {
6966 asection *sgot;
6967 asection *srel;
6968 Elf_Internal_Rela rel;
6969 bfd_byte *loc;
6970
6971 /* This symbol has a datalabel entry in the global offset table.
6972 Set it up. */
6973
6974 sgot = htab->sgot;
6975 srel = htab->srelgot;
6976 BFD_ASSERT (sgot != NULL && srel != NULL);
6977
6978 rel.r_offset = (sgot->output_section->vma
6979 + sgot->output_offset
6980 + (eh->datalabel_got.offset &~ (bfd_vma) 1));
6981
6982 /* If this is a static link, or it is a -Bsymbolic link and the
6983 symbol is defined locally or was forced to be local because
6984 of a version file, we just want to emit a RELATIVE reloc.
6985 The entry in the global offset table will already have been
6986 initialized in the relocate_section function. */
6987 if (info->shared
6988 && (info->symbolic
6989 || h->dynindx == -1
6990 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
6991 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
6992 {
6993 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
6994 rel.r_addend = (h->root.u.def.value
6995 + h->root.u.def.section->output_section->vma
6996 + h->root.u.def.section->output_offset);
6997 }
6998 else
6999 {
7000 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents
7001 + eh->datalabel_got.offset);
7002 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
7003 rel.r_addend = 0;
7004 }
7005
7006 loc = srel->contents;
7007 loc += srel->reloc_count++ * sizeof (Elf32_External_Rela);
7008 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7009 }
7010 }
7011#endif
7012
7013 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
7014 {
7015 asection *s;
7016 Elf_Internal_Rela rel;
7017 bfd_byte *loc;
7018
7019 /* This symbol needs a copy reloc. Set it up. */
7020
7021 BFD_ASSERT (h->dynindx != -1
7022 && (h->root.type == bfd_link_hash_defined
7023 || h->root.type == bfd_link_hash_defweak));
7024
7025 s = bfd_get_section_by_name (h->root.u.def.section->owner,
7026 ".rela.bss");
7027 BFD_ASSERT (s != NULL);
7028
7029 rel.r_offset = (h->root.u.def.value
7030 + h->root.u.def.section->output_section->vma
7031 + h->root.u.def.section->output_offset);
7032 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
7033 rel.r_addend = 0;
7034 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
7035 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
7036 }
7037
7038 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
7039 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
7040 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
7041 sym->st_shndx = SHN_ABS;
7042
7043 return TRUE;
7044}
7045
7046/* Finish up the dynamic sections. */
7047
7048static bfd_boolean
7049sh_elf_finish_dynamic_sections (output_bfd, info)
7050 bfd *output_bfd;
7051 struct bfd_link_info *info;
7052{
7053 struct elf_sh_link_hash_table *htab;
7054 bfd *dynobj;
7055 asection *sgot;
7056 asection *sdyn;
7057
7058 htab = sh_elf_hash_table (info);
7059 dynobj = htab->root.dynobj;
7060
7061 sgot = htab->sgotplt;
7062 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
7063
7064 if (htab->root.dynamic_sections_created)
7065 {
7066 asection *splt;
7067 Elf32_External_Dyn *dyncon, *dynconend;
7068
7069 BFD_ASSERT (sgot != NULL && sdyn != NULL);
7070
7071 dyncon = (Elf32_External_Dyn *) sdyn->contents;
7072 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
7073 for (; dyncon < dynconend; dyncon++)
7074 {
7075 Elf_Internal_Dyn dyn;
7076 asection *s;
7077#ifdef INCLUDE_SHMEDIA
7078 const char *name;
7079#endif
7080
7081 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
7082
7083 switch (dyn.d_tag)
7084 {
7085 default:
7086 break;
7087
7088#ifdef INCLUDE_SHMEDIA
7089 case DT_INIT:
7090 name = info->init_function;
7091 goto get_sym;
7092
7093 case DT_FINI:
7094 name = info->fini_function;
7095 get_sym:
7096 if (dyn.d_un.d_val != 0)
7097 {
7098 struct elf_link_hash_entry *h;
7099
7100 h = elf_link_hash_lookup (&htab->root, name,
7101 FALSE, FALSE, TRUE);
7102 if (h != NULL && (h->other & STO_SH5_ISA32))
7103 {
7104 dyn.d_un.d_val |= 1;
7105 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7106 }
7107 }
7108 break;
7109#endif
7110
7111 case DT_PLTGOT:
7112 s = htab->sgot->output_section;
7113 goto get_vma;
7114
7115 case DT_JMPREL:
7116 s = htab->srelplt->output_section;
7117 get_vma:
7118 BFD_ASSERT (s != NULL);
7119 dyn.d_un.d_ptr = s->vma;
7120 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7121 break;
7122
7123 case DT_PLTRELSZ:
7124 s = htab->srelplt->output_section;
7125 BFD_ASSERT (s != NULL);
7126 if (s->_cooked_size != 0)
7127 dyn.d_un.d_val = s->_cooked_size;
7128 else
7129 dyn.d_un.d_val = s->_raw_size;
7130 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7131 break;
7132
7133 case DT_RELASZ:
7134 /* My reading of the SVR4 ABI indicates that the
7135 procedure linkage table relocs (DT_JMPREL) should be
7136 included in the overall relocs (DT_RELA). This is
7137 what Solaris does. However, UnixWare can not handle
7138 that case. Therefore, we override the DT_RELASZ entry
7139 here to make it not include the JMPREL relocs. Since
7140 the linker script arranges for .rela.plt to follow all
7141 other relocation sections, we don't have to worry
7142 about changing the DT_RELA entry. */
7143 if (htab->srelplt != NULL)
7144 {
7145 s = htab->srelplt->output_section;
7146 if (s->_cooked_size != 0)
7147 dyn.d_un.d_val -= s->_cooked_size;
7148 else
7149 dyn.d_un.d_val -= s->_raw_size;
7150 }
7151 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7152 break;
7153 }
7154 }
7155
7156 /* Fill in the first entry in the procedure linkage table. */
7157 splt = htab->splt;
7158 if (splt && splt->_raw_size > 0)
7159 {
7160 if (info->shared)
7161 {
7162 if (elf_sh_pic_plt_entry == NULL)
7163 {
7164 elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
7165 elf_sh_pic_plt_entry_be :
7166 elf_sh_pic_plt_entry_le);
7167 }
7168 memcpy (splt->contents, elf_sh_pic_plt_entry,
7169 elf_sh_sizeof_plt (info));
7170 }
7171 else
7172 {
7173 if (elf_sh_plt0_entry == NULL)
7174 {
7175 elf_sh_plt0_entry = (bfd_big_endian (output_bfd) ?
7176 elf_sh_plt0_entry_be :
7177 elf_sh_plt0_entry_le);
7178 }
7179 memcpy (splt->contents, elf_sh_plt0_entry, PLT_ENTRY_SIZE);
7180#ifdef INCLUDE_SHMEDIA
7181 movi_shori_putval (output_bfd,
7182 sgot->output_section->vma
7183 + sgot->output_offset,
7184 splt->contents
7185 + elf_sh_plt0_gotplt_offset (info));
7186#else
7187 bfd_put_32 (output_bfd,
7188 sgot->output_section->vma + sgot->output_offset + 4,
7189 splt->contents + elf_sh_plt0_gotid_offset (info));
7190 bfd_put_32 (output_bfd,
7191 sgot->output_section->vma + sgot->output_offset + 8,
7192 splt->contents + elf_sh_plt0_linker_offset (info));
7193#endif
7194 }
7195
7196 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7197 really seem like the right value. */
7198 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7199 }
7200 }
7201
7202 /* Fill in the first three entries in the global offset table. */
7203 if (sgot && sgot->_raw_size > 0)
7204 {
7205 if (sdyn == NULL)
7206 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
7207 else
7208 bfd_put_32 (output_bfd,
7209 sdyn->output_section->vma + sdyn->output_offset,
7210 sgot->contents);
7211 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
7212 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
7213
7214 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
7215 }
7216
7217 return TRUE;
7218}
7219
7220static enum elf_reloc_type_class
7221sh_elf_reloc_type_class (rela)
7222 const Elf_Internal_Rela *rela;
7223{
7224 switch ((int) ELF32_R_TYPE (rela->r_info))
7225 {
7226 case R_SH_RELATIVE:
7227 return reloc_class_relative;
7228 case R_SH_JMP_SLOT:
7229 return reloc_class_plt;
7230 case R_SH_COPY:
7231 return reloc_class_copy;
7232 default:
7233 return reloc_class_normal;
7234 }
7235}
7236
7237/* Support for Linux core dump NOTE sections. */
7238static bfd_boolean
7239elf32_shlin_grok_prstatus (abfd, note)
7240 bfd *abfd;
7241 Elf_Internal_Note *note;
7242{
7243 int offset;
7244 unsigned int raw_size;
7245
7246 switch (note->descsz)
7247 {
7248 default:
7249 return FALSE;
7250
7251 case 168: /* Linux/SH */
7252 /* pr_cursig */
7253 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
7254
7255 /* pr_pid */
7256 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
7257
7258 /* pr_reg */
7259 offset = 72;
7260 raw_size = 92;
7261
7262 break;
7263 }
7264
7265 /* Make a ".reg/999" section. */
7266 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7267 raw_size, note->descpos + offset);
7268}
7269
7270static bfd_boolean
7271elf32_shlin_grok_psinfo (abfd, note)
7272 bfd *abfd;
7273 Elf_Internal_Note *note;
7274{
7275 switch (note->descsz)
7276 {
7277 default:
7278 return FALSE;
7279
7280 case 124: /* Linux/SH elf_prpsinfo */
7281 elf_tdata (abfd)->core_program
7282 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
7283 elf_tdata (abfd)->core_command
7284 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
7285 }
7286
7287 /* Note that for some reason, a spurious space is tacked
7288 onto the end of the args in some (at least one anyway)
7289 implementations, so strip it off if it exists. */
7290
7291 {
7292 char *command = elf_tdata (abfd)->core_command;
7293 int n = strlen (command);
7294
7295 if (0 < n && command[n - 1] == ' ')
7296 command[n - 1] = '\0';
7297 }
7298
7299 return TRUE;
7300}
7301
7302#define TARGET_BIG_SYM bfd_elf32_sh_vec
7303#define TARGET_BIG_NAME "elf32-sh"
7304#define TARGET_LITTLE_SYM bfd_elf32_shl_vec
7305#define TARGET_LITTLE_NAME "elf32-shl"
7306#define ELF_ARCH bfd_arch_sh
7307#define ELF_MACHINE_CODE EM_SH
7308#define ELF_MAXPAGESIZE 128
7309
7310#define elf_symbol_leading_char '_'
7311
7312#define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7313#define elf_info_to_howto sh_elf_info_to_howto
7314#define bfd_elf32_bfd_relax_section sh_elf_relax_section
7315#define elf_backend_relocate_section sh_elf_relocate_section
7316#define bfd_elf32_bfd_get_relocated_section_contents \
7317 sh_elf_get_relocated_section_contents
7318#define bfd_elf32_mkobject sh_elf_mkobject
7319#define elf_backend_object_p sh_elf_object_p
7320#define bfd_elf32_bfd_set_private_bfd_flags \
7321 sh_elf_set_private_flags
7322#define bfd_elf32_bfd_copy_private_bfd_data \
7323 sh_elf_copy_private_data
7324#define bfd_elf32_bfd_merge_private_bfd_data \
7325 sh_elf_merge_private_data
7326
7327#define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
7328#define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
7329#define elf_backend_check_relocs sh_elf_check_relocs
7330#define elf_backend_copy_indirect_symbol \
7331 sh_elf_copy_indirect_symbol
7332#define elf_backend_create_dynamic_sections \
7333 sh_elf_create_dynamic_sections
7334#define bfd_elf32_bfd_link_hash_table_create \
7335 sh_elf_link_hash_table_create
7336#define elf_backend_adjust_dynamic_symbol \
7337 sh_elf_adjust_dynamic_symbol
7338#define elf_backend_size_dynamic_sections \
7339 sh_elf_size_dynamic_sections
7340#define elf_backend_finish_dynamic_symbol \
7341 sh_elf_finish_dynamic_symbol
7342#define elf_backend_finish_dynamic_sections \
7343 sh_elf_finish_dynamic_sections
7344#define elf_backend_reloc_type_class sh_elf_reloc_type_class
7345
7346#define elf_backend_can_gc_sections 1
7347#define elf_backend_can_refcount 1
7348#define elf_backend_want_got_plt 1
7349#define elf_backend_plt_readonly 1
7350#define elf_backend_want_plt_sym 0
7351#define elf_backend_got_header_size 12
7352#define elf_backend_plt_header_size PLT_ENTRY_SIZE
7353
7354#ifndef INCLUDE_SHMEDIA
7355
7356#include "elf32-target.h"
7357
7358/* NetBSD support. */
7359#undef TARGET_BIG_SYM
7360#define TARGET_BIG_SYM bfd_elf32_shnbsd_vec
7361#undef TARGET_BIG_NAME
7362#define TARGET_BIG_NAME "elf32-sh-nbsd"
7363#undef TARGET_LITTLE_SYM
7364#define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec
7365#undef TARGET_LITTLE_NAME
7366#define TARGET_LITTLE_NAME "elf32-shl-nbsd"
7367#undef ELF_MAXPAGESIZE
7368#define ELF_MAXPAGESIZE 0x10000
7369#undef elf_symbol_leading_char
7370#define elf_symbol_leading_char 0
7371#undef elf32_bed
7372#define elf32_bed elf32_sh_nbsd_bed
7373
7374#include "elf32-target.h"
7375
7376
7377/* Linux support. */
7378#undef TARGET_BIG_SYM
7379#define TARGET_BIG_SYM bfd_elf32_shblin_vec
7380#undef TARGET_BIG_NAME
7381#define TARGET_BIG_NAME "elf32-shbig-linux"
7382#undef TARGET_LITTLE_SYM
7383#define TARGET_LITTLE_SYM bfd_elf32_shlin_vec
7384#undef TARGET_LITTLE_NAME
7385#define TARGET_LITTLE_NAME "elf32-sh-linux"
7386
7387#undef elf_backend_grok_prstatus
7388#define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
7389#undef elf_backend_grok_psinfo
7390#define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
7391#undef elf32_bed
7392#define elf32_bed elf32_sh_lin_bed
7393
7394#include "elf32-target.h"
7395
7396#endif /* INCLUDE_SHMEDIA */
Note: See TracBrowser for help on using the repository browser.