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