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