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