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