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