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