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