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