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