projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* elflink.c (_bfd_elf_gc_mark_hook): New function.
[deliverable/binutils-gdb.git] / bfd / elf32-h8300.c
1 /* BFD back-end for Renesas H8/300 ELF binaries.
2 Copyright 1993, 1995, 1998, 1999, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/h8.h"
26
27 static reloc_howto_type *elf32_h8_reloc_type_lookup
28 (bfd *abfd, bfd_reloc_code_real_type code);
29 static void elf32_h8_info_to_howto
30 (bfd *, arelent *, Elf_Internal_Rela *);
31 static void elf32_h8_info_to_howto_rel
32 (bfd *, arelent *, Elf_Internal_Rela *);
33 static unsigned long elf32_h8_mach (flagword);
34 static void elf32_h8_final_write_processing (bfd *, bfd_boolean);
35 static bfd_boolean elf32_h8_object_p (bfd *);
36 static bfd_boolean elf32_h8_merge_private_bfd_data (bfd *, bfd *);
37 static bfd_boolean elf32_h8_relax_section
38 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
39 static bfd_boolean elf32_h8_relax_delete_bytes
40 (bfd *, asection *, bfd_vma, int);
41 static bfd_boolean elf32_h8_symbol_address_p (bfd *, asection *, bfd_vma);
42 static bfd_byte *elf32_h8_get_relocated_section_contents
43 (bfd *, struct bfd_link_info *, struct bfd_link_order *,
44 bfd_byte *, bfd_boolean, asymbol **);
45 static bfd_reloc_status_type elf32_h8_final_link_relocate
46 (unsigned long, bfd *, bfd *, asection *,
47 bfd_byte *, bfd_vma, bfd_vma, bfd_vma,
48 struct bfd_link_info *, asection *, int);
49 static bfd_boolean elf32_h8_relocate_section
50 (bfd *, struct bfd_link_info *, bfd *, asection *,
51 bfd_byte *, Elf_Internal_Rela *,
52 Elf_Internal_Sym *, asection **);
53 static bfd_reloc_status_type special
54 (bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **);
55
56 /* This does not include any relocation information, but should be
57 good enough for GDB or objdump to read the file. */
58
59 static reloc_howto_type h8_elf_howto_table[] = {
60 #define R_H8_NONE_X 0
61 HOWTO (R_H8_NONE, /* type */
62 0, /* rightshift */
63 0, /* size (0 = byte, 1 = short, 2 = long) */
64 0, /* bitsize */
65 FALSE, /* pc_relative */
66 0, /* bitpos */
67 complain_overflow_dont,/* complain_on_overflow */
68 special, /* special_function */
69 "R_H8_NONE", /* name */
70 FALSE, /* partial_inplace */
71 0, /* src_mask */
72 0, /* dst_mask */
73 FALSE), /* pcrel_offset */
74 #define R_H8_DIR32_X (R_H8_NONE_X + 1)
75 HOWTO (R_H8_DIR32, /* type */
76 0, /* rightshift */
77 2, /* size (0 = byte, 1 = short, 2 = long) */
78 32, /* bitsize */
79 FALSE, /* pc_relative */
80 0, /* bitpos */
81 complain_overflow_dont,/* complain_on_overflow */
82 special, /* special_function */
83 "R_H8_DIR32", /* name */
84 FALSE, /* partial_inplace */
85 0, /* src_mask */
86 0xffffffff, /* dst_mask */
87 FALSE), /* pcrel_offset */
88 #define R_H8_DIR16_X (R_H8_DIR32_X + 1)
89 HOWTO (R_H8_DIR16, /* type */
90 0, /* rightshift */
91 1, /* size (0 = byte, 1 = short, 2 = long) */
92 16, /* bitsize */
93 FALSE, /* pc_relative */
94 0, /* bitpos */
95 complain_overflow_dont,/* complain_on_overflow */
96 special, /* special_function */
97 "R_H8_DIR16", /* name */
98 FALSE, /* partial_inplace */
99 0, /* src_mask */
100 0x0000ffff, /* dst_mask */
101 FALSE), /* pcrel_offset */
102 #define R_H8_DIR8_X (R_H8_DIR16_X + 1)
103 HOWTO (R_H8_DIR8, /* type */
104 0, /* rightshift */
105 0, /* size (0 = byte, 1 = short, 2 = long) */
106 8, /* bitsize */
107 FALSE, /* pc_relative */
108 0, /* bitpos */
109 complain_overflow_dont,/* complain_on_overflow */
110 special, /* special_function */
111 "R_H8_DIR8", /* name */
112 FALSE, /* partial_inplace */
113 0, /* src_mask */
114 0x000000ff, /* dst_mask */
115 FALSE), /* pcrel_offset */
116 #define R_H8_DIR16A8_X (R_H8_DIR8_X + 1)
117 HOWTO (R_H8_DIR16A8, /* type */
118 0, /* rightshift */
119 1, /* size (0 = byte, 1 = short, 2 = long) */
120 16, /* bitsize */
121 FALSE, /* pc_relative */
122 0, /* bitpos */
123 complain_overflow_bitfield, /* complain_on_overflow */
124 special, /* special_function */
125 "R_H8_DIR16A8", /* name */
126 FALSE, /* partial_inplace */
127 0, /* src_mask */
128 0x0000ffff, /* dst_mask */
129 FALSE), /* pcrel_offset */
130 #define R_H8_DIR16R8_X (R_H8_DIR16A8_X + 1)
131 HOWTO (R_H8_DIR16R8, /* type */
132 0, /* rightshift */
133 1, /* size (0 = byte, 1 = short, 2 = long) */
134 16, /* bitsize */
135 FALSE, /* pc_relative */
136 0, /* bitpos */
137 complain_overflow_bitfield, /* complain_on_overflow */
138 special, /* special_function */
139 "R_H8_DIR16R8", /* name */
140 FALSE, /* partial_inplace */
141 0, /* src_mask */
142 0x0000ffff, /* dst_mask */
143 FALSE), /* pcrel_offset */
144 #define R_H8_DIR24A8_X (R_H8_DIR16R8_X + 1)
145 HOWTO (R_H8_DIR24A8, /* type */
146 0, /* rightshift */
147 2, /* size (0 = byte, 1 = short, 2 = long) */
148 24, /* bitsize */
149 FALSE, /* pc_relative */
150 0, /* bitpos */
151 complain_overflow_bitfield, /* complain_on_overflow */
152 special, /* special_function */
153 "R_H8_DIR24A8", /* name */
154 TRUE, /* partial_inplace */
155 0xff000000, /* src_mask */
156 0x00ffffff, /* dst_mask */
157 FALSE), /* pcrel_offset */
158 #define R_H8_DIR24R8_X (R_H8_DIR24A8_X + 1)
159 HOWTO (R_H8_DIR24R8, /* type */
160 0, /* rightshift */
161 2, /* size (0 = byte, 1 = short, 2 = long) */
162 24, /* bitsize */
163 FALSE, /* pc_relative */
164 0, /* bitpos */
165 complain_overflow_bitfield, /* complain_on_overflow */
166 special, /* special_function */
167 "R_H8_DIR24R8", /* name */
168 TRUE, /* partial_inplace */
169 0xff000000, /* src_mask */
170 0x00ffffff, /* dst_mask */
171 FALSE), /* pcrel_offset */
172 #define R_H8_DIR32A16_X (R_H8_DIR24R8_X + 1)
173 HOWTO (R_H8_DIR32A16, /* type */
174 0, /* rightshift */
175 2, /* size (0 = byte, 1 = short, 2 = long) */
176 32, /* bitsize */
177 FALSE, /* pc_relative */
178 0, /* bitpos */
179 complain_overflow_dont,/* complain_on_overflow */
180 special, /* special_function */
181 "R_H8_DIR32A16", /* name */
182 FALSE, /* partial_inplace */
183 0, /* src_mask */
184 0xffffffff, /* dst_mask */
185 FALSE), /* pcrel_offset */
186 #define R_H8_PCREL16_X (R_H8_DIR32A16_X + 1)
187 HOWTO (R_H8_PCREL16, /* type */
188 0, /* rightshift */
189 1, /* size (0 = byte, 1 = short, 2 = long) */
190 16, /* bitsize */
191 TRUE, /* pc_relative */
192 0, /* bitpos */
193 complain_overflow_signed,/* complain_on_overflow */
194 special, /* special_function */
195 "R_H8_PCREL16", /* name */
196 FALSE, /* partial_inplace */
197 0xffff, /* src_mask */
198 0xffff, /* dst_mask */
199 TRUE), /* pcrel_offset */
200 #define R_H8_PCREL8_X (R_H8_PCREL16_X + 1)
201 HOWTO (R_H8_PCREL8, /* type */
202 0, /* rightshift */
203 0, /* size (0 = byte, 1 = short, 2 = long) */
204 8, /* bitsize */
205 TRUE, /* pc_relative */
206 0, /* bitpos */
207 complain_overflow_signed,/* complain_on_overflow */
208 special, /* special_function */
209 "R_H8_PCREL8", /* name */
210 FALSE, /* partial_inplace */
211 0xff, /* src_mask */
212 0xff, /* dst_mask */
213 TRUE), /* pcrel_offset */
214 };
215
216 /* This structure is used to map BFD reloc codes to H8 ELF relocs. */
217
218 struct elf_reloc_map {
219 bfd_reloc_code_real_type bfd_reloc_val;
220 unsigned char howto_index;
221 };
222
223 /* An array mapping BFD reloc codes to H8 ELF relocs. */
224
225 static const struct elf_reloc_map h8_reloc_map[] = {
226 { BFD_RELOC_NONE, R_H8_NONE_X },
227 { BFD_RELOC_32, R_H8_DIR32_X },
228 { BFD_RELOC_16, R_H8_DIR16_X },
229 { BFD_RELOC_8, R_H8_DIR8_X },
230 { BFD_RELOC_H8_DIR16A8, R_H8_DIR16A8_X },
231 { BFD_RELOC_H8_DIR16R8, R_H8_DIR16R8_X },
232 { BFD_RELOC_H8_DIR24A8, R_H8_DIR24A8_X },
233 { BFD_RELOC_H8_DIR24R8, R_H8_DIR24R8_X },
234 { BFD_RELOC_H8_DIR32A16, R_H8_DIR32A16_X },
235 { BFD_RELOC_16_PCREL, R_H8_PCREL16_X },
236 { BFD_RELOC_8_PCREL, R_H8_PCREL8_X },
237 };
238
239
240 static reloc_howto_type *
241 elf32_h8_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
242 bfd_reloc_code_real_type code)
243 {
244 unsigned int i;
245
246 for (i = 0; i < sizeof (h8_reloc_map) / sizeof (struct elf_reloc_map); i++)
247 {
248 if (h8_reloc_map[i].bfd_reloc_val == code)
249 return &h8_elf_howto_table[(int) h8_reloc_map[i].howto_index];
250 }
251 return NULL;
252 }
253
254 static void
255 elf32_h8_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
256 Elf_Internal_Rela *elf_reloc)
257 {
258 unsigned int r;
259 unsigned int i;
260
261 r = ELF32_R_TYPE (elf_reloc->r_info);
262 for (i = 0; i < sizeof (h8_elf_howto_table) / sizeof (reloc_howto_type); i++)
263 if (h8_elf_howto_table[i].type == r)
264 {
265 bfd_reloc->howto = &h8_elf_howto_table[i];
266 return;
267 }
268 abort ();
269 }
270
271 static void
272 elf32_h8_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
273 Elf_Internal_Rela *elf_reloc ATTRIBUTE_UNUSED)
274 {
275 unsigned int r;
276
277 abort ();
278 r = ELF32_R_TYPE (elf_reloc->r_info);
279 bfd_reloc->howto = &h8_elf_howto_table[r];
280 }
281
282 /* Special handling for H8/300 relocs.
283 We only come here for pcrel stuff and return normally if not an -r link.
284 When doing -r, we can't do any arithmetic for the pcrel stuff, because
285 we support relaxing on the H8/300 series chips. */
286 static bfd_reloc_status_type
287 special (bfd *abfd ATTRIBUTE_UNUSED,
288 arelent *reloc_entry ATTRIBUTE_UNUSED,
289 asymbol *symbol ATTRIBUTE_UNUSED,
290 PTR data ATTRIBUTE_UNUSED,
291 asection *input_section ATTRIBUTE_UNUSED,
292 bfd *output_bfd,
293 char **error_message ATTRIBUTE_UNUSED)
294 {
295 if (output_bfd == (bfd *) NULL)
296 return bfd_reloc_continue;
297
298 /* Adjust the reloc address to that in the output section. */
299 reloc_entry->address += input_section->output_offset;
300 return bfd_reloc_ok;
301 }
302
303 /* Perform a relocation as part of a final link. */
304 static bfd_reloc_status_type
305 elf32_h8_final_link_relocate (unsigned long r_type, bfd *input_bfd,
306 bfd *output_bfd ATTRIBUTE_UNUSED,
307 asection *input_section ATTRIBUTE_UNUSED,
308 bfd_byte *contents, bfd_vma offset,
309 bfd_vma value, bfd_vma addend,
310 struct bfd_link_info *info ATTRIBUTE_UNUSED,
311 asection *sym_sec ATTRIBUTE_UNUSED,
312 int is_local ATTRIBUTE_UNUSED)
313 {
314 bfd_byte *hit_data = contents + offset;
315
316 switch (r_type)
317 {
318 case R_H8_NONE:
319 return bfd_reloc_ok;
320
321 case R_H8_DIR32:
322 case R_H8_DIR32A16:
323 case R_H8_DIR24A8:
324 value += addend;
325 bfd_put_32 (input_bfd, value, hit_data);
326 return bfd_reloc_ok;
327
328 case R_H8_DIR16:
329 case R_H8_DIR16A8:
330 case R_H8_DIR16R8:
331 value += addend;
332 bfd_put_16 (input_bfd, value, hit_data);
333 return bfd_reloc_ok;
334
335 /* AKA R_RELBYTE */
336 case R_H8_DIR8:
337 value += addend;
338
339 bfd_put_8 (input_bfd, value, hit_data);
340 return bfd_reloc_ok;
341
342 case R_H8_DIR24R8:
343 value += addend;
344
345 /* HIT_DATA is the address for the first byte for the relocated
346 value. Subtract 1 so that we can manipulate the data in 32-bit
347 hunks. */
348 hit_data--;
349
350 /* Clear out the top byte in value. */
351 value &= 0xffffff;
352
353 /* Retrieve the type byte for value from the section contents. */
354 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
355
356 /* Now scribble it out in one 32-bit hunk. */
357 bfd_put_32 (input_bfd, value, hit_data);
358 return bfd_reloc_ok;
359
360 case R_H8_PCREL16:
361 value -= (input_section->output_section->vma
362 + input_section->output_offset);
363 value -= offset;
364 value += addend;
365
366 /* The value is relative to the start of the instruction,
367 not the relocation offset. Subtract 2 to account for
368 this minor issue. */
369 value -= 2;
370
371 bfd_put_16 (input_bfd, value, hit_data);
372 return bfd_reloc_ok;
373
374 case R_H8_PCREL8:
375 value -= (input_section->output_section->vma
376 + input_section->output_offset);
377 value -= offset;
378 value += addend;
379
380 /* The value is relative to the start of the instruction,
381 not the relocation offset. Subtract 1 to account for
382 this minor issue. */
383 value -= 1;
384
385 bfd_put_8 (input_bfd, value, hit_data);
386 return bfd_reloc_ok;
387
388 default:
389 return bfd_reloc_notsupported;
390 }
391 }
392 \f
393 /* Relocate an H8 ELF section. */
394 static bfd_boolean
395 elf32_h8_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
396 bfd *input_bfd, asection *input_section,
397 bfd_byte *contents, Elf_Internal_Rela *relocs,
398 Elf_Internal_Sym *local_syms,
399 asection **local_sections)
400 {
401 Elf_Internal_Shdr *symtab_hdr;
402 struct elf_link_hash_entry **sym_hashes;
403 Elf_Internal_Rela *rel, *relend;
404
405 if (info->relocatable)
406 return TRUE;
407
408 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
409 sym_hashes = elf_sym_hashes (input_bfd);
410
411 rel = relocs;
412 relend = relocs + input_section->reloc_count;
413 for (; rel < relend; rel++)
414 {
415 unsigned int r_type;
416 unsigned long r_symndx;
417 Elf_Internal_Sym *sym;
418 asection *sec;
419 struct elf_link_hash_entry *h;
420 bfd_vma relocation;
421 bfd_reloc_status_type r;
422
423 /* This is a final link. */
424 r_symndx = ELF32_R_SYM (rel->r_info);
425 r_type = ELF32_R_TYPE (rel->r_info);
426 h = NULL;
427 sym = NULL;
428 sec = NULL;
429 if (r_symndx < symtab_hdr->sh_info)
430 {
431 sym = local_syms + r_symndx;
432 sec = local_sections[r_symndx];
433 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
434 }
435 else
436 {
437 bfd_boolean unresolved_reloc, warned;
438
439 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
440 r_symndx, symtab_hdr, sym_hashes,
441 h, sec, relocation,
442 unresolved_reloc, warned);
443 }
444
445 r = elf32_h8_final_link_relocate (r_type, input_bfd, output_bfd,
446 input_section,
447 contents, rel->r_offset,
448 relocation, rel->r_addend,
449 info, sec, h == NULL);
450
451 if (r != bfd_reloc_ok)
452 {
453 const char *name;
454 const char *msg = (const char *) 0;
455 arelent bfd_reloc;
456 reloc_howto_type *howto;
457
458 elf32_h8_info_to_howto (input_bfd, &bfd_reloc, rel);
459 howto = bfd_reloc.howto;
460
461 if (h != NULL)
462 name = h->root.root.string;
463 else
464 {
465 name = (bfd_elf_string_from_elf_section
466 (input_bfd, symtab_hdr->sh_link, sym->st_name));
467 if (name == NULL || *name == '\0')
468 name = bfd_section_name (input_bfd, sec);
469 }
470
471 switch (r)
472 {
473 case bfd_reloc_overflow:
474 if (! ((*info->callbacks->reloc_overflow)
475 (info, (h ? &h->root : NULL), name, howto->name,
476 (bfd_vma) 0, input_bfd, input_section,
477 rel->r_offset)))
478 return FALSE;
479 break;
480
481 case bfd_reloc_undefined:
482 if (! ((*info->callbacks->undefined_symbol)
483 (info, name, input_bfd, input_section,
484 rel->r_offset, TRUE)))
485 return FALSE;
486 break;
487
488 case bfd_reloc_outofrange:
489 msg = _("internal error: out of range error");
490 goto common_error;
491
492 case bfd_reloc_notsupported:
493 msg = _("internal error: unsupported relocation error");
494 goto common_error;
495
496 case bfd_reloc_dangerous:
497 msg = _("internal error: dangerous error");
498 goto common_error;
499
500 default:
501 msg = _("internal error: unknown error");
502 /* fall through */
503
504 common_error:
505 if (!((*info->callbacks->warning)
506 (info, msg, name, input_bfd, input_section,
507 rel->r_offset)))
508 return FALSE;
509 break;
510 }
511 }
512 }
513
514 return TRUE;
515 }
516
517 /* Object files encode the specific H8 model they were compiled
518 for in the ELF flags field.
519
520 Examine that field and return the proper BFD machine type for
521 the object file. */
522 static unsigned long
523 elf32_h8_mach (flagword flags)
524 {
525 switch (flags & EF_H8_MACH)
526 {
527 case E_H8_MACH_H8300:
528 default:
529 return bfd_mach_h8300;
530
531 case E_H8_MACH_H8300H:
532 return bfd_mach_h8300h;
533
534 case E_H8_MACH_H8300S:
535 return bfd_mach_h8300s;
536
537 case E_H8_MACH_H8300HN:
538 return bfd_mach_h8300hn;
539
540 case E_H8_MACH_H8300SN:
541 return bfd_mach_h8300sn;
542
543 case E_H8_MACH_H8300SX:
544 return bfd_mach_h8300sx;
545
546 case E_H8_MACH_H8300SXN:
547 return bfd_mach_h8300sxn;
548 }
549 }
550
551 /* The final processing done just before writing out a H8 ELF object
552 file. We use this opportunity to encode the BFD machine type
553 into the flags field in the object file. */
554
555 static void
556 elf32_h8_final_write_processing (bfd *abfd,
557 bfd_boolean linker ATTRIBUTE_UNUSED)
558 {
559 unsigned long val;
560
561 switch (bfd_get_mach (abfd))
562 {
563 default:
564 case bfd_mach_h8300:
565 val = E_H8_MACH_H8300;
566 break;
567
568 case bfd_mach_h8300h:
569 val = E_H8_MACH_H8300H;
570 break;
571
572 case bfd_mach_h8300s:
573 val = E_H8_MACH_H8300S;
574 break;
575
576 case bfd_mach_h8300hn:
577 val = E_H8_MACH_H8300HN;
578 break;
579
580 case bfd_mach_h8300sn:
581 val = E_H8_MACH_H8300SN;
582 break;
583
584 case bfd_mach_h8300sx:
585 val = E_H8_MACH_H8300SX;
586 break;
587
588 case bfd_mach_h8300sxn:
589 val = E_H8_MACH_H8300SXN;
590 break;
591 }
592
593 elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH);
594 elf_elfheader (abfd)->e_flags |= val;
595 }
596
597 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
598 record the encoded machine type found in the ELF flags. */
599
600 static bfd_boolean
601 elf32_h8_object_p (bfd *abfd)
602 {
603 bfd_default_set_arch_mach (abfd, bfd_arch_h8300,
604 elf32_h8_mach (elf_elfheader (abfd)->e_flags));
605 return TRUE;
606 }
607
608 /* Merge backend specific data from an object file to the output
609 object file when linking. The only data we need to copy at this
610 time is the architecture/machine information. */
611
612 static bfd_boolean
613 elf32_h8_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
614 {
615 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
616 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
617 return TRUE;
618
619 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
620 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
621 {
622 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
623 bfd_get_mach (ibfd)))
624 return FALSE;
625 }
626
627 return TRUE;
628 }
629
630 /* This function handles relaxing for the H8..
631
632 There are a few relaxing opportunities available on the H8:
633
634 jmp/jsr:24 -> bra/bsr:8 2 bytes
635 The jmp may be completely eliminated if the previous insn is a
636 conditional branch to the insn after the jump. In that case
637 we invert the branch and delete the jump and save 4 bytes.
638
639 bCC:16 -> bCC:8 2 bytes
640 bsr:16 -> bsr:8 2 bytes
641
642 bset:16 -> bset:8 2 bytes
643 bset:24/32 -> bset:8 4 bytes
644 (also applicable to other bit manipulation instructions)
645
646 mov.b:16 -> mov.b:8 2 bytes
647 mov.b:24/32 -> mov.b:8 4 bytes
648
649 bset:24/32 -> bset:16 2 bytes
650 (also applicable to other bit manipulation instructions)
651
652 mov.[bwl]:24/32 -> mov.[bwl]:16 2 bytes */
653
654 static bfd_boolean
655 elf32_h8_relax_section (bfd *abfd, asection *sec,
656 struct bfd_link_info *link_info, bfd_boolean *again)
657 {
658 Elf_Internal_Shdr *symtab_hdr;
659 Elf_Internal_Rela *internal_relocs;
660 Elf_Internal_Rela *irel, *irelend;
661 bfd_byte *contents = NULL;
662 Elf_Internal_Sym *isymbuf = NULL;
663 static asection *last_input_section = NULL;
664 static Elf_Internal_Rela *last_reloc = NULL;
665
666 /* Assume nothing changes. */
667 *again = FALSE;
668
669 /* We don't have to do anything for a relocatable link, if
670 this section does not have relocs, or if this is not a
671 code section. */
672 if (link_info->relocatable
673 || (sec->flags & SEC_RELOC) == 0
674 || sec->reloc_count == 0
675 || (sec->flags & SEC_CODE) == 0)
676 return TRUE;
677
678 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
679
680 /* Get a copy of the native relocations. */
681 internal_relocs = (_bfd_elf_link_read_relocs
682 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
683 link_info->keep_memory));
684 if (internal_relocs == NULL)
685 goto error_return;
686
687 if (sec != last_input_section)
688 last_reloc = NULL;
689
690 last_input_section = sec;
691
692 /* Walk through the relocs looking for relaxing opportunities. */
693 irelend = internal_relocs + sec->reloc_count;
694 for (irel = internal_relocs; irel < irelend; irel++)
695 {
696 bfd_vma symval;
697
698 /* Keep track of the previous reloc so that we can delete
699 some long jumps created by the compiler. */
700 if (irel != internal_relocs)
701 last_reloc = irel - 1;
702
703 if (ELF32_R_TYPE (irel->r_info) != R_H8_DIR24R8
704 && ELF32_R_TYPE (irel->r_info) != R_H8_PCREL16
705 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR16A8
706 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR24A8
707 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR32A16)
708 continue;
709
710 /* Get the section contents if we haven't done so already. */
711 if (contents == NULL)
712 {
713 /* Get cached copy if it exists. */
714 if (elf_section_data (sec)->this_hdr.contents != NULL)
715 contents = elf_section_data (sec)->this_hdr.contents;
716 else
717 {
718 /* Go get them off disk. */
719 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
720 goto error_return;
721 }
722 }
723
724 /* Read this BFD's local symbols if we haven't done so already. */
725 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
726 {
727 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
728 if (isymbuf == NULL)
729 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
730 symtab_hdr->sh_info, 0,
731 NULL, NULL, NULL);
732 if (isymbuf == NULL)
733 goto error_return;
734 }
735
736 /* Get the value of the symbol referred to by the reloc. */
737 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
738 {
739 /* A local symbol. */
740 Elf_Internal_Sym *isym;
741 asection *sym_sec;
742
743 isym = isymbuf + ELF32_R_SYM (irel->r_info);
744 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
745 symval = isym->st_value;
746 /* If the reloc is absolute, it will not have
747 a symbol or section associated with it. */
748 if (sym_sec)
749 symval += sym_sec->output_section->vma
750 + sym_sec->output_offset;
751 }
752 else
753 {
754 unsigned long indx;
755 struct elf_link_hash_entry *h;
756
757 /* An external symbol. */
758 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
759 h = elf_sym_hashes (abfd)[indx];
760 BFD_ASSERT (h != NULL);
761 if (h->root.type != bfd_link_hash_defined
762 && h->root.type != bfd_link_hash_defweak)
763 {
764 /* This appears to be a reference to an undefined
765 symbol. Just ignore it--it will be caught by the
766 regular reloc processing. */
767 continue;
768 }
769
770 symval = (h->root.u.def.value
771 + h->root.u.def.section->output_section->vma
772 + h->root.u.def.section->output_offset);
773 }
774
775 /* For simplicity of coding, we are going to modify the section
776 contents, the section relocs, and the BFD symbol table. We
777 must tell the rest of the code not to free up this
778 information. It would be possible to instead create a table
779 of changes which have to be made, as is done in coff-mips.c;
780 that would be more work, but would require less memory when
781 the linker is run. */
782 switch (ELF32_R_TYPE (irel->r_info))
783 {
784 /* Try to turn a 24-bit absolute branch/call into an 8-bit
785 pc-relative branch/call. */
786 case R_H8_DIR24R8:
787 {
788 bfd_vma value = symval + irel->r_addend;
789 bfd_vma dot, gap;
790
791 /* Get the address of this instruction. */
792 dot = (sec->output_section->vma
793 + sec->output_offset + irel->r_offset - 1);
794
795 /* Compute the distance from this insn to the branch target. */
796 gap = value - dot;
797
798 /* If the distance is within -126..+130 inclusive, then we can
799 relax this jump. +130 is valid since the target will move
800 two bytes closer if we do relax this branch. */
801 if ((int) gap >= -126 && (int) gap <= 130)
802 {
803 unsigned char code;
804
805 /* Note that we've changed the relocs, section contents,
806 etc. */
807 elf_section_data (sec)->relocs = internal_relocs;
808 elf_section_data (sec)->this_hdr.contents = contents;
809 symtab_hdr->contents = (unsigned char *) isymbuf;
810
811 /* Get the instruction code being relaxed. */
812 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
813
814 /* If the previous instruction conditionally jumped around
815 this instruction, we may be able to reverse the condition
816 and redirect the previous instruction to the target of
817 this instruction.
818
819 Such sequences are used by the compiler to deal with
820 long conditional branches.
821
822 Only perform this optimisation for jumps (code 0x5a) not
823 subroutine calls, as otherwise it could transform:
824
825 mov.w r0,r0
826 beq .L1
827 jsr @_bar
828 .L1: rts
829 _bar: rts
830 into:
831 mov.w r0,r0
832 bne _bar
833 rts
834 _bar: rts
835
836 which changes the call (jsr) into a branch (bne). */
837 if (code == 0x5a
838 && (int) gap <= 130
839 && (int) gap >= -128
840 && last_reloc
841 && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
842 && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
843 {
844 bfd_vma last_value;
845 asection *last_sym_sec;
846 Elf_Internal_Sym *last_sym;
847
848 /* We will need to examine the symbol used by the
849 previous relocation. */
850
851 last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
852 last_sym_sec
853 = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
854 last_value = (last_sym->st_value
855 + last_sym_sec->output_section->vma
856 + last_sym_sec->output_offset);
857
858 /* Verify that the previous relocation was for a
859 branch around this instruction and that no symbol
860 exists at the current location. */
861 if (last_value == dot + 4
862 && last_reloc->r_offset + 2 == irel->r_offset
863 && ! elf32_h8_symbol_address_p (abfd, sec, dot))
864 {
865 /* We can eliminate this jump. Twiddle the
866 previous relocation as necessary. */
867 irel->r_info
868 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
869 ELF32_R_TYPE (R_H8_NONE));
870
871 last_reloc->r_info
872 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
873 ELF32_R_TYPE (R_H8_PCREL8));
874 last_reloc->r_addend = irel->r_addend;
875
876 code = bfd_get_8 (abfd,
877 contents + last_reloc->r_offset - 1);
878 code ^= 1;
879 bfd_put_8 (abfd,
880 code,
881 contents + last_reloc->r_offset - 1);
882
883 /* Delete four bytes of data. */
884 if (!elf32_h8_relax_delete_bytes (abfd, sec,
885 irel->r_offset - 1,
886 4))
887 goto error_return;
888
889 *again = TRUE;
890 break;
891 }
892 }
893
894 if (code == 0x5e)
895 /* This is jsr. */
896 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);
897 else if (code == 0x5a)
898 /* This is jmp. */
899 bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1);
900 else
901 abort ();
902
903 /* Fix the relocation's type. */
904 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
905 R_H8_PCREL8);
906
907 /* Delete two bytes of data. */
908 if (!elf32_h8_relax_delete_bytes (abfd, sec,
909 irel->r_offset + 1, 2))
910 goto error_return;
911
912 /* That will change things, so, we should relax again.
913 Note that this is not required, and it may be slow. */
914 *again = TRUE;
915 }
916 break;
917 }
918
919 /* Try to turn a 16-bit pc-relative branch into a 8-bit pc-relative
920 branch. */
921 case R_H8_PCREL16:
922 {
923 bfd_vma value = symval + irel->r_addend;
924 bfd_vma dot;
925 bfd_vma gap;
926
927 /* Get the address of this instruction. */
928 dot = (sec->output_section->vma
929 + sec->output_offset
930 + irel->r_offset - 2);
931
932 gap = value - dot;
933
934 /* If the distance is within -126..+130 inclusive, then we can
935 relax this jump. +130 is valid since the target will move
936 two bytes closer if we do relax this branch. */
937 if ((int) gap >= -126 && (int) gap <= 130)
938 {
939 unsigned char code;
940
941 /* Note that we've changed the relocs, section contents,
942 etc. */
943 elf_section_data (sec)->relocs = internal_relocs;
944 elf_section_data (sec)->this_hdr.contents = contents;
945 symtab_hdr->contents = (unsigned char *) isymbuf;
946
947 /* Get the opcode. */
948 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
949
950 if (code == 0x58)
951 {
952 /* bCC:16 -> bCC:8 */
953 /* Get the second byte of the original insn, which
954 contains the condition code. */
955 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
956
957 /* Compute the fisrt byte of the relaxed
958 instruction. The original sequence 0x58 0xX0
959 is relaxed to 0x4X, where X represents the
960 condition code. */
961 code &= 0xf0;
962 code >>= 4;
963 code |= 0x40;
964 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
965 }
966 else if (code == 0x5c)
967 /* This is bsr. */
968 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);
969 else
970 abort ();
971
972 /* Fix the relocation's type. */
973 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
974 R_H8_PCREL8);
975 irel->r_offset--;
976
977 /* Delete two bytes of data. */
978 if (!elf32_h8_relax_delete_bytes (abfd, sec,
979 irel->r_offset + 1, 2))
980 goto error_return;
981
982 /* That will change things, so, we should relax again.
983 Note that this is not required, and it may be slow. */
984 *again = TRUE;
985 }
986 break;
987 }
988
989 /* This is a 16-bit absolute address in one of the following
990 instructions:
991
992 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
993 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
994 "mov.b"
995
996 We may relax this into an 8-bit absolute address if it's in
997 the right range. */
998 case R_H8_DIR16A8:
999 {
1000 bfd_vma value;
1001
1002 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1003 if (value >= 0xffffff00u)
1004 {
1005 unsigned char code;
1006 unsigned char temp_code;
1007
1008 /* Note that we've changed the relocs, section contents,
1009 etc. */
1010 elf_section_data (sec)->relocs = internal_relocs;
1011 elf_section_data (sec)->this_hdr.contents = contents;
1012 symtab_hdr->contents = (unsigned char *) isymbuf;
1013
1014 /* Get the opcode. */
1015 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1016
1017 /* All instructions with R_H8_DIR16A8 start with
1018 0x6a. */
1019 if (code != 0x6a)
1020 abort ();
1021
1022 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1023 /* If this is a mov.b instruction, clear the lower
1024 nibble, which contains the source/destination
1025 register number. */
1026 if ((temp_code & 0x10) != 0x10)
1027 temp_code &= 0xf0;
1028
1029 switch (temp_code)
1030 {
1031 case 0x00:
1032 /* This is mov.b @aa:16,Rd. */
1033 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1034 contents + irel->r_offset - 2);
1035 break;
1036 case 0x80:
1037 /* This is mov.b Rs,@aa:16. */
1038 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1039 contents + irel->r_offset - 2);
1040 break;
1041 case 0x18:
1042 /* This is a bit-maniputation instruction that
1043 stores one bit into memory, one of "bclr",
1044 "bist", "bnot", "bset", and "bst". */
1045 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1046 break;
1047 case 0x10:
1048 /* This is a bit-maniputation instruction that
1049 loads one bit from memory, one of "band",
1050 "biand", "bild", "bior", "bixor", "bld", "bor",
1051 "btst", and "bxor". */
1052 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1053 break;
1054 default:
1055 abort ();
1056 }
1057
1058 /* Fix the relocation's type. */
1059 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1060 R_H8_DIR8);
1061
1062 /* Move the relocation. */
1063 irel->r_offset--;
1064
1065 /* Delete two bytes of data. */
1066 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1067 irel->r_offset + 1, 2))
1068 goto error_return;
1069
1070 /* That will change things, so, we should relax again.
1071 Note that this is not required, and it may be slow. */
1072 *again = TRUE;
1073 }
1074 break;
1075 }
1076
1077 /* This is a 24-bit absolute address in one of the following
1078 instructions:
1079
1080 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1081 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1082 "mov.b"
1083
1084 We may relax this into an 8-bit absolute address if it's in
1085 the right range. */
1086 case R_H8_DIR24A8:
1087 {
1088 bfd_vma value;
1089
1090 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1091 if (value >= 0xffffff00u)
1092 {
1093 unsigned char code;
1094 unsigned char temp_code;
1095
1096 /* Note that we've changed the relocs, section contents,
1097 etc. */
1098 elf_section_data (sec)->relocs = internal_relocs;
1099 elf_section_data (sec)->this_hdr.contents = contents;
1100 symtab_hdr->contents = (unsigned char *) isymbuf;
1101
1102 /* Get the opcode. */
1103 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1104
1105 /* All instructions with R_H8_DIR24A8 start with
1106 0x6a. */
1107 if (code != 0x6a)
1108 abort ();
1109
1110 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1111
1112 /* If this is a mov.b instruction, clear the lower
1113 nibble, which contains the source/destination
1114 register number. */
1115 if ((temp_code & 0x30) != 0x30)
1116 temp_code &= 0xf0;
1117
1118 switch (temp_code)
1119 {
1120 case 0x20:
1121 /* This is mov.b @aa:24/32,Rd. */
1122 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1123 contents + irel->r_offset - 2);
1124 break;
1125 case 0xa0:
1126 /* This is mov.b Rs,@aa:24/32. */
1127 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1128 contents + irel->r_offset - 2);
1129 break;
1130 case 0x38:
1131 /* This is a bit-maniputation instruction that
1132 stores one bit into memory, one of "bclr",
1133 "bist", "bnot", "bset", and "bst". */
1134 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1135 break;
1136 case 0x30:
1137 /* This is a bit-maniputation instruction that
1138 loads one bit from memory, one of "band",
1139 "biand", "bild", "bior", "bixor", "bld", "bor",
1140 "btst", and "bxor". */
1141 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1142 break;
1143 default:
1144 abort();
1145 }
1146
1147 /* Fix the relocation's type. */
1148 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1149 R_H8_DIR8);
1150 irel->r_offset--;
1151
1152 /* Delete two bytes of data. */
1153 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1154 irel->r_offset + 1, 4))
1155 goto error_return;
1156
1157 /* That will change things, so, we should relax again.
1158 Note that this is not required, and it may be slow. */
1159 *again = TRUE;
1160 break;
1161 }
1162 }
1163
1164 /* Fall through. */
1165
1166 /* This is a 24-/32-bit absolute address in one of the
1167 following instructions:
1168
1169 "band", "bclr", "biand", "bild", "bior", "bist",
1170 "bixor", "bld", "bnot", "bor", "bset", "bst", "btst",
1171 "bxor", "ldc.w", "stc.w" and "mov.[bwl]"
1172
1173 We may relax this into an 16-bit absolute address if it's
1174 in the right range. */
1175 case R_H8_DIR32A16:
1176 {
1177 bfd_vma value;
1178
1179 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1180 if (value <= 0x7fff || value >= 0xffff8000u)
1181 {
1182 unsigned char code;
1183
1184 /* Note that we've changed the relocs, section contents,
1185 etc. */
1186 elf_section_data (sec)->relocs = internal_relocs;
1187 elf_section_data (sec)->this_hdr.contents = contents;
1188 symtab_hdr->contents = (unsigned char *) isymbuf;
1189
1190 /* Get the opcode. */
1191 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1192
1193 /* Fix the opcode. For all the instructions that
1194 belong to this relaxation, we simply need to turn
1195 off bit 0x20 in the previous byte. */
1196 code &= ~0x20;
1197
1198 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1199
1200 /* Fix the relocation's type. */
1201 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1202 R_H8_DIR16);
1203
1204 /* Delete two bytes of data. */
1205 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1206 irel->r_offset + 1, 2))
1207 goto error_return;
1208
1209 /* That will change things, so, we should relax again.
1210 Note that this is not required, and it may be slow. */
1211 *again = TRUE;
1212 }
1213 break;
1214 }
1215
1216 default:
1217 break;
1218 }
1219 }
1220
1221 if (isymbuf != NULL
1222 && symtab_hdr->contents != (unsigned char *) isymbuf)
1223 {
1224 if (! link_info->keep_memory)
1225 free (isymbuf);
1226 else
1227 symtab_hdr->contents = (unsigned char *) isymbuf;
1228 }
1229
1230 if (contents != NULL
1231 && elf_section_data (sec)->this_hdr.contents != contents)
1232 {
1233 if (! link_info->keep_memory)
1234 free (contents);
1235 else
1236 {
1237 /* Cache the section contents for elf_link_input_bfd. */
1238 elf_section_data (sec)->this_hdr.contents = contents;
1239 }
1240 }
1241
1242 if (internal_relocs != NULL
1243 && elf_section_data (sec)->relocs != internal_relocs)
1244 free (internal_relocs);
1245
1246 return TRUE;
1247
1248 error_return:
1249 if (isymbuf != NULL
1250 && symtab_hdr->contents != (unsigned char *) isymbuf)
1251 free (isymbuf);
1252 if (contents != NULL
1253 && elf_section_data (sec)->this_hdr.contents != contents)
1254 free (contents);
1255 if (internal_relocs != NULL
1256 && elf_section_data (sec)->relocs != internal_relocs)
1257 free (internal_relocs);
1258 return FALSE;
1259 }
1260
1261 /* Delete some bytes from a section while relaxing. */
1262
1263 static bfd_boolean
1264 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count)
1265 {
1266 Elf_Internal_Shdr *symtab_hdr;
1267 unsigned int sec_shndx;
1268 bfd_byte *contents;
1269 Elf_Internal_Rela *irel, *irelend;
1270 Elf_Internal_Rela *irelalign;
1271 Elf_Internal_Sym *isym;
1272 Elf_Internal_Sym *isymend;
1273 bfd_vma toaddr;
1274 struct elf_link_hash_entry **sym_hashes;
1275 struct elf_link_hash_entry **end_hashes;
1276 unsigned int symcount;
1277
1278 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1279
1280 contents = elf_section_data (sec)->this_hdr.contents;
1281
1282 /* The deletion must stop at the next ALIGN reloc for an aligment
1283 power larger than the number of bytes we are deleting. */
1284
1285 irelalign = NULL;
1286 toaddr = sec->size;
1287
1288 irel = elf_section_data (sec)->relocs;
1289 irelend = irel + sec->reloc_count;
1290
1291 /* Actually delete the bytes. */
1292 memmove (contents + addr, contents + addr + count,
1293 (size_t) (toaddr - addr - count));
1294 sec->size -= count;
1295
1296 /* Adjust all the relocs. */
1297 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1298 {
1299 /* Get the new reloc address. */
1300 if ((irel->r_offset > addr
1301 && irel->r_offset < toaddr))
1302 irel->r_offset -= count;
1303 }
1304
1305 /* Adjust the local symbols defined in this section. */
1306 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1307 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1308 isymend = isym + symtab_hdr->sh_info;
1309 for (; isym < isymend; isym++)
1310 {
1311 if (isym->st_shndx == sec_shndx
1312 && isym->st_value > addr
1313 && isym->st_value < toaddr)
1314 isym->st_value -= count;
1315 }
1316
1317 /* Now adjust the global symbols defined in this section. */
1318 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1319 - symtab_hdr->sh_info);
1320 sym_hashes = elf_sym_hashes (abfd);
1321 end_hashes = sym_hashes + symcount;
1322 for (; sym_hashes < end_hashes; sym_hashes++)
1323 {
1324 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1325 if ((sym_hash->root.type == bfd_link_hash_defined
1326 || sym_hash->root.type == bfd_link_hash_defweak)
1327 && sym_hash->root.u.def.section == sec
1328 && sym_hash->root.u.def.value > addr
1329 && sym_hash->root.u.def.value < toaddr)
1330 {
1331 sym_hash->root.u.def.value -= count;
1332 }
1333 }
1334
1335 return TRUE;
1336 }
1337
1338 /* Return TRUE if a symbol exists at the given address, else return
1339 FALSE. */
1340 static bfd_boolean
1341 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr)
1342 {
1343 Elf_Internal_Shdr *symtab_hdr;
1344 unsigned int sec_shndx;
1345 Elf_Internal_Sym *isym;
1346 Elf_Internal_Sym *isymend;
1347 struct elf_link_hash_entry **sym_hashes;
1348 struct elf_link_hash_entry **end_hashes;
1349 unsigned int symcount;
1350
1351 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1352
1353 /* Examine all the symbols. */
1354 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1355 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1356 isymend = isym + symtab_hdr->sh_info;
1357 for (; isym < isymend; isym++)
1358 {
1359 if (isym->st_shndx == sec_shndx
1360 && isym->st_value == addr)
1361 return TRUE;
1362 }
1363
1364 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1365 - symtab_hdr->sh_info);
1366 sym_hashes = elf_sym_hashes (abfd);
1367 end_hashes = sym_hashes + symcount;
1368 for (; sym_hashes < end_hashes; sym_hashes++)
1369 {
1370 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1371 if ((sym_hash->root.type == bfd_link_hash_defined
1372 || sym_hash->root.type == bfd_link_hash_defweak)
1373 && sym_hash->root.u.def.section == sec
1374 && sym_hash->root.u.def.value == addr)
1375 return TRUE;
1376 }
1377
1378 return FALSE;
1379 }
1380
1381 /* This is a version of bfd_generic_get_relocated_section_contents
1382 which uses elf32_h8_relocate_section. */
1383
1384 static bfd_byte *
1385 elf32_h8_get_relocated_section_contents (bfd *output_bfd,
1386 struct bfd_link_info *link_info,
1387 struct bfd_link_order *link_order,
1388 bfd_byte *data,
1389 bfd_boolean relocatable,
1390 asymbol **symbols)
1391 {
1392 Elf_Internal_Shdr *symtab_hdr;
1393 asection *input_section = link_order->u.indirect.section;
1394 bfd *input_bfd = input_section->owner;
1395 asection **sections = NULL;
1396 Elf_Internal_Rela *internal_relocs = NULL;
1397 Elf_Internal_Sym *isymbuf = NULL;
1398
1399 /* We only need to handle the case of relaxing, or of having a
1400 particular set of section contents, specially. */
1401 if (relocatable
1402 || elf_section_data (input_section)->this_hdr.contents == NULL)
1403 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1404 link_order, data,
1405 relocatable,
1406 symbols);
1407
1408 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1409
1410 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1411 (size_t) input_section->size);
1412
1413 if ((input_section->flags & SEC_RELOC) != 0
1414 && input_section->reloc_count > 0)
1415 {
1416 asection **secpp;
1417 Elf_Internal_Sym *isym, *isymend;
1418 bfd_size_type amt;
1419
1420 internal_relocs = (_bfd_elf_link_read_relocs
1421 (input_bfd, input_section, (PTR) NULL,
1422 (Elf_Internal_Rela *) NULL, FALSE));
1423 if (internal_relocs == NULL)
1424 goto error_return;
1425
1426 if (symtab_hdr->sh_info != 0)
1427 {
1428 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1429 if (isymbuf == NULL)
1430 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1431 symtab_hdr->sh_info, 0,
1432 NULL, NULL, NULL);
1433 if (isymbuf == NULL)
1434 goto error_return;
1435 }
1436
1437 amt = symtab_hdr->sh_info;
1438 amt *= sizeof (asection *);
1439 sections = (asection **) bfd_malloc (amt);
1440 if (sections == NULL && amt != 0)
1441 goto error_return;
1442
1443 isymend = isymbuf + symtab_hdr->sh_info;
1444 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1445 {
1446 asection *isec;
1447
1448 if (isym->st_shndx == SHN_UNDEF)
1449 isec = bfd_und_section_ptr;
1450 else if (isym->st_shndx == SHN_ABS)
1451 isec = bfd_abs_section_ptr;
1452 else if (isym->st_shndx == SHN_COMMON)
1453 isec = bfd_com_section_ptr;
1454 else
1455 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1456
1457 *secpp = isec;
1458 }
1459
1460 if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1461 input_section, data, internal_relocs,
1462 isymbuf, sections))
1463 goto error_return;
1464
1465 if (sections != NULL)
1466 free (sections);
1467 if (isymbuf != NULL
1468 && symtab_hdr->contents != (unsigned char *) isymbuf)
1469 free (isymbuf);
1470 if (elf_section_data (input_section)->relocs != internal_relocs)
1471 free (internal_relocs);
1472 }
1473
1474 return data;
1475
1476 error_return:
1477 if (sections != NULL)
1478 free (sections);
1479 if (isymbuf != NULL
1480 && symtab_hdr->contents != (unsigned char *) isymbuf)
1481 free (isymbuf);
1482 if (internal_relocs != NULL
1483 && elf_section_data (input_section)->relocs != internal_relocs)
1484 free (internal_relocs);
1485 return NULL;
1486 }
1487
1488
1489 #define TARGET_BIG_SYM bfd_elf32_h8300_vec
1490 #define TARGET_BIG_NAME "elf32-h8300"
1491 #define ELF_ARCH bfd_arch_h8300
1492 #define ELF_MACHINE_CODE EM_H8_300
1493 #define ELF_MAXPAGESIZE 0x1
1494 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1495 #define elf_info_to_howto elf32_h8_info_to_howto
1496 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1497
1498 /* So we can set/examine bits in e_flags to get the specific
1499 H8 architecture in use. */
1500 #define elf_backend_final_write_processing \
1501 elf32_h8_final_write_processing
1502 #define elf_backend_object_p \
1503 elf32_h8_object_p
1504 #define bfd_elf32_bfd_merge_private_bfd_data \
1505 elf32_h8_merge_private_bfd_data
1506
1507 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1508 defaults to using _bfd_generic_link_hash_table_create, but
1509 bfd_elf_size_dynamic_sections uses
1510 dynobj = elf_hash_table (info)->dynobj;
1511 and thus requires an elf hash table. */
1512 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1513
1514 /* Use an H8 specific linker, not the ELF generic linker. */
1515 #define elf_backend_relocate_section elf32_h8_relocate_section
1516 #define elf_backend_rela_normal 1
1517 #define elf_backend_can_gc_sections 1
1518
1519 /* And relaxing stuff. */
1520 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1521 #define bfd_elf32_bfd_get_relocated_section_contents \
1522 elf32_h8_get_relocated_section_contents
1523
1524
1525 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.06058 seconds and 5 git commands to generate.