?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2000-12-22 H.J. Lu <hjl@gnu.org>
[binutils.git] / bfd / elf32-sh.c
blob1648b718932c4758c4d7c1256319457b0cef7e15
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
2849 \f
2850 /* Relocate an SH ELF section. */
2851
2852 static boolean
2853 sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
2854 contents, relocs, local_syms, local_sections)
2855 bfd *output_bfd ATTRIBUTE_UNUSED;
2856 struct bfd_link_info *info;
2857 bfd *input_bfd;
2858 asection *input_section;
2859 bfd_byte *contents;
2860 Elf_Internal_Rela *relocs;
2861 Elf_Internal_Sym *local_syms;
2862 asection **local_sections;
2863 {
2864 Elf_Internal_Shdr *symtab_hdr;
2865 struct elf_link_hash_entry **sym_hashes;
2866 Elf_Internal_Rela *rel, *relend;
2867 bfd *dynobj;
2868 bfd_vma *local_got_offsets;
2869 asection *sgot;
2870 asection *splt;
2871 asection *sreloc;
2872
2873 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2874 sym_hashes = elf_sym_hashes (input_bfd);
2875 dynobj = elf_hash_table (info)->dynobj;
2876 local_got_offsets = elf_local_got_offsets (input_bfd);
2877
2878 sgot = NULL;
2879 splt = NULL;
2880 sreloc = NULL;
2881
2882 rel = relocs;
2883 relend = relocs + input_section->reloc_count;
2884 for (; rel < relend; rel++)
2885 {
2886 int r_type;
2887 reloc_howto_type *howto;
2888 unsigned long r_symndx;
2889 Elf_Internal_Sym *sym;
2890 asection *sec;
2891 struct elf_link_hash_entry *h;
2892 bfd_vma relocation;
2893 bfd_vma addend = (bfd_vma) 0;
2894 bfd_reloc_status_type r;
2895
2896 r_symndx = ELF32_R_SYM (rel->r_info);
2897
2898 r_type = ELF32_R_TYPE (rel->r_info);
2899
2900 /* Many of the relocs are only used for relaxing, and are
2901 handled entirely by the relaxation code. */
2902 if (r_type > (int) R_SH_LAST_INVALID_RELOC
2903 && r_type < (int) R_SH_LOOP_START)
2904 continue;
2905 if (r_type == (int) R_SH_NONE)
2906 continue;
2907
2908 if (r_type < 0
2909 || r_type >= R_SH_max
2910 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
2911 && r_type <= (int) R_SH_LAST_INVALID_RELOC)
2912 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
2913 && r_type <= (int) R_SH_LAST_INVALID_RELOC_2))
2914 {
2915 bfd_set_error (bfd_error_bad_value);
2916 return false;
2917 }
2918
2919 howto = sh_elf_howto_table + r_type;
2920
2921 /* This is a final link. */
2922 h = NULL;
2923 sym = NULL;
2924 sec = NULL;
2925 if (r_symndx < symtab_hdr->sh_info)
2926 {
2927 sym = local_syms + r_symndx;
2928 sec = local_sections[r_symndx];
2929 relocation = (sec->output_section->vma
2930 + sec->output_offset
2931 + sym->st_value);
2932
2933 if (info->relocateable)
2934 {
2935 /* This is a relocateable link. We don't have to change
2936 anything, unless the reloc is against a section symbol,
2937 in which case we have to adjust according to where the
2938 section symbol winds up in the output section. */
2939 sym = local_syms + r_symndx;
2940 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2941 goto final_link_relocate;
2942
2943 continue;
2944 }
2945 }
2946 else
2947 {
2948 /* Section symbol are never (?) placed in the hash table, so
2949 we can just ignore hash relocations when creating a
2950 relocateable object file. */
2951 if (info->relocateable)
2952 continue;
2953
2954 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2955 while (h->root.type == bfd_link_hash_indirect
2956 || h->root.type == bfd_link_hash_warning)
2957 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2958 if (h->root.type == bfd_link_hash_defined
2959 || h->root.type == bfd_link_hash_defweak)
2960 {
2961 sec = h->root.u.def.section;
2962 /* In these cases, we don't need the relocation value.
2963 We check specially because in some obscure cases
2964 sec->output_section will be NULL. */
2965 if (r_type == R_SH_GOTPC
2966 || (r_type == R_SH_PLT32
2967 && h->plt.offset != (bfd_vma) -1)
2968 || (r_type == R_SH_GOT32
2969 && elf_hash_table (info)->dynamic_sections_created
2970 && (! info->shared
2971 || (! info->symbolic && h->dynindx != -1)
2972 || (h->elf_link_hash_flags
2973 & ELF_LINK_HASH_DEF_REGULAR) == 0))
2974 /* The cases above are those in which relocation is
2975 overwritten in the switch block below. The cases
2976 below are those in which we must defer relocation
2977 to run-time, because we can't resolve absolute
2978 addresses when creating a shared library. */
2979 || (info->shared
2980 && ((! info->symbolic && h->dynindx != -1)
2981 || (h->elf_link_hash_flags
2982 & ELF_LINK_HASH_DEF_REGULAR) == 0)
2983 && ((r_type == R_SH_DIR32
2984 && !(ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2985 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN))
2986 || r_type == R_SH_REL32)
2987 && ((input_section->flags & SEC_ALLOC) != 0
2988 /* DWARF will emit R_SH_DIR32 relocations in its
2989 sections against symbols defined externally
2990 in shared libraries. We can't do anything
2991 with them here. */
2992 || (input_section->flags & SEC_DEBUGGING) != 0)))
2993 relocation = 0;
2994 else if (sec->output_section == NULL)
2995 {
2996 (*_bfd_error_handler)
2997 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
2998 bfd_get_filename (input_bfd), h->root.root.string,
2999 bfd_get_section_name (input_bfd, input_section));
3000 relocation = 0;
3001 }
3002 else
3003 relocation = (h->root.u.def.value
3004 + sec->output_section->vma
3005 + sec->output_offset);
3006 }
3007 else if (h->root.type == bfd_link_hash_undefweak)
3008 relocation = 0;
3009 else if (info->shared && !info->symbolic && !info->no_undefined)
3010 relocation = 0;
3011 else
3012 {
3013 if (! ((*info->callbacks->undefined_symbol)
3014 (info, h->root.root.string, input_bfd,
3015 input_section, rel->r_offset, true)))
3016 return false;
3017 relocation = 0;
3018 }
3019 }
3020
3021 switch ((int) r_type)
3022 {
3023 final_link_relocate:
3024 /* COFF relocs don't use the addend. The addend is used for
3025 R_SH_DIR32 to be compatible with other compilers. */
3026 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3027 contents, rel->r_offset,
3028 relocation, addend);
3029 break;
3030
3031 case R_SH_IND12W:
3032 case R_SH_DIR8WPN:
3033 case R_SH_DIR8WPZ:
3034 case R_SH_DIR8WPL:
3035 /* These should normally be handled by the assembler, but at
3036 least IND12W is generated by ourselves, so we must deal
3037 with it. */
3038 relocation -= 4;
3039 goto final_link_relocate;
3040
3041 default:
3042 bfd_set_error (bfd_error_bad_value);
3043 return false;
3044
3045 case R_SH_DIR32:
3046 case R_SH_REL32:
3047 if (info->shared
3048 && (input_section->flags & SEC_ALLOC) != 0
3049 && (r_type != R_SH_REL32
3050 || (h != NULL
3051 && h->dynindx != -1
3052 && (! info->symbolic
3053 || (h->elf_link_hash_flags
3054 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
3055 {
3056 Elf_Internal_Rela outrel;
3057 boolean skip, relocate;
3058
3059 /* When generating a shared object, these relocations
3060 are copied into the output file to be resolved at run
3061 time. */
3062
3063 if (sreloc == NULL)
3064 {
3065 const char *name;
3066
3067 name = (bfd_elf_string_from_elf_section
3068 (input_bfd,
3069 elf_elfheader (input_bfd)->e_shstrndx,
3070 elf_section_data (input_section)->rel_hdr.sh_name));
3071 if (name == NULL)
3072 return false;
3073
3074 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
3075 && strcmp (bfd_get_section_name (input_bfd,
3076 input_section),
3077 name + 5) == 0);
3078
3079 sreloc = bfd_get_section_by_name (dynobj, name);
3080 BFD_ASSERT (sreloc != NULL);
3081 }
3082
3083 skip = false;
3084
3085 if (elf_section_data (input_section)->stab_info == NULL)
3086 outrel.r_offset = rel->r_offset;
3087 else
3088 {
3089 bfd_vma off;
3090
3091 off = (_bfd_stab_section_offset
3092 (output_bfd, &elf_hash_table (info)->stab_info,
3093 input_section,
3094 &elf_section_data (input_section)->stab_info,
3095 rel->r_offset));
3096 if (off == (bfd_vma) -1)
3097 skip = true;
3098 outrel.r_offset = off;
3099 }
3100
3101 outrel.r_offset += (input_section->output_section->vma
3102 + input_section->output_offset);
3103
3104 if (skip)
3105 {
3106 memset (&outrel, 0, sizeof outrel);
3107 relocate = false;
3108 }
3109 else if (r_type == R_SH_REL32)
3110 {
3111 BFD_ASSERT (h != NULL && h->dynindx != -1);
3112 relocate = false;
3113 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
3114 outrel.r_addend = rel->r_addend;
3115 }
3116 else
3117 {
3118 /* h->dynindx may be -1 if this symbol was marked to
3119 become local. */
3120 if (h == NULL
3121 || ((info->symbolic || h->dynindx == -1)
3122 && (h->elf_link_hash_flags
3123 & ELF_LINK_HASH_DEF_REGULAR) != 0))
3124 {
3125 relocate = true;
3126 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
3127 outrel.r_addend = relocation + rel->r_addend;
3128 }
3129 else
3130 {
3131 BFD_ASSERT (h->dynindx != -1);
3132 relocate = false;
3133 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
3134 outrel.r_addend = relocation + rel->r_addend;
3135 }
3136 }
3137
3138 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3139 (((Elf32_External_Rela *)
3140 sreloc->contents)
3141 + sreloc->reloc_count));
3142 ++sreloc->reloc_count;
3143
3144 /* If this reloc is against an external symbol, we do
3145 not want to fiddle with the addend. Otherwise, we
3146 need to include the symbol value so that it becomes
3147 an addend for the dynamic reloc. */
3148 if (! relocate)
3149 continue;
3150 }
3151 else if (r_type == R_SH_DIR32)
3152 addend = rel->r_addend;
3153 goto final_link_relocate;
3154
3155 case R_SH_GOT32:
3156 /* Relocation is to the entry for this symbol in the global
3157 offset table. */
3158 if (sgot == NULL)
3159 {
3160 sgot = bfd_get_section_by_name (dynobj, ".got");
3161 BFD_ASSERT (sgot != NULL);
3162 }
3163
3164 if (h != NULL)
3165 {
3166 bfd_vma off;
3167
3168 off = h->got.offset;
3169 BFD_ASSERT (off != (bfd_vma) -1);
3170
3171 if (! elf_hash_table (info)->dynamic_sections_created
3172 || (info->shared
3173 && (info->symbolic || h->dynindx == -1
3174 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3175 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
3176 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
3177 {
3178 /* This is actually a static link, or it is a
3179 -Bsymbolic link and the symbol is defined
3180 locally, or the symbol was forced to be local
3181 because of a version file. We must initialize
3182 this entry in the global offset table. Since the
3183 offset must always be a multiple of 4, we use the
3184 least significant bit to record whether we have
3185 initialized it already.
3186
3187 When doing a dynamic link, we create a .rela.got
3188 relocation entry to initialize the value. This
3189 is done in the finish_dynamic_symbol routine. */
3190 if ((off & 1) != 0)
3191 off &= ~1;
3192 else
3193 {
3194 bfd_put_32 (output_bfd, relocation,
3195 sgot->contents + off);
3196 h->got.offset |= 1;
3197 }
3198 }
3199
3200 relocation = sgot->output_offset + off;
3201 }
3202 else
3203 {
3204 bfd_vma off;
3205
3206 BFD_ASSERT (local_got_offsets != NULL
3207 && local_got_offsets[r_symndx] != (bfd_vma) -1);
3208
3209 off = local_got_offsets[r_symndx];
3210
3211 /* The offset must always be a multiple of 4. We use
3212 the least significant bit to record whether we have
3213 already generated the necessary reloc. */
3214 if ((off & 1) != 0)
3215 off &= ~1;
3216 else
3217 {
3218 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
3219
3220 if (info->shared)
3221 {
3222 asection *srelgot;
3223 Elf_Internal_Rela outrel;
3224
3225 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3226 BFD_ASSERT (srelgot != NULL);
3227
3228 outrel.r_offset = (sgot->output_section->vma
3229 + sgot->output_offset
3230 + off);
3231 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
3232 outrel.r_addend = relocation;
3233 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3234 (((Elf32_External_Rela *)
3235 srelgot->contents)
3236 + srelgot->reloc_count));
3237 ++srelgot->reloc_count;
3238 }
3239
3240 local_got_offsets[r_symndx] |= 1;
3241 }
3242
3243 relocation = sgot->output_offset + off;
3244 }
3245
3246 goto final_link_relocate;
3247
3248 case R_SH_GOTOFF:
3249 /* Relocation is relative to the start of the global offset
3250 table. */
3251
3252 if (sgot == NULL)
3253 {
3254 sgot = bfd_get_section_by_name (dynobj, ".got");
3255 BFD_ASSERT (sgot != NULL);
3256 }
3257
3258 /* Note that sgot->output_offset is not involved in this
3259 calculation. We always want the start of .got. If we
3260 defined _GLOBAL_OFFSET_TABLE in a different way, as is
3261 permitted by the ABI, we might have to change this
3262 calculation. */
3263 relocation -= sgot->output_section->vma;
3264
3265 goto final_link_relocate;
3266
3267 case R_SH_GOTPC:
3268 /* Use global offset table as symbol value. */
3269
3270 if (sgot == NULL)
3271 {
3272 sgot = bfd_get_section_by_name (dynobj, ".got");
3273 BFD_ASSERT (sgot != NULL);
3274 }
3275
3276 relocation = sgot->output_section->vma;
3277
3278 goto final_link_relocate;
3279
3280 case R_SH_PLT32:
3281 /* Relocation is to the entry for this symbol in the
3282 procedure linkage table. */
3283
3284 /* Resolve a PLT reloc against a local symbol directly,
3285 without using the procedure linkage table. */
3286 if (h == NULL)
3287 goto final_link_relocate;
3288
3289 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3290 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
3291 goto final_link_relocate;
3292
3293 if (h->plt.offset == (bfd_vma) -1)
3294 {
3295 /* We didn't make a PLT entry for this symbol. This
3296 happens when statically linking PIC code, or when
3297 using -Bsymbolic. */
3298 goto final_link_relocate;
3299 }
3300
3301 if (splt == NULL)
3302 {
3303 splt = bfd_get_section_by_name (dynobj, ".plt");
3304 BFD_ASSERT (splt != NULL);
3305 }
3306
3307 relocation = (splt->output_section->vma
3308 + splt->output_offset
3309 + h->plt.offset);
3310
3311 goto final_link_relocate;
3312
3313 case R_SH_LOOP_START:
3314 {
3315 static bfd_vma start, end;
3316
3317 start = (relocation + rel->r_addend
3318 - (sec->output_section->vma + sec->output_offset));
3319 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
3320 rel->r_offset, sec, start, end);
3321 break;
3322
3323 case R_SH_LOOP_END:
3324 end = (relocation + rel->r_addend
3325 - (sec->output_section->vma + sec->output_offset));
3326 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
3327 rel->r_offset, sec, start, end);
3328 break;
3329 }
3330 }
3331
3332 if (r != bfd_reloc_ok)
3333 {
3334 switch (r)
3335 {
3336 default:
3337 case bfd_reloc_outofrange:
3338 abort ();
3339 case bfd_reloc_overflow:
3340 {
3341 const char *name;
3342
3343 if (h != NULL)
3344 name = h->root.root.string;
3345 else
3346 {
3347 name = (bfd_elf_string_from_elf_section
3348 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3349 if (name == NULL)
3350 return false;
3351 if (*name == '\0')
3352 name = bfd_section_name (input_bfd, sec);
3353 }
3354 if (! ((*info->callbacks->reloc_overflow)
3355 (info, name, howto->name, (bfd_vma) 0,
3356 input_bfd, input_section, rel->r_offset)))
3357 return false;
3358 }
3359 break;
3360 }
3361 }
3362 }
3363
3364 return true;
3365 }
3366
3367 /* This is a version of bfd_generic_get_relocated_section_contents
3368 which uses sh_elf_relocate_section. */
3369
3370 static bfd_byte *
3371 sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
3372 data, relocateable, symbols)
3373 bfd *output_bfd;
3374 struct bfd_link_info *link_info;
3375 struct bfd_link_order *link_order;
3376 bfd_byte *data;
3377 boolean relocateable;
3378 asymbol **symbols;
3379 {
3380 Elf_Internal_Shdr *symtab_hdr;
3381 asection *input_section = link_order->u.indirect.section;
3382 bfd *input_bfd = input_section->owner;
3383 asection **sections = NULL;
3384 Elf_Internal_Rela *internal_relocs = NULL;
3385 Elf32_External_Sym *external_syms = NULL;
3386 Elf_Internal_Sym *internal_syms = NULL;
3387
3388 /* We only need to handle the case of relaxing, or of having a
3389 particular set of section contents, specially. */
3390 if (relocateable
3391 || elf_section_data (input_section)->this_hdr.contents == NULL)
3392 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3393 link_order, data,
3394 relocateable,
3395 symbols);
3396
3397 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3398
3399 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3400 input_section->_raw_size);
3401
3402 if ((input_section->flags & SEC_RELOC) != 0
3403 && input_section->reloc_count > 0)
3404 {
3405 Elf_Internal_Sym *isymp;
3406 asection **secpp;
3407 Elf32_External_Sym *esym, *esymend;
3408
3409 if (symtab_hdr->contents != NULL)
3410 external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
3411 else
3412 {
3413 external_syms = ((Elf32_External_Sym *)
3414 bfd_malloc (symtab_hdr->sh_info
3415 * sizeof (Elf32_External_Sym)));
3416 if (external_syms == NULL && symtab_hdr->sh_info > 0)
3417 goto error_return;
3418 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
3419 || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
3420 symtab_hdr->sh_info, input_bfd)
3421 != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
3422 goto error_return;
3423 }
3424
3425 internal_relocs = (_bfd_elf32_link_read_relocs
3426 (input_bfd, input_section, (PTR) NULL,
3427 (Elf_Internal_Rela *) NULL, false));
3428 if (internal_relocs == NULL)
3429 goto error_return;
3430
3431 internal_syms = ((Elf_Internal_Sym *)
3432 bfd_malloc (symtab_hdr->sh_info
3433 * sizeof (Elf_Internal_Sym)));
3434 if (internal_syms == NULL && symtab_hdr->sh_info > 0)
3435 goto error_return;
3436
3437 sections = (asection **) bfd_malloc (symtab_hdr->sh_info
3438 * sizeof (asection *));
3439 if (sections == NULL && symtab_hdr->sh_info > 0)
3440 goto error_return;
3441
3442 isymp = internal_syms;
3443 secpp = sections;
3444 esym = external_syms;
3445 esymend = esym + symtab_hdr->sh_info;
3446 for (; esym < esymend; ++esym, ++isymp, ++secpp)
3447 {
3448 asection *isec;
3449
3450 bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
3451
3452 if (isymp->st_shndx == SHN_UNDEF)
3453 isec = bfd_und_section_ptr;
3454 else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
3455 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
3456 else if (isymp->st_shndx == SHN_ABS)
3457 isec = bfd_abs_section_ptr;
3458 else if (isymp->st_shndx == SHN_COMMON)
3459 isec = bfd_com_section_ptr;
3460 else
3461 {
3462 /* Who knows? */
3463 isec = NULL;
3464 }
3465
3466 *secpp = isec;
3467 }
3468
3469 if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
3470 input_section, data, internal_relocs,
3471 internal_syms, sections))
3472 goto error_return;
3473
3474 if (sections != NULL)
3475 free (sections);
3476 sections = NULL;
3477 if (internal_syms != NULL)
3478 free (internal_syms);
3479 internal_syms = NULL;
3480 if (external_syms != NULL && symtab_hdr->contents == NULL)
3481 free (external_syms);
3482 external_syms = NULL;
3483 if (internal_relocs != elf_section_data (input_section)->relocs)
3484 free (internal_relocs);
3485 internal_relocs = NULL;
3486 }
3487
3488 return data;
3489
3490 error_return:
3491 if (internal_relocs != NULL
3492 && internal_relocs != elf_section_data (input_section)->relocs)
3493 free (internal_relocs);
3494 if (external_syms != NULL && symtab_hdr->contents == NULL)
3495 free (external_syms);
3496 if (internal_syms != NULL)
3497 free (internal_syms);
3498 if (sections != NULL)
3499 free (sections);
3500 return NULL;
3501 }
3502 static asection *
3503 sh_elf_gc_mark_hook (abfd, info, rel, h, sym)
3504 bfd *abfd;
3505 struct bfd_link_info *info ATTRIBUTE_UNUSED;
3506 Elf_Internal_Rela *rel;
3507 struct elf_link_hash_entry *h;
3508 Elf_Internal_Sym *sym;
3509 {
3510 if (h != NULL)
3511 {
3512 switch (ELF32_R_TYPE (rel->r_info))
3513 {
3514 case R_SH_GNU_VTINHERIT:
3515 case R_SH_GNU_VTENTRY:
3516 break;
3517
3518 default:
3519 switch (h->root.type)
3520 {
3521 case bfd_link_hash_defined:
3522 case bfd_link_hash_defweak:
3523 return h->root.u.def.section;
3524
3525 case bfd_link_hash_common:
3526 return h->root.u.c.p->section;
3527
3528 default:
3529 break;
3530 }
3531 }
3532 }
3533 else
3534 {
3535 if (!(elf_bad_symtab (abfd)
3536 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
3537 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
3538 && sym->st_shndx != SHN_COMMON))
3539 return bfd_section_from_elf_index (abfd, sym->st_shndx);
3540 }
3541 return NULL;
3542 }
3543
3544 /* Update the got entry reference counts for the section being removed. */
3545
3546 static boolean
3547 sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
3548 bfd *abfd ATTRIBUTE_UNUSED;
3549 struct bfd_link_info *info ATTRIBUTE_UNUSED;
3550 asection *sec ATTRIBUTE_UNUSED;
3551 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
3552 {
3553 /* We use got and plt entries for sh, but it would seem that the
3554 existing SH code does no sort of reference counting or whatnot on
3555 its GOT and PLT entries, so it is not possible to garbage collect
3556 them at this time. */
3557 return true;
3558 }
3559
3560 /* Look through the relocs for a section during the first phase.
3561 Since we don't do .gots or .plts, we just need to consider the
3562 virtual table relocs for gc. */
3563
3564 static boolean
3565 sh_elf_check_relocs (abfd, info, sec, relocs)
3566 bfd *abfd;
3567 struct bfd_link_info *info;
3568 asection *sec;
3569 const Elf_Internal_Rela *relocs;
3570 {
3571 Elf_Internal_Shdr *symtab_hdr;
3572 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
3573 const Elf_Internal_Rela *rel;
3574 const Elf_Internal_Rela *rel_end;
3575 bfd *dynobj;
3576 bfd_vma *local_got_offsets;
3577 asection *sgot;
3578 asection *srelgot;
3579 asection *sreloc;
3580
3581 sgot = NULL;
3582 srelgot = NULL;
3583 sreloc = NULL;
3584
3585 if (info->relocateable)
3586 return true;
3587
3588 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3589 sym_hashes = elf_sym_hashes (abfd);
3590 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
3591 if (!elf_bad_symtab (abfd))
3592 sym_hashes_end -= symtab_hdr->sh_info;
3593
3594 dynobj = elf_hash_table (info)->dynobj;
3595 local_got_offsets = elf_local_got_offsets (abfd);
3596
3597 rel_end = relocs + sec->reloc_count;
3598 for (rel = relocs; rel < rel_end; rel++)
3599 {
3600 struct elf_link_hash_entry *h;
3601 unsigned long r_symndx;
3602
3603 r_symndx = ELF32_R_SYM (rel->r_info);
3604 if (r_symndx < symtab_hdr->sh_info)
3605 h = NULL;
3606 else
3607 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3608
3609 /* Some relocs require a global offset table. */
3610 if (dynobj == NULL)
3611 {
3612 switch (ELF32_R_TYPE (rel->r_info))
3613 {
3614 case R_SH_GOT32:
3615 case R_SH_GOTOFF:
3616 case R_SH_GOTPC:
3617 elf_hash_table (info)->dynobj = dynobj = abfd;
3618 if (! _bfd_elf_create_got_section (dynobj, info))
3619 return false;
3620 break;
3621
3622 default:
3623 break;
3624 }
3625 }
3626
3627 switch (ELF32_R_TYPE (rel->r_info))
3628 {
3629 /* This relocation describes the C++ object vtable hierarchy.
3630 Reconstruct it for later use during GC. */
3631 case R_SH_GNU_VTINHERIT:
3632 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3633 return false;
3634 break;
3635
3636 /* This relocation describes which C++ vtable entries are actually
3637 used. Record for later use during GC. */
3638 case R_SH_GNU_VTENTRY:
3639 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3640 return false;
3641 break;
3642
3643 case R_SH_GOT32:
3644 /* This symbol requires a global offset table entry. */
3645
3646 if (sgot == NULL)
3647 {
3648 sgot = bfd_get_section_by_name (dynobj, ".got");
3649 BFD_ASSERT (sgot != NULL);
3650 }
3651
3652 if (srelgot == NULL
3653 && (h != NULL || info->shared))
3654 {
3655 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3656 if (srelgot == NULL)
3657 {
3658 srelgot = bfd_make_section (dynobj, ".rela.got");
3659 if (srelgot == NULL
3660 || ! bfd_set_section_flags (dynobj, srelgot,
3661 (SEC_ALLOC
3662 | SEC_LOAD
3663 | SEC_HAS_CONTENTS
3664 | SEC_IN_MEMORY
3665 | SEC_LINKER_CREATED
3666 | SEC_READONLY))
3667 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
3668 return false;
3669 }
3670 }
3671
3672 if (h != NULL)
3673 {
3674 if (h->got.offset != (bfd_vma) -1)
3675 {
3676 /* We have already allocated space in the .got. */
3677 break;
3678 }
3679 h->got.offset = sgot->_raw_size;
3680
3681 /* Make sure this symbol is output as a dynamic symbol. */
3682 if (h->dynindx == -1)
3683 {
3684 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
3685 return false;
3686 }
3687
3688 srelgot->_raw_size += sizeof (Elf32_External_Rela);
3689 }
3690 else
3691 {
3692 /* This is a global offset table entry for a local
3693 symbol. */
3694 if (local_got_offsets == NULL)
3695 {
3696 size_t size;
3697 register unsigned int i;
3698
3699 size = symtab_hdr->sh_info * sizeof (bfd_vma);
3700 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
3701 if (local_got_offsets == NULL)
3702 return false;
3703 elf_local_got_offsets (abfd) = local_got_offsets;
3704 for (i = 0; i < symtab_hdr->sh_info; i++)
3705 local_got_offsets[i] = (bfd_vma) -1;
3706 }
3707 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
3708 {
3709 /* We have already allocated space in the .got. */
3710 break;
3711 }
3712 local_got_offsets[r_symndx] = sgot->_raw_size;
3713
3714 if (info->shared)
3715 {
3716 /* If we are generating a shared object, we need to
3717 output a R_SH_RELATIVE reloc so that the dynamic
3718 linker can adjust this GOT entry. */
3719 srelgot->_raw_size += sizeof (Elf32_External_Rela);
3720 }
3721 }
3722
3723 sgot->_raw_size += 4;
3724
3725 break;
3726
3727 case R_SH_PLT32:
3728 /* This symbol requires a procedure linkage table entry. We
3729 actually build the entry in adjust_dynamic_symbol,
3730 because this might be a case of linking PIC code which is
3731 never referenced by a dynamic object, in which case we
3732 don't need to generate a procedure linkage table entry
3733 after all. */
3734
3735 /* If this is a local symbol, we resolve it directly without
3736 creating a procedure linkage table entry. */
3737 if (h == NULL)
3738 continue;
3739
3740 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
3741 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
3742 break;
3743
3744 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
3745
3746 break;
3747
3748 case R_SH_DIR32:
3749 case R_SH_REL32:
3750 if (h != NULL)
3751 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
3752
3753 /* If we are creating a shared library, and this is a reloc
3754 against a global symbol, or a non PC relative reloc
3755 against a local symbol, then we need to copy the reloc
3756 into the shared library. However, if we are linking with
3757 -Bsymbolic, we do not need to copy a reloc against a
3758 global symbol which is defined in an object we are
3759 including in the link (i.e., DEF_REGULAR is set). At
3760 this point we have not seen all the input files, so it is
3761 possible that DEF_REGULAR is not set now but will be set
3762 later (it is never cleared). We account for that
3763 possibility below by storing information in the
3764 pcrel_relocs_copied field of the hash table entry. */
3765 if (info->shared
3766 && (sec->flags & SEC_ALLOC) != 0
3767 && (ELF32_R_TYPE (rel->r_info) != R_SH_REL32
3768 || (h != NULL
3769 && (! info->symbolic
3770 || (h->elf_link_hash_flags
3771 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
3772 {
3773 /* When creating a shared object, we must copy these
3774 reloc types into the output file. We create a reloc
3775 section in dynobj and make room for this reloc. */
3776 if (sreloc == NULL)
3777 {
3778 const char *name;
3779
3780 name = (bfd_elf_string_from_elf_section
3781 (abfd,
3782 elf_elfheader (abfd)->e_shstrndx,
3783 elf_section_data (sec)->rel_hdr.sh_name));
3784 if (name == NULL)
3785 return false;
3786
3787 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
3788 && strcmp (bfd_get_section_name (abfd, sec),
3789 name + 5) == 0);
3790
3791 sreloc = bfd_get_section_by_name (dynobj, name);
3792 if (sreloc == NULL)
3793 {
3794 flagword flags;
3795
3796 sreloc = bfd_make_section (dynobj, name);
3797 flags = (SEC_HAS_CONTENTS | SEC_READONLY
3798 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3799 if ((sec->flags & SEC_ALLOC) != 0)
3800 flags |= SEC_ALLOC | SEC_LOAD;
3801 if (sreloc == NULL
3802 || ! bfd_set_section_flags (dynobj, sreloc, flags)
3803 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
3804 return false;
3805 }
3806 }
3807
3808 sreloc->_raw_size += sizeof (Elf32_External_Rela);
3809
3810 /* If we are linking with -Bsymbolic, and this is a
3811 global symbol, we count the number of PC relative
3812 relocations we have entered for this symbol, so that
3813 we can discard them again if the symbol is later
3814 defined by a regular object. Note that this function
3815 is only called if we are using an elf_sh linker
3816 hash table, which means that h is really a pointer to
3817 an elf_sh_link_hash_entry. */
3818 if (h != NULL && info->symbolic
3819 && ELF32_R_TYPE (rel->r_info) == R_SH_REL32)
3820 {
3821 struct elf_sh_link_hash_entry *eh;
3822 struct elf_sh_pcrel_relocs_copied *p;
3823
3824 eh = (struct elf_sh_link_hash_entry *) h;
3825
3826 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
3827 if (p->section == sreloc)
3828 break;
3829
3830 if (p == NULL)
3831 {
3832 p = ((struct elf_sh_pcrel_relocs_copied *)
3833 bfd_alloc (dynobj, sizeof *p));
3834 if (p == NULL)
3835 return false;
3836 p->next = eh->pcrel_relocs_copied;
3837 eh->pcrel_relocs_copied = p;
3838 p->section = sreloc;
3839 p->count = 0;
3840 }
3841
3842 ++p->count;
3843 }
3844 }
3845
3846 break;
3847 }
3848 }
3849
3850 return true;
3851 }
3852
3853 static boolean
3854 sh_elf_set_mach_from_flags (abfd)
3855 bfd *abfd;
3856 {
3857 flagword flags = elf_elfheader (abfd)->e_flags;
3858
3859 switch (flags & EF_SH_MACH_MASK)
3860 {
3861 case EF_SH1:
3862 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh);
3863 break;
3864 case EF_SH2:
3865 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2);
3866 break;
3867 case EF_SH_DSP:
3868 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp);
3869 break;
3870 case EF_SH3:
3871 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3);
3872 break;
3873 case EF_SH3_DSP:
3874 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp);
3875 break;
3876 case EF_SH3E:
3877 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e);
3878 break;
3879 case EF_SH_UNKNOWN:
3880 case EF_SH4:
3881 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4);
3882 break;
3883 default:
3884 return false;
3885 }
3886 return true;
3887 }
3888
3889 /* Function to keep SH specific file flags. */
3890
3891 static boolean
3892 sh_elf_set_private_flags (abfd, flags)
3893 bfd *abfd;
3894 flagword flags;
3895 {
3896 BFD_ASSERT (! elf_flags_init (abfd)
3897 || elf_elfheader (abfd)->e_flags == flags);
3898
3899 elf_elfheader (abfd)->e_flags = flags;
3900 elf_flags_init (abfd) = true;
3901 return sh_elf_set_mach_from_flags (abfd);
3902 }
3903
3904 /* Copy backend specific data from one object module to another */
3905
3906 static boolean
3907 sh_elf_copy_private_data (ibfd, obfd)
3908 bfd * ibfd;
3909 bfd * obfd;
3910 {
3911 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3912 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3913 return true;
3914
3915 return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
3916 }
3917
3918 /* This routine checks for linking big and little endian objects
3919 together, and for linking sh-dsp with sh3e / sh4 objects. */
3920
3921 static boolean
3922 sh_elf_merge_private_data (ibfd, obfd)
3923 bfd *ibfd;
3924 bfd *obfd;
3925 {
3926 flagword old_flags, new_flags;
3927
3928 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
3929 return false;
3930
3931 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3932 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3933 return true;
3934
3935 if (! elf_flags_init (obfd))
3936 {
3937 /* This happens when ld starts out with a 'blank' output file. */
3938 elf_flags_init (obfd) = true;
3939 elf_elfheader (obfd)->e_flags = EF_SH1;
3940 }
3941 old_flags = elf_elfheader (obfd)->e_flags;
3942 new_flags = elf_elfheader (ibfd)->e_flags;
3943 if ((EF_SH_HAS_DSP (old_flags) && EF_SH_HAS_FP (new_flags))
3944 || (EF_SH_HAS_DSP (new_flags) && EF_SH_HAS_FP (old_flags)))
3945 {
3946 (*_bfd_error_handler)
3947 ("%s: uses %s instructions while previous modules use %s instructions",
3948 bfd_get_filename (ibfd),
3949 EF_SH_HAS_DSP (new_flags) ? "dsp" : "floating point",
3950 EF_SH_HAS_DSP (new_flags) ? "floating point" : "dsp");
3951 bfd_set_error (bfd_error_bad_value);
3952 return false;
3953 }
3954 elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags);
3955
3956 return sh_elf_set_mach_from_flags (obfd);
3957 }
3958
3959 /* Finish up dynamic symbol handling. We set the contents of various
3960 dynamic sections here. */
3961
3962 static boolean
3963 sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
3964 bfd *output_bfd;
3965 struct bfd_link_info *info;
3966 struct elf_link_hash_entry *h;
3967 Elf_Internal_Sym *sym;
3968 {
3969 bfd *dynobj;
3970
3971 dynobj = elf_hash_table (info)->dynobj;
3972
3973 if (h->plt.offset != (bfd_vma) -1)
3974 {
3975 asection *splt;
3976 asection *sgot;
3977 asection *srel;
3978
3979 bfd_vma plt_index;
3980 bfd_vma got_offset;
3981 Elf_Internal_Rela rel;
3982
3983 /* This symbol has an entry in the procedure linkage table. Set
3984 it up. */
3985
3986 BFD_ASSERT (h->dynindx != -1);
3987
3988 splt = bfd_get_section_by_name (dynobj, ".plt");
3989 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3990 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3991 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3992
3993 /* Get the index in the procedure linkage table which
3994 corresponds to this symbol. This is the index of this symbol
3995 in all the symbols for which we are making plt entries. The
3996 first entry in the procedure linkage table is reserved. */
3997 plt_index = h->plt.offset / elf_sh_sizeof_plt (info) - 1;
3998
3999 /* Get the offset into the .got table of the entry that
4000 corresponds to this function. Each .got entry is 4 bytes.
4001 The first three are reserved. */
4002 got_offset = (plt_index + 3) * 4;
4003
4004 /* Fill in the entry in the procedure linkage table. */
4005 if (! info->shared)
4006 {
4007 if (elf_sh_plt_entry == NULL)
4008 {
4009 elf_sh_plt_entry = (bfd_big_endian (output_bfd) ?
4010 elf_sh_plt_entry_be : elf_sh_plt_entry_le);
4011 }
4012 memcpy (splt->contents + h->plt.offset, elf_sh_plt_entry,
4013 elf_sh_sizeof_plt (info));
4014 bfd_put_32 (output_bfd,
4015 (sgot->output_section->vma
4016 + sgot->output_offset
4017 + got_offset),
4018 (splt->contents + h->plt.offset
4019 + elf_sh_plt_symbol_offset (info)));
4020
4021 bfd_put_32 (output_bfd,
4022 (splt->output_section->vma + splt->output_offset),
4023 (splt->contents + h->plt.offset
4024 + elf_sh_plt_plt0_offset (info)));
4025 }
4026 else
4027 {
4028 if (elf_sh_pic_plt_entry == NULL)
4029 {
4030 elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
4031 elf_sh_pic_plt_entry_be :
4032 elf_sh_pic_plt_entry_le);
4033 }
4034 memcpy (splt->contents + h->plt.offset, elf_sh_pic_plt_entry,
4035 elf_sh_sizeof_plt (info));
4036 bfd_put_32 (output_bfd, got_offset,
4037 (splt->contents + h->plt.offset
4038 + elf_sh_plt_symbol_offset (info)));
4039 }
4040
4041 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4042 (splt->contents + h->plt.offset
4043 + elf_sh_plt_reloc_offset (info)));
4044
4045 /* Fill in the entry in the global offset table. */
4046 bfd_put_32 (output_bfd,
4047 (splt->output_section->vma
4048 + splt->output_offset
4049 + h->plt.offset
4050 + elf_sh_plt_temp_offset (info)),
4051 sgot->contents + got_offset);
4052
4053 /* Fill in the entry in the .rela.plt section. */
4054 rel.r_offset = (sgot->output_section->vma
4055 + sgot->output_offset
4056 + got_offset);
4057 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
4058 rel.r_addend = 0;
4059 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4060 ((Elf32_External_Rela *) srel->contents
4061 + plt_index));
4062
4063 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4064 {
4065 /* Mark the symbol as undefined, rather than as defined in
4066 the .plt section. Leave the value alone. */
4067 sym->st_shndx = SHN_UNDEF;
4068 }
4069 }
4070
4071 if (h->got.offset != (bfd_vma) -1)
4072 {
4073 asection *sgot;
4074 asection *srel;
4075 Elf_Internal_Rela rel;
4076
4077 /* This symbol has an entry in the global offset table. Set it
4078 up. */
4079
4080 sgot = bfd_get_section_by_name (dynobj, ".got");
4081 srel = bfd_get_section_by_name (dynobj, ".rela.got");
4082 BFD_ASSERT (sgot != NULL && srel != NULL);
4083
4084 rel.r_offset = (sgot->output_section->vma
4085 + sgot->output_offset
4086 + (h->got.offset &~ 1));
4087
4088 /* If this is a -Bsymbolic link, and the symbol is defined
4089 locally, we just want to emit a RELATIVE reloc. Likewise if
4090 the symbol was forced to be local because of a version file.
4091 The entry in the global offset table will already have been
4092 initialized in the relocate_section function. */
4093 if (info->shared
4094 && (info->symbolic || h->dynindx == -1)
4095 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
4096 {
4097 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
4098 rel.r_addend = (h->root.u.def.value
4099 + h->root.u.def.section->output_section->vma
4100 + h->root.u.def.section->output_offset);
4101 }
4102 else
4103 {
4104 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
4105 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
4106 rel.r_addend = 0;
4107 }
4108
4109 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4110 ((Elf32_External_Rela *) srel->contents
4111 + srel->reloc_count));
4112 ++srel->reloc_count;
4113 }
4114
4115 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
4116 {
4117 asection *s;
4118 Elf_Internal_Rela rel;
4119
4120 /* This symbol needs a copy reloc. Set it up. */
4121
4122 BFD_ASSERT (h->dynindx != -1
4123 && (h->root.type == bfd_link_hash_defined
4124 || h->root.type == bfd_link_hash_defweak));
4125
4126 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4127 ".rela.bss");
4128 BFD_ASSERT (s != NULL);
4129
4130 rel.r_offset = (h->root.u.def.value
4131 + h->root.u.def.section->output_section->vma
4132 + h->root.u.def.section->output_offset);
4133 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
4134 rel.r_addend = 0;
4135 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4136 ((Elf32_External_Rela *) s->contents
4137 + s->reloc_count));
4138 ++s->reloc_count;
4139 }
4140
4141 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4142 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4143 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
4144 sym->st_shndx = SHN_ABS;
4145
4146 return true;
4147 }
4148
4149 /* Finish up the dynamic sections. */
4150
4151 static boolean
4152 sh_elf_finish_dynamic_sections (output_bfd, info)
4153 bfd *output_bfd;
4154 struct bfd_link_info *info;
4155 {
4156 bfd *dynobj;
4157 asection *sgot;
4158 asection *sdyn;
4159
4160 dynobj = elf_hash_table (info)->dynobj;
4161
4162 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4163 BFD_ASSERT (sgot != NULL);
4164 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4165
4166 if (elf_hash_table (info)->dynamic_sections_created)
4167 {
4168 asection *splt;
4169 Elf32_External_Dyn *dyncon, *dynconend;
4170
4171 BFD_ASSERT (sdyn != NULL);
4172
4173 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4174 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4175 for (; dyncon < dynconend; dyncon++)
4176 {
4177 Elf_Internal_Dyn dyn;
4178 const char *name;
4179 asection *s;
4180
4181 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4182
4183 switch (dyn.d_tag)
4184 {
4185 default:
4186 break;
4187
4188 case DT_PLTGOT:
4189 name = ".got";
4190 goto get_vma;
4191
4192 case DT_JMPREL:
4193 name = ".rela.plt";
4194 get_vma:
4195 s = bfd_get_section_by_name (output_bfd, name);
4196 BFD_ASSERT (s != NULL);
4197 dyn.d_un.d_ptr = s->vma;
4198 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4199 break;
4200
4201 case DT_PLTRELSZ:
4202 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4203 BFD_ASSERT (s != NULL);
4204 if (s->_cooked_size != 0)
4205 dyn.d_un.d_val = s->_cooked_size;
4206 else
4207 dyn.d_un.d_val = s->_raw_size;
4208 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4209 break;
4210
4211 case DT_RELASZ:
4212 /* My reading of the SVR4 ABI indicates that the
4213 procedure linkage table relocs (DT_JMPREL) should be
4214 included in the overall relocs (DT_RELA). This is
4215 what Solaris does. However, UnixWare can not handle
4216 that case. Therefore, we override the DT_RELASZ entry
4217 here to make it not include the JMPREL relocs. Since
4218 the linker script arranges for .rela.plt to follow all
4219 other relocation sections, we don't have to worry
4220 about changing the DT_RELA entry. */
4221 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4222 if (s != NULL)
4223 {
4224 if (s->_cooked_size != 0)
4225 dyn.d_un.d_val -= s->_cooked_size;
4226 else
4227 dyn.d_un.d_val -= s->_raw_size;
4228 }
4229 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4230 break;
4231 }
4232 }
4233
4234 /* Fill in the first entry in the procedure linkage table. */
4235 splt = bfd_get_section_by_name (dynobj, ".plt");
4236 if (splt && splt->_raw_size > 0)
4237 {
4238 if (info->shared)
4239 {
4240 if (elf_sh_pic_plt_entry == NULL)
4241 {
4242 elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
4243 elf_sh_pic_plt_entry_be :
4244 elf_sh_pic_plt_entry_le);
4245 }
4246 memcpy (splt->contents, elf_sh_pic_plt_entry,
4247 elf_sh_sizeof_plt (info));
4248 }
4249 else
4250 {
4251 if (elf_sh_plt0_entry == NULL)
4252 {
4253 elf_sh_plt0_entry = (bfd_big_endian (output_bfd) ?
4254 elf_sh_plt0_entry_be :
4255 elf_sh_plt0_entry_le);
4256 }
4257 memcpy (splt->contents, elf_sh_plt0_entry, PLT_ENTRY_SIZE);
4258 bfd_put_32 (output_bfd,
4259 sgot->output_section->vma + sgot->output_offset + 4,
4260 splt->contents + elf_sh_plt0_gotid_offset (info));
4261 bfd_put_32 (output_bfd,
4262 sgot->output_section->vma + sgot->output_offset + 8,
4263 splt->contents + elf_sh_plt0_linker_offset (info));
4264 }
4265
4266 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4267 really seem like the right value. */
4268 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
4269 }
4270 }
4271
4272 /* Fill in the first three entries in the global offset table. */
4273 if (sgot->_raw_size > 0)
4274 {
4275 if (sdyn == NULL)
4276 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4277 else
4278 bfd_put_32 (output_bfd,
4279 sdyn->output_section->vma + sdyn->output_offset,
4280 sgot->contents);
4281 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4282 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4283 }
4284
4285 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4286
4287 return true;
4288 }
4289
4290 #ifndef ELF_ARCH
4291 #define TARGET_BIG_SYM bfd_elf32_sh_vec
4292 #define TARGET_BIG_NAME "elf32-sh"
4293 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
4294 #define TARGET_LITTLE_NAME "elf32-shl"
4295 #define ELF_ARCH bfd_arch_sh
4296 #define ELF_MACHINE_CODE EM_SH
4297 #define ELF_MAXPAGESIZE 128
4298
4299 #define elf_symbol_leading_char '_'
4300 #endif /* ELF_ARCH */
4301
4302 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
4303 #define elf_info_to_howto sh_elf_info_to_howto
4304 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
4305 #define elf_backend_relocate_section sh_elf_relocate_section
4306 #define bfd_elf32_bfd_get_relocated_section_contents \
4307 sh_elf_get_relocated_section_contents
4308 #define elf_backend_object_p sh_elf_set_mach_from_flags
4309 #define bfd_elf32_bfd_set_private_bfd_flags \
4310 sh_elf_set_private_flags
4311 #define bfd_elf32_bfd_copy_private_bfd_data \
4312 sh_elf_copy_private_data
4313 #define bfd_elf32_bfd_merge_private_bfd_data \
4314 sh_elf_merge_private_data
4315
4316 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
4317 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
4318 #define elf_backend_check_relocs sh_elf_check_relocs
4319
4320 #define elf_backend_can_gc_sections 1
4321 #define elf_backend_create_dynamic_sections \
4322 sh_elf_create_dynamic_sections
4323 #define bfd_elf32_bfd_link_hash_table_create \
4324 sh_elf_link_hash_table_create
4325 #define elf_backend_adjust_dynamic_symbol \
4326 sh_elf_adjust_dynamic_symbol
4327 #define elf_backend_size_dynamic_sections \
4328 sh_elf_size_dynamic_sections
4329 #define elf_backend_finish_dynamic_symbol \
4330 sh_elf_finish_dynamic_symbol
4331 #define elf_backend_finish_dynamic_sections \
4332 sh_elf_finish_dynamic_sections
4333
4334 #define elf_backend_want_got_plt 1
4335 #define elf_backend_plt_readonly 1
4336 #define elf_backend_want_plt_sym 0
4337 #define elf_backend_got_header_size 12
4338 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
4339 #include "elf32-target.h"
git-cvsimport of binutils cvsroot