?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2000-03-08 H.J. Lu (hjl@gnu.org)
[binutils.git] / bfd / elf32-sh.c
blobad60e07fd57c66fd2971c04722f8da808b4ce6ef
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 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
59 static reloc_howto_type sh_elf_howto_table[] =
60 {
61 /* No relocation. */
62 HOWTO (R_SH_NONE, /* type */
63 0, /* rightshift */
64 0, /* size (0 = byte, 1 = short, 2 = long) */
65 0, /* bitsize */
66 false, /* pc_relative */
67 0, /* bitpos */
68 complain_overflow_dont, /* complain_on_overflow */
69 sh_elf_reloc, /* special_function */
70 "R_SH_NONE", /* name */
71 false, /* partial_inplace */
72 0, /* src_mask */
73 0, /* dst_mask */
74 false), /* pcrel_offset */
75
76 /* 32 bit absolute relocation. Setting partial_inplace to true and
77 src_mask to a non-zero value is similar to the COFF toolchain. */
78 HOWTO (R_SH_DIR32, /* type */
79 0, /* rightshift */
80 2, /* size (0 = byte, 1 = short, 2 = long) */
81 32, /* bitsize */
82 false, /* pc_relative */
83 0, /* bitpos */
84 complain_overflow_bitfield, /* complain_on_overflow */
85 sh_elf_reloc, /* special_function */
86 "R_SH_DIR32", /* name */
87 true, /* partial_inplace */
88 0xffffffff, /* src_mask */
89 0xffffffff, /* dst_mask */
90 false), /* pcrel_offset */
91
92 /* 32 bit PC relative relocation. */
93 HOWTO (R_SH_REL32, /* type */
94 0, /* rightshift */
95 2, /* size (0 = byte, 1 = short, 2 = long) */
96 32, /* bitsize */
97 true, /* pc_relative */
98 0, /* bitpos */
99 complain_overflow_signed, /* complain_on_overflow */
100 sh_elf_reloc, /* special_function */
101 "R_SH_REL32", /* name */
102 false, /* partial_inplace */
103 0, /* src_mask */
104 0xffffffff, /* dst_mask */
105 true), /* pcrel_offset */
106
107 /* 8 bit PC relative branch divided by 2. */
108 HOWTO (R_SH_DIR8WPN, /* type */
109 1, /* rightshift */
110 1, /* size (0 = byte, 1 = short, 2 = long) */
111 8, /* bitsize */
112 true, /* pc_relative */
113 0, /* bitpos */
114 complain_overflow_signed, /* complain_on_overflow */
115 sh_elf_reloc, /* special_function */
116 "R_SH_DIR8WPN", /* name */
117 true, /* partial_inplace */
118 0xff, /* src_mask */
119 0xff, /* dst_mask */
120 true), /* pcrel_offset */
121
122 /* 12 bit PC relative branch divided by 2. */
123 HOWTO (R_SH_IND12W, /* type */
124 1, /* rightshift */
125 1, /* size (0 = byte, 1 = short, 2 = long) */
126 12, /* bitsize */
127 true, /* pc_relative */
128 0, /* bitpos */
129 complain_overflow_signed, /* complain_on_overflow */
130 sh_elf_reloc, /* special_function */
131 "R_SH_IND12W", /* name */
132 true, /* partial_inplace */
133 0xfff, /* src_mask */
134 0xfff, /* dst_mask */
135 true), /* pcrel_offset */
136
137 /* 8 bit unsigned PC relative divided by 4. */
138 HOWTO (R_SH_DIR8WPL, /* type */
139 2, /* rightshift */
140 1, /* size (0 = byte, 1 = short, 2 = long) */
141 8, /* bitsize */
142 true, /* pc_relative */
143 0, /* bitpos */
144 complain_overflow_unsigned, /* complain_on_overflow */
145 sh_elf_reloc, /* special_function */
146 "R_SH_DIR8WPL", /* name */
147 true, /* partial_inplace */
148 0xff, /* src_mask */
149 0xff, /* dst_mask */
150 true), /* pcrel_offset */
151
152 /* 8 bit unsigned PC relative divided by 2. */
153 HOWTO (R_SH_DIR8WPZ, /* type */
154 1, /* rightshift */
155 1, /* size (0 = byte, 1 = short, 2 = long) */
156 8, /* bitsize */
157 true, /* pc_relative */
158 0, /* bitpos */
159 complain_overflow_unsigned, /* complain_on_overflow */
160 sh_elf_reloc, /* special_function */
161 "R_SH_DIR8WPZ", /* name */
162 true, /* partial_inplace */
163 0xff, /* src_mask */
164 0xff, /* dst_mask */
165 true), /* pcrel_offset */
166
167 /* 8 bit GBR relative. FIXME: This only makes sense if we have some
168 special symbol for the GBR relative area, and that is not
169 implemented. */
170 HOWTO (R_SH_DIR8BP, /* type */
171 0, /* rightshift */
172 1, /* size (0 = byte, 1 = short, 2 = long) */
173 8, /* bitsize */
174 false, /* pc_relative */
175 0, /* bitpos */
176 complain_overflow_unsigned, /* complain_on_overflow */
177 sh_elf_reloc, /* special_function */
178 "R_SH_DIR8BP", /* name */
179 false, /* partial_inplace */
180 0, /* src_mask */
181 0xff, /* dst_mask */
182 true), /* pcrel_offset */
183
184 /* 8 bit GBR relative divided by 2. FIXME: This only makes sense if
185 we have some special symbol for the GBR relative area, and that
186 is not implemented. */
187 HOWTO (R_SH_DIR8W, /* type */
188 1, /* rightshift */
189 1, /* size (0 = byte, 1 = short, 2 = long) */
190 8, /* bitsize */
191 false, /* pc_relative */
192 0, /* bitpos */
193 complain_overflow_unsigned, /* complain_on_overflow */
194 sh_elf_reloc, /* special_function */
195 "R_SH_DIR8W", /* name */
196 false, /* partial_inplace */
197 0, /* src_mask */
198 0xff, /* dst_mask */
199 true), /* pcrel_offset */
200
201 /* 8 bit GBR relative divided by 4. FIXME: This only makes sense if
202 we have some special symbol for the GBR relative area, and that
203 is not implemented. */
204 HOWTO (R_SH_DIR8L, /* type */
205 2, /* rightshift */
206 1, /* size (0 = byte, 1 = short, 2 = long) */
207 8, /* bitsize */
208 false, /* pc_relative */
209 0, /* bitpos */
210 complain_overflow_unsigned, /* complain_on_overflow */
211 sh_elf_reloc, /* special_function */
212 "R_SH_DIR8L", /* name */
213 false, /* partial_inplace */
214 0, /* src_mask */
215 0xff, /* dst_mask */
216 true), /* pcrel_offset */
217
218 EMPTY_HOWTO (10),
219 EMPTY_HOWTO (11),
220 EMPTY_HOWTO (12),
221 EMPTY_HOWTO (13),
222 EMPTY_HOWTO (14),
223 EMPTY_HOWTO (15),
224 EMPTY_HOWTO (16),
225 EMPTY_HOWTO (17),
226 EMPTY_HOWTO (18),
227 EMPTY_HOWTO (19),
228 EMPTY_HOWTO (20),
229 EMPTY_HOWTO (21),
230 EMPTY_HOWTO (22),
231 EMPTY_HOWTO (23),
232 EMPTY_HOWTO (24),
233
234 /* The remaining relocs are a GNU extension used for relaxing. The
235 final pass of the linker never needs to do anything with any of
236 these relocs. Any required operations are handled by the
237 relaxation code. */
238
239 /* A 16 bit switch table entry. This is generated for an expression
240 such as ``.word L1 - L2''. The offset holds the difference
241 between the reloc address and L2. */
242 HOWTO (R_SH_SWITCH16, /* type */
243 0, /* rightshift */
244 1, /* size (0 = byte, 1 = short, 2 = long) */
245 16, /* bitsize */
246 false, /* pc_relative */
247 0, /* bitpos */
248 complain_overflow_unsigned, /* complain_on_overflow */
249 sh_elf_ignore_reloc, /* special_function */
250 "R_SH_SWITCH16", /* name */
251 false, /* partial_inplace */
252 0, /* src_mask */
253 0, /* dst_mask */
254 true), /* pcrel_offset */
255
256 /* A 32 bit switch table entry. This is generated for an expression
257 such as ``.long L1 - L2''. The offset holds the difference
258 between the reloc address and L2. */
259 HOWTO (R_SH_SWITCH32, /* type */
260 0, /* rightshift */
261 2, /* size (0 = byte, 1 = short, 2 = long) */
262 32, /* bitsize */
263 false, /* pc_relative */
264 0, /* bitpos */
265 complain_overflow_unsigned, /* complain_on_overflow */
266 sh_elf_ignore_reloc, /* special_function */
267 "R_SH_SWITCH32", /* name */
268 false, /* partial_inplace */
269 0, /* src_mask */
270 0, /* dst_mask */
271 true), /* pcrel_offset */
272
273 /* Indicates a .uses pseudo-op. The compiler will generate .uses
274 pseudo-ops when it finds a function call which can be relaxed.
275 The offset field holds the PC relative offset to the instruction
276 which loads the register used in the function call. */
277 HOWTO (R_SH_USES, /* type */
278 0, /* rightshift */
279 1, /* size (0 = byte, 1 = short, 2 = long) */
280 0, /* bitsize */
281 false, /* pc_relative */
282 0, /* bitpos */
283 complain_overflow_unsigned, /* complain_on_overflow */
284 sh_elf_ignore_reloc, /* special_function */
285 "R_SH_USES", /* name */
286 false, /* partial_inplace */
287 0, /* src_mask */
288 0, /* dst_mask */
289 true), /* pcrel_offset */
290
291 /* The assembler will generate this reloc for addresses referred to
292 by the register loads associated with USES relocs. The offset
293 field holds the number of times the address is referenced in the
294 object file. */
295 HOWTO (R_SH_COUNT, /* type */
296 0, /* rightshift */
297 1, /* size (0 = byte, 1 = short, 2 = long) */
298 0, /* bitsize */
299 false, /* pc_relative */
300 0, /* bitpos */
301 complain_overflow_unsigned, /* complain_on_overflow */
302 sh_elf_ignore_reloc, /* special_function */
303 "R_SH_COUNT", /* name */
304 false, /* partial_inplace */
305 0, /* src_mask */
306 0, /* dst_mask */
307 true), /* pcrel_offset */
308
309 /* Indicates an alignment statement. The offset field is the power
310 of 2 to which subsequent portions of the object file must be
311 aligned. */
312 HOWTO (R_SH_ALIGN, /* type */
313 0, /* rightshift */
314 1, /* size (0 = byte, 1 = short, 2 = long) */
315 0, /* bitsize */
316 false, /* pc_relative */
317 0, /* bitpos */
318 complain_overflow_unsigned, /* complain_on_overflow */
319 sh_elf_ignore_reloc, /* special_function */
320 "R_SH_ALIGN", /* name */
321 false, /* partial_inplace */
322 0, /* src_mask */
323 0, /* dst_mask */
324 true), /* pcrel_offset */
325
326 /* The assembler will generate this reloc before a block of
327 instructions. A section should be processed as assumining it
328 contains data, unless this reloc is seen. */
329 HOWTO (R_SH_CODE, /* type */
330 0, /* rightshift */
331 1, /* size (0 = byte, 1 = short, 2 = long) */
332 0, /* bitsize */
333 false, /* pc_relative */
334 0, /* bitpos */
335 complain_overflow_unsigned, /* complain_on_overflow */
336 sh_elf_ignore_reloc, /* special_function */
337 "R_SH_CODE", /* name */
338 false, /* partial_inplace */
339 0, /* src_mask */
340 0, /* dst_mask */
341 true), /* pcrel_offset */
342
343 /* The assembler will generate this reloc after a block of
344 instructions when it sees data that is not instructions. */
345 HOWTO (R_SH_DATA, /* type */
346 0, /* rightshift */
347 1, /* size (0 = byte, 1 = short, 2 = long) */
348 0, /* bitsize */
349 false, /* pc_relative */
350 0, /* bitpos */
351 complain_overflow_unsigned, /* complain_on_overflow */
352 sh_elf_ignore_reloc, /* special_function */
353 "R_SH_DATA", /* name */
354 false, /* partial_inplace */
355 0, /* src_mask */
356 0, /* dst_mask */
357 true), /* pcrel_offset */
358
359 /* The assembler generates this reloc for each label within a block
360 of instructions. This permits the linker to avoid swapping
361 instructions which are the targets of branches. */
362 HOWTO (R_SH_LABEL, /* type */
363 0, /* rightshift */
364 1, /* size (0 = byte, 1 = short, 2 = long) */
365 0, /* bitsize */
366 false, /* pc_relative */
367 0, /* bitpos */
368 complain_overflow_unsigned, /* complain_on_overflow */
369 sh_elf_ignore_reloc, /* special_function */
370 "R_SH_LABEL", /* name */
371 false, /* partial_inplace */
372 0, /* src_mask */
373 0, /* dst_mask */
374 true), /* pcrel_offset */
375
376 /* An 8 bit switch table entry. This is generated for an expression
377 such as ``.word L1 - L2''. The offset holds the difference
378 between the reloc address and L2. */
379 HOWTO (R_SH_SWITCH8, /* type */
380 0, /* rightshift */
381 0, /* size (0 = byte, 1 = short, 2 = long) */
382 8, /* bitsize */
383 false, /* pc_relative */
384 0, /* bitpos */
385 complain_overflow_unsigned, /* complain_on_overflow */
386 sh_elf_ignore_reloc, /* special_function */
387 "R_SH_SWITCH8", /* name */
388 false, /* partial_inplace */
389 0, /* src_mask */
390 0, /* dst_mask */
391 true), /* pcrel_offset */
392
393 /* GNU extension to record C++ vtable hierarchy */
394 HOWTO (R_SH_GNU_VTINHERIT, /* type */
395 0, /* rightshift */
396 2, /* size (0 = byte, 1 = short, 2 = long) */
397 0, /* bitsize */
398 false, /* pc_relative */
399 0, /* bitpos */
400 complain_overflow_dont, /* complain_on_overflow */
401 NULL, /* special_function */
402 "R_SH_GNU_VTINHERIT", /* name */
403 false, /* partial_inplace */
404 0, /* src_mask */
405 0, /* dst_mask */
406 false), /* pcrel_offset */
407
408 /* GNU extension to record C++ vtable member usage */
409 HOWTO (R_SH_GNU_VTENTRY, /* type */
410 0, /* rightshift */
411 2, /* size (0 = byte, 1 = short, 2 = long) */
412 0, /* bitsize */
413 false, /* pc_relative */
414 0, /* bitpos */
415 complain_overflow_dont, /* complain_on_overflow */
416 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
417 "R_SH_GNU_VTENTRY", /* name */
418 false, /* partial_inplace */
419 0, /* src_mask */
420 0, /* dst_mask */
421 false), /* pcrel_offset */
422
423 };
424
425 /* This function is used for normal relocs. This is like the COFF
426 function, and is almost certainly incorrect for other ELF targets. */
427
428 static bfd_reloc_status_type
429 sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
430 error_message)
431 bfd *abfd;
432 arelent *reloc_entry;
433 asymbol *symbol_in;
434 PTR data;
435 asection *input_section;
436 bfd *output_bfd;
437 char **error_message ATTRIBUTE_UNUSED;
438 {
439 unsigned long insn;
440 bfd_vma sym_value;
441 enum elf_sh_reloc_type r_type;
442 bfd_vma addr = reloc_entry->address;
443 bfd_byte *hit_data = addr + (bfd_byte *) data;
444
445 r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
446
447 if (output_bfd != NULL)
448 {
449 /* Partial linking--do nothing. */
450 reloc_entry->address += input_section->output_offset;
451 return bfd_reloc_ok;
452 }
453
454 /* Almost all relocs have to do with relaxing. If any work must be
455 done for them, it has been done in sh_relax_section. */
456 if (r_type != R_SH_DIR32
457 && (r_type != R_SH_IND12W
458 || (symbol_in->flags & BSF_LOCAL) != 0))
459 return bfd_reloc_ok;
460
461 if (symbol_in != NULL
462 && bfd_is_und_section (symbol_in->section))
463 return bfd_reloc_undefined;
464
465 if (bfd_is_com_section (symbol_in->section))
466 sym_value = 0;
467 else
468 sym_value = (symbol_in->value +
469 symbol_in->section->output_section->vma +
470 symbol_in->section->output_offset);
471
472 switch (r_type)
473 {
474 case R_SH_DIR32:
475 insn = bfd_get_32 (abfd, hit_data);
476 insn += sym_value + reloc_entry->addend;
477 bfd_put_32 (abfd, insn, hit_data);
478 break;
479 case R_SH_IND12W:
480 insn = bfd_get_16 (abfd, hit_data);
481 sym_value += reloc_entry->addend;
482 sym_value -= (input_section->output_section->vma
483 + input_section->output_offset
484 + addr
485 + 4);
486 sym_value += (insn & 0xfff) << 1;
487 if (insn & 0x800)
488 sym_value -= 0x1000;
489 insn = (insn & 0xf000) | (sym_value & 0xfff);
490 bfd_put_16 (abfd, insn, hit_data);
491 if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
492 return bfd_reloc_overflow;
493 break;
494 default:
495 abort ();
496 break;
497 }
498
499 return bfd_reloc_ok;
500 }
501
502 /* This function is used for relocs which are only used for relaxing,
503 which the linker should otherwise ignore. */
504
505 static bfd_reloc_status_type
506 sh_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
507 output_bfd, error_message)
508 bfd *abfd ATTRIBUTE_UNUSED;
509 arelent *reloc_entry;
510 asymbol *symbol ATTRIBUTE_UNUSED;
511 PTR data ATTRIBUTE_UNUSED;
512 asection *input_section;
513 bfd *output_bfd;
514 char **error_message ATTRIBUTE_UNUSED;
515 {
516 if (output_bfd != NULL)
517 reloc_entry->address += input_section->output_offset;
518 return bfd_reloc_ok;
519 }
520
521 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
522
523 struct elf_reloc_map
524 {
525 bfd_reloc_code_real_type bfd_reloc_val;
526 unsigned char elf_reloc_val;
527 };
528
529 /* An array mapping BFD reloc codes to SH ELF relocs. */
530
531 static const struct elf_reloc_map sh_reloc_map[] =
532 {
533 { BFD_RELOC_NONE, R_SH_NONE },
534 { BFD_RELOC_32, R_SH_DIR32 },
535 { BFD_RELOC_CTOR, R_SH_DIR32 },
536 { BFD_RELOC_32_PCREL, R_SH_REL32 },
537 { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
538 { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
539 { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
540 { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
541 { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
542 { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
543 { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
544 { BFD_RELOC_SH_USES, R_SH_USES },
545 { BFD_RELOC_SH_COUNT, R_SH_COUNT },
546 { BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
547 { BFD_RELOC_SH_CODE, R_SH_CODE },
548 { BFD_RELOC_SH_DATA, R_SH_DATA },
549 { BFD_RELOC_SH_LABEL, R_SH_LABEL },
550 { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
551 { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
552 };
553
554 /* Given a BFD reloc code, return the howto structure for the
555 corresponding SH ELf reloc. */
556
557 static reloc_howto_type *
558 sh_elf_reloc_type_lookup (abfd, code)
559 bfd *abfd ATTRIBUTE_UNUSED;
560 bfd_reloc_code_real_type code;
561 {
562 unsigned int i;
563
564 for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
565 {
566 if (sh_reloc_map[i].bfd_reloc_val == code)
567 return &sh_elf_howto_table[(int) sh_reloc_map[i].elf_reloc_val];
568 }
569
570 return NULL;
571 }
572
573 /* Given an ELF reloc, fill in the howto field of a relent. */
574
575 static void
576 sh_elf_info_to_howto (abfd, cache_ptr, dst)
577 bfd *abfd ATTRIBUTE_UNUSED;
578 arelent *cache_ptr;
579 Elf_Internal_Rela *dst;
580 {
581 unsigned int r;
582
583 r = ELF32_R_TYPE (dst->r_info);
584
585 BFD_ASSERT (r < (unsigned int) R_SH_max);
586 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
587
588 cache_ptr->howto = &sh_elf_howto_table[r];
589 }
590 \f
591 /* This function handles relaxing for SH ELF. See the corresponding
592 function in coff-sh.c for a description of what this does. FIXME:
593 There is a lot of duplication here between this code and the COFF
594 specific code. The format of relocs and symbols is wound deeply
595 into this code, but it would still be better if the duplication
596 could be eliminated somehow. Note in particular that although both
597 functions use symbols like R_SH_CODE, those symbols have different
598 values; in coff-sh.c they come from include/coff/sh.h, whereas here
599 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
600
601 static boolean
602 sh_elf_relax_section (abfd, sec, link_info, again)
603 bfd *abfd;
604 asection *sec;
605 struct bfd_link_info *link_info;
606 boolean *again;
607 {
608 Elf_Internal_Shdr *symtab_hdr;
609 Elf_Internal_Rela *internal_relocs;
610 Elf_Internal_Rela *free_relocs = NULL;
611 boolean have_code;
612 Elf_Internal_Rela *irel, *irelend;
613 bfd_byte *contents = NULL;
614 bfd_byte *free_contents = NULL;
615 Elf32_External_Sym *extsyms = NULL;
616 Elf32_External_Sym *free_extsyms = NULL;
617
618 *again = false;
619
620 if (link_info->relocateable
621 || (sec->flags & SEC_RELOC) == 0
622 || sec->reloc_count == 0)
623 return true;
624
625 /* If this is the first time we have been called for this section,
626 initialize the cooked size. */
627 if (sec->_cooked_size == 0)
628 sec->_cooked_size = sec->_raw_size;
629
630 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
631
632 internal_relocs = (_bfd_elf32_link_read_relocs
633 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
634 link_info->keep_memory));
635 if (internal_relocs == NULL)
636 goto error_return;
637 if (! link_info->keep_memory)
638 free_relocs = internal_relocs;
639
640 have_code = false;
641
642 irelend = internal_relocs + sec->reloc_count;
643 for (irel = internal_relocs; irel < irelend; irel++)
644 {
645 bfd_vma laddr, paddr, symval;
646 unsigned short insn;
647 Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
648 bfd_signed_vma foff;
649
650 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
651 have_code = true;
652
653 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
654 continue;
655
656 /* Get the section contents. */
657 if (contents == NULL)
658 {
659 if (elf_section_data (sec)->this_hdr.contents != NULL)
660 contents = elf_section_data (sec)->this_hdr.contents;
661 else
662 {
663 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
664 if (contents == NULL)
665 goto error_return;
666 free_contents = contents;
667
668 if (! bfd_get_section_contents (abfd, sec, contents,
669 (file_ptr) 0, sec->_raw_size))
670 goto error_return;
671 }
672 }
673
674 /* The r_addend field of the R_SH_USES reloc will point us to
675 the register load. The 4 is because the r_addend field is
676 computed as though it were a jump offset, which are based
677 from 4 bytes after the jump instruction. */
678 laddr = irel->r_offset + 4 + irel->r_addend;
679 if (laddr >= sec->_raw_size)
680 {
681 (*_bfd_error_handler) (_("%s: 0x%lx: warning: bad R_SH_USES offset"),
682 bfd_get_filename (abfd),
683 (unsigned long) irel->r_offset);
684 continue;
685 }
686 insn = bfd_get_16 (abfd, contents + laddr);
687
688 /* If the instruction is not mov.l NN,rN, we don't know what to
689 do. */
690 if ((insn & 0xf000) != 0xd000)
691 {
692 ((*_bfd_error_handler)
693 (_("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
694 bfd_get_filename (abfd), (unsigned long) irel->r_offset, insn));
695 continue;
696 }
697
698 /* Get the address from which the register is being loaded. The
699 displacement in the mov.l instruction is quadrupled. It is a
700 displacement from four bytes after the movl instruction, but,
701 before adding in the PC address, two least significant bits
702 of the PC are cleared. We assume that the section is aligned
703 on a four byte boundary. */
704 paddr = insn & 0xff;
705 paddr *= 4;
706 paddr += (laddr + 4) &~ 3;
707 if (paddr >= sec->_raw_size)
708 {
709 ((*_bfd_error_handler)
710 (_("%s: 0x%lx: warning: bad R_SH_USES load offset"),
711 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
712 continue;
713 }
714
715 /* Get the reloc for the address from which the register is
716 being loaded. This reloc will tell us which function is
717 actually being called. */
718 for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
719 if (irelfn->r_offset == paddr
720 && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
721 break;
722 if (irelfn >= irelend)
723 {
724 ((*_bfd_error_handler)
725 (_("%s: 0x%lx: warning: could not find expected reloc"),
726 bfd_get_filename (abfd), (unsigned long) paddr));
727 continue;
728 }
729
730 /* Read this BFD's symbols if we haven't done so already. */
731 if (extsyms == NULL)
732 {
733 if (symtab_hdr->contents != NULL)
734 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
735 else
736 {
737 extsyms = ((Elf32_External_Sym *)
738 bfd_malloc (symtab_hdr->sh_size));
739 if (extsyms == NULL)
740 goto error_return;
741 free_extsyms = extsyms;
742 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
743 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
744 != symtab_hdr->sh_size))
745 goto error_return;
746 }
747 }
748
749 /* Get the value of the symbol referred to by the reloc. */
750 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
751 {
752 Elf_Internal_Sym isym;
753
754 /* A local symbol. */
755 bfd_elf32_swap_symbol_in (abfd,
756 extsyms + ELF32_R_SYM (irelfn->r_info),
757 &isym);
758
759 if (isym.st_shndx != _bfd_elf_section_from_bfd_section (abfd, sec))
760 {
761 ((*_bfd_error_handler)
762 (_("%s: 0x%lx: warning: symbol in unexpected section"),
763 bfd_get_filename (abfd), (unsigned long) paddr));
764 continue;
765 }
766
767 symval = (isym.st_value
768 + sec->output_section->vma
769 + sec->output_offset);
770 }
771 else
772 {
773 unsigned long indx;
774 struct elf_link_hash_entry *h;
775
776 indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
777 h = elf_sym_hashes (abfd)[indx];
778 BFD_ASSERT (h != NULL);
779 if (h->root.type != bfd_link_hash_defined
780 && h->root.type != bfd_link_hash_defweak)
781 {
782 /* This appears to be a reference to an undefined
783 symbol. Just ignore it--it will be caught by the
784 regular reloc processing. */
785 continue;
786 }
787
788 symval = (h->root.u.def.value
789 + h->root.u.def.section->output_section->vma
790 + h->root.u.def.section->output_offset);
791 }
792
793 symval += bfd_get_32 (abfd, contents + paddr);
794
795 /* See if this function call can be shortened. */
796 foff = (symval
797 - (irel->r_offset
798 + sec->output_section->vma
799 + sec->output_offset
800 + 4));
801 if (foff < -0x1000 || foff >= 0x1000)
802 {
803 /* After all that work, we can't shorten this function call. */
804 continue;
805 }
806
807 /* Shorten the function call. */
808
809 /* For simplicity of coding, we are going to modify the section
810 contents, the section relocs, and the BFD symbol table. We
811 must tell the rest of the code not to free up this
812 information. It would be possible to instead create a table
813 of changes which have to be made, as is done in coff-mips.c;
814 that would be more work, but would require less memory when
815 the linker is run. */
816
817 elf_section_data (sec)->relocs = internal_relocs;
818 free_relocs = NULL;
819
820 elf_section_data (sec)->this_hdr.contents = contents;
821 free_contents = NULL;
822
823 symtab_hdr->contents = (bfd_byte *) extsyms;
824 free_extsyms = NULL;
825
826 /* Replace the jsr with a bsr. */
827
828 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
829 replace the jsr with a bsr. */
830 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
831 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
832 {
833 /* If this needs to be changed because of future relaxing,
834 it will be handled here like other internal IND12W
835 relocs. */
836 bfd_put_16 (abfd,
837 0xb000 | ((foff >> 1) & 0xfff),
838 contents + irel->r_offset);
839 }
840 else
841 {
842 /* We can't fully resolve this yet, because the external
843 symbol value may be changed by future relaxing. We let
844 the final link phase handle it. */
845 bfd_put_16 (abfd, 0xb000, contents + irel->r_offset);
846 }
847
848 /* See if there is another R_SH_USES reloc referring to the same
849 register load. */
850 for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
851 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
852 && laddr == irelscan->r_offset + 4 + irelscan->r_addend)
853 break;
854 if (irelscan < irelend)
855 {
856 /* Some other function call depends upon this register load,
857 and we have not yet converted that function call.
858 Indeed, we may never be able to convert it. There is
859 nothing else we can do at this point. */
860 continue;
861 }
862
863 /* Look for a R_SH_COUNT reloc on the location where the
864 function address is stored. Do this before deleting any
865 bytes, to avoid confusion about the address. */
866 for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
867 if (irelcount->r_offset == paddr
868 && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
869 break;
870
871 /* Delete the register load. */
872 if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
873 goto error_return;
874
875 /* That will change things, so, just in case it permits some
876 other function call to come within range, we should relax
877 again. Note that this is not required, and it may be slow. */
878 *again = true;
879
880 /* Now check whether we got a COUNT reloc. */
881 if (irelcount >= irelend)
882 {
883 ((*_bfd_error_handler)
884 (_("%s: 0x%lx: warning: could not find expected COUNT reloc"),
885 bfd_get_filename (abfd), (unsigned long) paddr));
886 continue;
887 }
888
889 /* The number of uses is stored in the r_addend field. We've
890 just deleted one. */
891 if (irelcount->r_addend == 0)
892 {
893 ((*_bfd_error_handler) (_("%s: 0x%lx: warning: bad count"),
894 bfd_get_filename (abfd),
895 (unsigned long) paddr));
896 continue;
897 }
898
899 --irelcount->r_addend;
900
901 /* If there are no more uses, we can delete the address. Reload
902 the address from irelfn, in case it was changed by the
903 previous call to sh_elf_relax_delete_bytes. */
904 if (irelcount->r_addend == 0)
905 {
906 if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
907 goto error_return;
908 }
909
910 /* We've done all we can with that function call. */
911 }
912
913 /* Look for load and store instructions that we can align on four
914 byte boundaries. */
915 if (have_code)
916 {
917 boolean swapped;
918
919 /* Get the section contents. */
920 if (contents == NULL)
921 {
922 if (elf_section_data (sec)->this_hdr.contents != NULL)
923 contents = elf_section_data (sec)->this_hdr.contents;
924 else
925 {
926 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
927 if (contents == NULL)
928 goto error_return;
929 free_contents = contents;
930
931 if (! bfd_get_section_contents (abfd, sec, contents,
932 (file_ptr) 0, sec->_raw_size))
933 goto error_return;
934 }
935 }
936
937 if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
938 &swapped))
939 goto error_return;
940
941 if (swapped)
942 {
943 elf_section_data (sec)->relocs = internal_relocs;
944 free_relocs = NULL;
945
946 elf_section_data (sec)->this_hdr.contents = contents;
947 free_contents = NULL;
948
949 symtab_hdr->contents = (bfd_byte *) extsyms;
950 free_extsyms = NULL;
951 }
952 }
953
954 if (free_relocs != NULL)
955 {
956 free (free_relocs);
957 free_relocs = NULL;
958 }
959
960 if (free_contents != NULL)
961 {
962 if (! link_info->keep_memory)
963 free (free_contents);
964 else
965 {
966 /* Cache the section contents for elf_link_input_bfd. */
967 elf_section_data (sec)->this_hdr.contents = contents;
968 }
969 free_contents = NULL;
970 }
971
972 if (free_extsyms != NULL)
973 {
974 if (! link_info->keep_memory)
975 free (free_extsyms);
976 else
977 {
978 /* Cache the symbols for elf_link_input_bfd. */
979 symtab_hdr->contents = extsyms;
980 }
981 free_extsyms = NULL;
982 }
983
984 return true;
985
986 error_return:
987 if (free_relocs != NULL)
988 free (free_relocs);
989 if (free_contents != NULL)
990 free (free_contents);
991 if (free_extsyms != NULL)
992 free (free_extsyms);
993 return false;
994 }
995
996 /* Delete some bytes from a section while relaxing. FIXME: There is a
997 lot of duplication between this function and sh_relax_delete_bytes
998 in coff-sh.c. */
999
1000 static boolean
1001 sh_elf_relax_delete_bytes (abfd, sec, addr, count)
1002 bfd *abfd;
1003 asection *sec;
1004 bfd_vma addr;
1005 int count;
1006 {
1007 Elf_Internal_Shdr *symtab_hdr;
1008 Elf32_External_Sym *extsyms;
1009 int shndx, index;
1010 bfd_byte *contents;
1011 Elf_Internal_Rela *irel, *irelend;
1012 Elf_Internal_Rela *irelalign;
1013 bfd_vma toaddr;
1014 Elf32_External_Sym *esym, *esymend;
1015 struct elf_link_hash_entry *sym_hash;
1016 asection *o;
1017
1018 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1019 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1020
1021 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1022
1023 contents = elf_section_data (sec)->this_hdr.contents;
1024
1025 /* The deletion must stop at the next ALIGN reloc for an aligment
1026 power larger than the number of bytes we are deleting. */
1027
1028 irelalign = NULL;
1029 toaddr = sec->_cooked_size;
1030
1031 irel = elf_section_data (sec)->relocs;
1032 irelend = irel + sec->reloc_count;
1033 for (; irel < irelend; irel++)
1034 {
1035 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
1036 && irel->r_offset > addr
1037 && count < (1 << irel->r_addend))
1038 {
1039 irelalign = irel;
1040 toaddr = irel->r_offset;
1041 break;
1042 }
1043 }
1044
1045 /* Actually delete the bytes. */
1046 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
1047 if (irelalign == NULL)
1048 sec->_cooked_size -= count;
1049 else
1050 {
1051 int i;
1052
1053 #define NOP_OPCODE (0x0009)
1054
1055 BFD_ASSERT ((count & 1) == 0);
1056 for (i = 0; i < count; i += 2)
1057 bfd_put_16 (abfd, NOP_OPCODE, contents + toaddr - count + i);
1058 }
1059
1060 /* Adjust all the relocs. */
1061 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1062 {
1063 bfd_vma nraddr, stop;
1064 bfd_vma start = 0;
1065 int insn = 0;
1066 Elf_Internal_Sym sym;
1067 int off, adjust, oinsn;
1068 bfd_signed_vma voff = 0;
1069 boolean overflow;
1070
1071 /* Get the new reloc address. */
1072 nraddr = irel->r_offset;
1073 if ((irel->r_offset > addr
1074 && irel->r_offset < toaddr)
1075 || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
1076 && irel->r_offset == toaddr))
1077 nraddr -= count;
1078
1079 /* See if this reloc was for the bytes we have deleted, in which
1080 case we no longer care about it. Don't delete relocs which
1081 represent addresses, though. */
1082 if (irel->r_offset >= addr
1083 && irel->r_offset < addr + count
1084 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
1085 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
1086 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
1087 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
1088 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1089 (int) R_SH_NONE);
1090
1091 /* If this is a PC relative reloc, see if the range it covers
1092 includes the bytes we have deleted. */
1093 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1094 {
1095 default:
1096 break;
1097
1098 case R_SH_DIR8WPN:
1099 case R_SH_IND12W:
1100 case R_SH_DIR8WPZ:
1101 case R_SH_DIR8WPL:
1102 start = irel->r_offset;
1103 insn = bfd_get_16 (abfd, contents + nraddr);
1104 break;
1105 }
1106
1107 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1108 {
1109 default:
1110 start = stop = addr;
1111 break;
1112
1113 case R_SH_DIR32:
1114 /* If this reloc is against a symbol defined in this
1115 section, and the symbol will not be adjusted below, we
1116 must check the addend to see it will put the value in
1117 range to be adjusted, and hence must be changed. */
1118 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1119 {
1120 bfd_elf32_swap_symbol_in (abfd,
1121 extsyms + ELF32_R_SYM (irel->r_info),
1122 &sym);
1123 if (sym.st_shndx == shndx
1124 && (sym.st_value <= addr
1125 || sym.st_value >= toaddr))
1126 {
1127 bfd_vma val;
1128
1129 val = bfd_get_32 (abfd, contents + nraddr);
1130 val += sym.st_value;
1131 if (val > addr && val < toaddr)
1132 bfd_put_32 (abfd, val - count, contents + nraddr);
1133 }
1134 }
1135 start = stop = addr;
1136 break;
1137
1138 case R_SH_DIR8WPN:
1139 off = insn & 0xff;
1140 if (off & 0x80)
1141 off -= 0x100;
1142 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1143 break;
1144
1145 case R_SH_IND12W:
1146 if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
1147 start = stop = addr;
1148 else
1149 {
1150 off = insn & 0xfff;
1151 if (off & 0x800)
1152 off -= 0x1000;
1153 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
1154 }
1155 break;
1156
1157 case R_SH_DIR8WPZ:
1158 off = insn & 0xff;
1159 stop = start + 4 + off * 2;
1160 break;
1161
1162 case R_SH_DIR8WPL:
1163 off = insn & 0xff;
1164 stop = (start &~ (bfd_vma) 3) + 4 + off * 4;
1165 break;
1166
1167 case R_SH_SWITCH8:
1168 case R_SH_SWITCH16:
1169 case R_SH_SWITCH32:
1170 /* These relocs types represent
1171 .word L2-L1
1172 The r_addend field holds the difference between the reloc
1173 address and L1. That is the start of the reloc, and
1174 adding in the contents gives us the top. We must adjust
1175 both the r_offset field and the section contents.
1176 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1177 and the elf bfd r_offset is called r_vaddr. */
1178
1179 stop = irel->r_offset;
1180 start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
1181
1182 if (start > addr
1183 && start < toaddr
1184 && (stop <= addr || stop >= toaddr))
1185 irel->r_addend += count;
1186 else if (stop > addr
1187 && stop < toaddr
1188 && (start <= addr || start >= toaddr))
1189 irel->r_addend -= count;
1190
1191 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
1192 voff = bfd_get_signed_16 (abfd, contents + nraddr);
1193 else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
1194 voff = bfd_get_8 (abfd, contents + nraddr);
1195 else
1196 voff = bfd_get_signed_32 (abfd, contents + nraddr);
1197 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1198
1199 break;
1200
1201 case R_SH_USES:
1202 start = irel->r_offset;
1203 stop = (bfd_vma) ((bfd_signed_vma) start
1204 + (long) irel->r_addend
1205 + 4);
1206 break;
1207 }
1208
1209 if (start > addr
1210 && start < toaddr
1211 && (stop <= addr || stop >= toaddr))
1212 adjust = count;
1213 else if (stop > addr
1214 && stop < toaddr
1215 && (start <= addr || start >= toaddr))
1216 adjust = - count;
1217 else
1218 adjust = 0;
1219
1220 if (adjust != 0)
1221 {
1222 oinsn = insn;
1223 overflow = false;
1224 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
1225 {
1226 default:
1227 abort ();
1228 break;
1229
1230 case R_SH_DIR8WPN:
1231 case R_SH_DIR8WPZ:
1232 insn += adjust / 2;
1233 if ((oinsn & 0xff00) != (insn & 0xff00))
1234 overflow = true;
1235 bfd_put_16 (abfd, insn, contents + nraddr);
1236 break;
1237
1238 case R_SH_IND12W:
1239 insn += adjust / 2;
1240 if ((oinsn & 0xf000) != (insn & 0xf000))
1241 overflow = true;
1242 bfd_put_16 (abfd, insn, contents + nraddr);
1243 break;
1244
1245 case R_SH_DIR8WPL:
1246 BFD_ASSERT (adjust == count || count >= 4);
1247 if (count >= 4)
1248 insn += adjust / 4;
1249 else
1250 {
1251 if ((irel->r_offset & 3) == 0)
1252 ++insn;
1253 }
1254 if ((oinsn & 0xff00) != (insn & 0xff00))
1255 overflow = true;
1256 bfd_put_16 (abfd, insn, contents + nraddr);
1257 break;
1258
1259 case R_SH_SWITCH16:
1260 voff += adjust;
1261 if (voff < - 0x8000 || voff >= 0x8000)
1262 overflow = true;
1263 bfd_put_signed_16 (abfd, voff, contents + nraddr);
1264 break;
1265
1266 case R_SH_SWITCH32:
1267 voff += adjust;
1268 bfd_put_signed_32 (abfd, voff, contents + nraddr);
1269 break;
1270
1271 case R_SH_USES:
1272 irel->r_addend += adjust;
1273 break;
1274 }
1275
1276 if (overflow)
1277 {
1278 ((*_bfd_error_handler)
1279 (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
1280 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
1281 bfd_set_error (bfd_error_bad_value);
1282 return false;
1283 }
1284 }
1285
1286 irel->r_offset = nraddr;
1287 }
1288
1289 /* Look through all the other sections. If there contain any IMM32
1290 relocs against internal symbols which we are not going to adjust
1291 below, we may need to adjust the addends. */
1292 for (o = abfd->sections; o != NULL; o = o->next)
1293 {
1294 Elf_Internal_Rela *internal_relocs;
1295 Elf_Internal_Rela *irelscan, *irelscanend;
1296 bfd_byte *ocontents;
1297
1298 if (o == sec
1299 || (o->flags & SEC_RELOC) == 0
1300 || o->reloc_count == 0)
1301 continue;
1302
1303 /* We always cache the relocs. Perhaps, if info->keep_memory is
1304 false, we should free them, if we are permitted to, when we
1305 leave sh_coff_relax_section. */
1306 internal_relocs = (_bfd_elf32_link_read_relocs
1307 (abfd, o, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1308 true));
1309 if (internal_relocs == NULL)
1310 return false;
1311
1312 ocontents = NULL;
1313 irelscanend = internal_relocs + o->reloc_count;
1314 for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
1315 {
1316 Elf_Internal_Sym sym;
1317
1318 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1319 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
1320 {
1321 bfd_vma start, stop;
1322 bfd_signed_vma voff;
1323
1324 if (ocontents == NULL)
1325 {
1326 if (elf_section_data (o)->this_hdr.contents != NULL)
1327 ocontents = elf_section_data (o)->this_hdr.contents;
1328 else
1329 {
1330 /* We always cache the section contents.
1331 Perhaps, if info->keep_memory is false, we
1332 should free them, if we are permitted to,
1333 when we leave sh_coff_relax_section. */
1334 ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
1335 if (ocontents == NULL)
1336 return false;
1337 if (! bfd_get_section_contents (abfd, o, ocontents,
1338 (file_ptr) 0,
1339 o->_raw_size))
1340 return false;
1341 elf_section_data (o)->this_hdr.contents = ocontents;
1342 }
1343 }
1344
1345 stop = irelscan->r_offset;
1346 start
1347 = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
1348
1349 /* STOP is in a different section, so it won't change. */
1350 if (start > addr && start < toaddr)
1351 irelscan->r_addend += count;
1352
1353 voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
1354 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
1355
1356 if (start > addr
1357 && start < toaddr
1358 && (stop <= addr || stop >= toaddr))
1359 bfd_put_signed_32 (abfd, voff + count,
1360 ocontents + irelscan->r_offset);
1361 else if (stop > addr
1362 && stop < toaddr
1363 && (start <= addr || start >= toaddr))
1364 bfd_put_signed_32 (abfd, voff - count,
1365 ocontents + irelscan->r_offset);
1366 }
1367
1368 if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
1369 continue;
1370
1371 if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
1372 continue;
1373
1374 bfd_elf32_swap_symbol_in (abfd,
1375 extsyms + ELF32_R_SYM (irelscan->r_info),
1376 &sym);
1377
1378 if (sym.st_shndx == shndx
1379 && (sym.st_value <= addr
1380 || sym.st_value >= toaddr))
1381 {
1382 bfd_vma val;
1383
1384 if (ocontents == NULL)
1385 {
1386 if (elf_section_data (o)->this_hdr.contents != NULL)
1387 ocontents = elf_section_data (o)->this_hdr.contents;
1388 else
1389 {
1390 /* We always cache the section contents.
1391 Perhaps, if info->keep_memory is false, we
1392 should free them, if we are permitted to,
1393 when we leave sh_coff_relax_section. */
1394 ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
1395 if (ocontents == NULL)
1396 return false;
1397 if (! bfd_get_section_contents (abfd, o, ocontents,
1398 (file_ptr) 0,
1399 o->_raw_size))
1400 return false;
1401 elf_section_data (o)->this_hdr.contents = ocontents;
1402 }
1403 }
1404
1405 val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
1406 val += sym.st_value;
1407 if (val > addr && val < toaddr)
1408 bfd_put_32 (abfd, val - count,
1409 ocontents + irelscan->r_offset);
1410 }
1411 }
1412 }
1413
1414 /* Adjust the local symbols defined in this section. */
1415 esym = extsyms;
1416 esymend = esym + symtab_hdr->sh_info;
1417 for (; esym < esymend; esym++)
1418 {
1419 Elf_Internal_Sym isym;
1420
1421 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1422
1423 if (isym.st_shndx == shndx
1424 && isym.st_value > addr
1425 && isym.st_value < toaddr)
1426 {
1427 isym.st_value -= count;
1428 bfd_elf32_swap_symbol_out (abfd, &isym, esym);
1429 }
1430 }
1431
1432 /* Now adjust the global symbols defined in this section. */
1433 esym = extsyms + symtab_hdr->sh_info;
1434 esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
1435 for (index = 0; esym < esymend; esym++, index++)
1436 {
1437 Elf_Internal_Sym isym;
1438
1439 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1440 sym_hash = elf_sym_hashes (abfd)[index];
1441 if (isym.st_shndx == shndx
1442 && ((sym_hash)->root.type == bfd_link_hash_defined
1443 || (sym_hash)->root.type == bfd_link_hash_defweak)
1444 && (sym_hash)->root.u.def.section == sec
1445 && (sym_hash)->root.u.def.value > addr
1446 && (sym_hash)->root.u.def.value < toaddr)
1447 {
1448 (sym_hash)->root.u.def.value -= count;
1449 }
1450 }
1451
1452 /* See if we can move the ALIGN reloc forward. We have adjusted
1453 r_offset for it already. */
1454 if (irelalign != NULL)
1455 {
1456 bfd_vma alignto, alignaddr;
1457
1458 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
1459 alignaddr = BFD_ALIGN (irelalign->r_offset,
1460 1 << irelalign->r_addend);
1461 if (alignto != alignaddr)
1462 {
1463 /* Tail recursion. */
1464 return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
1465 alignto - alignaddr);
1466 }
1467 }
1468
1469 return true;
1470 }
1471
1472 /* Look for loads and stores which we can align to four byte
1473 boundaries. This is like sh_align_loads in coff-sh.c. */
1474
1475 static boolean
1476 sh_elf_align_loads (abfd, sec, internal_relocs, contents, pswapped)
1477 bfd *abfd;
1478 asection *sec;
1479 Elf_Internal_Rela *internal_relocs;
1480 bfd_byte *contents;
1481 boolean *pswapped;
1482 {
1483 Elf_Internal_Rela *irel, *irelend;
1484 bfd_vma *labels = NULL;
1485 bfd_vma *label, *label_end;
1486
1487 *pswapped = false;
1488
1489 irelend = internal_relocs + sec->reloc_count;
1490
1491 /* Get all the addresses with labels on them. */
1492 labels = (bfd_vma *) bfd_malloc (sec->reloc_count * sizeof (bfd_vma));
1493 if (labels == NULL)
1494 goto error_return;
1495 label_end = labels;
1496 for (irel = internal_relocs; irel < irelend; irel++)
1497 {
1498 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
1499 {
1500 *label_end = irel->r_offset;
1501 ++label_end;
1502 }
1503 }
1504
1505 /* Note that the assembler currently always outputs relocs in
1506 address order. If that ever changes, this code will need to sort
1507 the label values and the relocs. */
1508
1509 label = labels;
1510
1511 for (irel = internal_relocs; irel < irelend; irel++)
1512 {
1513 bfd_vma start, stop;
1514
1515 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
1516 continue;
1517
1518 start = irel->r_offset;
1519
1520 for (irel++; irel < irelend; irel++)
1521 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
1522 break;
1523 if (irel < irelend)
1524 stop = irel->r_offset;
1525 else
1526 stop = sec->_cooked_size;
1527
1528 if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
1529 (PTR) internal_relocs, &label,
1530 label_end, start, stop, pswapped))
1531 goto error_return;
1532 }
1533
1534 free (labels);
1535
1536 return true;
1537
1538 error_return:
1539 if (labels != NULL)
1540 free (labels);
1541 return false;
1542 }
1543
1544 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1545
1546 static boolean
1547 sh_elf_swap_insns (abfd, sec, relocs, contents, addr)
1548 bfd *abfd;
1549 asection *sec;
1550 PTR relocs;
1551 bfd_byte *contents;
1552 bfd_vma addr;
1553 {
1554 Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
1555 unsigned short i1, i2;
1556 Elf_Internal_Rela *irel, *irelend;
1557
1558 /* Swap the instructions themselves. */
1559 i1 = bfd_get_16 (abfd, contents + addr);
1560 i2 = bfd_get_16 (abfd, contents + addr + 2);
1561 bfd_put_16 (abfd, i2, contents + addr);
1562 bfd_put_16 (abfd, i1, contents + addr + 2);
1563
1564 /* Adjust all reloc addresses. */
1565 irelend = internal_relocs + sec->reloc_count;
1566 for (irel = internal_relocs; irel < irelend; irel++)
1567 {
1568 enum elf_sh_reloc_type type;
1569 int add;
1570
1571 /* There are a few special types of relocs that we don't want to
1572 adjust. These relocs do not apply to the instruction itself,
1573 but are only associated with the address. */
1574 type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
1575 if (type == R_SH_ALIGN
1576 || type == R_SH_CODE
1577 || type == R_SH_DATA
1578 || type == R_SH_LABEL)
1579 continue;
1580
1581 /* If an R_SH_USES reloc points to one of the addresses being
1582 swapped, we must adjust it. It would be incorrect to do this
1583 for a jump, though, since we want to execute both
1584 instructions after the jump. (We have avoided swapping
1585 around a label, so the jump will not wind up executing an
1586 instruction it shouldn't). */
1587 if (type == R_SH_USES)
1588 {
1589 bfd_vma off;
1590
1591 off = irel->r_offset + 4 + irel->r_addend;
1592 if (off == addr)
1593 irel->r_offset += 2;
1594 else if (off == addr + 2)
1595 irel->r_offset -= 2;
1596 }
1597
1598 if (irel->r_offset == addr)
1599 {
1600 irel->r_offset += 2;
1601 add = -2;
1602 }
1603 else if (irel->r_offset == addr + 2)
1604 {
1605 irel->r_offset -= 2;
1606 add = 2;
1607 }
1608 else
1609 add = 0;
1610
1611 if (add != 0)
1612 {
1613 bfd_byte *loc;
1614 unsigned short insn, oinsn;
1615 boolean overflow;
1616
1617 loc = contents + irel->r_offset;
1618 overflow = false;
1619 switch (type)
1620 {
1621 default:
1622 break;
1623
1624 case R_SH_DIR8WPN:
1625 case R_SH_DIR8WPZ:
1626 insn = bfd_get_16 (abfd, loc);
1627 oinsn = insn;
1628 insn += add / 2;
1629 if ((oinsn & 0xff00) != (insn & 0xff00))
1630 overflow = true;
1631 bfd_put_16 (abfd, insn, loc);
1632 break;
1633
1634 case R_SH_IND12W:
1635 insn = bfd_get_16 (abfd, loc);
1636 oinsn = insn;
1637 insn += add / 2;
1638 if ((oinsn & 0xf000) != (insn & 0xf000))
1639 overflow = true;
1640 bfd_put_16 (abfd, insn, loc);
1641 break;
1642
1643 case R_SH_DIR8WPL:
1644 /* This reloc ignores the least significant 3 bits of
1645 the program counter before adding in the offset.
1646 This means that if ADDR is at an even address, the
1647 swap will not affect the offset. If ADDR is an at an
1648 odd address, then the instruction will be crossing a
1649 four byte boundary, and must be adjusted. */
1650 if ((addr & 3) != 0)
1651 {
1652 insn = bfd_get_16 (abfd, loc);
1653 oinsn = insn;
1654 insn += add / 2;
1655 if ((oinsn & 0xff00) != (insn & 0xff00))
1656 overflow = true;
1657 bfd_put_16 (abfd, insn, loc);
1658 }
1659
1660 break;
1661 }
1662
1663 if (overflow)
1664 {
1665 ((*_bfd_error_handler)
1666 (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
1667 bfd_get_filename (abfd), (unsigned long) irel->r_offset));
1668 bfd_set_error (bfd_error_bad_value);
1669 return false;
1670 }
1671 }
1672 }
1673
1674 return true;
1675 }
1676 \f
1677 /* Relocate an SH ELF section. */
1678
1679 static boolean
1680 sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1681 contents, relocs, local_syms, local_sections)
1682 bfd *output_bfd ATTRIBUTE_UNUSED;
1683 struct bfd_link_info *info;
1684 bfd *input_bfd;
1685 asection *input_section;
1686 bfd_byte *contents;
1687 Elf_Internal_Rela *relocs;
1688 Elf_Internal_Sym *local_syms;
1689 asection **local_sections;
1690 {
1691 Elf_Internal_Shdr *symtab_hdr;
1692 struct elf_link_hash_entry **sym_hashes;
1693 Elf_Internal_Rela *rel, *relend;
1694
1695 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1696 sym_hashes = elf_sym_hashes (input_bfd);
1697
1698 rel = relocs;
1699 relend = relocs + input_section->reloc_count;
1700 for (; rel < relend; rel++)
1701 {
1702 int r_type;
1703 reloc_howto_type *howto;
1704 unsigned long r_symndx;
1705 Elf_Internal_Sym *sym;
1706 asection *sec;
1707 struct elf_link_hash_entry *h;
1708 bfd_vma relocation;
1709 bfd_vma addend = (bfd_vma)0;
1710 bfd_reloc_status_type r;
1711
1712 r_symndx = ELF32_R_SYM (rel->r_info);
1713
1714 if (info->relocateable)
1715 {
1716 /* This is a relocateable link. We don't have to change
1717 anything, unless the reloc is against a section symbol,
1718 in which case we have to adjust according to where the
1719 section symbol winds up in the output section. */
1720 if (r_symndx < symtab_hdr->sh_info)
1721 {
1722 sym = local_syms + r_symndx;
1723 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1724 {
1725 sec = local_sections[r_symndx];
1726 rel->r_addend += sec->output_offset + sym->st_value;
1727 }
1728 }
1729
1730 continue;
1731 }
1732
1733 r_type = ELF32_R_TYPE (rel->r_info);
1734
1735 /* Many of the relocs are only used for relaxing, and are
1736 handled entirely by the relaxation code. */
1737 if (r_type > (int) R_SH_LAST_INVALID_RELOC)
1738 continue;
1739
1740 if (r_type < 0
1741 || r_type >= (int) R_SH_FIRST_INVALID_RELOC)
1742 {
1743 bfd_set_error (bfd_error_bad_value);
1744 return false;
1745 }
1746
1747 /* FIXME: This is certainly incorrect. However, it is how the
1748 COFF linker works. */
1749 if (r_type != (int) R_SH_DIR32
1750 && r_type != (int) R_SH_IND12W)
1751 continue;
1752
1753 howto = sh_elf_howto_table + r_type;
1754
1755 /* This is a final link. */
1756 h = NULL;
1757 sym = NULL;
1758 sec = NULL;
1759 if (r_symndx < symtab_hdr->sh_info)
1760 {
1761 /* There is nothing to be done for an internal IND12W
1762 relocation. FIXME: This is probably wrong, but it's how
1763 the COFF relocations work. */
1764 if (r_type == (int) R_SH_IND12W)
1765 continue;
1766 sym = local_syms + r_symndx;
1767 sec = local_sections[r_symndx];
1768 relocation = (sec->output_section->vma
1769 + sec->output_offset
1770 + sym->st_value);
1771 }
1772 else
1773 {
1774 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1775 while (h->root.type == bfd_link_hash_indirect
1776 || h->root.type == bfd_link_hash_warning)
1777 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1778 if (h->root.type == bfd_link_hash_defined
1779 || h->root.type == bfd_link_hash_defweak)
1780 {
1781 sec = h->root.u.def.section;
1782 relocation = (h->root.u.def.value
1783 + sec->output_section->vma
1784 + sec->output_offset);
1785 }
1786 else if (h->root.type == bfd_link_hash_undefweak)
1787 relocation = 0;
1788 else
1789 {
1790 if (! ((*info->callbacks->undefined_symbol)
1791 (info, h->root.root.string, input_bfd,
1792 input_section, rel->r_offset, true)))
1793 return false;
1794 relocation = 0;
1795 }
1796 }
1797
1798 /* FIXME: This is how the COFF relocations work. */
1799 if (r_type == (int) R_SH_IND12W)
1800 relocation -= 4;
1801
1802 switch ((int)r_type)
1803 {
1804 case (int)R_SH_DIR32:
1805 addend = rel->r_addend;
1806 break;
1807 }
1808
1809 /* COFF relocs don't use the addend. The addend is used for R_SH_DIR32
1810 to be compatible with other compilers. */
1811 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1812 contents, rel->r_offset,
1813 relocation, addend);
1814
1815 if (r != bfd_reloc_ok)
1816 {
1817 switch (r)
1818 {
1819 default:
1820 case bfd_reloc_outofrange:
1821 abort ();
1822 case bfd_reloc_overflow:
1823 {
1824 const char *name;
1825
1826 if (h != NULL)
1827 name = h->root.root.string;
1828 else
1829 {
1830 name = (bfd_elf_string_from_elf_section
1831 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1832 if (name == NULL)
1833 return false;
1834 if (*name == '\0')
1835 name = bfd_section_name (input_bfd, sec);
1836 }
1837 if (! ((*info->callbacks->reloc_overflow)
1838 (info, name, howto->name, (bfd_vma) 0,
1839 input_bfd, input_section, rel->r_offset)))
1840 return false;
1841 }
1842 break;
1843 }
1844 }
1845 }
1846
1847 return true;
1848 }
1849
1850 /* This is a version of bfd_generic_get_relocated_section_contents
1851 which uses sh_elf_relocate_section. */
1852
1853 static bfd_byte *
1854 sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
1855 data, relocateable, symbols)
1856 bfd *output_bfd;
1857 struct bfd_link_info *link_info;
1858 struct bfd_link_order *link_order;
1859 bfd_byte *data;
1860 boolean relocateable;
1861 asymbol **symbols;
1862 {
1863 Elf_Internal_Shdr *symtab_hdr;
1864 asection *input_section = link_order->u.indirect.section;
1865 bfd *input_bfd = input_section->owner;
1866 asection **sections = NULL;
1867 Elf_Internal_Rela *internal_relocs = NULL;
1868 Elf32_External_Sym *external_syms = NULL;
1869 Elf_Internal_Sym *internal_syms = NULL;
1870
1871 /* We only need to handle the case of relaxing, or of having a
1872 particular set of section contents, specially. */
1873 if (relocateable
1874 || elf_section_data (input_section)->this_hdr.contents == NULL)
1875 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1876 link_order, data,
1877 relocateable,
1878 symbols);
1879
1880 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1881
1882 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1883 input_section->_raw_size);
1884
1885 if ((input_section->flags & SEC_RELOC) != 0
1886 && input_section->reloc_count > 0)
1887 {
1888 Elf_Internal_Sym *isymp;
1889 asection **secpp;
1890 Elf32_External_Sym *esym, *esymend;
1891
1892 if (symtab_hdr->contents != NULL)
1893 external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
1894 else
1895 {
1896 external_syms = ((Elf32_External_Sym *)
1897 bfd_malloc (symtab_hdr->sh_info
1898 * sizeof (Elf32_External_Sym)));
1899 if (external_syms == NULL && symtab_hdr->sh_info > 0)
1900 goto error_return;
1901 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1902 || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
1903 symtab_hdr->sh_info, input_bfd)
1904 != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
1905 goto error_return;
1906 }
1907
1908 internal_relocs = (_bfd_elf32_link_read_relocs
1909 (input_bfd, input_section, (PTR) NULL,
1910 (Elf_Internal_Rela *) NULL, false));
1911 if (internal_relocs == NULL)
1912 goto error_return;
1913
1914 internal_syms = ((Elf_Internal_Sym *)
1915 bfd_malloc (symtab_hdr->sh_info
1916 * sizeof (Elf_Internal_Sym)));
1917 if (internal_syms == NULL && symtab_hdr->sh_info > 0)
1918 goto error_return;
1919
1920 sections = (asection **) bfd_malloc (symtab_hdr->sh_info
1921 * sizeof (asection *));
1922 if (sections == NULL && symtab_hdr->sh_info > 0)
1923 goto error_return;
1924
1925 isymp = internal_syms;
1926 secpp = sections;
1927 esym = external_syms;
1928 esymend = esym + symtab_hdr->sh_info;
1929 for (; esym < esymend; ++esym, ++isymp, ++secpp)
1930 {
1931 asection *isec;
1932
1933 bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
1934
1935 if (isymp->st_shndx == SHN_UNDEF)
1936 isec = bfd_und_section_ptr;
1937 else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
1938 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
1939 else if (isymp->st_shndx == SHN_ABS)
1940 isec = bfd_abs_section_ptr;
1941 else if (isymp->st_shndx == SHN_COMMON)
1942 isec = bfd_com_section_ptr;
1943 else
1944 {
1945 /* Who knows? */
1946 isec = NULL;
1947 }
1948
1949 *secpp = isec;
1950 }
1951
1952 if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
1953 input_section, data, internal_relocs,
1954 internal_syms, sections))
1955 goto error_return;
1956
1957 if (sections != NULL)
1958 free (sections);
1959 sections = NULL;
1960 if (internal_syms != NULL)
1961 free (internal_syms);
1962 internal_syms = NULL;
1963 if (external_syms != NULL && symtab_hdr->contents == NULL)
1964 free (external_syms);
1965 external_syms = NULL;
1966 if (internal_relocs != elf_section_data (input_section)->relocs)
1967 free (internal_relocs);
1968 internal_relocs = NULL;
1969 }
1970
1971 return data;
1972
1973 error_return:
1974 if (internal_relocs != NULL
1975 && internal_relocs != elf_section_data (input_section)->relocs)
1976 free (internal_relocs);
1977 if (external_syms != NULL && symtab_hdr->contents == NULL)
1978 free (external_syms);
1979 if (internal_syms != NULL)
1980 free (internal_syms);
1981 if (sections != NULL)
1982 free (sections);
1983 return NULL;
1984 }
1985 static asection *
1986 sh_elf_gc_mark_hook (abfd, info, rel, h, sym)
1987 bfd *abfd;
1988 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1989 Elf_Internal_Rela *rel;
1990 struct elf_link_hash_entry *h;
1991 Elf_Internal_Sym *sym;
1992 {
1993 if (h != NULL)
1994 {
1995 switch (ELF32_R_TYPE (rel->r_info))
1996 {
1997 case R_SH_GNU_VTINHERIT:
1998 case R_SH_GNU_VTENTRY:
1999 break;
2000
2001 default:
2002 switch (h->root.type)
2003 {
2004 case bfd_link_hash_defined:
2005 case bfd_link_hash_defweak:
2006 return h->root.u.def.section;
2007
2008 case bfd_link_hash_common:
2009 return h->root.u.c.p->section;
2010
2011 default:
2012 break;
2013 }
2014 }
2015 }
2016 else
2017 {
2018 if (!(elf_bad_symtab (abfd)
2019 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2020 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2021 && sym->st_shndx != SHN_COMMON))
2022 {
2023 return bfd_section_from_elf_index (abfd, sym->st_shndx);
2024 }
2025 }
2026 return NULL;
2027 }
2028
2029 static boolean
2030 sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
2031 bfd *abfd ATTRIBUTE_UNUSED;
2032 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2033 asection *sec ATTRIBUTE_UNUSED;
2034 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2035 {
2036 /* we don't use got and plt entries for sh. */
2037 return true;
2038 }
2039
2040 /* Look through the relocs for a section during the first phase.
2041 Since we don't do .gots or .plts, we just need to consider the
2042 virtual table relocs for gc. */
2043
2044 static boolean
2045 sh_elf_check_relocs (abfd, info, sec, relocs)
2046 bfd *abfd;
2047 struct bfd_link_info *info;
2048 asection *sec;
2049 const Elf_Internal_Rela *relocs;
2050 {
2051 Elf_Internal_Shdr *symtab_hdr;
2052 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2053 const Elf_Internal_Rela *rel;
2054 const Elf_Internal_Rela *rel_end;
2055
2056 if (info->relocateable)
2057 return true;
2058
2059 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2060 sym_hashes = elf_sym_hashes (abfd);
2061 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
2062 if (!elf_bad_symtab (abfd))
2063 sym_hashes_end -= symtab_hdr->sh_info;
2064
2065 rel_end = relocs + sec->reloc_count;
2066 for (rel = relocs; rel < rel_end; rel++)
2067 {
2068 struct elf_link_hash_entry *h;
2069 unsigned long r_symndx;
2070
2071 r_symndx = ELF32_R_SYM (rel->r_info);
2072 if (r_symndx < symtab_hdr->sh_info)
2073 h = NULL;
2074 else
2075 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2076
2077 switch (ELF32_R_TYPE (rel->r_info))
2078 {
2079 /* This relocation describes the C++ object vtable hierarchy.
2080 Reconstruct it for later use during GC. */
2081 case R_SH_GNU_VTINHERIT:
2082 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2083 return false;
2084 break;
2085
2086 /* This relocation describes which C++ vtable entries are actually
2087 used. Record for later use during GC. */
2088 case R_SH_GNU_VTENTRY:
2089 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2090 return false;
2091 break;
2092 }
2093 }
2094
2095 return true;
2096 }
2097
2098 boolean
2099 sh_elf_set_mach_from_flags (abfd)
2100 bfd * abfd;
2101 {
2102 flagword flags = elf_elfheader (abfd)->e_flags;
2103
2104 switch (flags & EF_SH_MACH_MASK)
2105 {
2106 case EF_SH1:
2107 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh);
2108 break;
2109 case EF_SH2:
2110 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2);
2111 break;
2112 case EF_SH_DSP:
2113 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp);
2114 break;
2115 case EF_SH3:
2116 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3);
2117 break;
2118 case EF_SH3_DSP:
2119 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp);
2120 break;
2121 case EF_SH3E:
2122 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e);
2123 break;
2124 case EF_SH_UNKNOWN:
2125 case EF_SH4:
2126 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4);
2127 break;
2128 default:
2129 return false;
2130 }
2131 return true;
2132 }
2133
2134 /* Function to keep SH specific file flags. */
2135 static boolean
2136 sh_elf_set_private_flags (abfd, flags)
2137 bfd * abfd;
2138 flagword flags;
2139 {
2140 BFD_ASSERT (! elf_flags_init (abfd)
2141 || elf_elfheader (abfd)->e_flags == flags);
2142
2143 elf_elfheader (abfd)->e_flags = flags;
2144 elf_flags_init (abfd) = true;
2145 return sh_elf_set_mach_from_flags (abfd);
2146 }
2147
2148 /* Copy backend specific data from one object module to another */
2149 static boolean
2150 sh_elf_copy_private_data (ibfd, obfd)
2151 bfd * ibfd;
2152 bfd * obfd;
2153 {
2154 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2155 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2156 return true;
2157
2158 return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
2159 }
2160
2161 /* This routine checks for linking big and little endian objects
2162 together, and for linking sh-dsp with sh3e / sh4 objects. */
2163
2164 static boolean
2165 sh_elf_merge_private_data (ibfd, obfd)
2166 bfd *ibfd;
2167 bfd *obfd;
2168 {
2169 flagword old_flags, new_flags;
2170
2171 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2172 return false;
2173
2174 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2175 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2176 return true;
2177
2178 if (! elf_flags_init (obfd))
2179 {
2180 elf_flags_init (obfd) = true;
2181 elf_elfheader (obfd)->e_flags = 0;
2182 }
2183 old_flags = elf_elfheader (obfd)->e_flags;
2184 new_flags = elf_elfheader (ibfd)->e_flags;
2185 if ((EF_SH_HAS_DSP (old_flags) && EF_SH_HAS_FP (new_flags))
2186 || (EF_SH_HAS_DSP (new_flags) && EF_SH_HAS_FP (old_flags)))
2187 {
2188 (*_bfd_error_handler)
2189 ("%s: uses %s instructions while previous modules use %s instructions",
2190 bfd_get_filename (ibfd),
2191 EF_SH_HAS_DSP (new_flags) ? "dsp" : "floating point",
2192 EF_SH_HAS_DSP (new_flags) ? "floating point" : "dsp");
2193 bfd_set_error (bfd_error_bad_value);
2194 return false;
2195 }
2196 elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags);
2197
2198 return sh_elf_set_mach_from_flags (obfd);
2199 }
2200
2201 #define TARGET_BIG_SYM bfd_elf32_sh_vec
2202 #define TARGET_BIG_NAME "elf32-sh"
2203 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
2204 #define TARGET_LITTLE_NAME "elf32-shl"
2205 #define ELF_ARCH bfd_arch_sh
2206 #define ELF_MACHINE_CODE EM_SH
2207 #define ELF_MAXPAGESIZE 0x1
2208
2209 #define elf_symbol_leading_char '_'
2210
2211 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
2212 #define elf_info_to_howto sh_elf_info_to_howto
2213 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
2214 #define elf_backend_relocate_section sh_elf_relocate_section
2215 #define bfd_elf32_bfd_get_relocated_section_contents \
2216 sh_elf_get_relocated_section_contents
2217 #define elf_backend_object_p sh_elf_set_mach_from_flags
2218 #define bfd_elf32_bfd_set_private_bfd_flags \
2219 sh_elf_set_private_flags
2220 #define bfd_elf32_bfd_copy_private_bfd_data \
2221 sh_elf_copy_private_data
2222 #define bfd_elf32_bfd_merge_private_bfd_data \
2223 sh_elf_merge_private_data
2224
2225 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
2226 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
2227 #define elf_backend_check_relocs sh_elf_check_relocs
2228
2229 #define elf_backend_can_gc_sections 1
2230 #include "elf32-target.h"
git-cvsimport of binutils cvsroot