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