projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
gas: avoid spurious failures in non-ELF targets in the SPARC testsuite.
[deliverable/binutils-gdb.git] / bfd / elf32-h8300.c
1 /* BFD back-end for Renesas H8/300 ELF binaries.
2 Copyright (C) 1993-2016 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 3, /* 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, ignored;
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, ignored);
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 (bfd_link_relocatable (info))
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 (*info->callbacks->reloc_overflow)
511 (info, (h ? &h->root : NULL), name, howto->name,
512 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
513 break;
514
515 case bfd_reloc_undefined:
516 (*info->callbacks->undefined_symbol)
517 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
518 break;
519
520 case bfd_reloc_outofrange:
521 msg = _("internal error: out of range error");
522 goto common_error;
523
524 case bfd_reloc_notsupported:
525 msg = _("internal error: unsupported relocation error");
526 goto common_error;
527
528 case bfd_reloc_dangerous:
529 msg = _("internal error: dangerous error");
530 goto common_error;
531
532 default:
533 msg = _("internal error: unknown error");
534 /* fall through */
535
536 common_error:
537 (*info->callbacks->warning) (info, msg, name, input_bfd,
538 input_section, rel->r_offset);
539 break;
540 }
541 }
542 }
543
544 return TRUE;
545 }
546
547 /* Object files encode the specific H8 model they were compiled
548 for in the ELF flags field.
549
550 Examine that field and return the proper BFD machine type for
551 the object file. */
552 static unsigned long
553 elf32_h8_mach (flagword flags)
554 {
555 switch (flags & EF_H8_MACH)
556 {
557 case E_H8_MACH_H8300:
558 default:
559 return bfd_mach_h8300;
560
561 case E_H8_MACH_H8300H:
562 return bfd_mach_h8300h;
563
564 case E_H8_MACH_H8300S:
565 return bfd_mach_h8300s;
566
567 case E_H8_MACH_H8300HN:
568 return bfd_mach_h8300hn;
569
570 case E_H8_MACH_H8300SN:
571 return bfd_mach_h8300sn;
572
573 case E_H8_MACH_H8300SX:
574 return bfd_mach_h8300sx;
575
576 case E_H8_MACH_H8300SXN:
577 return bfd_mach_h8300sxn;
578 }
579 }
580
581 /* The final processing done just before writing out a H8 ELF object
582 file. We use this opportunity to encode the BFD machine type
583 into the flags field in the object file. */
584
585 static void
586 elf32_h8_final_write_processing (bfd *abfd,
587 bfd_boolean linker ATTRIBUTE_UNUSED)
588 {
589 unsigned long val;
590
591 switch (bfd_get_mach (abfd))
592 {
593 default:
594 case bfd_mach_h8300:
595 val = E_H8_MACH_H8300;
596 break;
597
598 case bfd_mach_h8300h:
599 val = E_H8_MACH_H8300H;
600 break;
601
602 case bfd_mach_h8300s:
603 val = E_H8_MACH_H8300S;
604 break;
605
606 case bfd_mach_h8300hn:
607 val = E_H8_MACH_H8300HN;
608 break;
609
610 case bfd_mach_h8300sn:
611 val = E_H8_MACH_H8300SN;
612 break;
613
614 case bfd_mach_h8300sx:
615 val = E_H8_MACH_H8300SX;
616 break;
617
618 case bfd_mach_h8300sxn:
619 val = E_H8_MACH_H8300SXN;
620 break;
621 }
622
623 elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH);
624 elf_elfheader (abfd)->e_flags |= val;
625 }
626
627 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
628 record the encoded machine type found in the ELF flags. */
629
630 static bfd_boolean
631 elf32_h8_object_p (bfd *abfd)
632 {
633 bfd_default_set_arch_mach (abfd, bfd_arch_h8300,
634 elf32_h8_mach (elf_elfheader (abfd)->e_flags));
635 return TRUE;
636 }
637
638 /* Merge backend specific data from an object file to the output
639 object file when linking. The only data we need to copy at this
640 time is the architecture/machine information. */
641
642 static bfd_boolean
643 elf32_h8_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
644 {
645 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
646 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
647 return TRUE;
648
649 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
650 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
651 {
652 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
653 bfd_get_mach (ibfd)))
654 return FALSE;
655 }
656
657 return TRUE;
658 }
659
660 /* This function handles relaxing for the H8..
661
662 There are a few relaxing opportunities available on the H8:
663
664 jmp/jsr:24 -> bra/bsr:8 2 bytes
665 The jmp may be completely eliminated if the previous insn is a
666 conditional branch to the insn after the jump. In that case
667 we invert the branch and delete the jump and save 4 bytes.
668
669 bCC:16 -> bCC:8 2 bytes
670 bsr:16 -> bsr:8 2 bytes
671
672 bset:16 -> bset:8 2 bytes
673 bset:24/32 -> bset:8 4 bytes
674 (also applicable to other bit manipulation instructions)
675
676 mov.b:16 -> mov.b:8 2 bytes
677 mov.b:24/32 -> mov.b:8 4 bytes
678
679 bset:24/32 -> bset:16 2 bytes
680 (also applicable to other bit manipulation instructions)
681
682 mov.[bwl]:24/32 -> mov.[bwl]:16 2 bytes
683
684 mov.[bwl] @(displ:24/32+ERx) -> mov.[bwl] @(displ:16+ERx) 4 bytes. */
685
686 static bfd_boolean
687 elf32_h8_relax_section (bfd *abfd, asection *sec,
688 struct bfd_link_info *link_info, bfd_boolean *again)
689 {
690 Elf_Internal_Shdr *symtab_hdr;
691 Elf_Internal_Rela *internal_relocs;
692 Elf_Internal_Rela *irel, *irelend;
693 bfd_byte *contents = NULL;
694 Elf_Internal_Sym *isymbuf = NULL;
695 static asection *last_input_section = NULL;
696 static Elf_Internal_Rela *last_reloc = NULL;
697
698 /* Assume nothing changes. */
699 *again = FALSE;
700
701 /* We don't have to do anything for a relocatable link, if
702 this section does not have relocs, or if this is not a
703 code section. */
704 if (bfd_link_relocatable (link_info)
705 || (sec->flags & SEC_RELOC) == 0
706 || sec->reloc_count == 0
707 || (sec->flags & SEC_CODE) == 0)
708 return TRUE;
709
710 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
711
712 /* Get a copy of the native relocations. */
713 internal_relocs = (_bfd_elf_link_read_relocs
714 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
715 link_info->keep_memory));
716 if (internal_relocs == NULL)
717 goto error_return;
718
719 if (sec != last_input_section)
720 last_reloc = NULL;
721
722 last_input_section = sec;
723
724 /* Walk through the relocs looking for relaxing opportunities. */
725 irelend = internal_relocs + sec->reloc_count;
726 for (irel = internal_relocs; irel < irelend; irel++)
727 {
728 bfd_vma symval;
729
730 {
731 arelent bfd_reloc;
732
733 elf32_h8_info_to_howto (abfd, &bfd_reloc, irel);
734 }
735 /* Keep track of the previous reloc so that we can delete
736 some long jumps created by the compiler. */
737 if (irel != internal_relocs)
738 last_reloc = irel - 1;
739
740 switch(ELF32_R_TYPE (irel->r_info))
741 {
742 case R_H8_DIR24R8:
743 case R_H8_PCREL16:
744 case R_H8_DIR16A8:
745 case R_H8_DIR24A8:
746 case R_H8_DIR32A16:
747 case R_H8_DISP32A16:
748 break;
749 default:
750 continue;
751 }
752
753 /* Get the section contents if we haven't done so already. */
754 if (contents == NULL)
755 {
756 /* Get cached copy if it exists. */
757 if (elf_section_data (sec)->this_hdr.contents != NULL)
758 contents = elf_section_data (sec)->this_hdr.contents;
759 else
760 {
761 /* Go get them off disk. */
762 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
763 goto error_return;
764 }
765 }
766
767 /* Read this BFD's local symbols if we haven't done so already. */
768 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
769 {
770 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
771 if (isymbuf == NULL)
772 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
773 symtab_hdr->sh_info, 0,
774 NULL, NULL, NULL);
775 if (isymbuf == NULL)
776 goto error_return;
777 }
778
779 /* Get the value of the symbol referred to by the reloc. */
780 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
781 {
782 /* A local symbol. */
783 Elf_Internal_Sym *isym;
784 asection *sym_sec;
785
786 isym = isymbuf + ELF32_R_SYM (irel->r_info);
787 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
788 symval = isym->st_value;
789 /* If the reloc is absolute, it will not have
790 a symbol or section associated with it. */
791 if (sym_sec)
792 symval += sym_sec->output_section->vma
793 + sym_sec->output_offset;
794 }
795 else
796 {
797 unsigned long indx;
798 struct elf_link_hash_entry *h;
799
800 /* An external symbol. */
801 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
802 h = elf_sym_hashes (abfd)[indx];
803 BFD_ASSERT (h != NULL);
804 if (h->root.type != bfd_link_hash_defined
805 && h->root.type != bfd_link_hash_defweak)
806 {
807 /* This appears to be a reference to an undefined
808 symbol. Just ignore it--it will be caught by the
809 regular reloc processing. */
810 continue;
811 }
812
813 symval = (h->root.u.def.value
814 + h->root.u.def.section->output_section->vma
815 + h->root.u.def.section->output_offset);
816 }
817
818 /* For simplicity of coding, we are going to modify the section
819 contents, the section relocs, and the BFD symbol table. We
820 must tell the rest of the code not to free up this
821 information. It would be possible to instead create a table
822 of changes which have to be made, as is done in coff-mips.c;
823 that would be more work, but would require less memory when
824 the linker is run. */
825 switch (ELF32_R_TYPE (irel->r_info))
826 {
827 /* Try to turn a 24-bit absolute branch/call into an 8-bit
828 pc-relative branch/call. */
829 case R_H8_DIR24R8:
830 {
831 bfd_vma value = symval + irel->r_addend;
832 bfd_vma dot, gap;
833
834 /* Get the address of this instruction. */
835 dot = (sec->output_section->vma
836 + sec->output_offset + irel->r_offset - 1);
837
838 /* Compute the distance from this insn to the branch target. */
839 gap = value - dot;
840
841 /* If the distance is within -126..+130 inclusive, then we can
842 relax this jump. +130 is valid since the target will move
843 two bytes closer if we do relax this branch. */
844 if ((int) gap >= -126 && (int) gap <= 130)
845 {
846 unsigned char code;
847
848 /* Note that we've changed the relocs, section contents,
849 etc. */
850 elf_section_data (sec)->relocs = internal_relocs;
851 elf_section_data (sec)->this_hdr.contents = contents;
852 symtab_hdr->contents = (unsigned char *) isymbuf;
853
854 /* Get the instruction code being relaxed. */
855 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
856
857 /* If the previous instruction conditionally jumped around
858 this instruction, we may be able to reverse the condition
859 and redirect the previous instruction to the target of
860 this instruction.
861
862 Such sequences are used by the compiler to deal with
863 long conditional branches.
864
865 Only perform this optimisation for jumps (code 0x5a) not
866 subroutine calls, as otherwise it could transform:
867
868 mov.w r0,r0
869 beq .L1
870 jsr @_bar
871 .L1: rts
872 _bar: rts
873 into:
874 mov.w r0,r0
875 bne _bar
876 rts
877 _bar: rts
878
879 which changes the call (jsr) into a branch (bne). */
880 if (code == 0x5a /* jmp24. */
881 && (int) gap <= 130
882 && (int) gap >= -128
883 && last_reloc
884 && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
885 && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
886 {
887 bfd_vma last_value;
888 asection *last_sym_sec;
889 Elf_Internal_Sym *last_sym;
890
891 /* We will need to examine the symbol used by the
892 previous relocation. */
893
894 last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
895 last_sym_sec
896 = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
897 last_value = (last_sym->st_value
898 + last_sym_sec->output_section->vma
899 + last_sym_sec->output_offset);
900
901 /* Verify that the previous relocation was for a
902 branch around this instruction and that no symbol
903 exists at the current location. */
904 if (last_value == dot + 4
905 && last_reloc->r_offset + 2 == irel->r_offset
906 && ! elf32_h8_symbol_address_p (abfd, sec, dot))
907 {
908 /* We can eliminate this jump. Twiddle the
909 previous relocation as necessary. */
910 irel->r_info
911 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
912 ELF32_R_TYPE (R_H8_NONE));
913
914 last_reloc->r_info
915 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
916 ELF32_R_TYPE (R_H8_PCREL8));
917 last_reloc->r_addend = irel->r_addend;
918
919 code = bfd_get_8 (abfd,
920 contents + last_reloc->r_offset - 1);
921 code ^= 1;
922 bfd_put_8 (abfd,
923 code,
924 contents + last_reloc->r_offset - 1);
925
926 /* Delete four bytes of data. */
927 if (!elf32_h8_relax_delete_bytes (abfd, sec,
928 irel->r_offset - 1,
929 4))
930 goto error_return;
931
932 *again = TRUE;
933 break;
934 }
935 }
936
937 if (code == 0x5e)
938 /* This is jsr24 */
939 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1); /* bsr8. */
940 else if (code == 0x5a)
941 /* This is jmp24 */
942 bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1); /* bra8. */
943 else
944 abort ();
945
946 /* Fix the relocation's type. */
947 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
948 R_H8_PCREL8);
949
950 /* Delete two bytes of data. */
951 if (!elf32_h8_relax_delete_bytes (abfd, sec,
952 irel->r_offset + 1, 2))
953 goto error_return;
954
955 /* That will change things, so, we should relax again.
956 Note that this is not required, and it may be slow. */
957 *again = TRUE;
958 }
959 break;
960 }
961
962 /* Try to turn a 16-bit pc-relative branch into a 8-bit pc-relative
963 branch. */
964 case R_H8_PCREL16:
965 {
966 bfd_vma value = symval + irel->r_addend;
967 bfd_vma dot;
968 bfd_vma gap;
969
970 /* Get the address of this instruction. */
971 dot = (sec->output_section->vma
972 + sec->output_offset
973 + irel->r_offset - 2);
974
975 gap = value - dot;
976
977 /* If the distance is within -126..+130 inclusive, then we can
978 relax this jump. +130 is valid since the target will move
979 two bytes closer if we do relax this branch. */
980 if ((int) gap >= -126 && (int) gap <= 130)
981 {
982 unsigned char code;
983
984 /* Note that we've changed the relocs, section contents,
985 etc. */
986 elf_section_data (sec)->relocs = internal_relocs;
987 elf_section_data (sec)->this_hdr.contents = contents;
988 symtab_hdr->contents = (unsigned char *) isymbuf;
989
990 /* Get the opcode. */
991 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
992
993 if (code == 0x58)
994 {
995 /* bCC:16 -> bCC:8 */
996 /* Get the second byte of the original insn, which
997 contains the condition code. */
998 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
999
1000 /* Compute the first byte of the relaxed
1001 instruction. The original sequence 0x58 0xX0
1002 is relaxed to 0x4X, where X represents the
1003 condition code. */
1004 code &= 0xf0;
1005 code >>= 4;
1006 code |= 0x40;
1007 bfd_put_8 (abfd, code, contents + irel->r_offset - 2); /* bCC:8. */
1008 }
1009 else if (code == 0x5c) /* bsr16. */
1010 /* This is bsr. */
1011 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2); /* bsr8. */
1012 else
1013 /* Might be MOVSD. */
1014 break;
1015
1016 /* Fix the relocation's type. */
1017 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1018 R_H8_PCREL8);
1019 irel->r_offset--;
1020
1021 /* Delete two bytes of data. */
1022 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1023 irel->r_offset + 1, 2))
1024 goto error_return;
1025
1026 /* That will change things, so, we should relax again.
1027 Note that this is not required, and it may be slow. */
1028 *again = TRUE;
1029 }
1030 break;
1031 }
1032
1033 /* This is a 16-bit absolute address in one of the following
1034 instructions:
1035
1036 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1037 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1038 "mov.b"
1039
1040 We may relax this into an 8-bit absolute address if it's in
1041 the right range. */
1042 case R_H8_DIR16A8:
1043 {
1044 bfd_vma value;
1045
1046 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1047 if (value >= 0xffffff00u)
1048 {
1049 unsigned char code;
1050 unsigned char temp_code;
1051
1052 /* Note that we've changed the relocs, section contents,
1053 etc. */
1054 elf_section_data (sec)->relocs = internal_relocs;
1055 elf_section_data (sec)->this_hdr.contents = contents;
1056 symtab_hdr->contents = (unsigned char *) isymbuf;
1057
1058 /* Get the opcode. */
1059 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1060
1061 /* All instructions with R_H8_DIR16A8 start with
1062 0x6a. */
1063 if (code != 0x6a)
1064 abort ();
1065
1066 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1067 /* If this is a mov.b instruction, clear the lower
1068 nibble, which contains the source/destination
1069 register number. */
1070 if ((temp_code & 0x10) != 0x10)
1071 temp_code &= 0xf0;
1072
1073 switch (temp_code)
1074 {
1075 case 0x00:
1076 /* This is mov.b @aa:16,Rd. */
1077 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1078 contents + irel->r_offset - 2);
1079 break;
1080 case 0x80:
1081 /* This is mov.b Rs,@aa:16. */
1082 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1083 contents + irel->r_offset - 2);
1084 break;
1085 case 0x18:
1086 /* This is a bit-maniputation instruction that
1087 stores one bit into memory, one of "bclr",
1088 "bist", "bnot", "bset", and "bst". */
1089 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1090 break;
1091 case 0x10:
1092 /* This is a bit-maniputation instruction that
1093 loads one bit from memory, one of "band",
1094 "biand", "bild", "bior", "bixor", "bld", "bor",
1095 "btst", and "bxor". */
1096 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1097 break;
1098 default:
1099 abort ();
1100 }
1101
1102 /* Fix the relocation's type. */
1103 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1104 R_H8_DIR8);
1105
1106 /* Move the relocation. */
1107 irel->r_offset--;
1108
1109 /* Delete two bytes of data. */
1110 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1111 irel->r_offset + 1, 2))
1112 goto error_return;
1113
1114 /* That will change things, so, we should relax again.
1115 Note that this is not required, and it may be slow. */
1116 *again = TRUE;
1117 }
1118 break;
1119 }
1120
1121 /* This is a 24-bit absolute address in one of the following
1122 instructions:
1123
1124 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1125 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1126 "mov.b"
1127
1128 We may relax this into an 8-bit absolute address if it's in
1129 the right range. */
1130 case R_H8_DIR24A8:
1131 {
1132 bfd_vma value;
1133
1134 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1135 if (value >= 0xffffff00u)
1136 {
1137 unsigned char code;
1138 unsigned char temp_code;
1139
1140 /* Note that we've changed the relocs, section contents,
1141 etc. */
1142 elf_section_data (sec)->relocs = internal_relocs;
1143 elf_section_data (sec)->this_hdr.contents = contents;
1144 symtab_hdr->contents = (unsigned char *) isymbuf;
1145
1146 /* Get the opcode. */
1147 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1148
1149 /* All instructions with R_H8_DIR24A8 start with
1150 0x6a. */
1151 if (code != 0x6a)
1152 abort ();
1153
1154 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1155
1156 /* If this is a mov.b instruction, clear the lower
1157 nibble, which contains the source/destination
1158 register number. */
1159 if ((temp_code & 0x30) != 0x30)
1160 temp_code &= 0xf0;
1161
1162 switch (temp_code)
1163 {
1164 case 0x20:
1165 /* This is mov.b @aa:24/32,Rd. */
1166 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1167 contents + irel->r_offset - 2);
1168 break;
1169 case 0xa0:
1170 /* This is mov.b Rs,@aa:24/32. */
1171 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1172 contents + irel->r_offset - 2);
1173 break;
1174 case 0x38:
1175 /* This is a bit-maniputation instruction that
1176 stores one bit into memory, one of "bclr",
1177 "bist", "bnot", "bset", and "bst". */
1178 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1179 break;
1180 case 0x30:
1181 /* This is a bit-maniputation instruction that
1182 loads one bit from memory, one of "band",
1183 "biand", "bild", "bior", "bixor", "bld", "bor",
1184 "btst", and "bxor". */
1185 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1186 break;
1187 default:
1188 abort();
1189 }
1190
1191 /* Fix the relocation's type. */
1192 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1193 R_H8_DIR8);
1194 irel->r_offset--;
1195
1196 /* Delete four bytes of data. */
1197 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1198 irel->r_offset + 1, 4))
1199 goto error_return;
1200
1201 /* That will change things, so, we should relax again.
1202 Note that this is not required, and it may be slow. */
1203 *again = TRUE;
1204 break;
1205 }
1206 }
1207
1208 /* Fall through. */
1209
1210 /* This is a 24-/32-bit absolute address in one of the
1211 following instructions:
1212
1213 "band", "bclr", "biand", "bild", "bior", "bist",
1214 "bixor", "bld", "bnot", "bor", "bset", "bst", "btst",
1215 "bxor", "ldc.w", "stc.w" and "mov.[bwl]"
1216
1217 We may relax this into an 16-bit absolute address if it's
1218 in the right range. */
1219 case R_H8_DIR32A16:
1220 {
1221 bfd_vma value;
1222
1223 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1224 if (value <= 0x7fff || value >= 0xffff8000u)
1225 {
1226 unsigned char code;
1227 unsigned char op0, op1, op2, op3;
1228 unsigned char *op_ptr;
1229
1230 /* Note that we've changed the relocs, section contents,
1231 etc. */
1232 elf_section_data (sec)->relocs = internal_relocs;
1233 elf_section_data (sec)->this_hdr.contents = contents;
1234 symtab_hdr->contents = (unsigned char *) isymbuf;
1235
1236 if (irel->r_offset >= 4)
1237 {
1238 /* Check for 4-byte MOVA relaxation (SH-specific). */
1239 int second_reloc = 0;
1240
1241 op_ptr = contents + irel->r_offset - 4;
1242
1243 if (last_reloc)
1244 {
1245 arelent bfd_reloc;
1246 reloc_howto_type *h;
1247 bfd_vma last_reloc_size;
1248
1249 elf32_h8_info_to_howto (abfd, &bfd_reloc, last_reloc);
1250 h = bfd_reloc.howto;
1251 last_reloc_size = 1 << h->size;
1252 if (last_reloc->r_offset + last_reloc_size
1253 == irel->r_offset)
1254 {
1255 op_ptr -= last_reloc_size;
1256 second_reloc = 1;
1257 }
1258 }
1259
1260 if (irel + 1 < irelend)
1261 {
1262 Elf_Internal_Rela *next_reloc = irel + 1;
1263 arelent bfd_reloc;
1264 reloc_howto_type *h;
1265 bfd_vma next_reloc_size;
1266
1267 elf32_h8_info_to_howto (abfd, &bfd_reloc, next_reloc);
1268 h = bfd_reloc.howto;
1269 next_reloc_size = 1 << h->size;
1270 if (next_reloc->r_offset + next_reloc_size
1271 == irel->r_offset)
1272 {
1273 op_ptr -= next_reloc_size;
1274 second_reloc = 1;
1275 }
1276 }
1277
1278 op0 = bfd_get_8 (abfd, op_ptr + 0);
1279 op1 = bfd_get_8 (abfd, op_ptr + 1);
1280 op2 = bfd_get_8 (abfd, op_ptr + 2);
1281 op3 = bfd_get_8 (abfd, op_ptr + 3);
1282
1283 if (op0 == 0x01
1284 && (op1 & 0xdf) == 0x5f
1285 && (op2 & 0x40) == 0x40
1286 && (op3 & 0x80) == 0x80)
1287 {
1288 if ((op2 & 0x08) == 0)
1289 second_reloc = 1;
1290
1291 if (second_reloc)
1292 {
1293 op3 &= ~0x08;
1294 bfd_put_8 (abfd, op3, op_ptr + 3);
1295 }
1296 else
1297 {
1298 op2 &= ~0x08;
1299 bfd_put_8 (abfd, op2, op_ptr + 2);
1300 }
1301 goto r_h8_dir32a16_common;
1302 }
1303 }
1304
1305 /* Now check for short version of MOVA. (SH-specific) */
1306 op_ptr = contents + irel->r_offset - 2;
1307 op0 = bfd_get_8 (abfd, op_ptr + 0);
1308 op1 = bfd_get_8 (abfd, op_ptr + 1);
1309
1310 if (op0 == 0x7a
1311 && (op1 & 0x88) == 0x80)
1312 {
1313 op1 |= 0x08;
1314 bfd_put_8 (abfd, op1, op_ptr + 1);
1315 goto r_h8_dir32a16_common;
1316 }
1317
1318 /* Get the opcode. */
1319 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1320
1321 /* Fix the opcode. For all the instructions that
1322 belong to this relaxation, we simply need to turn
1323 off bit 0x20 in the previous byte. */
1324 code &= ~0x20;
1325
1326 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1327
1328 r_h8_dir32a16_common:
1329 /* Fix the relocation's type. */
1330 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1331 R_H8_DIR16);
1332
1333 /* Delete two bytes of data. */
1334 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1335 irel->r_offset + 1, 2))
1336 goto error_return;
1337
1338 /* That will change things, so, we should relax again.
1339 Note that this is not required, and it may be slow. */
1340 *again = TRUE;
1341 }
1342 break; /* case R_H8_DIR32A16 */
1343 }
1344
1345 case R_H8_DISP32A16:
1346 /* mov.[bwl] @(displ:24/32+ERx) -> mov.[bwl] @(displ:16+ERx) 4 bytes
1347 It is assured that instruction uses at least 4 bytes opcode before
1348 reloc entry addressing mode "register indirect with displacement"
1349 relaxing options (all saving 4 bytes):
1350 0x78 0sss0000 0x6A 0010dddd disp:32 mov.b @(d:32,ERs),Rd ->
1351 0x6E 0sssdddd disp:16 mov.b @(d:16,ERs),Rd
1352 0x78 0sss0000 0x6B 0010dddd disp:32 mov.w @(d:32,ERs),Rd ->
1353 0x6F 0sssdddd disp:16 mov.w @(d:16,ERs),Rd
1354 0x01 0x00 0x78 0sss0000 0x6B 00100ddd disp:32 mov.l @(d:32,ERs),ERd ->
1355 0x01 0x00 0x6F 0sss0ddd disp:16 mov.l @(d:16,ERs),ERd
1356
1357 0x78 0ddd0000 0x6A 1010ssss disp:32 mov.b Rs,@(d:32,ERd) ->
1358 0x6E 1dddssss disp:16 mov.b Rs,@(d:16,ERd)
1359 0x78 0ddd0000 0x6B 1010ssss disp:32 mov.w Rs,@(d:32,ERd) ->
1360 0x6F 1dddssss disp:16 mov.w Rs,@(d:16,ERd)
1361 0x01 0x00 0x78 xddd0000 0x6B 10100sss disp:32 mov.l ERs,@(d:32,ERd) ->
1362 0x01 0x00 0x6F 1ddd0sss disp:16 mov.l ERs,@(d:16,ERd)
1363 mov.l prefix 0x01 0x00 can be left as is and mov.l handled same
1364 as mov.w/ */
1365 {
1366 bfd_vma value;
1367
1368 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1369 if (value <= 0x7fff || value >= 0xffff8000u)
1370 {
1371 unsigned char op0, op1, op2, op3, op0n, op1n;
1372 int relax = 0;
1373
1374 /* Note that we've changed the relocs, section contents,
1375 etc. */
1376 elf_section_data (sec)->relocs = internal_relocs;
1377 elf_section_data (sec)->this_hdr.contents = contents;
1378 symtab_hdr->contents = (unsigned char *) isymbuf;
1379
1380 if (irel->r_offset >= 4)
1381 {
1382 op0 = bfd_get_8 (abfd, contents + irel->r_offset - 4);
1383 op1 = bfd_get_8 (abfd, contents + irel->r_offset - 3);
1384 op2 = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1385 op3 = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1386
1387 if (op0 == 0x78)
1388 {
1389 switch(op2)
1390 {
1391 case 0x6A:
1392 if ((op1 & 0x8F) == 0x00 && (op3 & 0x70) == 0x20)
1393 {
1394 /* mov.b. */
1395 op0n = 0x6E;
1396 relax = 1;
1397 }
1398 break;
1399 case 0x6B:
1400 if ((op1 & 0x0F) == 0x00 && (op3 & 0x70) == 0x20)
1401 {
1402 /* mov.w/l. */
1403 op0n = 0x6F;
1404 relax = 1;
1405 }
1406 break;
1407 default:
1408 break;
1409 }
1410 }
1411 }
1412
1413 if (relax)
1414 {
1415 op1n = (op3 & 0x8F) | (op1 & 0x70);
1416 bfd_put_8 (abfd, op0n, contents + irel->r_offset - 4);
1417 bfd_put_8 (abfd, op1n, contents + irel->r_offset - 3);
1418
1419 /* Fix the relocation's type. */
1420 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_H8_DIR16);
1421 irel->r_offset -= 2;
1422
1423 /* Delete four bytes of data. */
1424 if (!elf32_h8_relax_delete_bytes (abfd, sec, irel->r_offset + 2, 4))
1425 goto error_return;
1426
1427 /* That will change things, so, we should relax again.
1428 Note that this is not required, and it may be slow. */
1429 *again = TRUE;
1430 }
1431 }
1432 }
1433 break;
1434
1435 default:
1436 break;
1437 }
1438 }
1439
1440 if (isymbuf != NULL
1441 && symtab_hdr->contents != (unsigned char *) isymbuf)
1442 {
1443 if (! link_info->keep_memory)
1444 free (isymbuf);
1445 else
1446 symtab_hdr->contents = (unsigned char *) isymbuf;
1447 }
1448
1449 if (contents != NULL
1450 && elf_section_data (sec)->this_hdr.contents != contents)
1451 {
1452 if (! link_info->keep_memory)
1453 free (contents);
1454 else
1455 {
1456 /* Cache the section contents for elf_link_input_bfd. */
1457 elf_section_data (sec)->this_hdr.contents = contents;
1458 }
1459 }
1460
1461 if (internal_relocs != NULL
1462 && elf_section_data (sec)->relocs != internal_relocs)
1463 free (internal_relocs);
1464
1465 return TRUE;
1466
1467 error_return:
1468 if (isymbuf != NULL
1469 && symtab_hdr->contents != (unsigned char *) isymbuf)
1470 free (isymbuf);
1471 if (contents != NULL
1472 && elf_section_data (sec)->this_hdr.contents != contents)
1473 free (contents);
1474 if (internal_relocs != NULL
1475 && elf_section_data (sec)->relocs != internal_relocs)
1476 free (internal_relocs);
1477 return FALSE;
1478 }
1479
1480 /* Delete some bytes from a section while relaxing. */
1481
1482 static bfd_boolean
1483 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count)
1484 {
1485 Elf_Internal_Shdr *symtab_hdr;
1486 unsigned int sec_shndx;
1487 bfd_byte *contents;
1488 Elf_Internal_Rela *irel, *irelend;
1489 Elf_Internal_Sym *isym;
1490 Elf_Internal_Sym *isymend;
1491 bfd_vma toaddr;
1492 struct elf_link_hash_entry **sym_hashes;
1493 struct elf_link_hash_entry **end_hashes;
1494 unsigned int symcount;
1495
1496 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1497
1498 contents = elf_section_data (sec)->this_hdr.contents;
1499
1500 toaddr = sec->size;
1501
1502 irel = elf_section_data (sec)->relocs;
1503 irelend = irel + sec->reloc_count;
1504
1505 /* Actually delete the bytes. */
1506 memmove (contents + addr, contents + addr + count,
1507 (size_t) (toaddr - addr - count));
1508 sec->size -= count;
1509
1510 /* Adjust all the relocs. */
1511 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1512 {
1513 /* Get the new reloc address. */
1514 if ((irel->r_offset > addr
1515 && irel->r_offset <= toaddr))
1516 irel->r_offset -= count;
1517 }
1518
1519 /* Adjust the local symbols defined in this section. */
1520 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1521 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1522 isymend = isym + symtab_hdr->sh_info;
1523 for (; isym < isymend; isym++)
1524 {
1525 if (isym->st_shndx == sec_shndx
1526 && isym->st_value > addr
1527 && isym->st_value <= toaddr)
1528 isym->st_value -= count;
1529 }
1530
1531 /* Now adjust the global symbols defined in this section. */
1532 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1533 - symtab_hdr->sh_info);
1534 sym_hashes = elf_sym_hashes (abfd);
1535 end_hashes = sym_hashes + symcount;
1536 for (; sym_hashes < end_hashes; sym_hashes++)
1537 {
1538 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1539
1540 if ((sym_hash->root.type == bfd_link_hash_defined
1541 || sym_hash->root.type == bfd_link_hash_defweak)
1542 && sym_hash->root.u.def.section == sec
1543 && sym_hash->root.u.def.value > addr
1544 && sym_hash->root.u.def.value <= toaddr)
1545 sym_hash->root.u.def.value -= count;
1546 }
1547
1548 return TRUE;
1549 }
1550
1551 /* Return TRUE if a symbol exists at the given address, else return
1552 FALSE. */
1553 static bfd_boolean
1554 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr)
1555 {
1556 Elf_Internal_Shdr *symtab_hdr;
1557 unsigned int sec_shndx;
1558 Elf_Internal_Sym *isym;
1559 Elf_Internal_Sym *isymend;
1560 struct elf_link_hash_entry **sym_hashes;
1561 struct elf_link_hash_entry **end_hashes;
1562 unsigned int symcount;
1563
1564 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1565
1566 /* Examine all the symbols. */
1567 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1568 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1569 isymend = isym + symtab_hdr->sh_info;
1570 for (; isym < isymend; isym++)
1571 {
1572 if (isym->st_shndx == sec_shndx
1573 && isym->st_value == addr)
1574 return TRUE;
1575 }
1576
1577 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1578 - symtab_hdr->sh_info);
1579 sym_hashes = elf_sym_hashes (abfd);
1580 end_hashes = sym_hashes + symcount;
1581 for (; sym_hashes < end_hashes; sym_hashes++)
1582 {
1583 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1584 if ((sym_hash->root.type == bfd_link_hash_defined
1585 || sym_hash->root.type == bfd_link_hash_defweak)
1586 && sym_hash->root.u.def.section == sec
1587 && sym_hash->root.u.def.value == addr)
1588 return TRUE;
1589 }
1590
1591 return FALSE;
1592 }
1593
1594 /* This is a version of bfd_generic_get_relocated_section_contents
1595 which uses elf32_h8_relocate_section. */
1596
1597 static bfd_byte *
1598 elf32_h8_get_relocated_section_contents (bfd *output_bfd,
1599 struct bfd_link_info *link_info,
1600 struct bfd_link_order *link_order,
1601 bfd_byte *data,
1602 bfd_boolean relocatable,
1603 asymbol **symbols)
1604 {
1605 Elf_Internal_Shdr *symtab_hdr;
1606 asection *input_section = link_order->u.indirect.section;
1607 bfd *input_bfd = input_section->owner;
1608 asection **sections = NULL;
1609 Elf_Internal_Rela *internal_relocs = NULL;
1610 Elf_Internal_Sym *isymbuf = NULL;
1611
1612 /* We only need to handle the case of relaxing, or of having a
1613 particular set of section contents, specially. */
1614 if (relocatable
1615 || elf_section_data (input_section)->this_hdr.contents == NULL)
1616 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1617 link_order, data,
1618 relocatable,
1619 symbols);
1620
1621 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1622
1623 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1624 (size_t) input_section->size);
1625
1626 if ((input_section->flags & SEC_RELOC) != 0
1627 && input_section->reloc_count > 0)
1628 {
1629 asection **secpp;
1630 Elf_Internal_Sym *isym, *isymend;
1631 bfd_size_type amt;
1632
1633 internal_relocs = (_bfd_elf_link_read_relocs
1634 (input_bfd, input_section, NULL,
1635 (Elf_Internal_Rela *) NULL, FALSE));
1636 if (internal_relocs == NULL)
1637 goto error_return;
1638
1639 if (symtab_hdr->sh_info != 0)
1640 {
1641 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1642 if (isymbuf == NULL)
1643 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1644 symtab_hdr->sh_info, 0,
1645 NULL, NULL, NULL);
1646 if (isymbuf == NULL)
1647 goto error_return;
1648 }
1649
1650 amt = symtab_hdr->sh_info;
1651 amt *= sizeof (asection *);
1652 sections = (asection **) bfd_malloc (amt);
1653 if (sections == NULL && amt != 0)
1654 goto error_return;
1655
1656 isymend = isymbuf + symtab_hdr->sh_info;
1657 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1658 {
1659 asection *isec;
1660
1661 if (isym->st_shndx == SHN_UNDEF)
1662 isec = bfd_und_section_ptr;
1663 else if (isym->st_shndx == SHN_ABS)
1664 isec = bfd_abs_section_ptr;
1665 else if (isym->st_shndx == SHN_COMMON)
1666 isec = bfd_com_section_ptr;
1667 else
1668 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1669
1670 *secpp = isec;
1671 }
1672
1673 if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1674 input_section, data, internal_relocs,
1675 isymbuf, sections))
1676 goto error_return;
1677
1678 if (sections != NULL)
1679 free (sections);
1680 if (isymbuf != NULL
1681 && symtab_hdr->contents != (unsigned char *) isymbuf)
1682 free (isymbuf);
1683 if (elf_section_data (input_section)->relocs != internal_relocs)
1684 free (internal_relocs);
1685 }
1686
1687 return data;
1688
1689 error_return:
1690 if (sections != NULL)
1691 free (sections);
1692 if (isymbuf != NULL
1693 && symtab_hdr->contents != (unsigned char *) isymbuf)
1694 free (isymbuf);
1695 if (internal_relocs != NULL
1696 && elf_section_data (input_section)->relocs != internal_relocs)
1697 free (internal_relocs);
1698 return NULL;
1699 }
1700
1701
1702 #define TARGET_BIG_SYM h8300_elf32_vec
1703 #define TARGET_BIG_NAME "elf32-h8300"
1704 #define ELF_ARCH bfd_arch_h8300
1705 #define ELF_MACHINE_CODE EM_H8_300
1706 #define ELF_MAXPAGESIZE 0x1
1707 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1708 #define bfd_elf32_bfd_reloc_name_lookup elf32_h8_reloc_name_lookup
1709 #define elf_info_to_howto elf32_h8_info_to_howto
1710 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1711
1712 /* So we can set/examine bits in e_flags to get the specific
1713 H8 architecture in use. */
1714 #define elf_backend_final_write_processing \
1715 elf32_h8_final_write_processing
1716 #define elf_backend_object_p \
1717 elf32_h8_object_p
1718 #define bfd_elf32_bfd_merge_private_bfd_data \
1719 elf32_h8_merge_private_bfd_data
1720
1721 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1722 defaults to using _bfd_generic_link_hash_table_create, but
1723 bfd_elf_size_dynamic_sections uses
1724 dynobj = elf_hash_table (info)->dynobj;
1725 and thus requires an elf hash table. */
1726 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1727
1728 /* Use an H8 specific linker, not the ELF generic linker. */
1729 #define elf_backend_relocate_section elf32_h8_relocate_section
1730 #define elf_backend_rela_normal 1
1731 #define elf_backend_can_gc_sections 1
1732
1733 /* And relaxing stuff. */
1734 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1735 #define bfd_elf32_bfd_get_relocated_section_contents \
1736 elf32_h8_get_relocated_section_contents
1737
1738 #define elf_symbol_leading_char '_'
1739
1740 #include "elf32-target.h"
1741
1742 #undef TARGET_BIG_SYM
1743 #define TARGET_BIG_SYM h8300_elf32_linux_vec
1744 #undef TARGET_BIG_NAME
1745 #define TARGET_BIG_NAME "elf32-h8300-linux"
1746 #undef elf_symbol_leading_char
1747 #define elf32_bed elf32_h8300_linux_bed
1748
1749 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.066683 seconds and 4 git commands to generate.