?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2001-08-31 Eric Christopher <echristo@redhat.com>
[binutils.git] / bfd / elf32-sh.c
blob6cf497491825994caa3bc7a20f25edd8b2826dbc
1 /* Hitachi SH specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
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 ((int));
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 false, /* partial_inplace */
138 0, /* 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 EMPTY_HOWTO (45),
496 EMPTY_HOWTO (46),
497 EMPTY_HOWTO (47),
498 EMPTY_HOWTO (48),
499 EMPTY_HOWTO (49),
500 EMPTY_HOWTO (50),
501 EMPTY_HOWTO (51),
502 EMPTY_HOWTO (52),
503 EMPTY_HOWTO (53),
504 EMPTY_HOWTO (54),
505 EMPTY_HOWTO (55),
506 EMPTY_HOWTO (56),
507 EMPTY_HOWTO (57),
508 EMPTY_HOWTO (58),
509 EMPTY_HOWTO (59),
510 EMPTY_HOWTO (60),
511 EMPTY_HOWTO (61),
512 EMPTY_HOWTO (62),
513 EMPTY_HOWTO (63),
514 EMPTY_HOWTO (64),
515 EMPTY_HOWTO (65),
516 EMPTY_HOWTO (66),
517 EMPTY_HOWTO (67),
518 EMPTY_HOWTO (68),
519 EMPTY_HOWTO (69),
520 EMPTY_HOWTO (70),
521 EMPTY_HOWTO (71),
522 EMPTY_HOWTO (72),
523 EMPTY_HOWTO (73),
524 EMPTY_HOWTO (74),
525 EMPTY_HOWTO (75),
526 EMPTY_HOWTO (76),
527 EMPTY_HOWTO (77),
528 EMPTY_HOWTO (78),
529 EMPTY_HOWTO (79),
530 EMPTY_HOWTO (80),
531 EMPTY_HOWTO (81),
532 EMPTY_HOWTO (82),
533 EMPTY_HOWTO (83),
534 EMPTY_HOWTO (84),
535 EMPTY_HOWTO (85),
536 EMPTY_HOWTO (86),
537 EMPTY_HOWTO (87),
538 EMPTY_HOWTO (88),
539 EMPTY_HOWTO (89),
540 EMPTY_HOWTO (90),
541 EMPTY_HOWTO (91),
542 EMPTY_HOWTO (92),
543 EMPTY_HOWTO (93),
544 EMPTY_HOWTO (94),
545 EMPTY_HOWTO (95),
546 EMPTY_HOWTO (96),
547 EMPTY_HOWTO (97),
548 EMPTY_HOWTO (98),
549 EMPTY_HOWTO (99),
550 EMPTY_HOWTO (100),
551 EMPTY_HOWTO (101),
552 EMPTY_HOWTO (102),
553 EMPTY_HOWTO (103),
554 EMPTY_HOWTO (104),
555 EMPTY_HOWTO (105),
556 EMPTY_HOWTO (106),
557 EMPTY_HOWTO (107),
558 EMPTY_HOWTO (108),
559 EMPTY_HOWTO (109),
560 EMPTY_HOWTO (110),
561 EMPTY_HOWTO (111),
562 EMPTY_HOWTO (112),
563 EMPTY_HOWTO (113),
564 EMPTY_HOWTO (114),
565 EMPTY_HOWTO (115),
566 EMPTY_HOWTO (116),
567 EMPTY_HOWTO (117),
568 EMPTY_HOWTO (118),
569 EMPTY_HOWTO (119),
570 EMPTY_HOWTO (120),
571 EMPTY_HOWTO (121),
572 EMPTY_HOWTO (122),
573 EMPTY_HOWTO (123),
574 EMPTY_HOWTO (124),
575 EMPTY_HOWTO (125),
576 EMPTY_HOWTO (126),
577 EMPTY_HOWTO (127),
578 EMPTY_HOWTO (128),
579 EMPTY_HOWTO (129),
580 EMPTY_HOWTO (130),
581 EMPTY_HOWTO (131),
582 EMPTY_HOWTO (132),
583 EMPTY_HOWTO (133),
584 EMPTY_HOWTO (134),
585 EMPTY_HOWTO (135),
586 EMPTY_HOWTO (136),
587 EMPTY_HOWTO (137),
588 EMPTY_HOWTO (138),
589 EMPTY_HOWTO (139),
590 EMPTY_HOWTO (140),
591 EMPTY_HOWTO (141),
592 EMPTY_HOWTO (142),
593 EMPTY_HOWTO (143),
594 EMPTY_HOWTO (144),
595 EMPTY_HOWTO (145),
596 EMPTY_HOWTO (146),
597 EMPTY_HOWTO (147),
598 EMPTY_HOWTO (148),
599 EMPTY_HOWTO (149),
600 EMPTY_HOWTO (150),
601 EMPTY_HOWTO (151),
602 EMPTY_HOWTO (152),
603 EMPTY_HOWTO (153),
604 EMPTY_HOWTO (154),
605 EMPTY_HOWTO (155),
606 EMPTY_HOWTO (156),
607 EMPTY_HOWTO (157),
608 EMPTY_HOWTO (158),
609 EMPTY_HOWTO (159),
610
611 HOWTO (R_SH_GOT32, /* type */
612 0, /* rightshift */
613 2, /* size (0 = byte, 1 = short, 2 = long) */
614 32, /* bitsize */
615 false, /* pc_relative */
616 0, /* bitpos */
617 complain_overflow_bitfield, /* complain_on_overflow */
618 bfd_elf_generic_reloc, /* */
619 "R_SH_GOT32", /* name */
620 true, /* partial_inplace */
621 0xffffffff, /* src_mask */
622 0xffffffff, /* dst_mask */
623 false), /* pcrel_offset */
624
625 HOWTO (R_SH_PLT32, /* type */
626 0, /* rightshift */
627 2, /* size (0 = byte, 1 = short, 2 = long) */
628 32, /* bitsize */
629 true, /* pc_relative */
630 0, /* bitpos */
631 complain_overflow_bitfield, /* complain_on_overflow */
632 bfd_elf_generic_reloc, /* */
633 "R_SH_PLT32", /* name */
634 true, /* partial_inplace */
635 0xffffffff, /* src_mask */
636 0xffffffff, /* dst_mask */
637 true), /* pcrel_offset */
638
639 HOWTO (R_SH_COPY, /* type */
640 0, /* rightshift */
641 2, /* size (0 = byte, 1 = short, 2 = long) */
642 32, /* bitsize */
643 false, /* pc_relative */
644 0, /* bitpos */
645 complain_overflow_bitfield, /* complain_on_overflow */
646 bfd_elf_generic_reloc, /* */
647 "R_SH_COPY", /* name */
648 true, /* partial_inplace */
649 0xffffffff, /* src_mask */
650 0xffffffff, /* dst_mask */
651 false), /* pcrel_offset */
652
653 HOWTO (R_SH_GLOB_DAT, /* type */
654 0, /* rightshift */
655 2, /* size (0 = byte, 1 = short, 2 = long) */
656 32, /* bitsize */
657 false, /* pc_relative */
658 0, /* bitpos */
659 complain_overflow_bitfield, /* complain_on_overflow */
660 bfd_elf_generic_reloc, /* */
661 "R_SH_GLOB_DAT", /* name */
662 true, /* partial_inplace */
663 0xffffffff, /* src_mask */
664 0xffffffff, /* dst_mask */
665 false), /* pcrel_offset */
666
667 HOWTO (R_SH_JMP_SLOT, /* type */
668 0, /* rightshift */
669 2, /* size (0 = byte, 1 = short, 2 = long) */
670 32, /* bitsize */
671 false, /* pc_relative */
672 0, /* bitpos */
673 complain_overflow_bitfield, /* complain_on_overflow */
674 bfd_elf_generic_reloc, /* */
675 "R_SH_JMP_SLOT", /* name */
676 true, /* partial_inplace */
677 0xffffffff, /* src_mask */
678 0xffffffff, /* dst_mask */
679 false), /* pcrel_offset */
680
681 HOWTO (R_SH_RELATIVE, /* type */
682 0, /* rightshift */
683 2, /* size (0 = byte, 1 = short, 2 = long) */
684 32, /* bitsize */
685 false, /* pc_relative */
686 0, /* bitpos */
687 complain_overflow_bitfield, /* complain_on_overflow */
688 bfd_elf_generic_reloc, /* */
689 "R_SH_RELATIVE", /* name */
690 true, /* partial_inplace */
691 0xffffffff, /* src_mask */
692 0xffffffff, /* dst_mask */
693 false), /* pcrel_offset */
694
695 HOWTO (R_SH_GOTOFF, /* type */
696 0, /* rightshift */
697 2, /* size (0 = byte, 1 = short, 2 = long) */
698 32, /* bitsize */
699 false, /* pc_relative */
700 0, /* bitpos */
701 complain_overflow_bitfield, /* complain_on_overflow */
702 bfd_elf_generic_reloc, /* */
703 "R_SH_GOTOFF", /* name */
704 true, /* partial_inplace */
705 0xffffffff, /* src_mask */
706 0xffffffff, /* dst_mask */
707 false), /* pcrel_offset */
708
709 HOWTO (R_SH_GOTPC, /* type */
710 0, /* rightshift */
711 2, /* size (0 = byte, 1 = short, 2 = long) */
712 32, /* bitsize */
713 true, /* pc_relative */
714 0, /* bitpos */
715 complain_overflow_bitfield, /* complain_on_overflow */
716 bfd_elf_generic_reloc, /* */
717 "R_SH_GOTPC", /* name */
718 true, /* partial_inplace */
719 0xffffffff, /* src_mask */
720 0xffffffff, /* dst_mask */
721 true), /* pcrel_offset */
722
723 };
724
725 static bfd_reloc_status_type
726 sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, addr,
727 symbol_section, start, end)
728 int r_type ATTRIBUTE_UNUSED;
729 bfd *input_bfd;
730 asection *input_section;
731 bfd_byte *contents;
732 bfd_vma addr;
733 asection *symbol_section;
734 bfd_vma start, end;
735 {
736 static bfd_vma last_addr;
737 static asection *last_symbol_section;
738 bfd_byte *free_contents = NULL;
739 bfd_byte *start_ptr, *ptr, *last_ptr;
740 int diff, cum_diff;
741 bfd_signed_vma x;
742 int insn;
743
744 /* Sanity check the address. */
745 if (addr > input_section->_raw_size)
746 return bfd_reloc_outofrange;
747
748 /* We require the start and end relocations to be processed consecutively -
749 although we allow then to be processed forwards or backwards. */
750 if (! last_addr)
751 {
752 last_addr = addr;
753 last_symbol_section = symbol_section;
754 return bfd_reloc_ok;
755 }
756 if (last_addr != addr)
757 abort ();
758 last_addr = 0;
759
760 if (! symbol_section || last_symbol_section != symbol_section || end < start)
761 return bfd_reloc_outofrange;
762
763 /* Get the symbol_section contents. */
764 if (symbol_section != input_section)
765 {
766 if (elf_section_data (symbol_section)->this_hdr.contents != NULL)
767 contents = elf_section_data (symbol_section)->this_hdr.contents;
768 else
769 {
770 free_contents = contents
771 = (bfd_byte *) bfd_malloc (symbol_section->_raw_size);
772 if (contents == NULL)
773 return bfd_reloc_outofrange;
774 if (! bfd_get_section_contents (input_bfd, symbol_section, contents,
775 (file_ptr) 0,
776 symbol_section->_raw_size))
777 {
778 free (contents);
779 return bfd_reloc_outofrange;
780 }
781 }
782 }
783 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
784 start_ptr = contents + start;
785 for (cum_diff = -6, ptr = contents + end; cum_diff < 0 && ptr > start_ptr;)
786 {
787 for (last_ptr = ptr, ptr -= 4; ptr >= start_ptr && IS_PPI (ptr);)
788 ptr -= 2;
789 ptr += 2;
790 diff = (last_ptr - ptr) >> 1;
791 cum_diff += diff & 1;
792 cum_diff += diff;
793 }
794 /* Calculate the start / end values to load into rs / re minus four -
795 so that will cancel out the four we would otherwise have to add to
796 addr to get the value to subtract in order to get relative addressing. */
797 if (cum_diff >= 0)
798 {
799 start -= 4;
800 end = (ptr + cum_diff * 2) - contents;
801 }
802 else
803 {
804 bfd_vma start0 = start - 4;
805
806 while (start0 && IS_PPI (contents + start0))
807 start0 -= 2;
808 start0 = start - 2 - ((start - start0) & 2);
809 start = start0 - cum_diff - 2;
810 end = start0;
811 }
812
813 if (free_contents)
814 free (free_contents);
815
816 insn = bfd_get_16 (input_bfd, contents + addr);
817
818 x = (insn & 0x200 ? end : start) - addr;
819 if (input_section != symbol_section)
820 x += ((symbol_section->output_section->vma + symbol_section->output_offset)
821 - (input_section->output_section->vma
822 + input_section->output_offset));
823 x >>= 1;
824 if (x < -128 || x > 127)
825 return bfd_reloc_overflow;
826
827 x = (insn & ~0xff) | (x & 0xff);
828 bfd_put_16 (input_bfd, x, contents + addr);
829
830 return bfd_reloc_ok;
831 }
832
833 /* This function is used for normal relocs. This used to be like the COFF
834 function, and is almost certainly incorrect for other ELF targets. */
835
836 static bfd_reloc_status_type
837 sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
838 error_message)
839 bfd *abfd;
840 arelent *reloc_entry;
841 asymbol *symbol_in;
842 PTR data;
843 asection *input_section;
844 bfd *output_bfd;
845 char **error_message ATTRIBUTE_UNUSED;
846 {
847 unsigned long insn;
848 bfd_vma sym_value;
849 enum elf_sh_reloc_type r_type;
850 bfd_vma addr = reloc_entry->address;
851 bfd_byte *hit_data = addr + (bfd_byte *) data;
852
853 r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
854
855 if (output_bfd != NULL)
856 {
857 /* Partial linking--do nothing. */
858 reloc_entry->address += input_section->output_offset;
859 return bfd_reloc_ok;
860 }
861
862 /* Almost all relocs have to do with relaxing. If any work must be
863 done for them, it has been done in sh_relax_section. */
864 if (r_type == R_SH_IND12W && (symbol_in->flags & BSF_LOCAL) != 0)
865 return bfd_reloc_ok;
866
867 if (symbol_in != NULL
868 && bfd_is_und_section (symbol_in->section))
869 return bfd_reloc_undefined;
870
871 if (bfd_is_com_section (symbol_in->section))
872 sym_value = 0;
873 else
874 sym_value = (symbol_in->value +
875 symbol_in->section->output_section->vma +
876 symbol_in->section->output_offset);
877
878 switch (r_type)
879 {
880 case R_SH_DIR32:
881 insn = bfd_get_32 (abfd, hit_data);
882 insn += sym_value + reloc_entry->addend;
883 bfd_put_32 (abfd, insn, hit_data);
884 break;
885 case R_SH_IND12W:
886 insn = bfd_get_16 (abfd, hit_data);
887 sym_value += reloc_entry->addend;
888 sym_value -= (input_section->output_section->vma
889 + input_section->output_offset
890 + addr
891 + 4);
892 sym_value += (insn & 0xfff) << 1;
893 if (insn & 0x800)
894 sym_value -= 0x1000;
895 insn = (insn & 0xf000) | (sym_value & 0xfff);
896 bfd_put_16 (abfd, insn, hit_data);
897 if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
898 return bfd_reloc_overflow;
899 break;
900 default:
901 abort ();
902 break;
903 }
904
905 return bfd_reloc_ok;
906 }
907
908 /* This function is used for relocs which are only used for relaxing,
909 which the linker should otherwise ignore. */
910
911 static bfd_reloc_status_type
912 sh_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
913 output_bfd, error_message)
914 bfd *abfd ATTRIBUTE_UNUSED;
915 arelent *reloc_entry;
916 asymbol *symbol ATTRIBUTE_UNUSED;
917 PTR data ATTRIBUTE_UNUSED;
918 asection *input_section;
919 bfd *output_bfd;
920 char **error_message ATTRIBUTE_UNUSED;
921 {
922 if (output_bfd != NULL)
923 reloc_entry->address += input_section->output_offset;
924 return bfd_reloc_ok;
925 }
926
927 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
928
929 struct elf_reloc_map
930 {
931 bfd_reloc_code_real_type bfd_reloc_val;
932 unsigned char elf_reloc_val;
933 };
934
935 /* An array mapping BFD reloc codes to SH ELF relocs. */
936
937 static const struct elf_reloc_map sh_reloc_map[] =
938 {
939 { BFD_RELOC_NONE, R_SH_NONE },
940 { BFD_RELOC_32, R_SH_DIR32 },
941 { BFD_RELOC_CTOR, R_SH_DIR32 },
942 { BFD_RELOC_32_PCREL, R_SH_REL32 },
943 { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
944 { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
945 { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
946 { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
947 { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
948 { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
949 { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
950 { BFD_RELOC_SH_USES, R_SH_USES },
951 { BFD_RELOC_SH_COUNT, R_SH_COUNT },
952 { BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
953 { BFD_RELOC_SH_CODE, R_SH_CODE },
954 { BFD_RELOC_SH_DATA, R_SH_DATA },
955 { BFD_RELOC_SH_LABEL, R_SH_LABEL },
956 { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
957 { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
958 { BFD_RELOC_SH_LOOP_START, R_SH_LOOP_START },
959 { BFD_RELOC_SH_LOOP_END, R_SH_LOOP_END },
960 { BFD_RELOC_32_GOT_PCREL, R_SH_GOT32 },
961 { BFD_RELOC_32_PLT_PCREL, R_SH_PLT32 },
962 { BFD_RELOC_SH_COPY, R_SH_COPY },
963 { BFD_RELOC_SH_GLOB_DAT, R_SH_GLOB_DAT },
964 { BFD_RELOC_SH_JMP_SLOT, R_SH_JMP_SLOT },
965 { BFD_RELOC_SH_RELATIVE, R_SH_RELATIVE },
966 { BFD_RELOC_32_GOTOFF, R_SH_GOTOFF },
967 { BFD_RELOC_SH_GOTPC, R_SH_GOTPC },
968 };
969
970 /* Given a BFD reloc code, return the howto structure for the
971 corresponding SH ELf reloc. */
972
973 static reloc_howto_type *
974 sh_elf_reloc_type_lookup (abfd, code)
975 bfd *abfd ATTRIBUTE_UNUSED;
976 bfd_reloc_code_real_type code;
977 {
978 unsigned int i;
979
980 for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
981 {
982 if (sh_reloc_map[i].bfd_reloc_val == code)
983 return &sh_elf_howto_table[(int) sh_reloc_map[i].elf_reloc_val];
984 }
985
986 return NULL;
987 }
988
989 /* Given an ELF reloc, fill in the howto field of a relent. */
990
991 static void
992 sh_elf_info_to_howto (abfd, cache_ptr, dst)
993 bfd *abfd ATTRIBUTE_UNUSED;
994 arelent *cache_ptr;
995 Elf_Internal_Rela *dst;
996 {
997 unsigned int r;
998
999 r = ELF32_R_TYPE (dst->r_info);
1000
1001 BFD_ASSERT (r < (unsigned int) R_SH_max);
1002 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
1003 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_2 || r > R_SH_LAST_INVALID_RELOC_2);
1004
1005 cache_ptr->howto = &sh_elf_howto_table[r];
1006 }
1007 \f
1008 /* This function handles relaxing for SH ELF. See the corresponding
1009 function in coff-sh.c for a description of what this does. FIXME:
1010 There is a lot of duplication here between this code and the COFF
1011 specific code. The format of relocs and symbols is wound deeply
1012 into this code, but it would still be better if the duplication
1013 could be eliminated somehow. Note in particular that although both
1014 functions use symbols like R_SH_CODE, those symbols have different
1015 values; in coff-sh.c they come from include/coff/sh.h, whereas here
1016 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
1017
1018 static boolean
1019 sh_elf_relax_section (abfd, sec, link_info, again)
1020 bfd *abfd;
1021 asection *sec;
1022 struct bfd_link_info *link_info;
1023 boolean *again;
1024 {
1025 Elf_Internal_Shdr *symtab_hdr;
1026 Elf_Internal_Rela *internal_relocs;
1027 Elf_Internal_Rela *free_relocs = NULL;
1028 boolean have_code;
1029 Elf_Internal_Rela *irel, *irelend;
1030 bfd_byte *contents = NULL;
1031 bfd_byte *free_contents = NULL;
1032 Elf32_External_Sym *extsyms = NULL;
1033 Elf32_External_Sym *free_extsyms = NULL;
1034
1035 *again = false;
1036
1037 if (link_info->relocateable
1038 || (sec->flags & SEC_RELOC) == 0
1039 || sec->reloc_count == 0)
1040 return true;
1041
1042 /* If this is the first time we have been called for this section,
1043 initialize the cooked size. */
1044 if (sec->_cooked_size == 0)
1045 sec->_cooked_size = sec->_raw_size;
1046
1047 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1048
1049 internal_relocs = (_bfd_elf32_link_read_relocs
1050 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1051 link_info->keep_memory));
1052 if (internal_relocs == NULL)
1053 goto error_return;
1054 if (! link_info->keep_memory)
1055 free_relocs = internal_relocs;
1056
1057 have_code = false;
1058
1059 irelend = internal_relocs + sec->reloc_count;
1060 for (irel = internal_relocs; irel < irelend; irel++)
1061 {
1062 bfd_vma laddr, paddr, symval;
1063 unsigned short insn;
1064 Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
1065 bfd_signed_vma foff;
1066
1067 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
1068 have_code = true;
1069
1070 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
1071 continue;
1072
1073 /* Get the section contents. */
1074 if (contents == NULL)
1075 {
1076 if (elf_section_data (sec)->this_hdr.contents != NULL)
1077 contents = elf_section_data (sec)->this_hdr.contents;
1078 else
1079 {
1080 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1081 if (contents == NULL)
1082 goto error_return;
1083 free_contents = contents;
1084
1085 if (! bfd_get_section_contents (abfd, sec, contents,
1086 (file_ptr) 0, sec->_raw_size))
1087 goto error_return;
1088 }
1089 }
1090
1091 /* The r_addend field of the R_SH_USES reloc will point us to
1092 the register load. The 4 is because the r_addend field is
1093 computed as though it were a jump offset, which are based
1094 from 4 bytes after the jump instruction. */
1095 laddr = irel->r_offset + 4 + irel->r_addend;
1096 if (laddr >= sec->_raw_size)
1097 {
1098 (*_bfd_error_handler) (_("%s: 0x%lx: warning: bad R_SH_USES offset"),
1099 bfd_get_filename (abfd),
1100 (unsigned long) irel->r_offset);
1101 continue;
1102 }
1103 insn = bfd_get_16 (abfd, contents + laddr);
1104
1105 /* If the instruction is not mov.l NN,rN, we don't know what to
1106 do. */
1107 if ((insn & 0xf000) != 0xd000)
1108 {
1109 ((*_bfd_error_handler)
1110 (_("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
1111 bfd_get_filename (abfd), (unsigned long) irel->r_offset, insn));
1112 continue;
1113 }
1114
1115 /* Get the address from which the register is being loaded. The
1116 displacement in the mov.l instruction is quadrupled. It is a
1117 displacement from four bytes after the movl instruction, but,
1118 before adding in the PC address, two least significant bits
1119 of the PC are cleared. We assume that the section is aligned
1120 on a four byte boundary. */
1121 paddr = insn & 0xff;
1122 paddr *= 4;
1123 paddr += (laddr + 4) & ~3;
1124 if (paddr >= sec->_raw_size)
1125 {
1126 ((*_bfd_error_handler)
1127 (_("%s: 0x%lx: warning: bad R_SH_USES load offset"),
1128 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
1129 continue;
1130 }
1131
1132 /* Get the reloc for the address from which the register is
1133 being loaded. This reloc will tell us which function is
1134 actually being called. */
1135 for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
1136 if (irelfn->r_offset == paddr
1137 && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
1138 break;
1139 if (irelfn >= irelend)
1140 {
1141 ((*_bfd_error_handler)
1142 (_("%s: 0x%lx: warning: could not find expected reloc"),
1143 bfd_get_filename (abfd), (unsigned long) paddr));
1144 continue;
1145 }
1146
1147 /* Read this BFD's symbols if we haven't done so already. */
1148 if (extsyms == NULL)
1149 {
1150 if (symtab_hdr->contents != NULL)
1151 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1152 else
1153 {
1154 extsyms = ((Elf32_External_Sym *)
1155 bfd_malloc (symtab_hdr->sh_size));
1156 if (extsyms == NULL)
1157 goto error_return;
1158 free_extsyms = extsyms;
1159 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1160 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1161 != symtab_hdr->sh_size))
1162 goto error_return;
1163 }
1164 }
1165
1166 /* Get the value of the symbol referred to by the reloc. */
1167 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
1168 {
1169 Elf_Internal_Sym isym;
1170
1171 /* A local symbol. */
1172 bfd_elf32_swap_symbol_in (abfd,
1173 extsyms + ELF32_R_SYM (irelfn->r_info),
1174 &isym);
1175
1176 if (isym.st_shndx != _bfd_elf_section_from_bfd_section (abfd, sec))
1177 {
1178 ((*_bfd_error_handler)
1179 (_("%s: 0x%lx: warning: symbol in unexpected section"),
1180 bfd_get_filename (abfd), (unsigned long) paddr));
1181 continue;
1182 }
1183
1184 symval = (isym.st_value
1185 + sec->output_section->vma
1186 + sec->output_offset);
1187 }
1188 else
1189 {
1190 unsigned long indx;
1191 struct elf_link_hash_entry *h;
1192
1193 indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
1194 h = elf_sym_hashes (abfd)[indx];
1195 BFD_ASSERT (h != NULL);
1196 if (h->root.type != bfd_link_hash_defined
1197 && h->root.type != bfd_link_hash_defweak)
1198 {
1199 /* This appears to be a reference to an undefined
1200 symbol. Just ignore it--it will be caught by the
1201 regular reloc processing. */
1202 continue;
1203 }
1204
1205 symval = (h->root.u.def.value
1206 + h->root.u.def.section->output_section->vma
1207 + h->root.u.def.section->output_offset);
1208 }
1209
1210 symval += bfd_get_32 (abfd, contents + paddr);
1211
1212 /* See if this function call can be shortened. */
1213 foff = (symval
1214 - (irel->r_offset
1215 + sec->output_section->vma
1216 + sec->output_offset
1217 + 4));
1218 if (foff < -0x1000 || foff >= 0x1000)
1219 {
1220 /* After all that work, we can't shorten this function call. */
1221 continue;
1222 }
1223
1224 /* Shorten the function call. */
1225
1226 /* For simplicity of coding, we are going to modify the section
1227 contents, the section relocs, and the BFD symbol table. We
1228 must tell the rest of the code not to free up this
1229 information. It would be possible to instead create a table
1230 of changes which have to be made, as is done in coff-mips.c;
1231 that would be more work, but would require less memory when
1232 the linker is run. */
1233
1234 elf_section_data (sec)->relocs = internal_relocs;
1235 free_relocs = NULL;
1236
1237 elf_section_data (sec)->this_hdr.contents = contents;
1238 free_contents = NULL;
1239
1240 symtab_hdr->contents = (bfd_byte *) extsyms;
1241 free_extsyms = NULL;
1242
1243 /* Replace the jsr with a bsr. */
1244
1245 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
1246 replace the jsr with a bsr. */
1247 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
1248 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
1249 {
1250 /* If this needs to be changed because of future relaxing,
1251 it will be handled here like other internal IND12W
1252 relocs. */
1253 bfd_put_16 (abfd,
1254 0xb000 | ((foff >> 1) & 0xfff),
1255 contents + irel->r_offset);
1256 }
1257 else
1258 {
1259 /* We can't fully resolve this yet, because the external
1260 symbol value may be changed by future relaxing. We let
1261 the final link phase handle it. */
1262 bfd_put_16 (abfd, 0xb000, contents + irel->r_offset);
1263 }
1264
1265 /* See if there is another R_SH_USES reloc referring to the same
1266 register load. */
1267 for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
1268 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
1269 && laddr == irelscan->r_offset + 4 + irelscan->r_addend)
1270 break;
1271 if (irelscan < irelend)
1272 {
1273 /* Some other function call depends upon this register load,
1274 and we have not yet converted that function call.
1275 Indeed, we may never be able to convert it. There is
1276 nothing else we can do at this point. */
1277 continue;
1278 }
1279
1280 /* Look for a R_SH_COUNT reloc on the location where the
1281 function address is stored. Do this before deleting any
1282 bytes, to avoid confusion about the address. */
1283 for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
1284 if (irelcount->r_offset == paddr
1285 && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
1286 break;
1287
1288 /* Delete the register load. */
1289 if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
1290 goto error_return;
1291
1292 /* That will change things, so, just in case it permits some
1293 other function call to come within range, we should relax
1294 again. Note that this is not required, and it may be slow. */
1295 *again = true;
1296
1297 /* Now check whether we got a COUNT reloc. */
1298 if (irelcount >= irelend)
1299 {
1300 ((*_bfd_error_handler)
1301 (_("%s: 0x%lx: warning: could not find expected COUNT reloc"),
1302 bfd_get_filename (abfd), (unsigned long) paddr));
1303 continue;
1304 }
1305
1306 /* The number of uses is stored in the r_addend field. We've
1307 just deleted one. */
1308 if (irelcount->r_addend == 0)
1309 {
1310 ((*_bfd_error_handler) (_("%s: 0x%lx: warning: bad count"),
1311 bfd_get_filename (abfd),
1312 (unsigned long) paddr));
1313 continue;
1314 }
1315
1316 --irelcount->r_addend;
1317
1318 /* If there are no more uses, we can delete the address. Reload
1319 the address from irelfn, in case it was changed by the
1320 previous call to sh_elf_relax_delete_bytes. */
1321 if (irelcount->r_addend == 0)
1322 {
1323 if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
1324 goto error_return;
1325 }
1326
1327 /* We've done all we can with that function call. */
1328 }
1329
1330 /* Look for load and store instructions that we can align on four
1331 byte boundaries. */
1332 if (have_code)
1333 {
1334 boolean swapped;
1335
1336 /* Get the section contents. */
1337 if (contents == NULL)
1338 {
1339 if (elf_section_data (sec)->this_hdr.contents != NULL)
1340 contents = elf_section_data (sec)->this_hdr.contents;
1341 else
1342 {
1343 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1344 if (contents == NULL)
1345 goto error_return;
1346 free_contents = contents;
1347
1348 if (! bfd_get_section_contents (abfd, sec, contents,
1349 (file_ptr) 0, sec->_raw_size))
1350 goto error_return;
1351 }
1352 }
1353
1354 if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
1355 &swapped))
1356 goto error_return;
1357
1358 if (swapped)
1359 {
1360 elf_section_data (sec)->relocs = internal_relocs;
1361 free_relocs = NULL;
1362
1363 elf_section_data (sec)->this_hdr.contents = contents;
1364 free_contents = NULL;
1365
1366 symtab_hdr->contents = (bfd_byte *) extsyms;
1367 free_extsyms = NULL;
1368 }
1369 }
1370
1371 if (free_relocs != NULL)
1372 {
1373 free (free_relocs);
1374 free_relocs = NULL;
1375 }
1376
1377 if (free_contents != NULL)
1378 {
1379 if (! link_info->keep_memory)
1380 free (free_contents);
1381 else
1382 {
1383 /* Cache the section contents for elf_link_input_bfd. */
1384 elf_section_data (sec)->this_hdr.contents = contents;
1385 }
1386 free_contents = NULL;
1387 }
1388
1389 if (free_extsyms != NULL)
1390 {
1391 if (! link_info->keep_memory)
1392 free (free_extsyms);
1393 else
1394 {
1395 /* Cache the symbols for elf_link_input_bfd. */
1396 symtab_hdr->contents = extsyms;
1397 }
1398 free_extsyms = NULL;
1399 }
1400
1401 return true;
1402
1403 error_return:
1404 if (free_relocs != NULL)
1405 free (free_relocs);
1406 if (free_contents != NULL)
1407 free (free_contents);
1408 if (free_extsyms != NULL)
1409 free (free_extsyms);
1410 return false;
1411 }
1412
1413 /* Delete some bytes from a section while relaxing. FIXME: There is a
1414 lot of duplication between this function and sh_relax_delete_bytes
1415 in coff-sh.c. */
1416
1417 static boolean
1418 sh_elf_relax_delete_bytes (abfd, sec, addr, count)
1419 bfd *abfd;
1420 asection *sec;
1421 bfd_vma addr;
1422 int count;
1423 {
1424 Elf_Internal_Shdr *symtab_hdr;
1425 Elf32_External_Sym *extsyms;
1426 int shndx, index;
1427 bfd_byte *contents;
1428 Elf_Internal_Rela *irel, *irelend;
1429 Elf_Internal_Rela *irelalign;
1430 bfd_vma toaddr;
1431 Elf32_External_Sym *esym, *esymend;
1432 struct elf_link_hash_entry *sym_hash;
1433 asection *o;
1434
1435 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1436 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1437
1438 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1439
1440 contents = elf_section_data (sec)->this_hdr.contents;
1441
1442 /* The deletion must stop at the next ALIGN reloc for an aligment
1443 power larger than the number of bytes we are deleting. */
1444
1445 irelalign = NULL;
1446 toaddr = sec->_cooked_size;
1447
1448 irel = elf_section_data (sec)->relocs;
1449 irelend = irel + sec->reloc_count;
1450 for (; irel < irelend; irel++)
1451 {
1452 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
1453 && irel->r_offset > addr
1454 && count < (1 << irel->r_addend))
1455 {
1456 irelalign = irel;
1457 toaddr = irel->r_offset;
1458 break;
1459 }
1460 }
1461
1462 /* Actually delete the bytes. */
1463 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
1464 if (irelalign == NULL)
1465 sec->_cooked_size -= count;
1466 else
1467 {
1468 int i;
1469
1470 #define NOP_OPCODE (0x0009)
1471
1472 BFD_ASSERT ((count & 1) == 0);
1473 for (i = 0; i < count; i += 2)
1474 bfd_put_16 (abfd, NOP_OPCODE, contents + toaddr - count + i);
1475 }
1476
1477 /* Adjust all the relocs. */
1478 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1479 {
1480 bfd_vma nraddr, stop;
1481 bfd_vma start = 0;
1482 int insn = 0;
1483 Elf_Internal_Sym sym;
1484 int off, adjust, oinsn;
1485 bfd_signed_vma voff = 0;
1486 boolean overflow;
1487
1488 /* Get the new reloc address. */
1489 nraddr = irel->r_offset;
1490 if ((irel->r_offset > addr
1491 && irel->r_offset < toaddr)
1492 || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
1493 && irel->r_offset == toaddr))
1494 nraddr -= count;
1495
1496 /* See if this reloc was for the bytes we have deleted, in which
1497 case we no longer care about it. Don't delete relocs which
1498 represent addresses, though. */
1499 if (irel->r_offset >= addr
1500 && irel->r_offset < addr + count
1501 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
1502 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
1503 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
1504 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
1505 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1506 (int) R_SH_NONE);
1507
1508 /* If this is a PC relative reloc, see if the range it covers
1509 includes the bytes we have deleted. */
1510 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1511 {
1512 default:
1513 break;
1514
1515 case R_SH_DIR8WPN:
1516 case R_SH_IND12W:
1517 case R_SH_DIR8WPZ:
1518 case R_SH_DIR8WPL:
1519 start = irel->r_offset;
1520 insn = bfd_get_16 (abfd, contents + nraddr);
1521 break;
1522 }
1523
1524 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1525 {
1526 default:
1527 start = stop = addr;
1528 break;
1529
1530 case R_SH_DIR32:
1531 /* If this reloc is against a symbol defined in this
1532 section, and the symbol will not be adjusted below, we
1533 must check the addend to see it will put the value in
1534 range to be adjusted, and hence must be changed. */
1535 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1536 {
1537 bfd_elf32_swap_symbol_in (abfd,
1538 extsyms + ELF32_R_SYM (irel->r_info),
1539 &sym);
1540 if (sym.st_shndx == shndx
1541 && (sym.st_value <= addr
1542 || sym.st_value >= toaddr))
1543 {
1544 bfd_vma val;
1545
1546 val = bfd_get_32 (abfd, contents + nraddr);
1547 val += sym.st_value;
1548 if (val > addr && val < toaddr)
1549 bfd_put_32 (abfd, val - count, contents + nraddr);
1550 }
1551 }
1552 start = stop = addr;
1553 break;
1554
1555 case R_SH_DIR8WPN:
1556 off = insn & 0xff;
1557 if (off & 0x80)
1558 off -= 0x100;
1559 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1560 break;
1561
1562 case R_SH_IND12W:
1563 if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
1564 start = stop = addr;
1565 else
1566 {
1567 off = insn & 0xfff;
1568 if (off & 0x800)
1569 off -= 0x1000;
1570 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1571 }
1572 break;
1573
1574 case R_SH_DIR8WPZ:
1575 off = insn & 0xff;
1576 stop = start + 4 + off * 2;
1577 break;
1578
1579 case R_SH_DIR8WPL:
1580 off = insn & 0xff;
1581 stop = (start & ~(bfd_vma) 3) + 4 + off * 4;
1582 break;
1583
1584 case R_SH_SWITCH8:
1585 case R_SH_SWITCH16:
1586 case R_SH_SWITCH32:
1587 /* These relocs types represent
1588 .word L2-L1
1589 The r_addend field holds the difference between the reloc
1590 address and L1. That is the start of the reloc, and
1591 adding in the contents gives us the top. We must adjust
1592 both the r_offset field and the section contents.
1593 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1594 and the elf bfd r_offset is called r_vaddr. */
1595
1596 stop = irel->r_offset;
1597 start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
1598
1599 if (start > addr
1600 && start < toaddr
1601 && (stop <= addr || stop >= toaddr))
1602 irel->r_addend += count;
1603 else if (stop > addr
1604 && stop < toaddr
1605 && (start <= addr || start >= toaddr))
1606 irel->r_addend -= count;
1607
1608 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
1609 voff = bfd_get_signed_16 (abfd, contents + nraddr);
1610 else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
1611 voff = bfd_get_8 (abfd, contents + nraddr);
1612 else
1613 voff = bfd_get_signed_32 (abfd, contents + nraddr);
1614 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1615
1616 break;
1617
1618 case R_SH_USES:
1619 start = irel->r_offset;
1620 stop = (bfd_vma) ((bfd_signed_vma) start
1621 + (long) irel->r_addend
1622 + 4);
1623 break;
1624 }
1625
1626 if (start > addr
1627 && start < toaddr
1628 && (stop <= addr || stop >= toaddr))
1629 adjust = count;
1630 else if (stop > addr
1631 && stop < toaddr
1632 && (start <= addr || start >= toaddr))
1633 adjust = - count;
1634 else
1635 adjust = 0;
1636
1637 if (adjust != 0)
1638 {
1639 oinsn = insn;
1640 overflow = false;
1641 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1642 {
1643 default:
1644 abort ();
1645 break;
1646
1647 case R_SH_DIR8WPN:
1648 case R_SH_DIR8WPZ:
1649 insn += adjust / 2;
1650 if ((oinsn & 0xff00) != (insn & 0xff00))
1651 overflow = true;
1652 bfd_put_16 (abfd, insn, contents + nraddr);
1653 break;
1654
1655 case R_SH_IND12W:
1656 insn += adjust / 2;
1657 if ((oinsn & 0xf000) != (insn & 0xf000))
1658 overflow = true;
1659 bfd_put_16 (abfd, insn, contents + nraddr);
1660 break;
1661
1662 case R_SH_DIR8WPL:
1663 BFD_ASSERT (adjust == count || count >= 4);
1664 if (count >= 4)
1665 insn += adjust / 4;
1666 else
1667 {
1668 if ((irel->r_offset & 3) == 0)
1669 ++insn;
1670 }
1671 if ((oinsn & 0xff00) != (insn & 0xff00))
1672 overflow = true;
1673 bfd_put_16 (abfd, insn, contents + nraddr);
1674 break;
1675
1676 case R_SH_SWITCH8:
1677 voff += adjust;
1678 if (voff < 0 || voff >= 0xff)
1679 overflow = true;
1680 bfd_put_8 (abfd, voff, contents + nraddr);
1681 break;
1682
1683 case R_SH_SWITCH16:
1684 voff += adjust;
1685 if (voff < - 0x8000 || voff >= 0x8000)
1686 overflow = true;
1687 bfd_put_signed_16 (abfd, voff, contents + nraddr);
1688 break;
1689
1690 case R_SH_SWITCH32:
1691 voff += adjust;
1692 bfd_put_signed_32 (abfd, voff, contents + nraddr);
1693 break;
1694
1695 case R_SH_USES:
1696 irel->r_addend += adjust;
1697 break;
1698 }
1699
1700 if (overflow)
1701 {
1702 ((*_bfd_error_handler)
1703 (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
1704 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
1705 bfd_set_error (bfd_error_bad_value);
1706 return false;
1707 }
1708 }
1709
1710 irel->r_offset = nraddr;
1711 }
1712
1713 /* Look through all the other sections. If there contain any IMM32
1714 relocs against internal symbols which we are not going to adjust
1715 below, we may need to adjust the addends. */
1716 for (o = abfd->sections; o != NULL; o = o->next)
1717 {
1718 Elf_Internal_Rela *internal_relocs;
1719 Elf_Internal_Rela *irelscan, *irelscanend;
1720 bfd_byte *ocontents;
1721
1722 if (o == sec
1723 || (o->flags & SEC_RELOC) == 0
1724 || o->reloc_count == 0)
1725 continue;
1726
1727 /* We always cache the relocs. Perhaps, if info->keep_memory is
1728 false, we should free them, if we are permitted to, when we
1729 leave sh_coff_relax_section. */
1730 internal_relocs = (_bfd_elf32_link_read_relocs
1731 (abfd, o, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1732 true));
1733 if (internal_relocs == NULL)
1734 return false;
1735
1736 ocontents = NULL;
1737 irelscanend = internal_relocs + o->reloc_count;
1738 for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1739 {
1740 Elf_Internal_Sym sym;
1741
1742 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1743 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
1744 {
1745 bfd_vma start, stop;
1746 bfd_signed_vma voff;
1747
1748 if (ocontents == NULL)
1749 {
1750 if (elf_section_data (o)->this_hdr.contents != NULL)
1751 ocontents = elf_section_data (o)->this_hdr.contents;
1752 else
1753 {
1754 /* We always cache the section contents.
1755 Perhaps, if info->keep_memory is false, we
1756 should free them, if we are permitted to,
1757 when we leave sh_coff_relax_section. */
1758 ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
1759 if (ocontents == NULL)
1760 return false;
1761 if (! bfd_get_section_contents (abfd, o, ocontents,
1762 (file_ptr) 0,
1763 o->_raw_size))
1764 return false;
1765 elf_section_data (o)->this_hdr.contents = ocontents;
1766 }
1767 }
1768
1769 stop = irelscan->r_offset;
1770 start
1771 = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
1772
1773 /* STOP is in a different section, so it won't change. */
1774 if (start > addr && start < toaddr)
1775 irelscan->r_addend += count;
1776
1777 voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
1778 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1779
1780 if (start > addr
1781 && start < toaddr
1782 && (stop <= addr || stop >= toaddr))
1783 bfd_put_signed_32 (abfd, voff + count,
1784 ocontents + irelscan->r_offset);
1785 else if (stop > addr
1786 && stop < toaddr
1787 && (start <= addr || start >= toaddr))
1788 bfd_put_signed_32 (abfd, voff - count,
1789 ocontents + irelscan->r_offset);
1790 }
1791
1792 if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
1793 continue;
1794
1795 if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
1796 continue;
1797
1798 bfd_elf32_swap_symbol_in (abfd,
1799 extsyms + ELF32_R_SYM (irelscan->r_info),
1800 &sym);
1801
1802 if (sym.st_shndx == shndx
1803 && (sym.st_value <= addr
1804 || sym.st_value >= toaddr))
1805 {
1806 bfd_vma val;
1807
1808 if (ocontents == NULL)
1809 {
1810 if (elf_section_data (o)->this_hdr.contents != NULL)
1811 ocontents = elf_section_data (o)->this_hdr.contents;
1812 else
1813 {
1814 /* We always cache the section contents.
1815 Perhaps, if info->keep_memory is false, we
1816 should free them, if we are permitted to,
1817 when we leave sh_coff_relax_section. */
1818 ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
1819 if (ocontents == NULL)
1820 return false;
1821 if (! bfd_get_section_contents (abfd, o, ocontents,
1822 (file_ptr) 0,
1823 o->_raw_size))
1824 return false;
1825 elf_section_data (o)->this_hdr.contents = ocontents;
1826 }
1827 }
1828
1829 val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
1830 val += sym.st_value;
1831 if (val > addr && val < toaddr)
1832 bfd_put_32 (abfd, val - count,
1833 ocontents + irelscan->r_offset);
1834 }
1835 }
1836 }
1837
1838 /* Adjust the local symbols defined in this section. */
1839 esym = extsyms;
1840 esymend = esym + symtab_hdr->sh_info;
1841 for (; esym < esymend; esym++)
1842 {
1843 Elf_Internal_Sym isym;
1844
1845 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1846
1847 if (isym.st_shndx == shndx
1848 && isym.st_value > addr
1849 && isym.st_value < toaddr)
1850 {
1851 isym.st_value -= count;
1852 bfd_elf32_swap_symbol_out (abfd, &isym, esym);
1853 }
1854 }
1855
1856 /* Now adjust the global symbols defined in this section. */
1857 esym = extsyms + symtab_hdr->sh_info;
1858 esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
1859 for (index = 0; esym < esymend; esym++, index++)
1860 {
1861 Elf_Internal_Sym isym;
1862
1863 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1864 sym_hash = elf_sym_hashes (abfd)[index];
1865 if (isym.st_shndx == shndx
1866 && ((sym_hash)->root.type == bfd_link_hash_defined
1867 || (sym_hash)->root.type == bfd_link_hash_defweak)
1868 && (sym_hash)->root.u.def.section == sec
1869 && (sym_hash)->root.u.def.value > addr
1870 && (sym_hash)->root.u.def.value < toaddr)
1871 {
1872 (sym_hash)->root.u.def.value -= count;
1873 }
1874 }
1875
1876 /* See if we can move the ALIGN reloc forward. We have adjusted
1877 r_offset for it already. */
1878 if (irelalign != NULL)
1879 {
1880 bfd_vma alignto, alignaddr;
1881
1882 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
1883 alignaddr = BFD_ALIGN (irelalign->r_offset,
1884 1 << irelalign->r_addend);
1885 if (alignto != alignaddr)
1886 {
1887 /* Tail recursion. */
1888 return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
1889 alignto - alignaddr);
1890 }
1891 }
1892
1893 return true;
1894 }
1895
1896 /* Look for loads and stores which we can align to four byte
1897 boundaries. This is like sh_align_loads in coff-sh.c. */
1898
1899 static boolean
1900 sh_elf_align_loads (abfd, sec, internal_relocs, contents, pswapped)
1901 bfd *abfd;
1902 asection *sec;
1903 Elf_Internal_Rela *internal_relocs;
1904 bfd_byte *contents;
1905 boolean *pswapped;
1906 {
1907 Elf_Internal_Rela *irel, *irelend;
1908 bfd_vma *labels = NULL;
1909 bfd_vma *label, *label_end;
1910
1911 *pswapped = false;
1912
1913 irelend = internal_relocs + sec->reloc_count;
1914
1915 /* Get all the addresses with labels on them. */
1916 labels = (bfd_vma *) bfd_malloc (sec->reloc_count * sizeof (bfd_vma));
1917 if (labels == NULL)
1918 goto error_return;
1919 label_end = labels;
1920 for (irel = internal_relocs; irel < irelend; irel++)
1921 {
1922 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
1923 {
1924 *label_end = irel->r_offset;
1925 ++label_end;
1926 }
1927 }
1928
1929 /* Note that the assembler currently always outputs relocs in
1930 address order. If that ever changes, this code will need to sort
1931 the label values and the relocs. */
1932
1933 label = labels;
1934
1935 for (irel = internal_relocs; irel < irelend; irel++)
1936 {
1937 bfd_vma start, stop;
1938
1939 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
1940 continue;
1941
1942 start = irel->r_offset;
1943
1944 for (irel++; irel < irelend; irel++)
1945 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
1946 break;
1947 if (irel < irelend)
1948 stop = irel->r_offset;
1949 else
1950 stop = sec->_cooked_size;
1951
1952 if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
1953 (PTR) internal_relocs, &label,
1954 label_end, start, stop, pswapped))
1955 goto error_return;
1956 }
1957
1958 free (labels);
1959
1960 return true;
1961
1962 error_return:
1963 if (labels != NULL)
1964 free (labels);
1965 return false;
1966 }
1967
1968 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1969
1970 static boolean
1971 sh_elf_swap_insns (abfd, sec, relocs, contents, addr)
1972 bfd *abfd;
1973 asection *sec;
1974 PTR relocs;
1975 bfd_byte *contents;
1976 bfd_vma addr;
1977 {
1978 Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
1979 unsigned short i1, i2;
1980 Elf_Internal_Rela *irel, *irelend;
1981
1982 /* Swap the instructions themselves. */
1983 i1 = bfd_get_16 (abfd, contents + addr);
1984 i2 = bfd_get_16 (abfd, contents + addr + 2);
1985 bfd_put_16 (abfd, i2, contents + addr);
1986 bfd_put_16 (abfd, i1, contents + addr + 2);
1987
1988 /* Adjust all reloc addresses. */
1989 irelend = internal_relocs + sec->reloc_count;
1990 for (irel = internal_relocs; irel < irelend; irel++)
1991 {
1992 enum elf_sh_reloc_type type;
1993 int add;
1994
1995 /* There are a few special types of relocs that we don't want to
1996 adjust. These relocs do not apply to the instruction itself,
1997 but are only associated with the address. */
1998 type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
1999 if (type == R_SH_ALIGN
2000 || type == R_SH_CODE
2001 || type == R_SH_DATA
2002 || type == R_SH_LABEL)
2003 continue;
2004
2005 /* If an R_SH_USES reloc points to one of the addresses being
2006 swapped, we must adjust it. It would be incorrect to do this
2007 for a jump, though, since we want to execute both
2008 instructions after the jump. (We have avoided swapping
2009 around a label, so the jump will not wind up executing an
2010 instruction it shouldn't). */
2011 if (type == R_SH_USES)
2012 {
2013 bfd_vma off;
2014
2015 off = irel->r_offset + 4 + irel->r_addend;
2016 if (off == addr)
2017 irel->r_offset += 2;
2018 else if (off == addr + 2)
2019 irel->r_offset -= 2;
2020 }
2021
2022 if (irel->r_offset == addr)
2023 {
2024 irel->r_offset += 2;
2025 add = -2;
2026 }
2027 else if (irel->r_offset == addr + 2)
2028 {
2029 irel->r_offset -= 2;
2030 add = 2;
2031 }
2032 else
2033 add = 0;
2034
2035 if (add != 0)
2036 {
2037 bfd_byte *loc;
2038 unsigned short insn, oinsn;
2039 boolean overflow;
2040
2041 loc = contents + irel->r_offset;
2042 overflow = false;
2043 switch (type)
2044 {
2045 default:
2046 break;
2047
2048 case R_SH_DIR8WPN:
2049 case R_SH_DIR8WPZ:
2050 insn = bfd_get_16 (abfd, loc);
2051 oinsn = insn;
2052 insn += add / 2;
2053 if ((oinsn & 0xff00) != (insn & 0xff00))
2054 overflow = true;
2055 bfd_put_16 (abfd, insn, loc);
2056 break;
2057
2058 case R_SH_IND12W:
2059 insn = bfd_get_16 (abfd, loc);
2060 oinsn = insn;
2061 insn += add / 2;
2062 if ((oinsn & 0xf000) != (insn & 0xf000))
2063 overflow = true;
2064 bfd_put_16 (abfd, insn, loc);
2065 break;
2066
2067 case R_SH_DIR8WPL:
2068 /* This reloc ignores the least significant 3 bits of
2069 the program counter before adding in the offset.
2070 This means that if ADDR is at an even address, the
2071 swap will not affect the offset. If ADDR is an at an
2072 odd address, then the instruction will be crossing a
2073 four byte boundary, and must be adjusted. */
2074 if ((addr & 3) != 0)
2075 {
2076 insn = bfd_get_16 (abfd, loc);
2077 oinsn = insn;
2078 insn += add / 2;
2079 if ((oinsn & 0xff00) != (insn & 0xff00))
2080 overflow = true;
2081 bfd_put_16 (abfd, insn, loc);
2082 }
2083
2084 break;
2085 }
2086
2087 if (overflow)
2088 {
2089 ((*_bfd_error_handler)
2090 (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
2091 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
2092 bfd_set_error (bfd_error_bad_value);
2093 return false;
2094 }
2095 }
2096 }
2097
2098 return true;
2099 }
2100 \f
2101 /* The size in bytes of an entry in the procedure linkage table. */
2102
2103 #define PLT_ENTRY_SIZE 28
2104
2105 /* First entry in an absolute procedure linkage table look like this. */
2106
2107 #if 1
2108 /* Note - this code has been "optimised" not to use r2. r2 is used by
2109 GCC to return the address of large strutcures, so it should not be
2110 corrupted here. This does mean however, that this PLT does not conform
2111 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
2112 and r2 contains the GOT id. This version stores the GOT id in r0 and
2113 ignores the type. Loaders can easily detect this difference however,
2114 since the type will always be 0 or 8, and the GOT ids will always be
2115 greater than or equal to 12. */
2116 static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
2117 {
2118 0xd0, 0x05, /* mov.l 2f,r0 */
2119 0x60, 0x02, /* mov.l @r0,r0 */
2120 0x2f, 0x06, /* mov.l r0,@-r15 */
2121 0xd0, 0x03, /* mov.l 1f,r0 */
2122 0x60, 0x02, /* mov.l @r0,r0 */
2123 0x40, 0x2b, /* jmp @r0 */
2124 0x60, 0xf6, /* mov.l @r15+,r0 */
2125 0x00, 0x09, /* nop */
2126 0x00, 0x09, /* nop */
2127 0x00, 0x09, /* nop */
2128 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
2129 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
2130 };
2131
2132 static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
2133 {
2134 0x05, 0xd0, /* mov.l 2f,r0 */
2135 0x02, 0x60, /* mov.l @r0,r0 */
2136 0x06, 0x2f, /* mov.l r0,@-r15 */
2137 0x03, 0xd0, /* mov.l 1f,r0 */
2138 0x02, 0x60, /* mov.l @r0,r0 */
2139 0x2b, 0x40, /* jmp @r0 */
2140 0xf6, 0x60, /* mov.l @r15+,r0 */
2141 0x09, 0x00, /* nop */
2142 0x09, 0x00, /* nop */
2143 0x09, 0x00, /* nop */
2144 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
2145 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
2146 };
2147
2148 /* Sebsequent entries in an absolute procedure linkage table look like
2149 this. */
2150
2151 static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
2152 {
2153 0xd0, 0x04, /* mov.l 1f,r0 */
2154 0x60, 0x02, /* mov.l @r0,r0 */
2155 0xd1, 0x02, /* mov.l 0f,r1 */
2156 0x40, 0x2b, /* jmp @r0 */
2157 0x60, 0x13, /* mov r1,r0 */
2158 0xd1, 0x03, /* mov.l 2f,r1 */
2159 0x40, 0x2b, /* jmp @r0 */
2160 0x00, 0x09, /* nop */
2161 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
2162 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2163 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
2164 };
2165
2166 static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
2167 {
2168 0x04, 0xd0, /* mov.l 1f,r0 */
2169 0x02, 0x60, /* mov.l @r0,r0 */
2170 0x02, 0xd1, /* mov.l 0f,r1 */
2171 0x2b, 0x40, /* jmp @r0 */
2172 0x13, 0x60, /* mov r1,r0 */
2173 0x03, 0xd1, /* mov.l 2f,r1 */
2174 0x2b, 0x40, /* jmp @r0 */
2175 0x09, 0x00, /* nop */
2176 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
2177 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2178 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
2179 };
2180
2181 /* Entries in a PIC procedure linkage table look like this. */
2182
2183 static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
2184 {
2185 0xd0, 0x04, /* mov.l 1f,r0 */
2186 0x00, 0xce, /* mov.l @(r0,r12),r0 */
2187 0x40, 0x2b, /* jmp @r0 */
2188 0x00, 0x09, /* nop */
2189 0x50, 0xc2, /* mov.l @(8,r12),r0 */
2190 0xd1, 0x03, /* mov.l 2f,r1 */
2191 0x40, 0x2b, /* jmp @r0 */
2192 0x50, 0xc1, /* mov.l @(4,r12),r0 */
2193 0x00, 0x09, /* nop */
2194 0x00, 0x09, /* nop */
2195 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2196 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
2197 };
2198
2199 static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
2200 {
2201 0x04, 0xd0, /* mov.l 1f,r0 */
2202 0xce, 0x00, /* mov.l @(r0,r12),r0 */
2203 0x2b, 0x40, /* jmp @r0 */
2204 0x09, 0x00, /* nop */
2205 0xc2, 0x50, /* mov.l @(8,r12),r0 */
2206 0x03, 0xd1, /* mov.l 2f,r1 */
2207 0x2b, 0x40, /* jmp @r0 */
2208 0xc1, 0x50, /* mov.l @(4,r12),r0 */
2209 0x09, 0x00, /* nop */
2210 0x09, 0x00, /* nop */
2211 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2212 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
2213 };
2214
2215 #else /* These are the old style PLT entries. */
2216 static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
2217 {
2218 0xd0, 0x04, /* mov.l 1f,r0 */
2219 0xd2, 0x05, /* mov.l 2f,r2 */
2220 0x60, 0x02, /* mov.l @r0,r0 */
2221 0x62, 0x22, /* mov.l @r2,r2 */
2222 0x40, 0x2b, /* jmp @r0 */
2223 0xe0, 0x00, /* mov #0,r0 */
2224 0x00, 0x09, /* nop */
2225 0x00, 0x09, /* nop */
2226 0x00, 0x09, /* nop */
2227 0x00, 0x09, /* nop */
2228 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
2229 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
2230 };
2231
2232 static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
2233 {
2234 0x04, 0xd0, /* mov.l 1f,r0 */
2235 0x05, 0xd2, /* mov.l 2f,r2 */
2236 0x02, 0x60, /* mov.l @r0,r0 */
2237 0x22, 0x62, /* mov.l @r2,r2 */
2238 0x2b, 0x40, /* jmp @r0 */
2239 0x00, 0xe0, /* mov #0,r0 */
2240 0x09, 0x00, /* nop */
2241 0x09, 0x00, /* nop */
2242 0x09, 0x00, /* nop */
2243 0x09, 0x00, /* nop */
2244 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
2245 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
2246 };
2247
2248 /* Sebsequent entries in an absolute procedure linkage table look like
2249 this. */
2250
2251 static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
2252 {
2253 0xd0, 0x04, /* mov.l 1f,r0 */
2254 0x60, 0x02, /* mov.l @r0,r0 */
2255 0xd2, 0x02, /* mov.l 0f,r2 */
2256 0x40, 0x2b, /* jmp @r0 */
2257 0x60, 0x23, /* mov r2,r0 */
2258 0xd1, 0x03, /* mov.l 2f,r1 */
2259 0x40, 0x2b, /* jmp @r0 */
2260 0x00, 0x09, /* nop */
2261 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
2262 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2263 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
2264 };
2265
2266 static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
2267 {
2268 0x04, 0xd0, /* mov.l 1f,r0 */
2269 0x02, 0x60, /* mov.l @r0,r0 */
2270 0x02, 0xd2, /* mov.l 0f,r2 */
2271 0x2b, 0x40, /* jmp @r0 */
2272 0x23, 0x60, /* mov r2,r0 */
2273 0x03, 0xd1, /* mov.l 2f,r1 */
2274 0x2b, 0x40, /* jmp @r0 */
2275 0x09, 0x00, /* nop */
2276 0, 0, 0, 0, /* 0: replaced with address of .PLT. */
2277 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2278 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
2279 };
2280
2281 /* Entries in a PIC procedure linkage table look like this. */
2282
2283 static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
2284 {
2285 0xd0, 0x04, /* mov.l 1f,r0 */
2286 0x00, 0xce, /* mov.l @(r0,r12),r0 */
2287 0x40, 0x2b, /* jmp @r0 */
2288 0x00, 0x09, /* nop */
2289 0x50, 0xc2, /* 0: mov.l @(8,r12),r0 */
2290 0x52, 0xc1, /* 1: mov.l @(4,r12),r2 */
2291 0xd1, 0x02, /* mov.l 2f,r1 */
2292 0x40, 0x2b, /* jmp @r0 */
2293 0xe0, 0x00, /* mov #0,r0 ! shows the type of PLT. */
2294 0x00, 0x09, /* nop */
2295 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2296 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
2297 };
2298
2299 static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
2300 {
2301 0x04, 0xd0, /* mov.l 1f,r0 */
2302 0xce, 0x00, /* mov.l @(r0,r12),r0 */
2303 0x2b, 0x40, /* jmp @r0 */
2304 0x09, 0x00, /* nop */
2305 0xc2, 0x50, /* 0: mov.l @(8,r12),r0 */
2306 0xc1, 0x52, /* 1: mov.l @(4,r12),r2 */
2307 0x02, 0xd1, /* mov.l 2f,r1 */
2308 0x2b, 0x40, /* jmp @r0 */
2309 0x00, 0xe0, /* mov #0,r0 ! shows the type of PLT. */
2310 0x09, 0x00, /* nop */
2311 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2312 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
2313 };
2314 #endif /* old style PLT entries. */
2315
2316 static const bfd_byte *elf_sh_plt0_entry;
2317 static const bfd_byte *elf_sh_plt_entry;
2318 static const bfd_byte *elf_sh_pic_plt_entry;
2319
2320 /* Return size of a PLT entry. */
2321 #define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE
2322
2323 /* Return offset of the PLT0 address in an absolute PLT entry. */
2324 #define elf_sh_plt_plt0_offset(info) 16
2325
2326 /* Return offset of the linker in PLT0 entry. */
2327 #define elf_sh_plt0_linker_offset(info) 20
2328
2329 /* Return offset of the GOT id in PLT0 entry. */
2330 #define elf_sh_plt0_gotid_offset(info) 24
2331
2332 /* Return offset of the tempoline in PLT entry */
2333 #define elf_sh_plt_temp_offset(info) 8
2334
2335 /* Return offset of the symbol in PLT entry. */
2336 #define elf_sh_plt_symbol_offset(info) 20
2337
2338 /* Return offset of the relocation in PLT entry. */
2339 #define elf_sh_plt_reloc_offset(info) 24
2340
2341 /* The sh linker needs to keep track of the number of relocs that it
2342 decides to copy in check_relocs for each symbol. This is so that
2343 it can discard PC relative relocs if it doesn't need them when
2344 linking with -Bsymbolic. We store the information in a field
2345 extending the regular ELF linker hash table. */
2346
2347 /* This structure keeps track of the number of PC relative relocs we
2348 have copied for a given symbol. */
2349
2350 struct elf_sh_pcrel_relocs_copied
2351 {
2352 /* Next section. */
2353 struct elf_sh_pcrel_relocs_copied *next;
2354 /* A section in dynobj. */
2355 asection *section;
2356 /* Number of relocs copied in this section. */
2357 bfd_size_type count;
2358 };
2359
2360 /* sh ELF linker hash entry. */
2361
2362 struct elf_sh_link_hash_entry
2363 {
2364 struct elf_link_hash_entry root;
2365
2366 /* Number of PC relative relocs copied for this symbol. */
2367 struct elf_sh_pcrel_relocs_copied *pcrel_relocs_copied;
2368 };
2369
2370 /* sh ELF linker hash table. */
2371
2372 struct elf_sh_link_hash_table
2373 {
2374 struct elf_link_hash_table root;
2375 };
2376
2377 /* Declare this now that the above structures are defined. */
2378
2379 static boolean sh_elf_discard_copies
2380 PARAMS ((struct elf_sh_link_hash_entry *, PTR));
2381
2382 /* Traverse an sh ELF linker hash table. */
2383
2384 #define sh_elf_link_hash_traverse(table, func, info) \
2385 (elf_link_hash_traverse \
2386 (&(table)->root, \
2387 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
2388 (info)))
2389
2390 /* Get the sh ELF linker hash table from a link_info structure. */
2391
2392 #define sh_elf_hash_table(p) \
2393 ((struct elf_sh_link_hash_table *) ((p)->hash))
2394
2395 /* Create an entry in an sh ELF linker hash table. */
2396
2397 static struct bfd_hash_entry *
2398 sh_elf_link_hash_newfunc (entry, table, string)
2399 struct bfd_hash_entry *entry;
2400 struct bfd_hash_table *table;
2401 const char *string;
2402 {
2403 struct elf_sh_link_hash_entry *ret =
2404 (struct elf_sh_link_hash_entry *) entry;
2405
2406 /* Allocate the structure if it has not already been allocated by a
2407 subclass. */
2408 if (ret == (struct elf_sh_link_hash_entry *) NULL)
2409 ret = ((struct elf_sh_link_hash_entry *)
2410 bfd_hash_allocate (table,
2411 sizeof (struct elf_sh_link_hash_entry)));
2412 if (ret == (struct elf_sh_link_hash_entry *) NULL)
2413 return (struct bfd_hash_entry *) ret;
2414
2415 /* Call the allocation method of the superclass. */
2416 ret = ((struct elf_sh_link_hash_entry *)
2417 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2418 table, string));
2419 if (ret != (struct elf_sh_link_hash_entry *) NULL)
2420 {
2421 ret->pcrel_relocs_copied = NULL;
2422 }
2423
2424 return (struct bfd_hash_entry *) ret;
2425 }
2426
2427 /* Create an sh ELF linker hash table. */
2428
2429 static struct bfd_link_hash_table *
2430 sh_elf_link_hash_table_create (abfd)
2431 bfd *abfd;
2432 {
2433 struct elf_sh_link_hash_table *ret;
2434
2435 ret = ((struct elf_sh_link_hash_table *)
2436 bfd_alloc (abfd, sizeof (struct elf_sh_link_hash_table)));
2437 if (ret == (struct elf_sh_link_hash_table *) NULL)
2438 return NULL;
2439
2440 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
2441 sh_elf_link_hash_newfunc))
2442 {
2443 bfd_release (abfd, ret);
2444 return NULL;
2445 }
2446
2447 return &ret->root.root;
2448 }
2449
2450 /* Create dynamic sections when linking against a dynamic object. */
2451
2452 static boolean
2453 sh_elf_create_dynamic_sections (abfd, info)
2454 bfd *abfd;
2455 struct bfd_link_info *info;
2456 {
2457 flagword flags, pltflags;
2458 register asection *s;
2459 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2460 int ptralign = 0;
2461
2462 switch (bed->s->arch_size)
2463 {
2464 case 32:
2465 ptralign = 2;
2466 break;
2467
2468 case 64:
2469 ptralign = 3;
2470 break;
2471
2472 default:
2473 bfd_set_error (bfd_error_bad_value);
2474 return false;
2475 }
2476
2477 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2478 .rel[a].bss sections. */
2479
2480 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2481 | SEC_LINKER_CREATED);
2482
2483 pltflags = flags;
2484 pltflags |= SEC_CODE;
2485 if (bed->plt_not_loaded)
2486 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2487 if (bed->plt_readonly)
2488 pltflags |= SEC_READONLY;
2489
2490 s = bfd_make_section (abfd, ".plt");
2491 if (s == NULL
2492 || ! bfd_set_section_flags (abfd, s, pltflags)
2493 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2494 return false;
2495
2496 if (bed->want_plt_sym)
2497 {
2498 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2499 .plt section. */
2500 struct elf_link_hash_entry *h = NULL;
2501 if (! (_bfd_generic_link_add_one_symbol
2502 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2503 (bfd_vma) 0, (const char *) NULL, false,
2504 get_elf_backend_data (abfd)->collect,
2505 (struct bfd_link_hash_entry **) &h)))
2506 return false;
2507 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2508 h->type = STT_OBJECT;
2509
2510 if (info->shared
2511 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
2512 return false;
2513 }
2514
2515 s = bfd_make_section (abfd,
2516 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
2517 if (s == NULL
2518 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2519 || ! bfd_set_section_alignment (abfd, s, ptralign))
2520 return false;
2521
2522 if (! _bfd_elf_create_got_section (abfd, info))
2523 return false;
2524
2525 {
2526 const char *secname;
2527 char *relname;
2528 flagword secflags;
2529 asection *sec;
2530
2531 for (sec = abfd->sections; sec; sec = sec->next)
2532 {
2533 secflags = bfd_get_section_flags (abfd, sec);
2534 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
2535 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
2536 continue;
2537 secname = bfd_get_section_name (abfd, sec);
2538 relname = (char *) bfd_malloc (strlen (secname) + 6);
2539 strcpy (relname, ".rela");
2540 strcat (relname, secname);
2541 s = bfd_make_section (abfd, relname);
2542 if (s == NULL
2543 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2544 || ! bfd_set_section_alignment (abfd, s, ptralign))
2545 return false;
2546 }
2547 }
2548
2549 if (bed->want_dynbss)
2550 {
2551 /* The .dynbss section is a place to put symbols which are defined
2552 by dynamic objects, are referenced by regular objects, and are
2553 not functions. We must allocate space for them in the process
2554 image and use a R_*_COPY reloc to tell the dynamic linker to
2555 initialize them at run time. The linker script puts the .dynbss
2556 section into the .bss section of the final image. */
2557 s = bfd_make_section (abfd, ".dynbss");
2558 if (s == NULL
2559 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
2560 return false;
2561
2562 /* The .rel[a].bss section holds copy relocs. This section is not
2563 normally needed. We need to create it here, though, so that the
2564 linker will map it to an output section. We can't just create it
2565 only if we need it, because we will not know whether we need it
2566 until we have seen all the input files, and the first time the
2567 main linker code calls BFD after examining all the input files
2568 (size_dynamic_sections) the input sections have already been
2569 mapped to the output sections. If the section turns out not to
2570 be needed, we can discard it later. We will never need this
2571 section when generating a shared object, since they do not use
2572 copy relocs. */
2573 if (! info->shared)
2574 {
2575 s = bfd_make_section (abfd,
2576 (bed->default_use_rela_p
2577 ? ".rela.bss" : ".rel.bss"));
2578 if (s == NULL
2579 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2580 || ! bfd_set_section_alignment (abfd, s, ptralign))
2581 return false;
2582 }
2583 }
2584
2585 return true;
2586 }
2587 \f
2588 /* Adjust a symbol defined by a dynamic object and referenced by a
2589 regular object. The current definition is in some section of the
2590 dynamic object, but we're not including those sections. We have to
2591 change the definition to something the rest of the link can
2592 understand. */
2593
2594 static boolean
2595 sh_elf_adjust_dynamic_symbol (info, h)
2596 struct bfd_link_info *info;
2597 struct elf_link_hash_entry *h;
2598 {
2599 bfd *dynobj;
2600 asection *s;
2601 unsigned int power_of_two;
2602
2603 dynobj = elf_hash_table (info)->dynobj;
2604
2605 /* Make sure we know what is going on here. */
2606 BFD_ASSERT (dynobj != NULL
2607 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2608 || h->weakdef != NULL
2609 || ((h->elf_link_hash_flags
2610 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2611 && (h->elf_link_hash_flags
2612 & ELF_LINK_HASH_REF_REGULAR) != 0
2613 && (h->elf_link_hash_flags
2614 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2615
2616 /* If this is a function, put it in the procedure linkage table. We
2617 will fill in the contents of the procedure linkage table later,
2618 when we know the address of the .got section. */
2619 if (h->type == STT_FUNC
2620 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2621 {
2622 if (! info->shared
2623 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2624 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2625 {
2626 /* This case can occur if we saw a PLT reloc in an input
2627 file, but the symbol was never referred to by a dynamic
2628 object. In such a case, we don't actually need to build
2629 a procedure linkage table, and we can just do a REL32
2630 reloc instead. */
2631 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2632 return true;
2633 }
2634
2635 /* Make sure this symbol is output as a dynamic symbol. */
2636 if (h->dynindx == -1)
2637 {
2638 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2639 return false;
2640 }
2641
2642 s = bfd_get_section_by_name (dynobj, ".plt");
2643 BFD_ASSERT (s != NULL);
2644
2645 /* If this is the first .plt entry, make room for the special
2646 first entry. */
2647 if (s->_raw_size == 0)
2648 s->_raw_size += PLT_ENTRY_SIZE;
2649
2650 /* If this symbol is not defined in a regular file, and we are
2651 not generating a shared library, then set the symbol to this
2652 location in the .plt. This is required to make function
2653 pointers compare as equal between the normal executable and
2654 the shared library. */
2655 if (! info->shared
2656 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2657 {
2658 h->root.u.def.section = s;
2659 h->root.u.def.value = s->_raw_size;
2660 }
2661
2662 h->plt.offset = s->_raw_size;
2663
2664 /* Make room for this entry. */
2665 s->_raw_size += elf_sh_sizeof_plt (info);
2666
2667 /* We also need to make an entry in the .got.plt section, which
2668 will be placed in the .got section by the linker script. */
2669
2670 s = bfd_get_section_by_name (dynobj, ".got.plt");
2671 BFD_ASSERT (s != NULL);
2672 s->_raw_size += 4;
2673
2674 /* We also need to make an entry in the .rela.plt section. */
2675
2676 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2677 BFD_ASSERT (s != NULL);
2678 s->_raw_size += sizeof (Elf32_External_Rela);
2679
2680 return true;
2681 }
2682
2683 /* If this is a weak symbol, and there is a real definition, the
2684 processor independent code will have arranged for us to see the
2685 real definition first, and we can just use the same value. */
2686 if (h->weakdef != NULL)
2687 {
2688 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2689 || h->weakdef->root.type == bfd_link_hash_defweak);
2690 h->root.u.def.section = h->weakdef->root.u.def.section;
2691 h->root.u.def.value = h->weakdef->root.u.def.value;
2692 return true;
2693 }
2694
2695 /* This is a reference to a symbol defined by a dynamic object which
2696 is not a function. */
2697
2698 /* If we are creating a shared library, we must presume that the
2699 only references to the symbol are via the global offset table.
2700 For such cases we need not do anything here; the relocations will
2701 be handled correctly by relocate_section. */
2702 if (info->shared)
2703 return true;
2704
2705 /* If there are no references to this symbol that do not use the
2706 GOT, we don't need to generate a copy reloc. */
2707 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
2708 return true;
2709
2710 /* We must allocate the symbol in our .dynbss section, which will
2711 become part of the .bss section of the executable. There will be
2712 an entry for this symbol in the .dynsym section. The dynamic
2713 object will contain position independent code, so all references
2714 from the dynamic object to this symbol will go through the global
2715 offset table. The dynamic linker will use the .dynsym entry to
2716 determine the address it must put in the global offset table, so
2717 both the dynamic object and the regular object will refer to the
2718 same memory location for the variable. */
2719
2720 s = bfd_get_section_by_name (dynobj, ".dynbss");
2721 BFD_ASSERT (s != NULL);
2722
2723 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2724 copy the initial value out of the dynamic object and into the
2725 runtime process image. We need to remember the offset into the
2726 .rela.bss section we are going to use. */
2727 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2728 {
2729 asection *srel;
2730
2731 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
2732 BFD_ASSERT (srel != NULL);
2733 srel->_raw_size += sizeof (Elf32_External_Rela);
2734 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2735 }
2736
2737 /* We need to figure out the alignment required for this symbol. I
2738 have no idea how ELF linkers handle this. */
2739 power_of_two = bfd_log2 (h->size);
2740 if (power_of_two > 3)
2741 power_of_two = 3;
2742
2743 /* Apply the required alignment. */
2744 s->_raw_size = BFD_ALIGN (s->_raw_size,
2745 (bfd_size_type) (1 << power_of_two));
2746 if (power_of_two > bfd_get_section_alignment (dynobj, s))
2747 {
2748 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2749 return false;
2750 }
2751
2752 /* Define the symbol as being at this point in the section. */
2753 h->root.u.def.section = s;
2754 h->root.u.def.value = s->_raw_size;
2755
2756 /* Increment the section size to make room for the symbol. */
2757 s->_raw_size += h->size;
2758
2759 return true;
2760 }
2761
2762 /* Set the sizes of the dynamic sections. */
2763
2764 static boolean
2765 sh_elf_size_dynamic_sections (output_bfd, info)
2766 bfd *output_bfd ATTRIBUTE_UNUSED;
2767 struct bfd_link_info *info;
2768 {
2769 bfd *dynobj;
2770 asection *s;
2771 boolean plt;
2772 boolean relocs;
2773
2774 dynobj = elf_hash_table (info)->dynobj;
2775 BFD_ASSERT (dynobj != NULL);
2776
2777 if (elf_hash_table (info)->dynamic_sections_created)
2778 {
2779 /* Set the contents of the .interp section to the interpreter. */
2780 if (! info->shared)
2781 {
2782 s = bfd_get_section_by_name (dynobj, ".interp");
2783 BFD_ASSERT (s != NULL);
2784 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2785 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2786 }
2787 }
2788 else
2789 {
2790 /* We may have created entries in the .rela.got section.
2791 However, if we are not creating the dynamic sections, we will
2792 not actually use these entries. Reset the size of .rela.got,
2793 which will cause it to get stripped from the output file
2794 below. */
2795 s = bfd_get_section_by_name (dynobj, ".rela.got");
2796 if (s != NULL)
2797 s->_raw_size = 0;
2798 }
2799
2800 /* If this is a -Bsymbolic shared link, then we need to discard all
2801 PC relative relocs against symbols defined in a regular object.
2802 We allocated space for them in the check_relocs routine, but we
2803 will not fill them in in the relocate_section routine. */
2804 if (info->shared && info->symbolic)
2805 sh_elf_link_hash_traverse (sh_elf_hash_table (info),
2806 sh_elf_discard_copies,
2807 (PTR) NULL);
2808
2809 /* The check_relocs and adjust_dynamic_symbol entry points have
2810 determined the sizes of the various dynamic sections. Allocate
2811 memory for them. */
2812 plt = false;
2813 relocs = false;
2814 for (s = dynobj->sections; s != NULL; s = s->next)
2815 {
2816 const char *name;
2817 boolean strip;
2818
2819 if ((s->flags & SEC_LINKER_CREATED) == 0)
2820 continue;
2821
2822 /* It's OK to base decisions on the section name, because none
2823 of the dynobj section names depend upon the input files. */
2824 name = bfd_get_section_name (dynobj, s);
2825
2826 strip = false;
2827
2828 if (strcmp (name, ".plt") == 0)
2829 {
2830 if (s->_raw_size == 0)
2831 {
2832 /* Strip this section if we don't need it; see the
2833 comment below. */
2834 strip = true;
2835 }
2836 else
2837 {
2838 /* Remember whether there is a PLT. */
2839 plt = true;
2840 }
2841 }
2842 else if (strncmp (name, ".rela", 5) == 0)
2843 {
2844 if (s->_raw_size == 0)
2845 {
2846 /* If we don't need this section, strip it from the
2847 output file. This is mostly to handle .rela.bss and
2848 .rela.plt. We must create both sections in
2849 create_dynamic_sections, because they must be created
2850 before the linker maps input sections to output
2851 sections. The linker does that before
2852 adjust_dynamic_symbol is called, and it is that
2853 function which decides whether anything needs to go
2854 into these sections. */
2855 strip = true;
2856 }
2857 else
2858 {
2859 /* Remember whether there are any reloc sections other
2860 than .rela.plt. */
2861 if (strcmp (name, ".rela.plt") != 0)
2862 relocs = true;
2863
2864 /* We use the reloc_count field as a counter if we need
2865 to copy relocs into the output file. */
2866 s->reloc_count = 0;
2867 }
2868 }
2869 else if (strncmp (name, ".got", 4) != 0)
2870 {
2871 /* It's not one of our sections, so don't allocate space. */
2872 continue;
2873 }
2874
2875 if (strip)
2876 {
2877 _bfd_strip_section_from_output (info, s);
2878 continue;
2879 }
2880
2881 /* Allocate memory for the section contents. */
2882 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
2883 if (s->contents == NULL && s->_raw_size != 0)
2884 return false;
2885 }
2886
2887 if (elf_hash_table (info)->dynamic_sections_created)
2888 {
2889 /* Add some entries to the .dynamic section. We fill in the
2890 values later, in sh_elf_finish_dynamic_sections, but we
2891 must add the entries now so that we get the correct size for
2892 the .dynamic section. The DT_DEBUG entry is filled in by the
2893 dynamic linker and used by the debugger. */
2894 if (! info->shared)
2895 {
2896 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
2897 return false;
2898 }
2899
2900 if (plt)
2901 {
2902 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
2903 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2904 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
2905 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
2906 return false;
2907 }
2908
2909 if (relocs)
2910 {
2911 if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
2912 || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
2913 || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
2914 sizeof (Elf32_External_Rela)))
2915 return false;
2916 }
2917
2918 if ((info->flags & DF_TEXTREL) != 0)
2919 {
2920 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
2921 return false;
2922 }
2923 }
2924
2925 return true;
2926 }
2927
2928 /* This function is called via sh_elf_link_hash_traverse if we are
2929 creating a shared object with -Bsymbolic. It discards the space
2930 allocated to copy PC relative relocs against symbols which are
2931 defined in regular objects. We allocated space for them in the
2932 check_relocs routine, but we won't fill them in in the
2933 relocate_section routine. */
2934
2935 static boolean
2936 sh_elf_discard_copies (h, ignore)
2937 struct elf_sh_link_hash_entry *h;
2938 PTR ignore ATTRIBUTE_UNUSED;
2939 {
2940 struct elf_sh_pcrel_relocs_copied *s;
2941
2942 /* We only discard relocs for symbols defined in a regular object. */
2943 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2944 return true;
2945
2946 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
2947 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rela);
2948
2949 return true;
2950 }
2951 \f
2952 /* Relocate an SH ELF section. */
2953
2954 static boolean
2955 sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
2956 contents, relocs, local_syms, local_sections)
2957 bfd *output_bfd ATTRIBUTE_UNUSED;
2958 struct bfd_link_info *info;
2959 bfd *input_bfd;
2960 asection *input_section;
2961 bfd_byte *contents;
2962 Elf_Internal_Rela *relocs;
2963 Elf_Internal_Sym *local_syms;
2964 asection **local_sections;
2965 {
2966 Elf_Internal_Shdr *symtab_hdr;
2967 struct elf_link_hash_entry **sym_hashes;
2968 Elf_Internal_Rela *rel, *relend;
2969 bfd *dynobj;
2970 bfd_vma *local_got_offsets;
2971 asection *sgot;
2972 asection *splt;
2973 asection *sreloc;
2974
2975 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2976 sym_hashes = elf_sym_hashes (input_bfd);
2977 dynobj = elf_hash_table (info)->dynobj;
2978 local_got_offsets = elf_local_got_offsets (input_bfd);
2979
2980 sgot = NULL;
2981 splt = NULL;
2982 sreloc = NULL;
2983
2984 rel = relocs;
2985 relend = relocs + input_section->reloc_count;
2986 for (; rel < relend; rel++)
2987 {
2988 int r_type;
2989 reloc_howto_type *howto;
2990 unsigned long r_symndx;
2991 Elf_Internal_Sym *sym;
2992 asection *sec;
2993 struct elf_link_hash_entry *h;
2994 bfd_vma relocation;
2995 bfd_vma addend = (bfd_vma) 0;
2996 bfd_reloc_status_type r;
2997
2998 r_symndx = ELF32_R_SYM (rel->r_info);
2999
3000 r_type = ELF32_R_TYPE (rel->r_info);
3001
3002 /* Many of the relocs are only used for relaxing, and are
3003 handled entirely by the relaxation code. */
3004 if (r_type > (int) R_SH_LAST_INVALID_RELOC
3005 && r_type < (int) R_SH_LOOP_START)
3006 continue;
3007 if (r_type == (int) R_SH_NONE)
3008 continue;
3009
3010 if (r_type < 0
3011 || r_type >= R_SH_max
3012 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
3013 && r_type <= (int) R_SH_LAST_INVALID_RELOC)
3014 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
3015 && r_type <= (int) R_SH_LAST_INVALID_RELOC_2))
3016 {
3017 bfd_set_error (bfd_error_bad_value);
3018 return false;
3019 }
3020
3021 howto = sh_elf_howto_table + r_type;
3022
3023 /* This is a final link. */
3024 h = NULL;
3025 sym = NULL;
3026 sec = NULL;
3027 if (r_symndx < symtab_hdr->sh_info)
3028 {
3029 sym = local_syms + r_symndx;
3030 sec = local_sections[r_symndx];
3031 relocation = (sec->output_section->vma
3032 + sec->output_offset
3033 + sym->st_value);
3034
3035 if (info->relocateable)
3036 {
3037 /* This is a relocateable link. We don't have to change
3038 anything, unless the reloc is against a section symbol,
3039 in which case we have to adjust according to where the
3040 section symbol winds up in the output section. */
3041 sym = local_syms + r_symndx;
3042 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3043 goto final_link_relocate;
3044
3045 continue;
3046 }
3047 }
3048 else
3049 {
3050 /* Section symbol are never (?) placed in the hash table, so
3051 we can just ignore hash relocations when creating a
3052 relocateable object file. */
3053 if (info->relocateable)
3054 continue;
3055
3056 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3057 while (h->root.type == bfd_link_hash_indirect
3058 || h->root.type == bfd_link_hash_warning)
3059 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3060 if (h->root.type == bfd_link_hash_defined
3061 || h->root.type == bfd_link_hash_defweak)
3062 {
3063 sec = h->root.u.def.section;
3064 /* In these cases, we don't need the relocation value.
3065 We check specially because in some obscure cases
3066 sec->output_section will be NULL. */
3067 if (r_type == R_SH_GOTPC
3068 || (r_type == R_SH_PLT32
3069 && h->plt.offset != (bfd_vma) -1)
3070 || (r_type == R_SH_GOT32
3071 && elf_hash_table (info)->dynamic_sections_created
3072 && (! info->shared
3073 || (! info->symbolic && h->dynindx != -1)
3074 || (h->elf_link_hash_flags
3075 & ELF_LINK_HASH_DEF_REGULAR) == 0))
3076 /* The cases above are those in which relocation is
3077 overwritten in the switch block below. The cases
3078 below are those in which we must defer relocation
3079 to run-time, because we can't resolve absolute
3080 addresses when creating a shared library. */
3081 || (info->shared
3082 && ((! info->symbolic && h->dynindx != -1)
3083 || (h->elf_link_hash_flags
3084 & ELF_LINK_HASH_DEF_REGULAR) == 0)
3085 && ((r_type == R_SH_DIR32
3086 && !(ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3087 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN))
3088 || r_type == R_SH_REL32)
3089 && ((input_section->flags & SEC_ALLOC) != 0
3090 /* DWARF will emit R_SH_DIR32 relocations in its
3091 sections against symbols defined externally
3092 in shared libraries. We can't do anything
3093 with them here. */
3094 || (input_section->flags & SEC_DEBUGGING) != 0)))
3095 relocation = 0;
3096 else if (sec->output_section == NULL)
3097 {
3098 (*_bfd_error_handler)
3099 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
3100 bfd_get_filename (input_bfd), h->root.root.string,
3101 bfd_get_section_name (input_bfd, input_section));
3102 relocation = 0;
3103 }
3104 else
3105 relocation = (h->root.u.def.value
3106 + sec->output_section->vma
3107 + sec->output_offset);
3108 }
3109 else if (h->root.type == bfd_link_hash_undefweak)
3110 relocation = 0;
3111 else if (info->shared && !info->symbolic && !info->no_undefined)
3112 relocation = 0;
3113 else
3114 {
3115 if (! ((*info->callbacks->undefined_symbol)
3116 (info, h->root.root.string, input_bfd,
3117 input_section, rel->r_offset, true)))
3118 return false;
3119 relocation = 0;
3120 }
3121 }
3122
3123 switch ((int) r_type)
3124 {
3125 final_link_relocate:
3126 /* COFF relocs don't use the addend. The addend is used for
3127 R_SH_DIR32 to be compatible with other compilers. */
3128 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3129 contents, rel->r_offset,
3130 relocation, addend);
3131 break;
3132
3133 case R_SH_IND12W:
3134 relocation -= 4;
3135 goto final_link_relocate;
3136
3137 case R_SH_DIR8WPN:
3138 case R_SH_DIR8WPZ:
3139 case R_SH_DIR8WPL:
3140 /* If the reloc is against the start of this section, then
3141 the assembler has already taken care of it and the reloc
3142 is here only to assist in relaxing. If the reloc is not
3143 against the start of this section, then it's against an
3144 external symbol and we must deal with it ourselves. */
3145 if (input_section->output_section->vma + input_section->output_offset
3146 != relocation)
3147 {
3148 int disp = (relocation
3149 - input_section->output_section->vma
3150 - input_section->output_offset
3151 - rel->r_offset);
3152 int mask = 0;
3153 switch (r_type)
3154 {
3155 case R_SH_DIR8WPN:
3156 case R_SH_DIR8WPZ: mask = 1; break;
3157 case R_SH_DIR8WPL: mask = 3; break;
3158 default: mask = 0; break;
3159 }
3160 if (disp & mask)
3161 {
3162 ((*_bfd_error_handler)
3163 (_("%s: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
3164 bfd_get_filename (input_section->owner),
3165 (unsigned long) rel->r_offset));
3166 bfd_set_error (bfd_error_bad_value);
3167 return false;
3168 }
3169 relocation -= 4;
3170 goto final_link_relocate;
3171 }
3172 r = bfd_reloc_ok;
3173 break;
3174
3175 default:
3176 bfd_set_error (bfd_error_bad_value);
3177 return false;
3178
3179 case R_SH_DIR32:
3180 case R_SH_REL32:
3181 if (info->shared
3182 && (input_section->flags & SEC_ALLOC) != 0
3183 && (r_type != R_SH_REL32
3184 || (h != NULL
3185 && h->dynindx != -1
3186 && (! info->symbolic
3187 || (h->elf_link_hash_flags
3188 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
3189 {
3190 Elf_Internal_Rela outrel;
3191 boolean skip, relocate;
3192
3193 /* When generating a shared object, these relocations
3194 are copied into the output file to be resolved at run
3195 time. */
3196
3197 if (sreloc == NULL)
3198 {
3199 const char *name;
3200
3201 name = (bfd_elf_string_from_elf_section
3202 (input_bfd,
3203 elf_elfheader (input_bfd)->e_shstrndx,
3204 elf_section_data (input_section)->rel_hdr.sh_name));
3205 if (name == NULL)
3206 return false;
3207
3208 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
3209 && strcmp (bfd_get_section_name (input_bfd,
3210 input_section),
3211 name + 5) == 0);
3212
3213 sreloc = bfd_get_section_by_name (dynobj, name);
3214 BFD_ASSERT (sreloc != NULL);
3215 }
3216
3217 skip = false;
3218
3219 if (elf_section_data (input_section)->stab_info == NULL)
3220 outrel.r_offset = rel->r_offset;
3221 else
3222 {
3223 bfd_vma off;
3224
3225 off = (_bfd_stab_section_offset
3226 (output_bfd, &elf_hash_table (info)->stab_info,
3227 input_section,
3228 &elf_section_data (input_section)->stab_info,
3229 rel->r_offset));
3230 if (off == (bfd_vma) -1)
3231 skip = true;
3232 outrel.r_offset = off;
3233 }
3234
3235 outrel.r_offset += (input_section->output_section->vma
3236 + input_section->output_offset);
3237
3238 if (skip)
3239 {
3240 memset (&outrel, 0, sizeof outrel);
3241 relocate = false;
3242 }
3243 else if (r_type == R_SH_REL32)
3244 {
3245 BFD_ASSERT (h != NULL && h->dynindx != -1);
3246 relocate = false;
3247 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
3248 outrel.r_addend = rel->r_addend;
3249 }
3250 else
3251 {
3252 /* h->dynindx may be -1 if this symbol was marked to
3253 become local. */
3254 if (h == NULL
3255 || ((info->symbolic || h->dynindx == -1)
3256 && (h->elf_link_hash_flags
3257 & ELF_LINK_HASH_DEF_REGULAR) != 0))
3258 {
3259 relocate = true;
3260 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
3261 outrel.r_addend = relocation + rel->r_addend;
3262 }
3263 else
3264 {
3265 BFD_ASSERT (h->dynindx != -1);
3266 relocate = false;
3267 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
3268 outrel.r_addend = relocation + rel->r_addend;
3269 }
3270 }
3271
3272 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3273 (((Elf32_External_Rela *)
3274 sreloc->contents)
3275 + sreloc->reloc_count));
3276 ++sreloc->reloc_count;
3277
3278 /* If this reloc is against an external symbol, we do
3279 not want to fiddle with the addend. Otherwise, we
3280 need to include the symbol value so that it becomes
3281 an addend for the dynamic reloc. */
3282 if (! relocate)
3283 continue;
3284 }
3285 else if (r_type == R_SH_DIR32)
3286 addend = rel->r_addend;
3287 goto final_link_relocate;
3288
3289 case R_SH_GOT32:
3290 /* Relocation is to the entry for this symbol in the global
3291 offset table. */
3292 if (sgot == NULL)
3293 {
3294 sgot = bfd_get_section_by_name (dynobj, ".got");
3295 BFD_ASSERT (sgot != NULL);
3296 }
3297
3298 if (h != NULL)
3299 {
3300 bfd_vma off;
3301
3302 off = h->got.offset;
3303 BFD_ASSERT (off != (bfd_vma) -1);
3304
3305 if (! elf_hash_table (info)->dynamic_sections_created
3306 || (info->shared
3307 && (info->symbolic || h->dynindx == -1
3308 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3309 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
3310 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
3311 {
3312 /* This is actually a static link, or it is a
3313 -Bsymbolic link and the symbol is defined
3314 locally, or the symbol was forced to be local
3315 because of a version file. We must initialize
3316 this entry in the global offset table. Since the
3317 offset must always be a multiple of 4, we use the
3318 least significant bit to record whether we have
3319 initialized it already.
3320
3321 When doing a dynamic link, we create a .rela.got
3322 relocation entry to initialize the value. This
3323 is done in the finish_dynamic_symbol routine. */
3324 if ((off & 1) != 0)
3325 off &= ~1;
3326 else
3327 {
3328 bfd_put_32 (output_bfd, relocation,
3329 sgot->contents + off);
3330 h->got.offset |= 1;
3331 }
3332 }
3333
3334 relocation = sgot->output_offset + off;
3335 }
3336 else
3337 {
3338 bfd_vma off;
3339
3340 BFD_ASSERT (local_got_offsets != NULL
3341 && local_got_offsets[r_symndx] != (bfd_vma) -1);
3342
3343 off = local_got_offsets[r_symndx];
3344
3345 /* The offset must always be a multiple of 4. We use
3346 the least significant bit to record whether we have
3347 already generated the necessary reloc. */
3348 if ((off & 1) != 0)
3349 off &= ~1;
3350 else
3351 {
3352 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
3353
3354 if (info->shared)
3355 {
3356 asection *srelgot;
3357 Elf_Internal_Rela outrel;
3358
3359 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3360 BFD_ASSERT (srelgot != NULL);
3361
3362 outrel.r_offset = (sgot->output_section->vma
3363 + sgot->output_offset
3364 + off);
3365 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
3366 outrel.r_addend = relocation;
3367 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3368 (((Elf32_External_Rela *)
3369 srelgot->contents)
3370 + srelgot->reloc_count));
3371 ++srelgot->reloc_count;
3372 }
3373
3374 local_got_offsets[r_symndx] |= 1;
3375 }
3376
3377 relocation = sgot->output_offset + off;
3378 }
3379
3380 goto final_link_relocate;
3381
3382 case R_SH_GOTOFF:
3383 /* Relocation is relative to the start of the global offset
3384 table. */
3385
3386 if (sgot == NULL)
3387 {
3388 sgot = bfd_get_section_by_name (dynobj, ".got");
3389 BFD_ASSERT (sgot != NULL);
3390 }
3391
3392 /* Note that sgot->output_offset is not involved in this
3393 calculation. We always want the start of .got. If we
3394 defined _GLOBAL_OFFSET_TABLE in a different way, as is
3395 permitted by the ABI, we might have to change this
3396 calculation. */
3397 relocation -= sgot->output_section->vma;
3398
3399 goto final_link_relocate;
3400
3401 case R_SH_GOTPC:
3402 /* Use global offset table as symbol value. */
3403
3404 if (sgot == NULL)
3405 {
3406 sgot = bfd_get_section_by_name (dynobj, ".got");
3407 BFD_ASSERT (sgot != NULL);
3408 }
3409
3410 relocation = sgot->output_section->vma;
3411
3412 goto final_link_relocate;
3413
3414 case R_SH_PLT32:
3415 /* Relocation is to the entry for this symbol in the
3416 procedure linkage table. */
3417
3418 /* Resolve a PLT reloc against a local symbol directly,
3419 without using the procedure linkage table. */
3420 if (h == NULL)
3421 goto final_link_relocate;
3422
3423 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3424 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
3425 goto final_link_relocate;
3426
3427 if (h->plt.offset == (bfd_vma) -1)
3428 {
3429 /* We didn't make a PLT entry for this symbol. This
3430 happens when statically linking PIC code, or when
3431 using -Bsymbolic. */
3432 goto final_link_relocate;
3433 }
3434
3435 if (splt == NULL)
3436 {
3437 splt = bfd_get_section_by_name (dynobj, ".plt");
3438 BFD_ASSERT (splt != NULL);
3439 }
3440
3441 relocation = (splt->output_section->vma
3442 + splt->output_offset
3443 + h->plt.offset);
3444
3445 goto final_link_relocate;
3446
3447 case R_SH_LOOP_START:
3448 {
3449 static bfd_vma start, end;
3450
3451 start = (relocation + rel->r_addend
3452 - (sec->output_section->vma + sec->output_offset));
3453 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
3454 rel->r_offset, sec, start, end);
3455 break;
3456
3457 case R_SH_LOOP_END:
3458 end = (relocation + rel->r_addend
3459 - (sec->output_section->vma + sec->output_offset));
3460 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
3461 rel->r_offset, sec, start, end);
3462 break;
3463 }
3464 }
3465
3466 if (r != bfd_reloc_ok)
3467 {
3468 switch (r)
3469 {
3470 default:
3471 case bfd_reloc_outofrange:
3472 abort ();
3473 case bfd_reloc_overflow:
3474 {
3475 const char *name;
3476
3477 if (h != NULL)
3478 name = h->root.root.string;
3479 else
3480 {
3481 name = (bfd_elf_string_from_elf_section
3482 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3483 if (name == NULL)
3484 return false;
3485 if (*name == '\0')
3486 name = bfd_section_name (input_bfd, sec);
3487 }
3488 if (! ((*info->callbacks->reloc_overflow)
3489 (info, name, howto->name, (bfd_vma) 0,
3490 input_bfd, input_section, rel->r_offset)))
3491 return false;
3492 }
3493 break;
3494 }
3495 }
3496 }
3497
3498 return true;
3499 }
3500
3501 /* This is a version of bfd_generic_get_relocated_section_contents
3502 which uses sh_elf_relocate_section. */
3503
3504 static bfd_byte *
3505 sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
3506 data, relocateable, symbols)
3507 bfd *output_bfd;
3508 struct bfd_link_info *link_info;
3509 struct bfd_link_order *link_order;
3510 bfd_byte *data;
3511 boolean relocateable;
3512 asymbol **symbols;
3513 {
3514 Elf_Internal_Shdr *symtab_hdr;
3515 asection *input_section = link_order->u.indirect.section;
3516 bfd *input_bfd = input_section->owner;
3517 asection **sections = NULL;
3518 Elf_Internal_Rela *internal_relocs = NULL;
3519 Elf32_External_Sym *external_syms = NULL;
3520 Elf_Internal_Sym *internal_syms = NULL;
3521
3522 /* We only need to handle the case of relaxing, or of having a
3523 particular set of section contents, specially. */
3524 if (relocateable
3525 || elf_section_data (input_section)->this_hdr.contents == NULL)
3526 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3527 link_order, data,
3528 relocateable,
3529 symbols);
3530
3531 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3532
3533 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3534 input_section->_raw_size);
3535
3536 if ((input_section->flags & SEC_RELOC) != 0
3537 && input_section->reloc_count > 0)
3538 {
3539 Elf_Internal_Sym *isymp;
3540 asection **secpp;
3541 Elf32_External_Sym *esym, *esymend;
3542
3543 if (symtab_hdr->contents != NULL)
3544 external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
3545 else
3546 {
3547 external_syms = ((Elf32_External_Sym *)
3548 bfd_malloc (symtab_hdr->sh_info
3549 * sizeof (Elf32_External_Sym)));
3550 if (external_syms == NULL && symtab_hdr->sh_info > 0)
3551 goto error_return;
3552 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
3553 || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
3554 symtab_hdr->sh_info, input_bfd)
3555 != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
3556 goto error_return;
3557 }
3558
3559 internal_relocs = (_bfd_elf32_link_read_relocs
3560 (input_bfd, input_section, (PTR) NULL,
3561 (Elf_Internal_Rela *) NULL, false));
3562 if (internal_relocs == NULL)
3563 goto error_return;
3564
3565 internal_syms = ((Elf_Internal_Sym *)
3566 bfd_malloc (symtab_hdr->sh_info
3567 * sizeof (Elf_Internal_Sym)));
3568 if (internal_syms == NULL && symtab_hdr->sh_info > 0)
3569 goto error_return;
3570
3571 sections = (asection **) bfd_malloc (symtab_hdr->sh_info
3572 * sizeof (asection *));
3573 if (sections == NULL && symtab_hdr->sh_info > 0)
3574 goto error_return;
3575
3576 isymp = internal_syms;
3577 secpp = sections;
3578 esym = external_syms;
3579 esymend = esym + symtab_hdr->sh_info;
3580 for (; esym < esymend; ++esym, ++isymp, ++secpp)
3581 {
3582 asection *isec;
3583
3584 bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
3585
3586 if (isymp->st_shndx == SHN_UNDEF)
3587 isec = bfd_und_section_ptr;
3588 else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
3589 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
3590 else if (isymp->st_shndx == SHN_ABS)
3591 isec = bfd_abs_section_ptr;
3592 else if (isymp->st_shndx == SHN_COMMON)
3593 isec = bfd_com_section_ptr;
3594 else
3595 {
3596 /* Who knows? */
3597 isec = NULL;
3598 }
3599
3600 *secpp = isec;
3601 }
3602
3603 if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
3604 input_section, data, internal_relocs,
3605 internal_syms, sections))
3606 goto error_return;
3607
3608 if (sections != NULL)
3609 free (sections);
3610 sections = NULL;
3611 if (internal_syms != NULL)
3612 free (internal_syms);
3613 internal_syms = NULL;
3614 if (external_syms != NULL && symtab_hdr->contents == NULL)
3615 free (external_syms);
3616 external_syms = NULL;
3617 if (internal_relocs != elf_section_data (input_section)->relocs)
3618 free (internal_relocs);
3619 internal_relocs = NULL;
3620 }
3621
3622 return data;
3623
3624 error_return:
3625 if (internal_relocs != NULL
3626 && internal_relocs != elf_section_data (input_section)->relocs)
3627 free (internal_relocs);
3628 if (external_syms != NULL && symtab_hdr->contents == NULL)
3629 free (external_syms);
3630 if (internal_syms != NULL)
3631 free (internal_syms);
3632 if (sections != NULL)
3633 free (sections);
3634 return NULL;
3635 }
3636
3637 static asection *
3638 sh_elf_gc_mark_hook (abfd, info, rel, h, sym)
3639 bfd *abfd;
3640 struct bfd_link_info *info ATTRIBUTE_UNUSED;
3641 Elf_Internal_Rela *rel;
3642 struct elf_link_hash_entry *h;
3643 Elf_Internal_Sym *sym;
3644 {
3645 if (h != NULL)
3646 {
3647 switch (ELF32_R_TYPE (rel->r_info))
3648 {
3649 case R_SH_GNU_VTINHERIT:
3650 case R_SH_GNU_VTENTRY:
3651 break;
3652
3653 default:
3654 switch (h->root.type)
3655 {
3656 case bfd_link_hash_defined:
3657 case bfd_link_hash_defweak:
3658 return h->root.u.def.section;
3659
3660 case bfd_link_hash_common:
3661 return h->root.u.c.p->section;
3662
3663 default:
3664 break;
3665 }
3666 }
3667 }
3668 else
3669 {
3670 if (!(elf_bad_symtab (abfd)
3671 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
3672 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
3673 && sym->st_shndx != SHN_COMMON))
3674 return bfd_section_from_elf_index (abfd, sym->st_shndx);
3675 }
3676 return NULL;
3677 }
3678
3679 /* Update the got entry reference counts for the section being removed. */
3680
3681 static boolean
3682 sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
3683 bfd *abfd ATTRIBUTE_UNUSED;
3684 struct bfd_link_info *info ATTRIBUTE_UNUSED;
3685 asection *sec ATTRIBUTE_UNUSED;
3686 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
3687 {
3688 /* We use got and plt entries for sh, but it would seem that the
3689 existing SH code does no sort of reference counting or whatnot on
3690 its GOT and PLT entries, so it is not possible to garbage collect
3691 them at this time. */
3692 return true;
3693 }
3694
3695 /* Look through the relocs for a section during the first phase.
3696 Since we don't do .gots or .plts, we just need to consider the
3697 virtual table relocs for gc. */
3698
3699 static boolean
3700 sh_elf_check_relocs (abfd, info, sec, relocs)
3701 bfd *abfd;
3702 struct bfd_link_info *info;
3703 asection *sec;
3704 const Elf_Internal_Rela *relocs;
3705 {
3706 Elf_Internal_Shdr *symtab_hdr;
3707 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
3708 const Elf_Internal_Rela *rel;
3709 const Elf_Internal_Rela *rel_end;
3710 bfd *dynobj;
3711 bfd_vma *local_got_offsets;
3712 asection *sgot;
3713 asection *srelgot;
3714 asection *sreloc;
3715
3716 sgot = NULL;
3717 srelgot = NULL;
3718 sreloc = NULL;
3719
3720 if (info->relocateable)
3721 return true;
3722
3723 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3724 sym_hashes = elf_sym_hashes (abfd);
3725 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
3726 if (!elf_bad_symtab (abfd))
3727 sym_hashes_end -= symtab_hdr->sh_info;
3728
3729 dynobj = elf_hash_table (info)->dynobj;
3730 local_got_offsets = elf_local_got_offsets (abfd);
3731
3732 rel_end = relocs + sec->reloc_count;
3733 for (rel = relocs; rel < rel_end; rel++)
3734 {
3735 struct elf_link_hash_entry *h;
3736 unsigned long r_symndx;
3737
3738 r_symndx = ELF32_R_SYM (rel->r_info);
3739 if (r_symndx < symtab_hdr->sh_info)
3740 h = NULL;
3741 else
3742 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3743
3744 /* Some relocs require a global offset table. */
3745 if (dynobj == NULL)
3746 {
3747 switch (ELF32_R_TYPE (rel->r_info))
3748 {
3749 case R_SH_GOT32:
3750 case R_SH_GOTOFF:
3751 case R_SH_GOTPC:
3752 elf_hash_table (info)->dynobj = dynobj = abfd;
3753 if (! _bfd_elf_create_got_section (dynobj, info))
3754 return false;
3755 break;
3756
3757 default:
3758 break;
3759 }
3760 }
3761
3762 switch (ELF32_R_TYPE (rel->r_info))
3763 {
3764 /* This relocation describes the C++ object vtable hierarchy.
3765 Reconstruct it for later use during GC. */
3766 case R_SH_GNU_VTINHERIT:
3767 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3768 return false;
3769 break;
3770
3771 /* This relocation describes which C++ vtable entries are actually
3772 used. Record for later use during GC. */
3773 case R_SH_GNU_VTENTRY:
3774 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3775 return false;
3776 break;
3777
3778 case R_SH_GOT32:
3779 /* This symbol requires a global offset table entry. */
3780
3781 if (sgot == NULL)
3782 {
3783 sgot = bfd_get_section_by_name (dynobj, ".got");
3784 BFD_ASSERT (sgot != NULL);
3785 }
3786
3787 if (srelgot == NULL
3788 && (h != NULL || info->shared))
3789 {
3790 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3791 if (srelgot == NULL)
3792 {
3793 srelgot = bfd_make_section (dynobj, ".rela.got");
3794 if (srelgot == NULL
3795 || ! bfd_set_section_flags (dynobj, srelgot,
3796 (SEC_ALLOC
3797 | SEC_LOAD
3798 | SEC_HAS_CONTENTS
3799 | SEC_IN_MEMORY
3800 | SEC_LINKER_CREATED
3801 | SEC_READONLY))
3802 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
3803 return false;
3804 }
3805 }
3806
3807 if (h != NULL)
3808 {
3809 if (h->got.offset != (bfd_vma) -1)
3810 {
3811 /* We have already allocated space in the .got. */
3812 break;
3813 }
3814 h->got.offset = sgot->_raw_size;
3815
3816 /* Make sure this symbol is output as a dynamic symbol. */
3817 if (h->dynindx == -1)
3818 {
3819 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
3820 return false;
3821 }
3822
3823 srelgot->_raw_size += sizeof (Elf32_External_Rela);
3824 }
3825 else
3826 {
3827 /* This is a global offset table entry for a local
3828 symbol. */
3829 if (local_got_offsets == NULL)
3830 {
3831 size_t size;
3832 register unsigned int i;
3833
3834 size = symtab_hdr->sh_info * sizeof (bfd_vma);
3835 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
3836 if (local_got_offsets == NULL)
3837 return false;
3838 elf_local_got_offsets (abfd) = local_got_offsets;
3839 for (i = 0; i < symtab_hdr->sh_info; i++)
3840 local_got_offsets[i] = (bfd_vma) -1;
3841 }
3842 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
3843 {
3844 /* We have already allocated space in the .got. */
3845 break;
3846 }
3847 local_got_offsets[r_symndx] = sgot->_raw_size;
3848
3849 if (info->shared)
3850 {
3851 /* If we are generating a shared object, we need to
3852 output a R_SH_RELATIVE reloc so that the dynamic
3853 linker can adjust this GOT entry. */
3854 srelgot->_raw_size += sizeof (Elf32_External_Rela);
3855 }
3856 }
3857
3858 sgot->_raw_size += 4;
3859
3860 break;
3861
3862 case R_SH_PLT32:
3863 /* This symbol requires a procedure linkage table entry. We
3864 actually build the entry in adjust_dynamic_symbol,
3865 because this might be a case of linking PIC code which is
3866 never referenced by a dynamic object, in which case we
3867 don't need to generate a procedure linkage table entry
3868 after all. */
3869
3870 /* If this is a local symbol, we resolve it directly without
3871 creating a procedure linkage table entry. */
3872 if (h == NULL)
3873 continue;
3874
3875 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3876 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
3877 break;
3878
3879 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
3880
3881 break;
3882
3883 case R_SH_DIR32:
3884 case R_SH_REL32:
3885 if (h != NULL)
3886 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
3887
3888 /* If we are creating a shared library, and this is a reloc
3889 against a global symbol, or a non PC relative reloc
3890 against a local symbol, then we need to copy the reloc
3891 into the shared library. However, if we are linking with
3892 -Bsymbolic, we do not need to copy a reloc against a
3893 global symbol which is defined in an object we are
3894 including in the link (i.e., DEF_REGULAR is set). At
3895 this point we have not seen all the input files, so it is
3896 possible that DEF_REGULAR is not set now but will be set
3897 later (it is never cleared). We account for that
3898 possibility below by storing information in the
3899 pcrel_relocs_copied field of the hash table entry. */
3900 if (info->shared
3901 && (sec->flags & SEC_ALLOC) != 0
3902 && (ELF32_R_TYPE (rel->r_info) != R_SH_REL32
3903 || (h != NULL
3904 && (! info->symbolic
3905 || (h->elf_link_hash_flags
3906 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
3907 {
3908 /* When creating a shared object, we must copy these
3909 reloc types into the output file. We create a reloc
3910 section in dynobj and make room for this reloc. */
3911 if (sreloc == NULL)
3912 {
3913 const char *name;
3914
3915 name = (bfd_elf_string_from_elf_section
3916 (abfd,
3917 elf_elfheader (abfd)->e_shstrndx,
3918 elf_section_data (sec)->rel_hdr.sh_name));
3919 if (name == NULL)
3920 return false;
3921
3922 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
3923 && strcmp (bfd_get_section_name (abfd, sec),
3924 name + 5) == 0);
3925
3926 sreloc = bfd_get_section_by_name (dynobj, name);
3927 if (sreloc == NULL)
3928 {
3929 flagword flags;
3930
3931 sreloc = bfd_make_section (dynobj, name);
3932 flags = (SEC_HAS_CONTENTS | SEC_READONLY
3933 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3934 if ((sec->flags & SEC_ALLOC) != 0)
3935 flags |= SEC_ALLOC | SEC_LOAD;
3936 if (sreloc == NULL
3937 || ! bfd_set_section_flags (dynobj, sreloc, flags)
3938 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
3939 return false;
3940 }
3941 if (sec->flags & SEC_READONLY)
3942 info->flags |= DF_TEXTREL;
3943 }
3944
3945 sreloc->_raw_size += sizeof (Elf32_External_Rela);
3946
3947 /* If we are linking with -Bsymbolic, and this is a
3948 global symbol, we count the number of PC relative
3949 relocations we have entered for this symbol, so that
3950 we can discard them again if the symbol is later
3951 defined by a regular object. Note that this function
3952 is only called if we are using an elf_sh linker
3953 hash table, which means that h is really a pointer to
3954 an elf_sh_link_hash_entry. */
3955 if (h != NULL && info->symbolic
3956 && ELF32_R_TYPE (rel->r_info) == R_SH_REL32)
3957 {
3958 struct elf_sh_link_hash_entry *eh;
3959 struct elf_sh_pcrel_relocs_copied *p;
3960
3961 eh = (struct elf_sh_link_hash_entry *) h;
3962
3963 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
3964 if (p->section == sreloc)
3965 break;
3966
3967 if (p == NULL)
3968 {
3969 p = ((struct elf_sh_pcrel_relocs_copied *)
3970 bfd_alloc (dynobj, sizeof *p));
3971 if (p == NULL)
3972 return false;
3973 p->next = eh->pcrel_relocs_copied;
3974 eh->pcrel_relocs_copied = p;
3975 p->section = sreloc;
3976 p->count = 0;
3977 }
3978
3979 ++p->count;
3980 }
3981 }
3982
3983 break;
3984 }
3985 }
3986
3987 return true;
3988 }
3989
3990 static boolean
3991 sh_elf_set_mach_from_flags (abfd)
3992 bfd *abfd;
3993 {
3994 flagword flags = elf_elfheader (abfd)->e_flags;
3995
3996 switch (flags & EF_SH_MACH_MASK)
3997 {
3998 case EF_SH1:
3999 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh);
4000 break;
4001 case EF_SH2:
4002 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2);
4003 break;
4004 case EF_SH_DSP:
4005 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp);
4006 break;
4007 case EF_SH3:
4008 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3);
4009 break;
4010 case EF_SH3_DSP:
4011 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp);
4012 break;
4013 case EF_SH3E:
4014 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e);
4015 break;
4016 case EF_SH_UNKNOWN:
4017 case EF_SH4:
4018 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4);
4019 break;
4020 default:
4021 return false;
4022 }
4023 return true;
4024 }
4025
4026 /* Function to keep SH specific file flags. */
4027
4028 static boolean
4029 sh_elf_set_private_flags (abfd, flags)
4030 bfd *abfd;
4031 flagword flags;
4032 {
4033 BFD_ASSERT (! elf_flags_init (abfd)
4034 || elf_elfheader (abfd)->e_flags == flags);
4035
4036 elf_elfheader (abfd)->e_flags = flags;
4037 elf_flags_init (abfd) = true;
4038 return sh_elf_set_mach_from_flags (abfd);
4039 }
4040
4041 /* Copy backend specific data from one object module to another */
4042
4043 static boolean
4044 sh_elf_copy_private_data (ibfd, obfd)
4045 bfd * ibfd;
4046 bfd * obfd;
4047 {
4048 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4049 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4050 return true;
4051
4052 return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
4053 }
4054
4055 /* This routine checks for linking big and little endian objects
4056 together, and for linking sh-dsp with sh3e / sh4 objects. */
4057
4058 static boolean
4059 sh_elf_merge_private_data (ibfd, obfd)
4060 bfd *ibfd;
4061 bfd *obfd;
4062 {
4063 flagword old_flags, new_flags;
4064
4065 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
4066 return false;
4067
4068 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4069 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4070 return true;
4071
4072 if (! elf_flags_init (obfd))
4073 {
4074 /* This happens when ld starts out with a 'blank' output file. */
4075 elf_flags_init (obfd) = true;
4076 elf_elfheader (obfd)->e_flags = EF_SH1;
4077 }
4078 old_flags = elf_elfheader (obfd)->e_flags;
4079 new_flags = elf_elfheader (ibfd)->e_flags;
4080 if ((EF_SH_HAS_DSP (old_flags) && EF_SH_HAS_FP (new_flags))
4081 || (EF_SH_HAS_DSP (new_flags) && EF_SH_HAS_FP (old_flags)))
4082 {
4083 (*_bfd_error_handler)
4084 ("%s: uses %s instructions while previous modules use %s instructions",
4085 bfd_get_filename (ibfd),
4086 EF_SH_HAS_DSP (new_flags) ? "dsp" : "floating point",
4087 EF_SH_HAS_DSP (new_flags) ? "floating point" : "dsp");
4088 bfd_set_error (bfd_error_bad_value);
4089 return false;
4090 }
4091 elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags);
4092
4093 return sh_elf_set_mach_from_flags (obfd);
4094 }
4095
4096 /* Finish up dynamic symbol handling. We set the contents of various
4097 dynamic sections here. */
4098
4099 static boolean
4100 sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
4101 bfd *output_bfd;
4102 struct bfd_link_info *info;
4103 struct elf_link_hash_entry *h;
4104 Elf_Internal_Sym *sym;
4105 {
4106 bfd *dynobj;
4107
4108 dynobj = elf_hash_table (info)->dynobj;
4109
4110 if (h->plt.offset != (bfd_vma) -1)
4111 {
4112 asection *splt;
4113 asection *sgot;
4114 asection *srel;
4115
4116 bfd_vma plt_index;
4117 bfd_vma got_offset;
4118 Elf_Internal_Rela rel;
4119
4120 /* This symbol has an entry in the procedure linkage table. Set
4121 it up. */
4122
4123 BFD_ASSERT (h->dynindx != -1);
4124
4125 splt = bfd_get_section_by_name (dynobj, ".plt");
4126 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4127 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4128 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
4129
4130 /* Get the index in the procedure linkage table which
4131 corresponds to this symbol. This is the index of this symbol
4132 in all the symbols for which we are making plt entries. The
4133 first entry in the procedure linkage table is reserved. */
4134 plt_index = h->plt.offset / elf_sh_sizeof_plt (info) - 1;
4135
4136 /* Get the offset into the .got table of the entry that
4137 corresponds to this function. Each .got entry is 4 bytes.
4138 The first three are reserved. */
4139 got_offset = (plt_index + 3) * 4;
4140
4141 /* Fill in the entry in the procedure linkage table. */
4142 if (! info->shared)
4143 {
4144 if (elf_sh_plt_entry == NULL)
4145 {
4146 elf_sh_plt_entry = (bfd_big_endian (output_bfd) ?
4147 elf_sh_plt_entry_be : elf_sh_plt_entry_le);
4148 }
4149 memcpy (splt->contents + h->plt.offset, elf_sh_plt_entry,
4150 elf_sh_sizeof_plt (info));
4151 bfd_put_32 (output_bfd,
4152 (sgot->output_section->vma
4153 + sgot->output_offset
4154 + got_offset),
4155 (splt->contents + h->plt.offset
4156 + elf_sh_plt_symbol_offset (info)));
4157
4158 bfd_put_32 (output_bfd,
4159 (splt->output_section->vma + splt->output_offset),
4160 (splt->contents + h->plt.offset
4161 + elf_sh_plt_plt0_offset (info)));
4162 }
4163 else
4164 {
4165 if (elf_sh_pic_plt_entry == NULL)
4166 {
4167 elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
4168 elf_sh_pic_plt_entry_be :
4169 elf_sh_pic_plt_entry_le);
4170 }
4171 memcpy (splt->contents + h->plt.offset, elf_sh_pic_plt_entry,
4172 elf_sh_sizeof_plt (info));
4173 bfd_put_32 (output_bfd, got_offset,
4174 (splt->contents + h->plt.offset
4175 + elf_sh_plt_symbol_offset (info)));
4176 }
4177
4178 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4179 (splt->contents + h->plt.offset
4180 + elf_sh_plt_reloc_offset (info)));
4181
4182 /* Fill in the entry in the global offset table. */
4183 bfd_put_32 (output_bfd,
4184 (splt->output_section->vma
4185 + splt->output_offset
4186 + h->plt.offset
4187 + elf_sh_plt_temp_offset (info)),
4188 sgot->contents + got_offset);
4189
4190 /* Fill in the entry in the .rela.plt section. */
4191 rel.r_offset = (sgot->output_section->vma
4192 + sgot->output_offset
4193 + got_offset);
4194 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
4195 rel.r_addend = 0;
4196 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4197 ((Elf32_External_Rela *) srel->contents
4198 + plt_index));
4199
4200 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4201 {
4202 /* Mark the symbol as undefined, rather than as defined in
4203 the .plt section. Leave the value alone. */
4204 sym->st_shndx = SHN_UNDEF;
4205 }
4206 }
4207
4208 if (h->got.offset != (bfd_vma) -1)
4209 {
4210 asection *sgot;
4211 asection *srel;
4212 Elf_Internal_Rela rel;
4213
4214 /* This symbol has an entry in the global offset table. Set it
4215 up. */
4216
4217 sgot = bfd_get_section_by_name (dynobj, ".got");
4218 srel = bfd_get_section_by_name (dynobj, ".rela.got");
4219 BFD_ASSERT (sgot != NULL && srel != NULL);
4220
4221 rel.r_offset = (sgot->output_section->vma
4222 + sgot->output_offset
4223 + (h->got.offset &~ 1));
4224
4225 /* If this is a -Bsymbolic link, and the symbol is defined
4226 locally, we just want to emit a RELATIVE reloc. Likewise if
4227 the symbol was forced to be local because of a version file.
4228 The entry in the global offset table will already have been
4229 initialized in the relocate_section function. */
4230 if (info->shared
4231 && (info->symbolic || h->dynindx == -1)
4232 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
4233 {
4234 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4235 rel.r_addend = (h->root.u.def.value
4236 + h->root.u.def.section->output_section->vma
4237 + h->root.u.def.section->output_offset);
4238 }
4239 else
4240 {
4241 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
4242 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
4243 rel.r_addend = 0;
4244 }
4245
4246 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4247 ((Elf32_External_Rela *) srel->contents
4248 + srel->reloc_count));
4249 ++srel->reloc_count;
4250 }
4251
4252 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
4253 {
4254 asection *s;
4255 Elf_Internal_Rela rel;
4256
4257 /* This symbol needs a copy reloc. Set it up. */
4258
4259 BFD_ASSERT (h->dynindx != -1
4260 && (h->root.type == bfd_link_hash_defined
4261 || h->root.type == bfd_link_hash_defweak));
4262
4263 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4264 ".rela.bss");
4265 BFD_ASSERT (s != NULL);
4266
4267 rel.r_offset = (h->root.u.def.value
4268 + h->root.u.def.section->output_section->vma
4269 + h->root.u.def.section->output_offset);
4270 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
4271 rel.r_addend = 0;
4272 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4273 ((Elf32_External_Rela *) s->contents
4274 + s->reloc_count));
4275 ++s->reloc_count;
4276 }
4277
4278 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4279 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4280 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
4281 sym->st_shndx = SHN_ABS;
4282
4283 return true;
4284 }
4285
4286 /* Finish up the dynamic sections. */
4287
4288 static boolean
4289 sh_elf_finish_dynamic_sections (output_bfd, info)
4290 bfd *output_bfd;
4291 struct bfd_link_info *info;
4292 {
4293 bfd *dynobj;
4294 asection *sgot;
4295 asection *sdyn;
4296
4297 dynobj = elf_hash_table (info)->dynobj;
4298
4299 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4300 BFD_ASSERT (sgot != NULL);
4301 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4302
4303 if (elf_hash_table (info)->dynamic_sections_created)
4304 {
4305 asection *splt;
4306 Elf32_External_Dyn *dyncon, *dynconend;
4307
4308 BFD_ASSERT (sdyn != NULL);
4309
4310 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4311 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4312 for (; dyncon < dynconend; dyncon++)
4313 {
4314 Elf_Internal_Dyn dyn;
4315 const char *name;
4316 asection *s;
4317
4318 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4319
4320 switch (dyn.d_tag)
4321 {
4322 default:
4323 break;
4324
4325 case DT_PLTGOT:
4326 name = ".got";
4327 goto get_vma;
4328
4329 case DT_JMPREL:
4330 name = ".rela.plt";
4331 get_vma:
4332 s = bfd_get_section_by_name (output_bfd, name);
4333 BFD_ASSERT (s != NULL);
4334 dyn.d_un.d_ptr = s->vma;
4335 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4336 break;
4337
4338 case DT_PLTRELSZ:
4339 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4340 BFD_ASSERT (s != NULL);
4341 if (s->_cooked_size != 0)
4342 dyn.d_un.d_val = s->_cooked_size;
4343 else
4344 dyn.d_un.d_val = s->_raw_size;
4345 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4346 break;
4347
4348 case DT_RELASZ:
4349 /* My reading of the SVR4 ABI indicates that the
4350 procedure linkage table relocs (DT_JMPREL) should be
4351 included in the overall relocs (DT_RELA). This is
4352 what Solaris does. However, UnixWare can not handle
4353 that case. Therefore, we override the DT_RELASZ entry
4354 here to make it not include the JMPREL relocs. Since
4355 the linker script arranges for .rela.plt to follow all
4356 other relocation sections, we don't have to worry
4357 about changing the DT_RELA entry. */
4358 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4359 if (s != NULL)
4360 {
4361 if (s->_cooked_size != 0)
4362 dyn.d_un.d_val -= s->_cooked_size;
4363 else
4364 dyn.d_un.d_val -= s->_raw_size;
4365 }
4366 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4367 break;
4368 }
4369 }
4370
4371 /* Fill in the first entry in the procedure linkage table. */
4372 splt = bfd_get_section_by_name (dynobj, ".plt");
4373 if (splt && splt->_raw_size > 0)
4374 {
4375 if (info->shared)
4376 {
4377 if (elf_sh_pic_plt_entry == NULL)
4378 {
4379 elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
4380 elf_sh_pic_plt_entry_be :
4381 elf_sh_pic_plt_entry_le);
4382 }
4383 memcpy (splt->contents, elf_sh_pic_plt_entry,
4384 elf_sh_sizeof_plt (info));
4385 }
4386 else
4387 {
4388 if (elf_sh_plt0_entry == NULL)
4389 {
4390 elf_sh_plt0_entry = (bfd_big_endian (output_bfd) ?
4391 elf_sh_plt0_entry_be :
4392 elf_sh_plt0_entry_le);
4393 }
4394 memcpy (splt->contents, elf_sh_plt0_entry, PLT_ENTRY_SIZE);
4395 bfd_put_32 (output_bfd,
4396 sgot->output_section->vma + sgot->output_offset + 4,
4397 splt->contents + elf_sh_plt0_gotid_offset (info));
4398 bfd_put_32 (output_bfd,
4399 sgot->output_section->vma + sgot->output_offset + 8,
4400 splt->contents + elf_sh_plt0_linker_offset (info));
4401 }
4402
4403 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4404 really seem like the right value. */
4405 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
4406 }
4407 }
4408
4409 /* Fill in the first three entries in the global offset table. */
4410 if (sgot->_raw_size > 0)
4411 {
4412 if (sdyn == NULL)
4413 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4414 else
4415 bfd_put_32 (output_bfd,
4416 sdyn->output_section->vma + sdyn->output_offset,
4417 sgot->contents);
4418 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4419 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4420 }
4421
4422 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4423
4424 return true;
4425 }
4426
4427 static enum elf_reloc_type_class
4428 sh_elf_reloc_type_class (type)
4429 int type;
4430 {
4431 switch (type)
4432 {
4433 case R_SH_RELATIVE:
4434 return reloc_class_relative;
4435 case R_SH_JMP_SLOT:
4436 return reloc_class_plt;
4437 case R_SH_COPY:
4438 return reloc_class_copy;
4439 default:
4440 return reloc_class_normal;
4441 }
4442 }
4443
4444 #ifndef ELF_ARCH
4445 #define TARGET_BIG_SYM bfd_elf32_sh_vec
4446 #define TARGET_BIG_NAME "elf32-sh"
4447 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
4448 #define TARGET_LITTLE_NAME "elf32-shl"
4449 #define ELF_ARCH bfd_arch_sh
4450 #define ELF_MACHINE_CODE EM_SH
4451 #define ELF_MAXPAGESIZE 128
4452
4453 #define elf_symbol_leading_char '_'
4454 #endif /* ELF_ARCH */
4455
4456 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
4457 #define elf_info_to_howto sh_elf_info_to_howto
4458 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
4459 #define elf_backend_relocate_section sh_elf_relocate_section
4460 #define bfd_elf32_bfd_get_relocated_section_contents \
4461 sh_elf_get_relocated_section_contents
4462 #define elf_backend_object_p sh_elf_set_mach_from_flags
4463 #define bfd_elf32_bfd_set_private_bfd_flags \
4464 sh_elf_set_private_flags
4465 #define bfd_elf32_bfd_copy_private_bfd_data \
4466 sh_elf_copy_private_data
4467 #define bfd_elf32_bfd_merge_private_bfd_data \
4468 sh_elf_merge_private_data
4469
4470 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
4471 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
4472 #define elf_backend_check_relocs sh_elf_check_relocs
4473
4474 #define elf_backend_can_gc_sections 1
4475 #define elf_backend_create_dynamic_sections \
4476 sh_elf_create_dynamic_sections
4477 #define bfd_elf32_bfd_link_hash_table_create \
4478 sh_elf_link_hash_table_create
4479 #define elf_backend_adjust_dynamic_symbol \
4480 sh_elf_adjust_dynamic_symbol
4481 #define elf_backend_size_dynamic_sections \
4482 sh_elf_size_dynamic_sections
4483 #define elf_backend_finish_dynamic_symbol \
4484 sh_elf_finish_dynamic_symbol
4485 #define elf_backend_finish_dynamic_sections \
4486 sh_elf_finish_dynamic_sections
4487 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
4488
4489 #define elf_backend_want_got_plt 1
4490 #define elf_backend_plt_readonly 1
4491 #define elf_backend_want_plt_sym 0
4492 #define elf_backend_got_header_size 12
4493 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
4494 #include "elf32-target.h"
git-cvsimport of binutils cvsroot