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