?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2004-04-21 Andrew Cagney <cagney@redhat.com>
[binutils.git] / bfd / elf32-h8300.c
blob877da8a6a31858b9e1a7a4419ac6728943c4f4be
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 /* If this is the first time we have been called for this section,
683 initialize the cooked size. */
684 if (sec->_cooked_size == 0)
685 sec->_cooked_size = sec->_raw_size;
686
687 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
688
689 /* Get a copy of the native relocations. */
690 internal_relocs = (_bfd_elf_link_read_relocs
691 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
692 link_info->keep_memory));
693 if (internal_relocs == NULL)
694 goto error_return;
695
696 if (sec != last_input_section)
697 last_reloc = NULL;
698
699 last_input_section = sec;
700
701 /* Walk through the relocs looking for relaxing opportunities. */
702 irelend = internal_relocs + sec->reloc_count;
703 for (irel = internal_relocs; irel < irelend; irel++)
704 {
705 bfd_vma symval;
706
707 /* Keep track of the previous reloc so that we can delete
708 some long jumps created by the compiler. */
709 if (irel != internal_relocs)
710 last_reloc = irel - 1;
711
712 if (ELF32_R_TYPE (irel->r_info) != R_H8_DIR24R8
713 && ELF32_R_TYPE (irel->r_info) != R_H8_PCREL16
714 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR16A8
715 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR24A8
716 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR32A16)
717 continue;
718
719 /* Get the section contents if we haven't done so already. */
720 if (contents == NULL)
721 {
722 /* Get cached copy if it exists. */
723 if (elf_section_data (sec)->this_hdr.contents != NULL)
724 contents = elf_section_data (sec)->this_hdr.contents;
725 else
726 {
727 /* Go get them off disk. */
728 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
729 if (contents == NULL)
730 goto error_return;
731
732 if (! bfd_get_section_contents (abfd, sec, contents,
733 (file_ptr) 0, sec->_raw_size))
734 goto error_return;
735 }
736 }
737
738 /* Read this BFD's local symbols if we haven't done so already. */
739 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
740 {
741 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
742 if (isymbuf == NULL)
743 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
744 symtab_hdr->sh_info, 0,
745 NULL, NULL, NULL);
746 if (isymbuf == NULL)
747 goto error_return;
748 }
749
750 /* Get the value of the symbol referred to by the reloc. */
751 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
752 {
753 /* A local symbol. */
754 Elf_Internal_Sym *isym;
755 asection *sym_sec;
756
757 isym = isymbuf + ELF32_R_SYM (irel->r_info);
758 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
759 symval = isym->st_value;
760 /* If the reloc is absolute, it will not have
761 a symbol or section associated with it. */
762 if (sym_sec)
763 symval += sym_sec->output_section->vma
764 + sym_sec->output_offset;
765 }
766 else
767 {
768 unsigned long indx;
769 struct elf_link_hash_entry *h;
770
771 /* An external symbol. */
772 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
773 h = elf_sym_hashes (abfd)[indx];
774 BFD_ASSERT (h != NULL);
775 if (h->root.type != bfd_link_hash_defined
776 && h->root.type != bfd_link_hash_defweak)
777 {
778 /* This appears to be a reference to an undefined
779 symbol. Just ignore it--it will be caught by the
780 regular reloc processing. */
781 continue;
782 }
783
784 symval = (h->root.u.def.value
785 + h->root.u.def.section->output_section->vma
786 + h->root.u.def.section->output_offset);
787 }
788
789 /* For simplicity of coding, we are going to modify the section
790 contents, the section relocs, and the BFD symbol table. We
791 must tell the rest of the code not to free up this
792 information. It would be possible to instead create a table
793 of changes which have to be made, as is done in coff-mips.c;
794 that would be more work, but would require less memory when
795 the linker is run. */
796 switch (ELF32_R_TYPE (irel->r_info))
797 {
798 /* Try to turn a 24-bit absolute branch/call into an 8-bit
799 pc-relative branch/call. */
800 case R_H8_DIR24R8:
801 {
802 bfd_vma value = symval + irel->r_addend;
803 bfd_vma dot, gap;
804
805 /* Get the address of this instruction. */
806 dot = (sec->output_section->vma
807 + sec->output_offset + irel->r_offset - 1);
808
809 /* Compute the distance from this insn to the branch target. */
810 gap = value - dot;
811
812 /* If the distance is within -126..+130 inclusive, then we can
813 relax this jump. +130 is valid since the target will move
814 two bytes closer if we do relax this branch. */
815 if ((int) gap >= -126 && (int) gap <= 130)
816 {
817 unsigned char code;
818
819 /* Note that we've changed the relocs, section contents,
820 etc. */
821 elf_section_data (sec)->relocs = internal_relocs;
822 elf_section_data (sec)->this_hdr.contents = contents;
823 symtab_hdr->contents = (unsigned char *) isymbuf;
824
825 /* Get the instruction code being relaxed. */
826 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
827
828 /* If the previous instruction conditionally jumped around
829 this instruction, we may be able to reverse the condition
830 and redirect the previous instruction to the target of
831 this instruction.
832
833 Such sequences are used by the compiler to deal with
834 long conditional branches.
835
836 Only perform this optimisation for jumps (code 0x5a) not
837 subroutine calls, as otherwise it could transform:
838
839 mov.w r0,r0
840 beq .L1
841 jsr @_bar
842 .L1: rts
843 _bar: rts
844 into:
845 mov.w r0,r0
846 bne _bar
847 rts
848 _bar: rts
849
850 which changes the call (jsr) into a branch (bne). */
851 if (code == 0x5a
852 && (int) gap <= 130
853 && (int) gap >= -128
854 && last_reloc
855 && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
856 && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
857 {
858 bfd_vma last_value;
859 asection *last_sym_sec;
860 Elf_Internal_Sym *last_sym;
861
862 /* We will need to examine the symbol used by the
863 previous relocation. */
864
865 last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
866 last_sym_sec
867 = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
868 last_value = (last_sym->st_value
869 + last_sym_sec->output_section->vma
870 + last_sym_sec->output_offset);
871
872 /* Verify that the previous relocation was for a
873 branch around this instruction and that no symbol
874 exists at the current location. */
875 if (last_value == dot + 4
876 && last_reloc->r_offset + 2 == irel->r_offset
877 && ! elf32_h8_symbol_address_p (abfd, sec, dot))
878 {
879 /* We can eliminate this jump. Twiddle the
880 previous relocation as necessary. */
881 irel->r_info
882 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
883 ELF32_R_TYPE (R_H8_NONE));
884
885 last_reloc->r_info
886 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
887 ELF32_R_TYPE (R_H8_PCREL8));
888 last_reloc->r_addend = irel->r_addend;
889
890 code = bfd_get_8 (abfd,
891 contents + last_reloc->r_offset - 1);
892 code ^= 1;
893 bfd_put_8 (abfd,
894 code,
895 contents + last_reloc->r_offset - 1);
896
897 /* Delete four bytes of data. */
898 if (!elf32_h8_relax_delete_bytes (abfd, sec,
899 irel->r_offset - 1,
900 4))
901 goto error_return;
902
903 *again = TRUE;
904 break;
905 }
906 }
907
908 if (code == 0x5e)
909 /* This is jsr. */
910 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);
911 else if (code == 0x5a)
912 /* This is jmp. */
913 bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1);
914 else
915 abort ();
916
917 /* Fix the relocation's type. */
918 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
919 R_H8_PCREL8);
920
921 /* Delete two bytes of data. */
922 if (!elf32_h8_relax_delete_bytes (abfd, sec,
923 irel->r_offset + 1, 2))
924 goto error_return;
925
926 /* That will change things, so, we should relax again.
927 Note that this is not required, and it may be slow. */
928 *again = TRUE;
929 }
930 break;
931 }
932
933 /* Try to turn a 16-bit pc-relative branch into a 8-bit pc-relative
934 branch. */
935 case R_H8_PCREL16:
936 {
937 bfd_vma value = symval + irel->r_addend;
938 bfd_vma dot;
939 bfd_vma gap;
940
941 /* Get the address of this instruction. */
942 dot = (sec->output_section->vma
943 + sec->output_offset
944 + irel->r_offset - 2);
945
946 gap = value - dot;
947
948 /* If the distance is within -126..+130 inclusive, then we can
949 relax this jump. +130 is valid since the target will move
950 two bytes closer if we do relax this branch. */
951 if ((int) gap >= -126 && (int) gap <= 130)
952 {
953 unsigned char code;
954
955 /* Note that we've changed the relocs, section contents,
956 etc. */
957 elf_section_data (sec)->relocs = internal_relocs;
958 elf_section_data (sec)->this_hdr.contents = contents;
959 symtab_hdr->contents = (unsigned char *) isymbuf;
960
961 /* Get the opcode. */
962 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
963
964 if (code == 0x58)
965 {
966 /* bCC:16 -> bCC:8 */
967 /* Get the second byte of the original insn, which
968 contains the condition code. */
969 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
970
971 /* Compute the fisrt byte of the relaxed
972 instruction. The original sequence 0x58 0xX0
973 is relaxed to 0x4X, where X represents the
974 condition code. */
975 code &= 0xf0;
976 code >>= 4;
977 code |= 0x40;
978 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
979 }
980 else if (code == 0x5c)
981 /* This is bsr. */
982 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);
983 else
984 abort ();
985
986 /* Fix the relocation's type. */
987 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
988 R_H8_PCREL8);
989 irel->r_offset--;
990
991 /* Delete two bytes of data. */
992 if (!elf32_h8_relax_delete_bytes (abfd, sec,
993 irel->r_offset + 1, 2))
994 goto error_return;
995
996 /* That will change things, so, we should relax again.
997 Note that this is not required, and it may be slow. */
998 *again = TRUE;
999 }
1000 break;
1001 }
1002
1003 /* This is a 16-bit absolute address in one of the following
1004 instructions:
1005
1006 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1007 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1008 "mov.b"
1009
1010 We may relax this into an 8-bit absolute address if it's in
1011 the right range. */
1012 case R_H8_DIR16A8:
1013 {
1014 bfd_vma value;
1015
1016 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1017 if (value >= 0xffffff00u)
1018 {
1019 unsigned char code;
1020 unsigned char temp_code;
1021
1022 /* Note that we've changed the relocs, section contents,
1023 etc. */
1024 elf_section_data (sec)->relocs = internal_relocs;
1025 elf_section_data (sec)->this_hdr.contents = contents;
1026 symtab_hdr->contents = (unsigned char *) isymbuf;
1027
1028 /* Get the opcode. */
1029 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1030
1031 /* All instructions with R_H8_DIR16A8 start with
1032 0x6a. */
1033 if (code != 0x6a)
1034 abort ();
1035
1036 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1037 /* If this is a mov.b instruction, clear the lower
1038 nibble, which contains the source/destination
1039 register number. */
1040 if ((temp_code & 0x10) != 0x10)
1041 temp_code &= 0xf0;
1042
1043 switch (temp_code)
1044 {
1045 case 0x00:
1046 /* This is mov.b @aa:16,Rd. */
1047 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1048 contents + irel->r_offset - 2);
1049 break;
1050 case 0x80:
1051 /* This is mov.b Rs,@aa:16. */
1052 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1053 contents + irel->r_offset - 2);
1054 break;
1055 case 0x18:
1056 /* This is a bit-maniputation instruction that
1057 stores one bit into memory, one of "bclr",
1058 "bist", "bnot", "bset", and "bst". */
1059 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1060 break;
1061 case 0x10:
1062 /* This is a bit-maniputation instruction that
1063 loads one bit from memory, one of "band",
1064 "biand", "bild", "bior", "bixor", "bld", "bor",
1065 "btst", and "bxor". */
1066 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1067 break;
1068 default:
1069 abort ();
1070 }
1071
1072 /* Fix the relocation's type. */
1073 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1074 R_H8_DIR8);
1075
1076 /* Move the relocation. */
1077 irel->r_offset--;
1078
1079 /* Delete two bytes of data. */
1080 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1081 irel->r_offset + 1, 2))
1082 goto error_return;
1083
1084 /* That will change things, so, we should relax again.
1085 Note that this is not required, and it may be slow. */
1086 *again = TRUE;
1087 }
1088 break;
1089 }
1090
1091 /* This is a 24-bit absolute address in one of the following
1092 instructions:
1093
1094 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1095 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1096 "mov.b"
1097
1098 We may relax this into an 8-bit absolute address if it's in
1099 the right range. */
1100 case R_H8_DIR24A8:
1101 {
1102 bfd_vma value;
1103
1104 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1105 if (value >= 0xffffff00u)
1106 {
1107 unsigned char code;
1108 unsigned char temp_code;
1109
1110 /* Note that we've changed the relocs, section contents,
1111 etc. */
1112 elf_section_data (sec)->relocs = internal_relocs;
1113 elf_section_data (sec)->this_hdr.contents = contents;
1114 symtab_hdr->contents = (unsigned char *) isymbuf;
1115
1116 /* Get the opcode. */
1117 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1118
1119 /* All instructions with R_H8_DIR24A8 start with
1120 0x6a. */
1121 if (code != 0x6a)
1122 abort ();
1123
1124 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1125
1126 /* If this is a mov.b instruction, clear the lower
1127 nibble, which contains the source/destination
1128 register number. */
1129 if ((temp_code & 0x30) != 0x30)
1130 temp_code &= 0xf0;
1131
1132 switch (temp_code)
1133 {
1134 case 0x20:
1135 /* This is mov.b @aa:24/32,Rd. */
1136 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1137 contents + irel->r_offset - 2);
1138 break;
1139 case 0xa0:
1140 /* This is mov.b Rs,@aa:24/32. */
1141 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1142 contents + irel->r_offset - 2);
1143 break;
1144 case 0x38:
1145 /* This is a bit-maniputation instruction that
1146 stores one bit into memory, one of "bclr",
1147 "bist", "bnot", "bset", and "bst". */
1148 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1149 break;
1150 case 0x30:
1151 /* This is a bit-maniputation instruction that
1152 loads one bit from memory, one of "band",
1153 "biand", "bild", "bior", "bixor", "bld", "bor",
1154 "btst", and "bxor". */
1155 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1156 break;
1157 default:
1158 abort();
1159 }
1160
1161 /* Fix the relocation's type. */
1162 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1163 R_H8_DIR8);
1164 irel->r_offset--;
1165
1166 /* Delete two bytes of data. */
1167 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1168 irel->r_offset + 1, 4))
1169 goto error_return;
1170
1171 /* That will change things, so, we should relax again.
1172 Note that this is not required, and it may be slow. */
1173 *again = TRUE;
1174 break;
1175 }
1176 }
1177
1178 /* Fall through. */
1179
1180 /* This is a 24-/32-bit absolute address in one of the
1181 following instructions:
1182
1183 "band", "bclr", "biand", "bild", "bior", "bist",
1184 "bixor", "bld", "bnot", "bor", "bset", "bst", "btst",
1185 "bxor", "ldc.w", "stc.w" and "mov.[bwl]"
1186
1187 We may relax this into an 16-bit absolute address if it's
1188 in the right range. */
1189 case R_H8_DIR32A16:
1190 {
1191 bfd_vma value;
1192
1193 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1194 if (value <= 0x7fff || value >= 0xffff8000u)
1195 {
1196 unsigned char code;
1197
1198 /* Note that we've changed the relocs, section contents,
1199 etc. */
1200 elf_section_data (sec)->relocs = internal_relocs;
1201 elf_section_data (sec)->this_hdr.contents = contents;
1202 symtab_hdr->contents = (unsigned char *) isymbuf;
1203
1204 /* Get the opcode. */
1205 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1206
1207 /* Fix the opcode. For all the instructions that
1208 belong to this relaxation, we simply need to turn
1209 off bit 0x20 in the previous byte. */
1210 code &= ~0x20;
1211
1212 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1213
1214 /* Fix the relocation's type. */
1215 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1216 R_H8_DIR16);
1217
1218 /* Delete two bytes of data. */
1219 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1220 irel->r_offset + 1, 2))
1221 goto error_return;
1222
1223 /* That will change things, so, we should relax again.
1224 Note that this is not required, and it may be slow. */
1225 *again = TRUE;
1226 }
1227 break;
1228 }
1229
1230 default:
1231 break;
1232 }
1233 }
1234
1235 if (isymbuf != NULL
1236 && symtab_hdr->contents != (unsigned char *) isymbuf)
1237 {
1238 if (! link_info->keep_memory)
1239 free (isymbuf);
1240 else
1241 symtab_hdr->contents = (unsigned char *) isymbuf;
1242 }
1243
1244 if (contents != NULL
1245 && elf_section_data (sec)->this_hdr.contents != contents)
1246 {
1247 if (! link_info->keep_memory)
1248 free (contents);
1249 else
1250 {
1251 /* Cache the section contents for elf_link_input_bfd. */
1252 elf_section_data (sec)->this_hdr.contents = contents;
1253 }
1254 }
1255
1256 if (internal_relocs != NULL
1257 && elf_section_data (sec)->relocs != internal_relocs)
1258 free (internal_relocs);
1259
1260 return TRUE;
1261
1262 error_return:
1263 if (isymbuf != NULL
1264 && symtab_hdr->contents != (unsigned char *) isymbuf)
1265 free (isymbuf);
1266 if (contents != NULL
1267 && elf_section_data (sec)->this_hdr.contents != contents)
1268 free (contents);
1269 if (internal_relocs != NULL
1270 && elf_section_data (sec)->relocs != internal_relocs)
1271 free (internal_relocs);
1272 return FALSE;
1273 }
1274
1275 /* Delete some bytes from a section while relaxing. */
1276
1277 static bfd_boolean
1278 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count)
1279 {
1280 Elf_Internal_Shdr *symtab_hdr;
1281 unsigned int sec_shndx;
1282 bfd_byte *contents;
1283 Elf_Internal_Rela *irel, *irelend;
1284 Elf_Internal_Rela *irelalign;
1285 Elf_Internal_Sym *isym;
1286 Elf_Internal_Sym *isymend;
1287 bfd_vma toaddr;
1288 struct elf_link_hash_entry **sym_hashes;
1289 struct elf_link_hash_entry **end_hashes;
1290 unsigned int symcount;
1291
1292 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1293
1294 contents = elf_section_data (sec)->this_hdr.contents;
1295
1296 /* The deletion must stop at the next ALIGN reloc for an aligment
1297 power larger than the number of bytes we are deleting. */
1298
1299 irelalign = NULL;
1300 toaddr = sec->_cooked_size;
1301
1302 irel = elf_section_data (sec)->relocs;
1303 irelend = irel + sec->reloc_count;
1304
1305 /* Actually delete the bytes. */
1306 memmove (contents + addr, contents + addr + count,
1307 (size_t) (toaddr - addr - count));
1308 sec->_cooked_size -= count;
1309
1310 /* Adjust all the relocs. */
1311 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1312 {
1313 /* Get the new reloc address. */
1314 if ((irel->r_offset > addr
1315 && irel->r_offset < toaddr))
1316 irel->r_offset -= count;
1317 }
1318
1319 /* Adjust the local symbols defined in this section. */
1320 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1321 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1322 isymend = isym + symtab_hdr->sh_info;
1323 for (; isym < isymend; isym++)
1324 {
1325 if (isym->st_shndx == sec_shndx
1326 && isym->st_value > addr
1327 && isym->st_value < toaddr)
1328 isym->st_value -= count;
1329 }
1330
1331 /* Now adjust the global symbols defined in this section. */
1332 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1333 - symtab_hdr->sh_info);
1334 sym_hashes = elf_sym_hashes (abfd);
1335 end_hashes = sym_hashes + symcount;
1336 for (; sym_hashes < end_hashes; sym_hashes++)
1337 {
1338 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1339 if ((sym_hash->root.type == bfd_link_hash_defined
1340 || sym_hash->root.type == bfd_link_hash_defweak)
1341 && sym_hash->root.u.def.section == sec
1342 && sym_hash->root.u.def.value > addr
1343 && sym_hash->root.u.def.value < toaddr)
1344 {
1345 sym_hash->root.u.def.value -= count;
1346 }
1347 }
1348
1349 return TRUE;
1350 }
1351
1352 /* Return TRUE if a symbol exists at the given address, else return
1353 FALSE. */
1354 static bfd_boolean
1355 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr)
1356 {
1357 Elf_Internal_Shdr *symtab_hdr;
1358 unsigned int sec_shndx;
1359 Elf_Internal_Sym *isym;
1360 Elf_Internal_Sym *isymend;
1361 struct elf_link_hash_entry **sym_hashes;
1362 struct elf_link_hash_entry **end_hashes;
1363 unsigned int symcount;
1364
1365 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1366
1367 /* Examine all the symbols. */
1368 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1369 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1370 isymend = isym + symtab_hdr->sh_info;
1371 for (; isym < isymend; isym++)
1372 {
1373 if (isym->st_shndx == sec_shndx
1374 && isym->st_value == addr)
1375 return TRUE;
1376 }
1377
1378 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1379 - symtab_hdr->sh_info);
1380 sym_hashes = elf_sym_hashes (abfd);
1381 end_hashes = sym_hashes + symcount;
1382 for (; sym_hashes < end_hashes; sym_hashes++)
1383 {
1384 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1385 if ((sym_hash->root.type == bfd_link_hash_defined
1386 || sym_hash->root.type == bfd_link_hash_defweak)
1387 && sym_hash->root.u.def.section == sec
1388 && sym_hash->root.u.def.value == addr)
1389 return TRUE;
1390 }
1391
1392 return FALSE;
1393 }
1394
1395 /* This is a version of bfd_generic_get_relocated_section_contents
1396 which uses elf32_h8_relocate_section. */
1397
1398 static bfd_byte *
1399 elf32_h8_get_relocated_section_contents (bfd *output_bfd,
1400 struct bfd_link_info *link_info,
1401 struct bfd_link_order *link_order,
1402 bfd_byte *data,
1403 bfd_boolean relocatable,
1404 asymbol **symbols)
1405 {
1406 Elf_Internal_Shdr *symtab_hdr;
1407 asection *input_section = link_order->u.indirect.section;
1408 bfd *input_bfd = input_section->owner;
1409 asection **sections = NULL;
1410 Elf_Internal_Rela *internal_relocs = NULL;
1411 Elf_Internal_Sym *isymbuf = NULL;
1412
1413 /* We only need to handle the case of relaxing, or of having a
1414 particular set of section contents, specially. */
1415 if (relocatable
1416 || elf_section_data (input_section)->this_hdr.contents == NULL)
1417 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1418 link_order, data,
1419 relocatable,
1420 symbols);
1421
1422 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1423
1424 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1425 (size_t) input_section->_raw_size);
1426
1427 if ((input_section->flags & SEC_RELOC) != 0
1428 && input_section->reloc_count > 0)
1429 {
1430 asection **secpp;
1431 Elf_Internal_Sym *isym, *isymend;
1432 bfd_size_type amt;
1433
1434 internal_relocs = (_bfd_elf_link_read_relocs
1435 (input_bfd, input_section, (PTR) NULL,
1436 (Elf_Internal_Rela *) NULL, FALSE));
1437 if (internal_relocs == NULL)
1438 goto error_return;
1439
1440 if (symtab_hdr->sh_info != 0)
1441 {
1442 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1443 if (isymbuf == NULL)
1444 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1445 symtab_hdr->sh_info, 0,
1446 NULL, NULL, NULL);
1447 if (isymbuf == NULL)
1448 goto error_return;
1449 }
1450
1451 amt = symtab_hdr->sh_info;
1452 amt *= sizeof (asection *);
1453 sections = (asection **) bfd_malloc (amt);
1454 if (sections == NULL && amt != 0)
1455 goto error_return;
1456
1457 isymend = isymbuf + symtab_hdr->sh_info;
1458 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1459 {
1460 asection *isec;
1461
1462 if (isym->st_shndx == SHN_UNDEF)
1463 isec = bfd_und_section_ptr;
1464 else if (isym->st_shndx == SHN_ABS)
1465 isec = bfd_abs_section_ptr;
1466 else if (isym->st_shndx == SHN_COMMON)
1467 isec = bfd_com_section_ptr;
1468 else
1469 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1470
1471 *secpp = isec;
1472 }
1473
1474 if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1475 input_section, data, internal_relocs,
1476 isymbuf, sections))
1477 goto error_return;
1478
1479 if (sections != NULL)
1480 free (sections);
1481 if (isymbuf != NULL
1482 && symtab_hdr->contents != (unsigned char *) isymbuf)
1483 free (isymbuf);
1484 if (elf_section_data (input_section)->relocs != internal_relocs)
1485 free (internal_relocs);
1486 }
1487
1488 return data;
1489
1490 error_return:
1491 if (sections != NULL)
1492 free (sections);
1493 if (isymbuf != NULL
1494 && symtab_hdr->contents != (unsigned char *) isymbuf)
1495 free (isymbuf);
1496 if (internal_relocs != NULL
1497 && elf_section_data (input_section)->relocs != internal_relocs)
1498 free (internal_relocs);
1499 return NULL;
1500 }
1501
1502 static asection *
1503 elf32_h8_gc_mark_hook (asection *sec,
1504 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1505 Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
1506 struct elf_link_hash_entry *h,
1507 Elf_Internal_Sym *sym)
1508 {
1509 if (h != NULL)
1510 {
1511 switch (h->root.type)
1512 {
1513 case bfd_link_hash_defined:
1514 case bfd_link_hash_defweak:
1515 return h->root.u.def.section;
1516
1517 case bfd_link_hash_common:
1518 return h->root.u.c.p->section;
1519
1520 default:
1521 break;
1522 }
1523 }
1524 else
1525 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1526 return NULL;
1527 }
1528
1529 static bfd_boolean
1530 elf32_h8_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
1531 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1532 asection *sec ATTRIBUTE_UNUSED,
1533 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
1534 {
1535 return TRUE;
1536 }
1537
1538
1539 #define TARGET_BIG_SYM bfd_elf32_h8300_vec
1540 #define TARGET_BIG_NAME "elf32-h8300"
1541 #define ELF_ARCH bfd_arch_h8300
1542 #define ELF_MACHINE_CODE EM_H8_300
1543 #define ELF_MAXPAGESIZE 0x1
1544 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1545 #define elf_info_to_howto elf32_h8_info_to_howto
1546 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1547
1548 /* So we can set/examine bits in e_flags to get the specific
1549 H8 architecture in use. */
1550 #define elf_backend_final_write_processing \
1551 elf32_h8_final_write_processing
1552 #define elf_backend_object_p \
1553 elf32_h8_object_p
1554 #define bfd_elf32_bfd_merge_private_bfd_data \
1555 elf32_h8_merge_private_bfd_data
1556 #define elf_backend_gc_mark_hook elf32_h8_gc_mark_hook
1557 #define elf_backend_gc_sweep_hook elf32_h8_gc_sweep_hook
1558
1559 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1560 defaults to using _bfd_generic_link_hash_table_create, but
1561 bfd_elf_size_dynamic_sections uses
1562 dynobj = elf_hash_table (info)->dynobj;
1563 and thus requires an elf hash table. */
1564 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1565
1566 /* Use an H8 specific linker, not the ELF generic linker. */
1567 #define elf_backend_relocate_section elf32_h8_relocate_section
1568 #define elf_backend_rela_normal 1
1569 #define elf_backend_can_gc_sections 1
1570
1571 /* And relaxing stuff. */
1572 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1573 #define bfd_elf32_bfd_get_relocated_section_contents \
1574 elf32_h8_get_relocated_section_contents
1575
1576
1577 #include "elf32-target.h"
git-cvsimport of binutils cvsroot