projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
daily update
[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 2007 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 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
406 sym_hashes = elf_sym_hashes (input_bfd);
407
408 rel = relocs;
409 relend = relocs + input_section->reloc_count;
410 for (; rel < relend; rel++)
411 {
412 unsigned int r_type;
413 unsigned long r_symndx;
414 Elf_Internal_Sym *sym;
415 asection *sec;
416 struct elf_link_hash_entry *h;
417 bfd_vma relocation;
418 bfd_reloc_status_type r;
419 arelent bfd_reloc;
420 reloc_howto_type *howto;
421
422 elf32_h8_info_to_howto (input_bfd, &bfd_reloc, rel);
423 howto = bfd_reloc.howto;
424
425 r_symndx = ELF32_R_SYM (rel->r_info);
426 r_type = ELF32_R_TYPE (rel->r_info);
427 h = NULL;
428 sym = NULL;
429 sec = NULL;
430 if (r_symndx < symtab_hdr->sh_info)
431 {
432 sym = local_syms + r_symndx;
433 sec = local_sections[r_symndx];
434 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
435 }
436 else
437 {
438 bfd_boolean unresolved_reloc, warned;
439
440 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
441 r_symndx, symtab_hdr, sym_hashes,
442 h, sec, relocation,
443 unresolved_reloc, warned);
444 }
445
446 if (sec != NULL && elf_discarded_section (sec))
447 {
448 /* For relocs against symbols from removed linkonce sections,
449 or sections discarded by a linker script, we just want the
450 section contents zeroed. Avoid any special processing. */
451 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
452 rel->r_info = 0;
453 rel->r_addend = 0;
454 continue;
455 }
456
457 if (info->relocatable)
458 continue;
459
460 r = elf32_h8_final_link_relocate (r_type, input_bfd, output_bfd,
461 input_section,
462 contents, rel->r_offset,
463 relocation, rel->r_addend,
464 info, sec, h == NULL);
465
466 if (r != bfd_reloc_ok)
467 {
468 const char *name;
469 const char *msg = (const char *) 0;
470
471 if (h != NULL)
472 name = h->root.root.string;
473 else
474 {
475 name = (bfd_elf_string_from_elf_section
476 (input_bfd, symtab_hdr->sh_link, sym->st_name));
477 if (name == NULL || *name == '\0')
478 name = bfd_section_name (input_bfd, sec);
479 }
480
481 switch (r)
482 {
483 case bfd_reloc_overflow:
484 if (! ((*info->callbacks->reloc_overflow)
485 (info, (h ? &h->root : NULL), name, howto->name,
486 (bfd_vma) 0, input_bfd, input_section,
487 rel->r_offset)))
488 return FALSE;
489 break;
490
491 case bfd_reloc_undefined:
492 if (! ((*info->callbacks->undefined_symbol)
493 (info, name, input_bfd, input_section,
494 rel->r_offset, TRUE)))
495 return FALSE;
496 break;
497
498 case bfd_reloc_outofrange:
499 msg = _("internal error: out of range error");
500 goto common_error;
501
502 case bfd_reloc_notsupported:
503 msg = _("internal error: unsupported relocation error");
504 goto common_error;
505
506 case bfd_reloc_dangerous:
507 msg = _("internal error: dangerous error");
508 goto common_error;
509
510 default:
511 msg = _("internal error: unknown error");
512 /* fall through */
513
514 common_error:
515 if (!((*info->callbacks->warning)
516 (info, msg, name, input_bfd, input_section,
517 rel->r_offset)))
518 return FALSE;
519 break;
520 }
521 }
522 }
523
524 return TRUE;
525 }
526
527 /* Object files encode the specific H8 model they were compiled
528 for in the ELF flags field.
529
530 Examine that field and return the proper BFD machine type for
531 the object file. */
532 static unsigned long
533 elf32_h8_mach (flagword flags)
534 {
535 switch (flags & EF_H8_MACH)
536 {
537 case E_H8_MACH_H8300:
538 default:
539 return bfd_mach_h8300;
540
541 case E_H8_MACH_H8300H:
542 return bfd_mach_h8300h;
543
544 case E_H8_MACH_H8300S:
545 return bfd_mach_h8300s;
546
547 case E_H8_MACH_H8300HN:
548 return bfd_mach_h8300hn;
549
550 case E_H8_MACH_H8300SN:
551 return bfd_mach_h8300sn;
552
553 case E_H8_MACH_H8300SX:
554 return bfd_mach_h8300sx;
555
556 case E_H8_MACH_H8300SXN:
557 return bfd_mach_h8300sxn;
558 }
559 }
560
561 /* The final processing done just before writing out a H8 ELF object
562 file. We use this opportunity to encode the BFD machine type
563 into the flags field in the object file. */
564
565 static void
566 elf32_h8_final_write_processing (bfd *abfd,
567 bfd_boolean linker ATTRIBUTE_UNUSED)
568 {
569 unsigned long val;
570
571 switch (bfd_get_mach (abfd))
572 {
573 default:
574 case bfd_mach_h8300:
575 val = E_H8_MACH_H8300;
576 break;
577
578 case bfd_mach_h8300h:
579 val = E_H8_MACH_H8300H;
580 break;
581
582 case bfd_mach_h8300s:
583 val = E_H8_MACH_H8300S;
584 break;
585
586 case bfd_mach_h8300hn:
587 val = E_H8_MACH_H8300HN;
588 break;
589
590 case bfd_mach_h8300sn:
591 val = E_H8_MACH_H8300SN;
592 break;
593
594 case bfd_mach_h8300sx:
595 val = E_H8_MACH_H8300SX;
596 break;
597
598 case bfd_mach_h8300sxn:
599 val = E_H8_MACH_H8300SXN;
600 break;
601 }
602
603 elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH);
604 elf_elfheader (abfd)->e_flags |= val;
605 }
606
607 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
608 record the encoded machine type found in the ELF flags. */
609
610 static bfd_boolean
611 elf32_h8_object_p (bfd *abfd)
612 {
613 bfd_default_set_arch_mach (abfd, bfd_arch_h8300,
614 elf32_h8_mach (elf_elfheader (abfd)->e_flags));
615 return TRUE;
616 }
617
618 /* Merge backend specific data from an object file to the output
619 object file when linking. The only data we need to copy at this
620 time is the architecture/machine information. */
621
622 static bfd_boolean
623 elf32_h8_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
624 {
625 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
626 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
627 return TRUE;
628
629 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
630 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
631 {
632 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
633 bfd_get_mach (ibfd)))
634 return FALSE;
635 }
636
637 return TRUE;
638 }
639
640 /* This function handles relaxing for the H8..
641
642 There are a few relaxing opportunities available on the H8:
643
644 jmp/jsr:24 -> bra/bsr:8 2 bytes
645 The jmp may be completely eliminated if the previous insn is a
646 conditional branch to the insn after the jump. In that case
647 we invert the branch and delete the jump and save 4 bytes.
648
649 bCC:16 -> bCC:8 2 bytes
650 bsr:16 -> bsr:8 2 bytes
651
652 bset:16 -> bset:8 2 bytes
653 bset:24/32 -> bset:8 4 bytes
654 (also applicable to other bit manipulation instructions)
655
656 mov.b:16 -> mov.b:8 2 bytes
657 mov.b:24/32 -> mov.b:8 4 bytes
658
659 bset:24/32 -> bset:16 2 bytes
660 (also applicable to other bit manipulation instructions)
661
662 mov.[bwl]:24/32 -> mov.[bwl]:16 2 bytes */
663
664 static bfd_boolean
665 elf32_h8_relax_section (bfd *abfd, asection *sec,
666 struct bfd_link_info *link_info, bfd_boolean *again)
667 {
668 Elf_Internal_Shdr *symtab_hdr;
669 Elf_Internal_Rela *internal_relocs;
670 Elf_Internal_Rela *irel, *irelend;
671 bfd_byte *contents = NULL;
672 Elf_Internal_Sym *isymbuf = NULL;
673 static asection *last_input_section = NULL;
674 static Elf_Internal_Rela *last_reloc = NULL;
675
676 /* Assume nothing changes. */
677 *again = FALSE;
678
679 /* We don't have to do anything for a relocatable link, if
680 this section does not have relocs, or if this is not a
681 code section. */
682 if (link_info->relocatable
683 || (sec->flags & SEC_RELOC) == 0
684 || sec->reloc_count == 0
685 || (sec->flags & SEC_CODE) == 0)
686 return TRUE;
687
688 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
689
690 /* Get a copy of the native relocations. */
691 internal_relocs = (_bfd_elf_link_read_relocs
692 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
693 link_info->keep_memory));
694 if (internal_relocs == NULL)
695 goto error_return;
696
697 if (sec != last_input_section)
698 last_reloc = NULL;
699
700 last_input_section = sec;
701
702 /* Walk through the relocs looking for relaxing opportunities. */
703 irelend = internal_relocs + sec->reloc_count;
704 for (irel = internal_relocs; irel < irelend; irel++)
705 {
706 bfd_vma symval;
707
708 /* Keep track of the previous reloc so that we can delete
709 some long jumps created by the compiler. */
710 if (irel != internal_relocs)
711 last_reloc = irel - 1;
712
713 if (ELF32_R_TYPE (irel->r_info) != R_H8_DIR24R8
714 && ELF32_R_TYPE (irel->r_info) != R_H8_PCREL16
715 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR16A8
716 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR24A8
717 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR32A16)
718 continue;
719
720 /* Get the section contents if we haven't done so already. */
721 if (contents == NULL)
722 {
723 /* Get cached copy if it exists. */
724 if (elf_section_data (sec)->this_hdr.contents != NULL)
725 contents = elf_section_data (sec)->this_hdr.contents;
726 else
727 {
728 /* Go get them off disk. */
729 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
730 goto error_return;
731 }
732 }
733
734 /* Read this BFD's local symbols if we haven't done so already. */
735 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
736 {
737 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
738 if (isymbuf == NULL)
739 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
740 symtab_hdr->sh_info, 0,
741 NULL, NULL, NULL);
742 if (isymbuf == NULL)
743 goto error_return;
744 }
745
746 /* Get the value of the symbol referred to by the reloc. */
747 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
748 {
749 /* A local symbol. */
750 Elf_Internal_Sym *isym;
751 asection *sym_sec;
752
753 isym = isymbuf + ELF32_R_SYM (irel->r_info);
754 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
755 symval = isym->st_value;
756 /* If the reloc is absolute, it will not have
757 a symbol or section associated with it. */
758 if (sym_sec)
759 symval += sym_sec->output_section->vma
760 + sym_sec->output_offset;
761 }
762 else
763 {
764 unsigned long indx;
765 struct elf_link_hash_entry *h;
766
767 /* An external symbol. */
768 indx = ELF32_R_SYM (irel->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 /* For simplicity of coding, we are going to modify the section
786 contents, the section relocs, and the BFD symbol table. We
787 must tell the rest of the code not to free up this
788 information. It would be possible to instead create a table
789 of changes which have to be made, as is done in coff-mips.c;
790 that would be more work, but would require less memory when
791 the linker is run. */
792 switch (ELF32_R_TYPE (irel->r_info))
793 {
794 /* Try to turn a 24-bit absolute branch/call into an 8-bit
795 pc-relative branch/call. */
796 case R_H8_DIR24R8:
797 {
798 bfd_vma value = symval + irel->r_addend;
799 bfd_vma dot, gap;
800
801 /* Get the address of this instruction. */
802 dot = (sec->output_section->vma
803 + sec->output_offset + irel->r_offset - 1);
804
805 /* Compute the distance from this insn to the branch target. */
806 gap = value - dot;
807
808 /* If the distance is within -126..+130 inclusive, then we can
809 relax this jump. +130 is valid since the target will move
810 two bytes closer if we do relax this branch. */
811 if ((int) gap >= -126 && (int) gap <= 130)
812 {
813 unsigned char code;
814
815 /* Note that we've changed the relocs, section contents,
816 etc. */
817 elf_section_data (sec)->relocs = internal_relocs;
818 elf_section_data (sec)->this_hdr.contents = contents;
819 symtab_hdr->contents = (unsigned char *) isymbuf;
820
821 /* Get the instruction code being relaxed. */
822 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
823
824 /* If the previous instruction conditionally jumped around
825 this instruction, we may be able to reverse the condition
826 and redirect the previous instruction to the target of
827 this instruction.
828
829 Such sequences are used by the compiler to deal with
830 long conditional branches.
831
832 Only perform this optimisation for jumps (code 0x5a) not
833 subroutine calls, as otherwise it could transform:
834
835 mov.w r0,r0
836 beq .L1
837 jsr @_bar
838 .L1: rts
839 _bar: rts
840 into:
841 mov.w r0,r0
842 bne _bar
843 rts
844 _bar: rts
845
846 which changes the call (jsr) into a branch (bne). */
847 if (code == 0x5a
848 && (int) gap <= 130
849 && (int) gap >= -128
850 && last_reloc
851 && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
852 && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
853 {
854 bfd_vma last_value;
855 asection *last_sym_sec;
856 Elf_Internal_Sym *last_sym;
857
858 /* We will need to examine the symbol used by the
859 previous relocation. */
860
861 last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
862 last_sym_sec
863 = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
864 last_value = (last_sym->st_value
865 + last_sym_sec->output_section->vma
866 + last_sym_sec->output_offset);
867
868 /* Verify that the previous relocation was for a
869 branch around this instruction and that no symbol
870 exists at the current location. */
871 if (last_value == dot + 4
872 && last_reloc->r_offset + 2 == irel->r_offset
873 && ! elf32_h8_symbol_address_p (abfd, sec, dot))
874 {
875 /* We can eliminate this jump. Twiddle the
876 previous relocation as necessary. */
877 irel->r_info
878 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
879 ELF32_R_TYPE (R_H8_NONE));
880
881 last_reloc->r_info
882 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
883 ELF32_R_TYPE (R_H8_PCREL8));
884 last_reloc->r_addend = irel->r_addend;
885
886 code = bfd_get_8 (abfd,
887 contents + last_reloc->r_offset - 1);
888 code ^= 1;
889 bfd_put_8 (abfd,
890 code,
891 contents + last_reloc->r_offset - 1);
892
893 /* Delete four bytes of data. */
894 if (!elf32_h8_relax_delete_bytes (abfd, sec,
895 irel->r_offset - 1,
896 4))
897 goto error_return;
898
899 *again = TRUE;
900 break;
901 }
902 }
903
904 if (code == 0x5e)
905 /* This is jsr. */
906 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);
907 else if (code == 0x5a)
908 /* This is jmp. */
909 bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1);
910 else
911 abort ();
912
913 /* Fix the relocation's type. */
914 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
915 R_H8_PCREL8);
916
917 /* Delete two bytes of data. */
918 if (!elf32_h8_relax_delete_bytes (abfd, sec,
919 irel->r_offset + 1, 2))
920 goto error_return;
921
922 /* That will change things, so, we should relax again.
923 Note that this is not required, and it may be slow. */
924 *again = TRUE;
925 }
926 break;
927 }
928
929 /* Try to turn a 16-bit pc-relative branch into a 8-bit pc-relative
930 branch. */
931 case R_H8_PCREL16:
932 {
933 bfd_vma value = symval + irel->r_addend;
934 bfd_vma dot;
935 bfd_vma gap;
936
937 /* Get the address of this instruction. */
938 dot = (sec->output_section->vma
939 + sec->output_offset
940 + irel->r_offset - 2);
941
942 gap = value - dot;
943
944 /* If the distance is within -126..+130 inclusive, then we can
945 relax this jump. +130 is valid since the target will move
946 two bytes closer if we do relax this branch. */
947 if ((int) gap >= -126 && (int) gap <= 130)
948 {
949 unsigned char code;
950
951 /* Note that we've changed the relocs, section contents,
952 etc. */
953 elf_section_data (sec)->relocs = internal_relocs;
954 elf_section_data (sec)->this_hdr.contents = contents;
955 symtab_hdr->contents = (unsigned char *) isymbuf;
956
957 /* Get the opcode. */
958 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
959
960 if (code == 0x58)
961 {
962 /* bCC:16 -> bCC:8 */
963 /* Get the second byte of the original insn, which
964 contains the condition code. */
965 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
966
967 /* Compute the fisrt byte of the relaxed
968 instruction. The original sequence 0x58 0xX0
969 is relaxed to 0x4X, where X represents the
970 condition code. */
971 code &= 0xf0;
972 code >>= 4;
973 code |= 0x40;
974 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
975 }
976 else if (code == 0x5c)
977 /* This is bsr. */
978 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);
979 else
980 abort ();
981
982 /* Fix the relocation's type. */
983 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
984 R_H8_PCREL8);
985 irel->r_offset--;
986
987 /* Delete two bytes of data. */
988 if (!elf32_h8_relax_delete_bytes (abfd, sec,
989 irel->r_offset + 1, 2))
990 goto error_return;
991
992 /* That will change things, so, we should relax again.
993 Note that this is not required, and it may be slow. */
994 *again = TRUE;
995 }
996 break;
997 }
998
999 /* This is a 16-bit absolute address in one of the following
1000 instructions:
1001
1002 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1003 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1004 "mov.b"
1005
1006 We may relax this into an 8-bit absolute address if it's in
1007 the right range. */
1008 case R_H8_DIR16A8:
1009 {
1010 bfd_vma value;
1011
1012 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1013 if (value >= 0xffffff00u)
1014 {
1015 unsigned char code;
1016 unsigned char temp_code;
1017
1018 /* Note that we've changed the relocs, section contents,
1019 etc. */
1020 elf_section_data (sec)->relocs = internal_relocs;
1021 elf_section_data (sec)->this_hdr.contents = contents;
1022 symtab_hdr->contents = (unsigned char *) isymbuf;
1023
1024 /* Get the opcode. */
1025 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1026
1027 /* All instructions with R_H8_DIR16A8 start with
1028 0x6a. */
1029 if (code != 0x6a)
1030 abort ();
1031
1032 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1033 /* If this is a mov.b instruction, clear the lower
1034 nibble, which contains the source/destination
1035 register number. */
1036 if ((temp_code & 0x10) != 0x10)
1037 temp_code &= 0xf0;
1038
1039 switch (temp_code)
1040 {
1041 case 0x00:
1042 /* This is mov.b @aa:16,Rd. */
1043 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1044 contents + irel->r_offset - 2);
1045 break;
1046 case 0x80:
1047 /* This is mov.b Rs,@aa:16. */
1048 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1049 contents + irel->r_offset - 2);
1050 break;
1051 case 0x18:
1052 /* This is a bit-maniputation instruction that
1053 stores one bit into memory, one of "bclr",
1054 "bist", "bnot", "bset", and "bst". */
1055 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1056 break;
1057 case 0x10:
1058 /* This is a bit-maniputation instruction that
1059 loads one bit from memory, one of "band",
1060 "biand", "bild", "bior", "bixor", "bld", "bor",
1061 "btst", and "bxor". */
1062 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1063 break;
1064 default:
1065 abort ();
1066 }
1067
1068 /* Fix the relocation's type. */
1069 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1070 R_H8_DIR8);
1071
1072 /* Move the relocation. */
1073 irel->r_offset--;
1074
1075 /* Delete two bytes of data. */
1076 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1077 irel->r_offset + 1, 2))
1078 goto error_return;
1079
1080 /* That will change things, so, we should relax again.
1081 Note that this is not required, and it may be slow. */
1082 *again = TRUE;
1083 }
1084 break;
1085 }
1086
1087 /* This is a 24-bit absolute address in one of the following
1088 instructions:
1089
1090 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1091 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1092 "mov.b"
1093
1094 We may relax this into an 8-bit absolute address if it's in
1095 the right range. */
1096 case R_H8_DIR24A8:
1097 {
1098 bfd_vma value;
1099
1100 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1101 if (value >= 0xffffff00u)
1102 {
1103 unsigned char code;
1104 unsigned char temp_code;
1105
1106 /* Note that we've changed the relocs, section contents,
1107 etc. */
1108 elf_section_data (sec)->relocs = internal_relocs;
1109 elf_section_data (sec)->this_hdr.contents = contents;
1110 symtab_hdr->contents = (unsigned char *) isymbuf;
1111
1112 /* Get the opcode. */
1113 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1114
1115 /* All instructions with R_H8_DIR24A8 start with
1116 0x6a. */
1117 if (code != 0x6a)
1118 abort ();
1119
1120 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1121
1122 /* If this is a mov.b instruction, clear the lower
1123 nibble, which contains the source/destination
1124 register number. */
1125 if ((temp_code & 0x30) != 0x30)
1126 temp_code &= 0xf0;
1127
1128 switch (temp_code)
1129 {
1130 case 0x20:
1131 /* This is mov.b @aa:24/32,Rd. */
1132 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1133 contents + irel->r_offset - 2);
1134 break;
1135 case 0xa0:
1136 /* This is mov.b Rs,@aa:24/32. */
1137 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1138 contents + irel->r_offset - 2);
1139 break;
1140 case 0x38:
1141 /* This is a bit-maniputation instruction that
1142 stores one bit into memory, one of "bclr",
1143 "bist", "bnot", "bset", and "bst". */
1144 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1145 break;
1146 case 0x30:
1147 /* This is a bit-maniputation instruction that
1148 loads one bit from memory, one of "band",
1149 "biand", "bild", "bior", "bixor", "bld", "bor",
1150 "btst", and "bxor". */
1151 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1152 break;
1153 default:
1154 abort();
1155 }
1156
1157 /* Fix the relocation's type. */
1158 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1159 R_H8_DIR8);
1160 irel->r_offset--;
1161
1162 /* Delete two bytes of data. */
1163 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1164 irel->r_offset + 1, 4))
1165 goto error_return;
1166
1167 /* That will change things, so, we should relax again.
1168 Note that this is not required, and it may be slow. */
1169 *again = TRUE;
1170 break;
1171 }
1172 }
1173
1174 /* Fall through. */
1175
1176 /* This is a 24-/32-bit absolute address in one of the
1177 following instructions:
1178
1179 "band", "bclr", "biand", "bild", "bior", "bist",
1180 "bixor", "bld", "bnot", "bor", "bset", "bst", "btst",
1181 "bxor", "ldc.w", "stc.w" and "mov.[bwl]"
1182
1183 We may relax this into an 16-bit absolute address if it's
1184 in the right range. */
1185 case R_H8_DIR32A16:
1186 {
1187 bfd_vma value;
1188
1189 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1190 if (value <= 0x7fff || value >= 0xffff8000u)
1191 {
1192 unsigned char code;
1193
1194 /* Note that we've changed the relocs, section contents,
1195 etc. */
1196 elf_section_data (sec)->relocs = internal_relocs;
1197 elf_section_data (sec)->this_hdr.contents = contents;
1198 symtab_hdr->contents = (unsigned char *) isymbuf;
1199
1200 /* Get the opcode. */
1201 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1202
1203 /* Fix the opcode. For all the instructions that
1204 belong to this relaxation, we simply need to turn
1205 off bit 0x20 in the previous byte. */
1206 code &= ~0x20;
1207
1208 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1209
1210 /* Fix the relocation's type. */
1211 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1212 R_H8_DIR16);
1213
1214 /* Delete two bytes of data. */
1215 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1216 irel->r_offset + 1, 2))
1217 goto error_return;
1218
1219 /* That will change things, so, we should relax again.
1220 Note that this is not required, and it may be slow. */
1221 *again = TRUE;
1222 }
1223 break;
1224 }
1225
1226 default:
1227 break;
1228 }
1229 }
1230
1231 if (isymbuf != NULL
1232 && symtab_hdr->contents != (unsigned char *) isymbuf)
1233 {
1234 if (! link_info->keep_memory)
1235 free (isymbuf);
1236 else
1237 symtab_hdr->contents = (unsigned char *) isymbuf;
1238 }
1239
1240 if (contents != NULL
1241 && elf_section_data (sec)->this_hdr.contents != contents)
1242 {
1243 if (! link_info->keep_memory)
1244 free (contents);
1245 else
1246 {
1247 /* Cache the section contents for elf_link_input_bfd. */
1248 elf_section_data (sec)->this_hdr.contents = contents;
1249 }
1250 }
1251
1252 if (internal_relocs != NULL
1253 && elf_section_data (sec)->relocs != internal_relocs)
1254 free (internal_relocs);
1255
1256 return TRUE;
1257
1258 error_return:
1259 if (isymbuf != NULL
1260 && symtab_hdr->contents != (unsigned char *) isymbuf)
1261 free (isymbuf);
1262 if (contents != NULL
1263 && elf_section_data (sec)->this_hdr.contents != contents)
1264 free (contents);
1265 if (internal_relocs != NULL
1266 && elf_section_data (sec)->relocs != internal_relocs)
1267 free (internal_relocs);
1268 return FALSE;
1269 }
1270
1271 /* Delete some bytes from a section while relaxing. */
1272
1273 static bfd_boolean
1274 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count)
1275 {
1276 Elf_Internal_Shdr *symtab_hdr;
1277 unsigned int sec_shndx;
1278 bfd_byte *contents;
1279 Elf_Internal_Rela *irel, *irelend;
1280 Elf_Internal_Rela *irelalign;
1281 Elf_Internal_Sym *isym;
1282 Elf_Internal_Sym *isymend;
1283 bfd_vma toaddr;
1284 struct elf_link_hash_entry **sym_hashes;
1285 struct elf_link_hash_entry **end_hashes;
1286 unsigned int symcount;
1287
1288 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1289
1290 contents = elf_section_data (sec)->this_hdr.contents;
1291
1292 /* The deletion must stop at the next ALIGN reloc for an aligment
1293 power larger than the number of bytes we are deleting. */
1294
1295 irelalign = NULL;
1296 toaddr = sec->size;
1297
1298 irel = elf_section_data (sec)->relocs;
1299 irelend = irel + sec->reloc_count;
1300
1301 /* Actually delete the bytes. */
1302 memmove (contents + addr, contents + addr + count,
1303 (size_t) (toaddr - addr - count));
1304 sec->size -= count;
1305
1306 /* Adjust all the relocs. */
1307 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1308 {
1309 /* Get the new reloc address. */
1310 if ((irel->r_offset > addr
1311 && irel->r_offset < toaddr))
1312 irel->r_offset -= count;
1313 }
1314
1315 /* Adjust the local symbols defined in this section. */
1316 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1317 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1318 isymend = isym + symtab_hdr->sh_info;
1319 for (; isym < isymend; isym++)
1320 {
1321 if (isym->st_shndx == sec_shndx
1322 && isym->st_value > addr
1323 && isym->st_value < toaddr)
1324 isym->st_value -= count;
1325 }
1326
1327 /* Now adjust the global symbols defined in this section. */
1328 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1329 - symtab_hdr->sh_info);
1330 sym_hashes = elf_sym_hashes (abfd);
1331 end_hashes = sym_hashes + symcount;
1332 for (; sym_hashes < end_hashes; sym_hashes++)
1333 {
1334 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1335 if ((sym_hash->root.type == bfd_link_hash_defined
1336 || sym_hash->root.type == bfd_link_hash_defweak)
1337 && sym_hash->root.u.def.section == sec
1338 && sym_hash->root.u.def.value > addr
1339 && sym_hash->root.u.def.value < toaddr)
1340 {
1341 sym_hash->root.u.def.value -= count;
1342 }
1343 }
1344
1345 return TRUE;
1346 }
1347
1348 /* Return TRUE if a symbol exists at the given address, else return
1349 FALSE. */
1350 static bfd_boolean
1351 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr)
1352 {
1353 Elf_Internal_Shdr *symtab_hdr;
1354 unsigned int sec_shndx;
1355 Elf_Internal_Sym *isym;
1356 Elf_Internal_Sym *isymend;
1357 struct elf_link_hash_entry **sym_hashes;
1358 struct elf_link_hash_entry **end_hashes;
1359 unsigned int symcount;
1360
1361 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1362
1363 /* Examine all the symbols. */
1364 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1365 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1366 isymend = isym + symtab_hdr->sh_info;
1367 for (; isym < isymend; isym++)
1368 {
1369 if (isym->st_shndx == sec_shndx
1370 && isym->st_value == addr)
1371 return TRUE;
1372 }
1373
1374 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1375 - symtab_hdr->sh_info);
1376 sym_hashes = elf_sym_hashes (abfd);
1377 end_hashes = sym_hashes + symcount;
1378 for (; sym_hashes < end_hashes; sym_hashes++)
1379 {
1380 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1381 if ((sym_hash->root.type == bfd_link_hash_defined
1382 || sym_hash->root.type == bfd_link_hash_defweak)
1383 && sym_hash->root.u.def.section == sec
1384 && sym_hash->root.u.def.value == addr)
1385 return TRUE;
1386 }
1387
1388 return FALSE;
1389 }
1390
1391 /* This is a version of bfd_generic_get_relocated_section_contents
1392 which uses elf32_h8_relocate_section. */
1393
1394 static bfd_byte *
1395 elf32_h8_get_relocated_section_contents (bfd *output_bfd,
1396 struct bfd_link_info *link_info,
1397 struct bfd_link_order *link_order,
1398 bfd_byte *data,
1399 bfd_boolean relocatable,
1400 asymbol **symbols)
1401 {
1402 Elf_Internal_Shdr *symtab_hdr;
1403 asection *input_section = link_order->u.indirect.section;
1404 bfd *input_bfd = input_section->owner;
1405 asection **sections = NULL;
1406 Elf_Internal_Rela *internal_relocs = NULL;
1407 Elf_Internal_Sym *isymbuf = NULL;
1408
1409 /* We only need to handle the case of relaxing, or of having a
1410 particular set of section contents, specially. */
1411 if (relocatable
1412 || elf_section_data (input_section)->this_hdr.contents == NULL)
1413 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1414 link_order, data,
1415 relocatable,
1416 symbols);
1417
1418 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1419
1420 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1421 (size_t) input_section->size);
1422
1423 if ((input_section->flags & SEC_RELOC) != 0
1424 && input_section->reloc_count > 0)
1425 {
1426 asection **secpp;
1427 Elf_Internal_Sym *isym, *isymend;
1428 bfd_size_type amt;
1429
1430 internal_relocs = (_bfd_elf_link_read_relocs
1431 (input_bfd, input_section, (PTR) NULL,
1432 (Elf_Internal_Rela *) NULL, FALSE));
1433 if (internal_relocs == NULL)
1434 goto error_return;
1435
1436 if (symtab_hdr->sh_info != 0)
1437 {
1438 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1439 if (isymbuf == NULL)
1440 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1441 symtab_hdr->sh_info, 0,
1442 NULL, NULL, NULL);
1443 if (isymbuf == NULL)
1444 goto error_return;
1445 }
1446
1447 amt = symtab_hdr->sh_info;
1448 amt *= sizeof (asection *);
1449 sections = (asection **) bfd_malloc (amt);
1450 if (sections == NULL && amt != 0)
1451 goto error_return;
1452
1453 isymend = isymbuf + symtab_hdr->sh_info;
1454 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1455 {
1456 asection *isec;
1457
1458 if (isym->st_shndx == SHN_UNDEF)
1459 isec = bfd_und_section_ptr;
1460 else if (isym->st_shndx == SHN_ABS)
1461 isec = bfd_abs_section_ptr;
1462 else if (isym->st_shndx == SHN_COMMON)
1463 isec = bfd_com_section_ptr;
1464 else
1465 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1466
1467 *secpp = isec;
1468 }
1469
1470 if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1471 input_section, data, internal_relocs,
1472 isymbuf, sections))
1473 goto error_return;
1474
1475 if (sections != NULL)
1476 free (sections);
1477 if (isymbuf != NULL
1478 && symtab_hdr->contents != (unsigned char *) isymbuf)
1479 free (isymbuf);
1480 if (elf_section_data (input_section)->relocs != internal_relocs)
1481 free (internal_relocs);
1482 }
1483
1484 return data;
1485
1486 error_return:
1487 if (sections != NULL)
1488 free (sections);
1489 if (isymbuf != NULL
1490 && symtab_hdr->contents != (unsigned char *) isymbuf)
1491 free (isymbuf);
1492 if (internal_relocs != NULL
1493 && elf_section_data (input_section)->relocs != internal_relocs)
1494 free (internal_relocs);
1495 return NULL;
1496 }
1497
1498
1499 #define TARGET_BIG_SYM bfd_elf32_h8300_vec
1500 #define TARGET_BIG_NAME "elf32-h8300"
1501 #define ELF_ARCH bfd_arch_h8300
1502 #define ELF_MACHINE_CODE EM_H8_300
1503 #define ELF_MAXPAGESIZE 0x1
1504 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1505 #define elf_info_to_howto elf32_h8_info_to_howto
1506 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1507
1508 /* So we can set/examine bits in e_flags to get the specific
1509 H8 architecture in use. */
1510 #define elf_backend_final_write_processing \
1511 elf32_h8_final_write_processing
1512 #define elf_backend_object_p \
1513 elf32_h8_object_p
1514 #define bfd_elf32_bfd_merge_private_bfd_data \
1515 elf32_h8_merge_private_bfd_data
1516
1517 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1518 defaults to using _bfd_generic_link_hash_table_create, but
1519 bfd_elf_size_dynamic_sections uses
1520 dynobj = elf_hash_table (info)->dynobj;
1521 and thus requires an elf hash table. */
1522 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1523
1524 /* Use an H8 specific linker, not the ELF generic linker. */
1525 #define elf_backend_relocate_section elf32_h8_relocate_section
1526 #define elf_backend_rela_normal 1
1527 #define elf_backend_can_gc_sections 1
1528
1529 /* And relaxing stuff. */
1530 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1531 #define bfd_elf32_bfd_get_relocated_section_contents \
1532 elf32_h8_get_relocated_section_contents
1533
1534
1535 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.07735 seconds and 4 git commands to generate.