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