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