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