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