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