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