projects / deliverable / binutils-gdb.git / blob
? search:


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