?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2013-03-12 Sebastian Huber <sebastian.huber@embedded-brains.de>
[binutils-gdb.git] / bfd / elf32-h8300.c
blob43ac16e551a3dcd4d07d85fd646a488176bdaea6
1 /* BFD back-end for Renesas H8/300 ELF binaries.
2 Copyright 1993, 1995, 1998, 1999, 2001, 2002, 2003, 2004, 2005, 2006,
3 2007, 2008, 2009, 2010, 2012 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 3 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,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/h8.h"
27
28 static reloc_howto_type *elf32_h8_reloc_type_lookup
29 (bfd *abfd, bfd_reloc_code_real_type code);
30 static void elf32_h8_info_to_howto
31 (bfd *, arelent *, Elf_Internal_Rela *);
32 static void elf32_h8_info_to_howto_rel
33 (bfd *, arelent *, Elf_Internal_Rela *);
34 static unsigned long elf32_h8_mach (flagword);
35 static void elf32_h8_final_write_processing (bfd *, bfd_boolean);
36 static bfd_boolean elf32_h8_object_p (bfd *);
37 static bfd_boolean elf32_h8_merge_private_bfd_data (bfd *, bfd *);
38 static bfd_boolean elf32_h8_relax_section
39 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
40 static bfd_boolean elf32_h8_relax_delete_bytes
41 (bfd *, asection *, bfd_vma, int);
42 static bfd_boolean elf32_h8_symbol_address_p (bfd *, asection *, bfd_vma);
43 static bfd_byte *elf32_h8_get_relocated_section_contents
44 (bfd *, struct bfd_link_info *, struct bfd_link_order *,
45 bfd_byte *, bfd_boolean, asymbol **);
46 static bfd_reloc_status_type elf32_h8_final_link_relocate
47 (unsigned long, bfd *, bfd *, asection *,
48 bfd_byte *, bfd_vma, bfd_vma, bfd_vma,
49 struct bfd_link_info *, asection *, int);
50 static bfd_boolean elf32_h8_relocate_section
51 (bfd *, struct bfd_link_info *, bfd *, asection *,
52 bfd_byte *, Elf_Internal_Rela *,
53 Elf_Internal_Sym *, asection **);
54 static bfd_reloc_status_type special
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56
57 /* This does not include any relocation information, but should be
58 good enough for GDB or objdump to read the file. */
59
60 static reloc_howto_type h8_elf_howto_table[] =
61 {
62 #define R_H8_NONE_X 0
63 HOWTO (R_H8_NONE, /* type */
64 0, /* rightshift */
65 0, /* size (0 = byte, 1 = short, 2 = long) */
66 0, /* bitsize */
67 FALSE, /* pc_relative */
68 0, /* bitpos */
69 complain_overflow_dont,/* complain_on_overflow */
70 special, /* special_function */
71 "R_H8_NONE", /* name */
72 FALSE, /* partial_inplace */
73 0, /* src_mask */
74 0, /* dst_mask */
75 FALSE), /* pcrel_offset */
76 #define R_H8_DIR32_X (R_H8_NONE_X + 1)
77 HOWTO (R_H8_DIR32, /* type */
78 0, /* rightshift */
79 2, /* size (0 = byte, 1 = short, 2 = long) */
80 32, /* bitsize */
81 FALSE, /* pc_relative */
82 0, /* bitpos */
83 complain_overflow_dont,/* complain_on_overflow */
84 special, /* special_function */
85 "R_H8_DIR32", /* name */
86 FALSE, /* partial_inplace */
87 0, /* src_mask */
88 0xffffffff, /* dst_mask */
89 FALSE), /* pcrel_offset */
90 #define R_H8_DIR16_X (R_H8_DIR32_X + 1)
91 HOWTO (R_H8_DIR16, /* type */
92 0, /* rightshift */
93 1, /* size (0 = byte, 1 = short, 2 = long) */
94 16, /* bitsize */
95 FALSE, /* pc_relative */
96 0, /* bitpos */
97 complain_overflow_dont,/* complain_on_overflow */
98 special, /* special_function */
99 "R_H8_DIR16", /* name */
100 FALSE, /* partial_inplace */
101 0, /* src_mask */
102 0x0000ffff, /* dst_mask */
103 FALSE), /* pcrel_offset */
104 #define R_H8_DIR8_X (R_H8_DIR16_X + 1)
105 HOWTO (R_H8_DIR8, /* type */
106 0, /* rightshift */
107 0, /* size (0 = byte, 1 = short, 2 = long) */
108 8, /* bitsize */
109 FALSE, /* pc_relative */
110 0, /* bitpos */
111 complain_overflow_dont,/* complain_on_overflow */
112 special, /* special_function */
113 "R_H8_DIR8", /* name */
114 FALSE, /* partial_inplace */
115 0, /* src_mask */
116 0x000000ff, /* dst_mask */
117 FALSE), /* pcrel_offset */
118 #define R_H8_DIR16A8_X (R_H8_DIR8_X + 1)
119 HOWTO (R_H8_DIR16A8, /* type */
120 0, /* rightshift */
121 1, /* size (0 = byte, 1 = short, 2 = long) */
122 16, /* bitsize */
123 FALSE, /* pc_relative */
124 0, /* bitpos */
125 complain_overflow_bitfield, /* complain_on_overflow */
126 special, /* special_function */
127 "R_H8_DIR16A8", /* name */
128 FALSE, /* partial_inplace */
129 0, /* src_mask */
130 0x0000ffff, /* dst_mask */
131 FALSE), /* pcrel_offset */
132 #define R_H8_DIR16R8_X (R_H8_DIR16A8_X + 1)
133 HOWTO (R_H8_DIR16R8, /* type */
134 0, /* rightshift */
135 1, /* size (0 = byte, 1 = short, 2 = long) */
136 16, /* bitsize */
137 FALSE, /* pc_relative */
138 0, /* bitpos */
139 complain_overflow_bitfield, /* complain_on_overflow */
140 special, /* special_function */
141 "R_H8_DIR16R8", /* name */
142 FALSE, /* partial_inplace */
143 0, /* src_mask */
144 0x0000ffff, /* dst_mask */
145 FALSE), /* pcrel_offset */
146 #define R_H8_DIR24A8_X (R_H8_DIR16R8_X + 1)
147 HOWTO (R_H8_DIR24A8, /* type */
148 0, /* rightshift */
149 2, /* size (0 = byte, 1 = short, 2 = long) */
150 24, /* bitsize */
151 FALSE, /* pc_relative */
152 0, /* bitpos */
153 complain_overflow_bitfield, /* complain_on_overflow */
154 special, /* special_function */
155 "R_H8_DIR24A8", /* name */
156 TRUE, /* partial_inplace */
157 0xff000000, /* src_mask */
158 0x00ffffff, /* dst_mask */
159 FALSE), /* pcrel_offset */
160 #define R_H8_DIR24R8_X (R_H8_DIR24A8_X + 1)
161 HOWTO (R_H8_DIR24R8, /* type */
162 0, /* rightshift */
163 2, /* size (0 = byte, 1 = short, 2 = long) */
164 24, /* bitsize */
165 FALSE, /* pc_relative */
166 0, /* bitpos */
167 complain_overflow_bitfield, /* complain_on_overflow */
168 special, /* special_function */
169 "R_H8_DIR24R8", /* name */
170 TRUE, /* partial_inplace */
171 0xff000000, /* src_mask */
172 0x00ffffff, /* dst_mask */
173 FALSE), /* pcrel_offset */
174 #define R_H8_DIR32A16_X (R_H8_DIR24R8_X + 1)
175 HOWTO (R_H8_DIR32A16, /* type */
176 0, /* rightshift */
177 2, /* size (0 = byte, 1 = short, 2 = long) */
178 32, /* bitsize */
179 FALSE, /* pc_relative */
180 0, /* bitpos */
181 complain_overflow_dont,/* complain_on_overflow */
182 special, /* special_function */
183 "R_H8_DIR32A16", /* name */
184 FALSE, /* partial_inplace */
185 0, /* src_mask */
186 0xffffffff, /* dst_mask */
187 FALSE), /* pcrel_offset */
188 #define R_H8_PCREL16_X (R_H8_DIR32A16_X + 1)
189 HOWTO (R_H8_PCREL16, /* type */
190 0, /* rightshift */
191 1, /* size (0 = byte, 1 = short, 2 = long) */
192 16, /* bitsize */
193 TRUE, /* pc_relative */
194 0, /* bitpos */
195 complain_overflow_signed,/* complain_on_overflow */
196 special, /* special_function */
197 "R_H8_PCREL16", /* name */
198 FALSE, /* partial_inplace */
199 0xffff, /* src_mask */
200 0xffff, /* dst_mask */
201 TRUE), /* pcrel_offset */
202 #define R_H8_PCREL8_X (R_H8_PCREL16_X + 1)
203 HOWTO (R_H8_PCREL8, /* type */
204 0, /* rightshift */
205 0, /* size (0 = byte, 1 = short, 2 = long) */
206 8, /* bitsize */
207 TRUE, /* pc_relative */
208 0, /* bitpos */
209 complain_overflow_signed,/* complain_on_overflow */
210 special, /* special_function */
211 "R_H8_PCREL8", /* name */
212 FALSE, /* partial_inplace */
213 0xff, /* src_mask */
214 0xff, /* dst_mask */
215 TRUE), /* pcrel_offset */
216 };
217
218 /* This structure is used to map BFD reloc codes to H8 ELF relocs. */
219
220 struct elf_reloc_map {
221 bfd_reloc_code_real_type bfd_reloc_val;
222 unsigned char howto_index;
223 };
224
225 /* An array mapping BFD reloc codes to H8 ELF relocs. */
226
227 static const struct elf_reloc_map h8_reloc_map[] = {
228 { BFD_RELOC_NONE, R_H8_NONE_X },
229 { BFD_RELOC_32, R_H8_DIR32_X },
230 { BFD_RELOC_16, R_H8_DIR16_X },
231 { BFD_RELOC_8, R_H8_DIR8_X },
232 { BFD_RELOC_H8_DIR16A8, R_H8_DIR16A8_X },
233 { BFD_RELOC_H8_DIR16R8, R_H8_DIR16R8_X },
234 { BFD_RELOC_H8_DIR24A8, R_H8_DIR24A8_X },
235 { BFD_RELOC_H8_DIR24R8, R_H8_DIR24R8_X },
236 { BFD_RELOC_H8_DIR32A16, R_H8_DIR32A16_X },
237 { BFD_RELOC_16_PCREL, R_H8_PCREL16_X },
238 { BFD_RELOC_8_PCREL, R_H8_PCREL8_X },
239 };
240
241
242 static reloc_howto_type *
243 elf32_h8_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
244 bfd_reloc_code_real_type code)
245 {
246 unsigned int i;
247
248 for (i = 0; i < sizeof (h8_reloc_map) / sizeof (struct elf_reloc_map); i++)
249 {
250 if (h8_reloc_map[i].bfd_reloc_val == code)
251 return &h8_elf_howto_table[(int) h8_reloc_map[i].howto_index];
252 }
253 return NULL;
254 }
255
256 static reloc_howto_type *
257 elf32_h8_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
258 const char *r_name)
259 {
260 unsigned int i;
261
262 for (i = 0;
263 i < sizeof (h8_elf_howto_table) / sizeof (h8_elf_howto_table[0]);
264 i++)
265 if (h8_elf_howto_table[i].name != NULL
266 && strcasecmp (h8_elf_howto_table[i].name, r_name) == 0)
267 return &h8_elf_howto_table[i];
268
269 return NULL;
270 }
271
272 static void
273 elf32_h8_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
274 Elf_Internal_Rela *elf_reloc)
275 {
276 unsigned int r;
277 unsigned int i;
278
279 r = ELF32_R_TYPE (elf_reloc->r_info);
280 for (i = 0; i < sizeof (h8_elf_howto_table) / sizeof (reloc_howto_type); i++)
281 if (h8_elf_howto_table[i].type == r)
282 {
283 bfd_reloc->howto = &h8_elf_howto_table[i];
284 return;
285 }
286 abort ();
287 }
288
289 static void
290 elf32_h8_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
291 Elf_Internal_Rela *elf_reloc ATTRIBUTE_UNUSED)
292 {
293 unsigned int r;
294
295 abort ();
296 r = ELF32_R_TYPE (elf_reloc->r_info);
297 bfd_reloc->howto = &h8_elf_howto_table[r];
298 }
299
300 /* Special handling for H8/300 relocs.
301 We only come here for pcrel stuff and return normally if not an -r link.
302 When doing -r, we can't do any arithmetic for the pcrel stuff, because
303 we support relaxing on the H8/300 series chips. */
304 static bfd_reloc_status_type
305 special (bfd *abfd ATTRIBUTE_UNUSED,
306 arelent *reloc_entry ATTRIBUTE_UNUSED,
307 asymbol *symbol ATTRIBUTE_UNUSED,
308 void * data ATTRIBUTE_UNUSED,
309 asection *input_section ATTRIBUTE_UNUSED,
310 bfd *output_bfd,
311 char **error_message ATTRIBUTE_UNUSED)
312 {
313 if (output_bfd == (bfd *) NULL)
314 return bfd_reloc_continue;
315
316 /* Adjust the reloc address to that in the output section. */
317 reloc_entry->address += input_section->output_offset;
318 return bfd_reloc_ok;
319 }
320
321 /* Perform a relocation as part of a final link. */
322 static bfd_reloc_status_type
323 elf32_h8_final_link_relocate (unsigned long r_type, bfd *input_bfd,
324 bfd *output_bfd ATTRIBUTE_UNUSED,
325 asection *input_section ATTRIBUTE_UNUSED,
326 bfd_byte *contents, bfd_vma offset,
327 bfd_vma value, bfd_vma addend,
328 struct bfd_link_info *info ATTRIBUTE_UNUSED,
329 asection *sym_sec ATTRIBUTE_UNUSED,
330 int is_local ATTRIBUTE_UNUSED)
331 {
332 bfd_byte *hit_data = contents + offset;
333
334 switch (r_type)
335 {
336 case R_H8_NONE:
337 return bfd_reloc_ok;
338
339 case R_H8_DIR32:
340 case R_H8_DIR32A16:
341 case R_H8_DIR24A8:
342 value += addend;
343 bfd_put_32 (input_bfd, value, hit_data);
344 return bfd_reloc_ok;
345
346 case R_H8_DIR16:
347 case R_H8_DIR16A8:
348 case R_H8_DIR16R8:
349 value += addend;
350 bfd_put_16 (input_bfd, value, hit_data);
351 return bfd_reloc_ok;
352
353 /* AKA R_RELBYTE */
354 case R_H8_DIR8:
355 value += addend;
356
357 bfd_put_8 (input_bfd, value, hit_data);
358 return bfd_reloc_ok;
359
360 case R_H8_DIR24R8:
361 value += addend;
362
363 /* HIT_DATA is the address for the first byte for the relocated
364 value. Subtract 1 so that we can manipulate the data in 32-bit
365 hunks. */
366 hit_data--;
367
368 /* Clear out the top byte in value. */
369 value &= 0xffffff;
370
371 /* Retrieve the type byte for value from the section contents. */
372 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
373
374 /* Now scribble it out in one 32-bit hunk. */
375 bfd_put_32 (input_bfd, value, hit_data);
376 return bfd_reloc_ok;
377
378 case R_H8_PCREL16:
379 value -= (input_section->output_section->vma
380 + input_section->output_offset);
381 value -= offset;
382 value += addend;
383
384 /* The value is relative to the start of the instruction,
385 not the relocation offset. Subtract 2 to account for
386 this minor issue. */
387 value -= 2;
388
389 bfd_put_16 (input_bfd, value, hit_data);
390 return bfd_reloc_ok;
391
392 case R_H8_PCREL8:
393 value -= (input_section->output_section->vma
394 + input_section->output_offset);
395 value -= offset;
396 value += addend;
397
398 /* The value is relative to the start of the instruction,
399 not the relocation offset. Subtract 1 to account for
400 this minor issue. */
401 value -= 1;
402
403 bfd_put_8 (input_bfd, value, hit_data);
404 return bfd_reloc_ok;
405
406 default:
407 return bfd_reloc_notsupported;
408 }
409 }
410 \f
411 /* Relocate an H8 ELF section. */
412 static bfd_boolean
413 elf32_h8_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
414 bfd *input_bfd, asection *input_section,
415 bfd_byte *contents, Elf_Internal_Rela *relocs,
416 Elf_Internal_Sym *local_syms,
417 asection **local_sections)
418 {
419 Elf_Internal_Shdr *symtab_hdr;
420 struct elf_link_hash_entry **sym_hashes;
421 Elf_Internal_Rela *rel, *relend;
422
423 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
424 sym_hashes = elf_sym_hashes (input_bfd);
425
426 rel = relocs;
427 relend = relocs + input_section->reloc_count;
428 for (; rel < relend; rel++)
429 {
430 unsigned int r_type;
431 unsigned long r_symndx;
432 Elf_Internal_Sym *sym;
433 asection *sec;
434 struct elf_link_hash_entry *h;
435 bfd_vma relocation;
436 bfd_reloc_status_type r;
437 arelent bfd_reloc;
438 reloc_howto_type *howto;
439
440 elf32_h8_info_to_howto (input_bfd, &bfd_reloc, rel);
441 howto = bfd_reloc.howto;
442
443 r_symndx = ELF32_R_SYM (rel->r_info);
444 r_type = ELF32_R_TYPE (rel->r_info);
445 h = NULL;
446 sym = NULL;
447 sec = NULL;
448 if (r_symndx < symtab_hdr->sh_info)
449 {
450 sym = local_syms + r_symndx;
451 sec = local_sections[r_symndx];
452 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
453 }
454 else
455 {
456 bfd_boolean unresolved_reloc, warned;
457
458 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
459 r_symndx, symtab_hdr, sym_hashes,
460 h, sec, relocation,
461 unresolved_reloc, warned);
462 }
463
464 if (sec != NULL && discarded_section (sec))
465 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
466 rel, 1, relend, howto, 0, contents);
467
468 if (info->relocatable)
469 continue;
470
471 r = elf32_h8_final_link_relocate (r_type, input_bfd, output_bfd,
472 input_section,
473 contents, rel->r_offset,
474 relocation, rel->r_addend,
475 info, sec, h == NULL);
476
477 if (r != bfd_reloc_ok)
478 {
479 const char *name;
480 const char *msg = (const char *) 0;
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, (h ? &h->root : NULL), name, howto->name,
497 (bfd_vma) 0, input_bfd, input_section,
498 rel->r_offset)))
499 return FALSE;
500 break;
501
502 case bfd_reloc_undefined:
503 if (! ((*info->callbacks->undefined_symbol)
504 (info, name, input_bfd, input_section,
505 rel->r_offset, TRUE)))
506 return FALSE;
507 break;
508
509 case bfd_reloc_outofrange:
510 msg = _("internal error: out of range error");
511 goto common_error;
512
513 case bfd_reloc_notsupported:
514 msg = _("internal error: unsupported relocation error");
515 goto common_error;
516
517 case bfd_reloc_dangerous:
518 msg = _("internal error: dangerous error");
519 goto common_error;
520
521 default:
522 msg = _("internal error: unknown error");
523 /* fall through */
524
525 common_error:
526 if (!((*info->callbacks->warning)
527 (info, msg, name, input_bfd, input_section,
528 rel->r_offset)))
529 return FALSE;
530 break;
531 }
532 }
533 }
534
535 return TRUE;
536 }
537
538 /* Object files encode the specific H8 model they were compiled
539 for in the ELF flags field.
540
541 Examine that field and return the proper BFD machine type for
542 the object file. */
543 static unsigned long
544 elf32_h8_mach (flagword flags)
545 {
546 switch (flags & EF_H8_MACH)
547 {
548 case E_H8_MACH_H8300:
549 default:
550 return bfd_mach_h8300;
551
552 case E_H8_MACH_H8300H:
553 return bfd_mach_h8300h;
554
555 case E_H8_MACH_H8300S:
556 return bfd_mach_h8300s;
557
558 case E_H8_MACH_H8300HN:
559 return bfd_mach_h8300hn;
560
561 case E_H8_MACH_H8300SN:
562 return bfd_mach_h8300sn;
563
564 case E_H8_MACH_H8300SX:
565 return bfd_mach_h8300sx;
566
567 case E_H8_MACH_H8300SXN:
568 return bfd_mach_h8300sxn;
569 }
570 }
571
572 /* The final processing done just before writing out a H8 ELF object
573 file. We use this opportunity to encode the BFD machine type
574 into the flags field in the object file. */
575
576 static void
577 elf32_h8_final_write_processing (bfd *abfd,
578 bfd_boolean linker ATTRIBUTE_UNUSED)
579 {
580 unsigned long val;
581
582 switch (bfd_get_mach (abfd))
583 {
584 default:
585 case bfd_mach_h8300:
586 val = E_H8_MACH_H8300;
587 break;
588
589 case bfd_mach_h8300h:
590 val = E_H8_MACH_H8300H;
591 break;
592
593 case bfd_mach_h8300s:
594 val = E_H8_MACH_H8300S;
595 break;
596
597 case bfd_mach_h8300hn:
598 val = E_H8_MACH_H8300HN;
599 break;
600
601 case bfd_mach_h8300sn:
602 val = E_H8_MACH_H8300SN;
603 break;
604
605 case bfd_mach_h8300sx:
606 val = E_H8_MACH_H8300SX;
607 break;
608
609 case bfd_mach_h8300sxn:
610 val = E_H8_MACH_H8300SXN;
611 break;
612 }
613
614 elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH);
615 elf_elfheader (abfd)->e_flags |= val;
616 }
617
618 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
619 record the encoded machine type found in the ELF flags. */
620
621 static bfd_boolean
622 elf32_h8_object_p (bfd *abfd)
623 {
624 bfd_default_set_arch_mach (abfd, bfd_arch_h8300,
625 elf32_h8_mach (elf_elfheader (abfd)->e_flags));
626 return TRUE;
627 }
628
629 /* Merge backend specific data from an object file to the output
630 object file when linking. The only data we need to copy at this
631 time is the architecture/machine information. */
632
633 static bfd_boolean
634 elf32_h8_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
635 {
636 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
637 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
638 return TRUE;
639
640 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
641 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
642 {
643 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
644 bfd_get_mach (ibfd)))
645 return FALSE;
646 }
647
648 return TRUE;
649 }
650
651 /* This function handles relaxing for the H8..
652
653 There are a few relaxing opportunities available on the H8:
654
655 jmp/jsr:24 -> bra/bsr:8 2 bytes
656 The jmp may be completely eliminated if the previous insn is a
657 conditional branch to the insn after the jump. In that case
658 we invert the branch and delete the jump and save 4 bytes.
659
660 bCC:16 -> bCC:8 2 bytes
661 bsr:16 -> bsr:8 2 bytes
662
663 bset:16 -> bset:8 2 bytes
664 bset:24/32 -> bset:8 4 bytes
665 (also applicable to other bit manipulation instructions)
666
667 mov.b:16 -> mov.b:8 2 bytes
668 mov.b:24/32 -> mov.b:8 4 bytes
669
670 bset:24/32 -> bset:16 2 bytes
671 (also applicable to other bit manipulation instructions)
672
673 mov.[bwl]:24/32 -> mov.[bwl]:16 2 bytes */
674
675 static bfd_boolean
676 elf32_h8_relax_section (bfd *abfd, asection *sec,
677 struct bfd_link_info *link_info, bfd_boolean *again)
678 {
679 Elf_Internal_Shdr *symtab_hdr;
680 Elf_Internal_Rela *internal_relocs;
681 Elf_Internal_Rela *irel, *irelend;
682 bfd_byte *contents = NULL;
683 Elf_Internal_Sym *isymbuf = NULL;
684 static asection *last_input_section = NULL;
685 static Elf_Internal_Rela *last_reloc = NULL;
686
687 /* Assume nothing changes. */
688 *again = FALSE;
689
690 /* We don't have to do anything for a relocatable link, if
691 this section does not have relocs, or if this is not a
692 code section. */
693 if (link_info->relocatable
694 || (sec->flags & SEC_RELOC) == 0
695 || sec->reloc_count == 0
696 || (sec->flags & SEC_CODE) == 0)
697 return TRUE;
698
699 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
700
701 /* Get a copy of the native relocations. */
702 internal_relocs = (_bfd_elf_link_read_relocs
703 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
704 link_info->keep_memory));
705 if (internal_relocs == NULL)
706 goto error_return;
707
708 if (sec != last_input_section)
709 last_reloc = NULL;
710
711 last_input_section = sec;
712
713 /* Walk through the relocs looking for relaxing opportunities. */
714 irelend = internal_relocs + sec->reloc_count;
715 for (irel = internal_relocs; irel < irelend; irel++)
716 {
717 bfd_vma symval;
718
719 {
720 arelent bfd_reloc;
721
722 elf32_h8_info_to_howto (abfd, &bfd_reloc, irel);
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 /* Might be MOVSD. */
997 break;
998
999 /* Fix the relocation's type. */
1000 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1001 R_H8_PCREL8);
1002 irel->r_offset--;
1003
1004 /* Delete two bytes of data. */
1005 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1006 irel->r_offset + 1, 2))
1007 goto error_return;
1008
1009 /* That will change things, so, we should relax again.
1010 Note that this is not required, and it may be slow. */
1011 *again = TRUE;
1012 }
1013 break;
1014 }
1015
1016 /* This is a 16-bit absolute address in one of the following
1017 instructions:
1018
1019 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1020 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1021 "mov.b"
1022
1023 We may relax this into an 8-bit absolute address if it's in
1024 the right range. */
1025 case R_H8_DIR16A8:
1026 {
1027 bfd_vma value;
1028
1029 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1030 if (value >= 0xffffff00u)
1031 {
1032 unsigned char code;
1033 unsigned char temp_code;
1034
1035 /* Note that we've changed the relocs, section contents,
1036 etc. */
1037 elf_section_data (sec)->relocs = internal_relocs;
1038 elf_section_data (sec)->this_hdr.contents = contents;
1039 symtab_hdr->contents = (unsigned char *) isymbuf;
1040
1041 /* Get the opcode. */
1042 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1043
1044 /* All instructions with R_H8_DIR16A8 start with
1045 0x6a. */
1046 if (code != 0x6a)
1047 abort ();
1048
1049 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1050 /* If this is a mov.b instruction, clear the lower
1051 nibble, which contains the source/destination
1052 register number. */
1053 if ((temp_code & 0x10) != 0x10)
1054 temp_code &= 0xf0;
1055
1056 switch (temp_code)
1057 {
1058 case 0x00:
1059 /* This is mov.b @aa:16,Rd. */
1060 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1061 contents + irel->r_offset - 2);
1062 break;
1063 case 0x80:
1064 /* This is mov.b Rs,@aa:16. */
1065 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1066 contents + irel->r_offset - 2);
1067 break;
1068 case 0x18:
1069 /* This is a bit-maniputation instruction that
1070 stores one bit into memory, one of "bclr",
1071 "bist", "bnot", "bset", and "bst". */
1072 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1073 break;
1074 case 0x10:
1075 /* This is a bit-maniputation instruction that
1076 loads one bit from memory, one of "band",
1077 "biand", "bild", "bior", "bixor", "bld", "bor",
1078 "btst", and "bxor". */
1079 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1080 break;
1081 default:
1082 abort ();
1083 }
1084
1085 /* Fix the relocation's type. */
1086 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1087 R_H8_DIR8);
1088
1089 /* Move the relocation. */
1090 irel->r_offset--;
1091
1092 /* Delete two bytes of data. */
1093 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1094 irel->r_offset + 1, 2))
1095 goto error_return;
1096
1097 /* That will change things, so, we should relax again.
1098 Note that this is not required, and it may be slow. */
1099 *again = TRUE;
1100 }
1101 break;
1102 }
1103
1104 /* This is a 24-bit absolute address in one of the following
1105 instructions:
1106
1107 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1108 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1109 "mov.b"
1110
1111 We may relax this into an 8-bit absolute address if it's in
1112 the right range. */
1113 case R_H8_DIR24A8:
1114 {
1115 bfd_vma value;
1116
1117 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1118 if (value >= 0xffffff00u)
1119 {
1120 unsigned char code;
1121 unsigned char temp_code;
1122
1123 /* Note that we've changed the relocs, section contents,
1124 etc. */
1125 elf_section_data (sec)->relocs = internal_relocs;
1126 elf_section_data (sec)->this_hdr.contents = contents;
1127 symtab_hdr->contents = (unsigned char *) isymbuf;
1128
1129 /* Get the opcode. */
1130 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1131
1132 /* All instructions with R_H8_DIR24A8 start with
1133 0x6a. */
1134 if (code != 0x6a)
1135 abort ();
1136
1137 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1138
1139 /* If this is a mov.b instruction, clear the lower
1140 nibble, which contains the source/destination
1141 register number. */
1142 if ((temp_code & 0x30) != 0x30)
1143 temp_code &= 0xf0;
1144
1145 switch (temp_code)
1146 {
1147 case 0x20:
1148 /* This is mov.b @aa:24/32,Rd. */
1149 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1150 contents + irel->r_offset - 2);
1151 break;
1152 case 0xa0:
1153 /* This is mov.b Rs,@aa:24/32. */
1154 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1155 contents + irel->r_offset - 2);
1156 break;
1157 case 0x38:
1158 /* This is a bit-maniputation instruction that
1159 stores one bit into memory, one of "bclr",
1160 "bist", "bnot", "bset", and "bst". */
1161 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1162 break;
1163 case 0x30:
1164 /* This is a bit-maniputation instruction that
1165 loads one bit from memory, one of "band",
1166 "biand", "bild", "bior", "bixor", "bld", "bor",
1167 "btst", and "bxor". */
1168 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1169 break;
1170 default:
1171 abort();
1172 }
1173
1174 /* Fix the relocation's type. */
1175 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1176 R_H8_DIR8);
1177 irel->r_offset--;
1178
1179 /* Delete two bytes of data. */
1180 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1181 irel->r_offset + 1, 4))
1182 goto error_return;
1183
1184 /* That will change things, so, we should relax again.
1185 Note that this is not required, and it may be slow. */
1186 *again = TRUE;
1187 break;
1188 }
1189 }
1190
1191 /* Fall through. */
1192
1193 /* This is a 24-/32-bit absolute address in one of the
1194 following instructions:
1195
1196 "band", "bclr", "biand", "bild", "bior", "bist",
1197 "bixor", "bld", "bnot", "bor", "bset", "bst", "btst",
1198 "bxor", "ldc.w", "stc.w" and "mov.[bwl]"
1199
1200 We may relax this into an 16-bit absolute address if it's
1201 in the right range. */
1202 case R_H8_DIR32A16:
1203 {
1204 bfd_vma value;
1205
1206 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1207 if (value <= 0x7fff || value >= 0xffff8000u)
1208 {
1209 unsigned char code;
1210 unsigned char op0, op1, op2, op3;
1211 unsigned char *op_ptr;
1212
1213 /* Note that we've changed the relocs, section contents,
1214 etc. */
1215 elf_section_data (sec)->relocs = internal_relocs;
1216 elf_section_data (sec)->this_hdr.contents = contents;
1217 symtab_hdr->contents = (unsigned char *) isymbuf;
1218
1219 if (irel->r_offset >= 4)
1220 {
1221 /* Check for 4-byte MOVA relaxation. */
1222 int second_reloc = 0;
1223
1224 op_ptr = contents + irel->r_offset - 4;
1225
1226 if (last_reloc)
1227 {
1228 arelent bfd_reloc;
1229 reloc_howto_type *h;
1230 bfd_vma last_reloc_size;
1231
1232 elf32_h8_info_to_howto (abfd, &bfd_reloc, last_reloc);
1233 h = bfd_reloc.howto;
1234 last_reloc_size = 1 << h->size;
1235 if (last_reloc->r_offset + last_reloc_size
1236 == irel->r_offset)
1237 {
1238 op_ptr -= last_reloc_size;
1239 second_reloc = 1;
1240 }
1241 }
1242 if (irel + 1 < irelend)
1243 {
1244 Elf_Internal_Rela *next_reloc = irel + 1;
1245 arelent bfd_reloc;
1246 reloc_howto_type *h;
1247 bfd_vma next_reloc_size;
1248
1249 elf32_h8_info_to_howto (abfd, &bfd_reloc, next_reloc);
1250 h = bfd_reloc.howto;
1251 next_reloc_size = 1 << h->size;
1252 if (next_reloc->r_offset + next_reloc_size
1253 == irel->r_offset)
1254 {
1255 op_ptr -= next_reloc_size;
1256 second_reloc = 1;
1257 }
1258 }
1259
1260 op0 = bfd_get_8 (abfd, op_ptr + 0);
1261 op1 = bfd_get_8 (abfd, op_ptr + 1);
1262 op2 = bfd_get_8 (abfd, op_ptr + 2);
1263 op3 = bfd_get_8 (abfd, op_ptr + 3);
1264
1265 if (op0 == 0x01
1266 && (op1 & 0xdf) == 0x5f
1267 && (op2 & 0x40) == 0x40
1268 && (op3 & 0x80) == 0x80)
1269 {
1270 if ((op2 & 0x08) == 0)
1271 second_reloc = 1;
1272
1273 if (second_reloc)
1274 {
1275 op3 &= ~0x08;
1276 bfd_put_8 (abfd, op3, op_ptr + 3);
1277 }
1278 else
1279 {
1280 op2 &= ~0x08;
1281 bfd_put_8 (abfd, op2, op_ptr + 2);
1282 }
1283 goto r_h8_dir32a16_common;
1284 }
1285 }
1286
1287 /* Now check for short version of MOVA. */
1288 op_ptr = contents + irel->r_offset - 2;
1289 op0 = bfd_get_8 (abfd, op_ptr + 0);
1290 op1 = bfd_get_8 (abfd, op_ptr + 1);
1291
1292 if (op0 == 0x7a
1293 && (op1 & 0x88) == 0x80)
1294 {
1295 op1 |= 0x08;
1296 bfd_put_8 (abfd, op1, op_ptr + 1);
1297 goto r_h8_dir32a16_common;
1298 }
1299
1300 /* Get the opcode. */
1301 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1302
1303 /* Fix the opcode. For all the instructions that
1304 belong to this relaxation, we simply need to turn
1305 off bit 0x20 in the previous byte. */
1306 code &= ~0x20;
1307
1308 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1309
1310 r_h8_dir32a16_common:
1311 /* Fix the relocation's type. */
1312 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1313 R_H8_DIR16);
1314
1315 /* Delete two bytes of data. */
1316 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1317 irel->r_offset + 1, 2))
1318 goto error_return;
1319
1320 /* That will change things, so, we should relax again.
1321 Note that this is not required, and it may be slow. */
1322 *again = TRUE;
1323 }
1324 break;
1325 }
1326
1327 default:
1328 break;
1329 }
1330 }
1331
1332 if (isymbuf != NULL
1333 && symtab_hdr->contents != (unsigned char *) isymbuf)
1334 {
1335 if (! link_info->keep_memory)
1336 free (isymbuf);
1337 else
1338 symtab_hdr->contents = (unsigned char *) isymbuf;
1339 }
1340
1341 if (contents != NULL
1342 && elf_section_data (sec)->this_hdr.contents != contents)
1343 {
1344 if (! link_info->keep_memory)
1345 free (contents);
1346 else
1347 {
1348 /* Cache the section contents for elf_link_input_bfd. */
1349 elf_section_data (sec)->this_hdr.contents = contents;
1350 }
1351 }
1352
1353 if (internal_relocs != NULL
1354 && elf_section_data (sec)->relocs != internal_relocs)
1355 free (internal_relocs);
1356
1357 return TRUE;
1358
1359 error_return:
1360 if (isymbuf != NULL
1361 && symtab_hdr->contents != (unsigned char *) isymbuf)
1362 free (isymbuf);
1363 if (contents != NULL
1364 && elf_section_data (sec)->this_hdr.contents != contents)
1365 free (contents);
1366 if (internal_relocs != NULL
1367 && elf_section_data (sec)->relocs != internal_relocs)
1368 free (internal_relocs);
1369 return FALSE;
1370 }
1371
1372 /* Delete some bytes from a section while relaxing. */
1373
1374 static bfd_boolean
1375 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count)
1376 {
1377 Elf_Internal_Shdr *symtab_hdr;
1378 unsigned int sec_shndx;
1379 bfd_byte *contents;
1380 Elf_Internal_Rela *irel, *irelend;
1381 Elf_Internal_Sym *isym;
1382 Elf_Internal_Sym *isymend;
1383 bfd_vma toaddr;
1384 struct elf_link_hash_entry **sym_hashes;
1385 struct elf_link_hash_entry **end_hashes;
1386 unsigned int symcount;
1387
1388 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1389
1390 contents = elf_section_data (sec)->this_hdr.contents;
1391
1392 toaddr = sec->size;
1393
1394 irel = elf_section_data (sec)->relocs;
1395 irelend = irel + sec->reloc_count;
1396
1397 /* Actually delete the bytes. */
1398 memmove (contents + addr, contents + addr + count,
1399 (size_t) (toaddr - addr - count));
1400 sec->size -= count;
1401
1402 /* Adjust all the relocs. */
1403 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1404 {
1405 /* Get the new reloc address. */
1406 if ((irel->r_offset > addr
1407 && irel->r_offset < toaddr))
1408 irel->r_offset -= count;
1409 }
1410
1411 /* Adjust the local symbols defined in this section. */
1412 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1413 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1414 isymend = isym + symtab_hdr->sh_info;
1415 for (; isym < isymend; isym++)
1416 {
1417 if (isym->st_shndx == sec_shndx
1418 && isym->st_value > addr
1419 && isym->st_value < toaddr)
1420 isym->st_value -= count;
1421 }
1422
1423 /* Now adjust the global symbols defined in this section. */
1424 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1425 - symtab_hdr->sh_info);
1426 sym_hashes = elf_sym_hashes (abfd);
1427 end_hashes = sym_hashes + symcount;
1428 for (; sym_hashes < end_hashes; sym_hashes++)
1429 {
1430 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1431 if ((sym_hash->root.type == bfd_link_hash_defined
1432 || sym_hash->root.type == bfd_link_hash_defweak)
1433 && sym_hash->root.u.def.section == sec
1434 && sym_hash->root.u.def.value > addr
1435 && sym_hash->root.u.def.value < toaddr)
1436 {
1437 sym_hash->root.u.def.value -= count;
1438 }
1439 }
1440
1441 return TRUE;
1442 }
1443
1444 /* Return TRUE if a symbol exists at the given address, else return
1445 FALSE. */
1446 static bfd_boolean
1447 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr)
1448 {
1449 Elf_Internal_Shdr *symtab_hdr;
1450 unsigned int sec_shndx;
1451 Elf_Internal_Sym *isym;
1452 Elf_Internal_Sym *isymend;
1453 struct elf_link_hash_entry **sym_hashes;
1454 struct elf_link_hash_entry **end_hashes;
1455 unsigned int symcount;
1456
1457 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1458
1459 /* Examine all the symbols. */
1460 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1461 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1462 isymend = isym + symtab_hdr->sh_info;
1463 for (; isym < isymend; isym++)
1464 {
1465 if (isym->st_shndx == sec_shndx
1466 && isym->st_value == addr)
1467 return TRUE;
1468 }
1469
1470 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1471 - symtab_hdr->sh_info);
1472 sym_hashes = elf_sym_hashes (abfd);
1473 end_hashes = sym_hashes + symcount;
1474 for (; sym_hashes < end_hashes; sym_hashes++)
1475 {
1476 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1477 if ((sym_hash->root.type == bfd_link_hash_defined
1478 || sym_hash->root.type == bfd_link_hash_defweak)
1479 && sym_hash->root.u.def.section == sec
1480 && sym_hash->root.u.def.value == addr)
1481 return TRUE;
1482 }
1483
1484 return FALSE;
1485 }
1486
1487 /* This is a version of bfd_generic_get_relocated_section_contents
1488 which uses elf32_h8_relocate_section. */
1489
1490 static bfd_byte *
1491 elf32_h8_get_relocated_section_contents (bfd *output_bfd,
1492 struct bfd_link_info *link_info,
1493 struct bfd_link_order *link_order,
1494 bfd_byte *data,
1495 bfd_boolean relocatable,
1496 asymbol **symbols)
1497 {
1498 Elf_Internal_Shdr *symtab_hdr;
1499 asection *input_section = link_order->u.indirect.section;
1500 bfd *input_bfd = input_section->owner;
1501 asection **sections = NULL;
1502 Elf_Internal_Rela *internal_relocs = NULL;
1503 Elf_Internal_Sym *isymbuf = NULL;
1504
1505 /* We only need to handle the case of relaxing, or of having a
1506 particular set of section contents, specially. */
1507 if (relocatable
1508 || elf_section_data (input_section)->this_hdr.contents == NULL)
1509 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1510 link_order, data,
1511 relocatable,
1512 symbols);
1513
1514 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1515
1516 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1517 (size_t) input_section->size);
1518
1519 if ((input_section->flags & SEC_RELOC) != 0
1520 && input_section->reloc_count > 0)
1521 {
1522 asection **secpp;
1523 Elf_Internal_Sym *isym, *isymend;
1524 bfd_size_type amt;
1525
1526 internal_relocs = (_bfd_elf_link_read_relocs
1527 (input_bfd, input_section, NULL,
1528 (Elf_Internal_Rela *) NULL, FALSE));
1529 if (internal_relocs == NULL)
1530 goto error_return;
1531
1532 if (symtab_hdr->sh_info != 0)
1533 {
1534 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1535 if (isymbuf == NULL)
1536 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1537 symtab_hdr->sh_info, 0,
1538 NULL, NULL, NULL);
1539 if (isymbuf == NULL)
1540 goto error_return;
1541 }
1542
1543 amt = symtab_hdr->sh_info;
1544 amt *= sizeof (asection *);
1545 sections = (asection **) bfd_malloc (amt);
1546 if (sections == NULL && amt != 0)
1547 goto error_return;
1548
1549 isymend = isymbuf + symtab_hdr->sh_info;
1550 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1551 {
1552 asection *isec;
1553
1554 if (isym->st_shndx == SHN_UNDEF)
1555 isec = bfd_und_section_ptr;
1556 else if (isym->st_shndx == SHN_ABS)
1557 isec = bfd_abs_section_ptr;
1558 else if (isym->st_shndx == SHN_COMMON)
1559 isec = bfd_com_section_ptr;
1560 else
1561 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1562
1563 *secpp = isec;
1564 }
1565
1566 if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1567 input_section, data, internal_relocs,
1568 isymbuf, sections))
1569 goto error_return;
1570
1571 if (sections != NULL)
1572 free (sections);
1573 if (isymbuf != NULL
1574 && symtab_hdr->contents != (unsigned char *) isymbuf)
1575 free (isymbuf);
1576 if (elf_section_data (input_section)->relocs != internal_relocs)
1577 free (internal_relocs);
1578 }
1579
1580 return data;
1581
1582 error_return:
1583 if (sections != NULL)
1584 free (sections);
1585 if (isymbuf != NULL
1586 && symtab_hdr->contents != (unsigned char *) isymbuf)
1587 free (isymbuf);
1588 if (internal_relocs != NULL
1589 && elf_section_data (input_section)->relocs != internal_relocs)
1590 free (internal_relocs);
1591 return NULL;
1592 }
1593
1594
1595 #define TARGET_BIG_SYM bfd_elf32_h8300_vec
1596 #define TARGET_BIG_NAME "elf32-h8300"
1597 #define ELF_ARCH bfd_arch_h8300
1598 #define ELF_MACHINE_CODE EM_H8_300
1599 #define ELF_MAXPAGESIZE 0x1
1600 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1601 #define bfd_elf32_bfd_reloc_name_lookup elf32_h8_reloc_name_lookup
1602 #define elf_info_to_howto elf32_h8_info_to_howto
1603 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1604
1605 /* So we can set/examine bits in e_flags to get the specific
1606 H8 architecture in use. */
1607 #define elf_backend_final_write_processing \
1608 elf32_h8_final_write_processing
1609 #define elf_backend_object_p \
1610 elf32_h8_object_p
1611 #define bfd_elf32_bfd_merge_private_bfd_data \
1612 elf32_h8_merge_private_bfd_data
1613
1614 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1615 defaults to using _bfd_generic_link_hash_table_create, but
1616 bfd_elf_size_dynamic_sections uses
1617 dynobj = elf_hash_table (info)->dynobj;
1618 and thus requires an elf hash table. */
1619 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1620
1621 /* Use an H8 specific linker, not the ELF generic linker. */
1622 #define elf_backend_relocate_section elf32_h8_relocate_section
1623 #define elf_backend_rela_normal 1
1624 #define elf_backend_can_gc_sections 1
1625
1626 /* And relaxing stuff. */
1627 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1628 #define bfd_elf32_bfd_get_relocated_section_contents \
1629 elf32_h8_get_relocated_section_contents
1630
1631 #define elf_symbol_leading_char '_'
1632
1633 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.