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