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