projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
2003-05-16 Michael Snyder <msnyder@redhat.com>
[binutils-gdb.git] / bfd / elf32-h8300.c
1 /* BFD back-end for Renesas H8/300 ELF binaries.
2 Copyright 1993, 1995, 1998, 1999, 2001, 2002, 2003
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 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
29 static void elf32_h8_info_to_howto
30 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
31 static void elf32_h8_info_to_howto_rel
32 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
33 static unsigned long elf32_h8_mach
34 PARAMS ((flagword));
35 static void elf32_h8_final_write_processing
36 PARAMS ((bfd *, bfd_boolean));
37 static bfd_boolean elf32_h8_object_p
38 PARAMS ((bfd *));
39 static bfd_boolean elf32_h8_merge_private_bfd_data
40 PARAMS ((bfd *, bfd *));
41 static bfd_boolean elf32_h8_relax_section
42 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
43 static bfd_boolean elf32_h8_relax_delete_bytes
44 PARAMS ((bfd *, asection *, bfd_vma, int));
45 static bfd_boolean elf32_h8_symbol_address_p
46 PARAMS ((bfd *, asection *, bfd_vma));
47 static bfd_byte *elf32_h8_get_relocated_section_contents
48 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
49 bfd_byte *, bfd_boolean, asymbol **));
50 static bfd_reloc_status_type elf32_h8_final_link_relocate
51 PARAMS ((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 PARAMS ((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 PARAMS ((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_DIR32", /* 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 SH 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 (abfd, code)
247 bfd *abfd ATTRIBUTE_UNUSED;
248 bfd_reloc_code_real_type code;
249 {
250 unsigned int i;
251
252 for (i = 0; i < sizeof (h8_reloc_map) / sizeof (struct elf_reloc_map); i++)
253 {
254 if (h8_reloc_map[i].bfd_reloc_val == code)
255 return &h8_elf_howto_table[(int) h8_reloc_map[i].howto_index];
256 }
257 return NULL;
258 }
259
260 static void
261 elf32_h8_info_to_howto (abfd, bfd_reloc, elf_reloc)
262 bfd *abfd ATTRIBUTE_UNUSED;
263 arelent *bfd_reloc;
264 Elf_Internal_Rela *elf_reloc;
265 {
266 unsigned int r;
267 unsigned int i;
268
269 r = ELF32_R_TYPE (elf_reloc->r_info);
270 for (i = 0; i < sizeof (h8_elf_howto_table) / sizeof (reloc_howto_type); i++)
271 if (h8_elf_howto_table[i].type == r)
272 {
273 bfd_reloc->howto = &h8_elf_howto_table[i];
274 return;
275 }
276 abort ();
277 }
278
279 static void
280 elf32_h8_info_to_howto_rel (abfd, bfd_reloc, elf_reloc)
281 bfd *abfd ATTRIBUTE_UNUSED;
282 arelent *bfd_reloc;
283 Elf_Internal_Rela *elf_reloc ATTRIBUTE_UNUSED;
284 {
285 unsigned int r;
286
287 abort ();
288 r = ELF32_R_TYPE (elf_reloc->r_info);
289 bfd_reloc->howto = &h8_elf_howto_table[r];
290 }
291
292 /* Special handling for H8/300 relocs.
293 We only come here for pcrel stuff and return normally if not an -r link.
294 When doing -r, we can't do any arithmetic for the pcrel stuff, because
295 we support relaxing on the H8/300 series chips. */
296 static bfd_reloc_status_type
297 special (abfd, reloc_entry, symbol, data, input_section, output_bfd,
298 error_message)
299 bfd *abfd ATTRIBUTE_UNUSED;
300 arelent *reloc_entry ATTRIBUTE_UNUSED;
301 asymbol *symbol ATTRIBUTE_UNUSED;
302 PTR data ATTRIBUTE_UNUSED;
303 asection *input_section ATTRIBUTE_UNUSED;
304 bfd *output_bfd;
305 char **error_message ATTRIBUTE_UNUSED;
306 {
307 if (output_bfd == (bfd *) NULL)
308 return bfd_reloc_continue;
309
310 /* Adjust the reloc address to that in the output section. */
311 reloc_entry->address += input_section->output_offset;
312 return bfd_reloc_ok;
313 }
314
315 /* Perform a relocation as part of a final link. */
316 static bfd_reloc_status_type
317 elf32_h8_final_link_relocate (r_type, input_bfd, output_bfd,
318 input_section, contents, offset, value,
319 addend, info, sym_sec, is_local)
320 unsigned long r_type;
321 bfd *input_bfd;
322 bfd *output_bfd ATTRIBUTE_UNUSED;
323 asection *input_section ATTRIBUTE_UNUSED;
324 bfd_byte *contents;
325 bfd_vma offset;
326 bfd_vma value;
327 bfd_vma addend;
328 struct bfd_link_info *info ATTRIBUTE_UNUSED;
329 asection *sym_sec ATTRIBUTE_UNUSED;
330 int is_local ATTRIBUTE_UNUSED;
331 {
332 bfd_byte *hit_data = contents + offset;
333
334 switch (r_type)
335 {
336
337 case R_H8_NONE:
338 return bfd_reloc_ok;
339
340 case R_H8_DIR32:
341 case R_H8_DIR32A16:
342 case R_H8_DIR24A8:
343 value += addend;
344 bfd_put_32 (input_bfd, value, hit_data);
345 return bfd_reloc_ok;
346
347 case R_H8_DIR16:
348 case R_H8_DIR16A8:
349 case R_H8_DIR16R8:
350 value += addend;
351 bfd_put_16 (input_bfd, value, hit_data);
352 return bfd_reloc_ok;
353
354 /* AKA R_RELBYTE */
355 case R_H8_DIR8:
356 value += addend;
357
358 bfd_put_8 (input_bfd, value, hit_data);
359 return bfd_reloc_ok;
360
361 case R_H8_DIR24R8:
362 value += addend;
363
364 /* HIT_DATA is the address for the first byte for the relocated
365 value. Subtract 1 so that we can manipulate the data in 32bit
366 hunks. */
367 hit_data--;
368
369 /* Clear out the top byte in value. */
370 value &= 0xffffff;
371
372 /* Retrieve the type byte for value from the section contents. */
373 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
374
375 /* Now scribble it out in one 32bit hunk. */
376 bfd_put_32 (input_bfd, value, hit_data);
377 return bfd_reloc_ok;
378
379 case R_H8_PCREL16:
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 2 to account for
387 this minor issue. */
388 value -= 2;
389
390 bfd_put_16 (input_bfd, value, hit_data);
391 return bfd_reloc_ok;
392
393 case R_H8_PCREL8:
394 value -= (input_section->output_section->vma
395 + input_section->output_offset);
396 value -= offset;
397 value += addend;
398
399 /* The value is relative to the start of the instruction,
400 not the relocation offset. Subtract 1 to account for
401 this minor issue. */
402 value -= 1;
403
404 bfd_put_8 (input_bfd, value, hit_data);
405 return bfd_reloc_ok;
406
407 default:
408 return bfd_reloc_notsupported;
409 }
410 }
411 \f
412 /* Relocate an H8 ELF section. */
413 static bfd_boolean
414 elf32_h8_relocate_section (output_bfd, info, input_bfd, input_section,
415 contents, relocs, local_syms, local_sections)
416 bfd *output_bfd;
417 struct bfd_link_info *info;
418 bfd *input_bfd;
419 asection *input_section;
420 bfd_byte *contents;
421 Elf_Internal_Rela *relocs;
422 Elf_Internal_Sym *local_syms;
423 asection **local_sections;
424 {
425 Elf_Internal_Shdr *symtab_hdr;
426 struct elf_link_hash_entry **sym_hashes;
427 Elf_Internal_Rela *rel, *relend;
428
429 if (info->relocateable)
430 return TRUE;
431
432 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
433 sym_hashes = elf_sym_hashes (input_bfd);
434
435 rel = relocs;
436 relend = relocs + input_section->reloc_count;
437 for (; rel < relend; rel++)
438 {
439 unsigned int r_type;
440 unsigned long r_symndx;
441 Elf_Internal_Sym *sym;
442 asection *sec;
443 struct elf_link_hash_entry *h;
444 bfd_vma relocation;
445 bfd_reloc_status_type r;
446
447 /* This is a final link. */
448 r_symndx = ELF32_R_SYM (rel->r_info);
449 r_type = ELF32_R_TYPE (rel->r_info);
450 h = NULL;
451 sym = NULL;
452 sec = NULL;
453 if (r_symndx < symtab_hdr->sh_info)
454 {
455 sym = local_syms + r_symndx;
456 sec = local_sections[r_symndx];
457 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
458 }
459 else
460 {
461 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
462 while (h->root.type == bfd_link_hash_indirect
463 || h->root.type == bfd_link_hash_warning)
464 h = (struct elf_link_hash_entry *) h->root.u.i.link;
465 if (h->root.type == bfd_link_hash_defined
466 || h->root.type == bfd_link_hash_defweak)
467 {
468 sec = h->root.u.def.section;
469 relocation = (h->root.u.def.value
470 + sec->output_section->vma
471 + sec->output_offset);
472 }
473 else if (h->root.type == bfd_link_hash_undefweak)
474 relocation = 0;
475 else
476 {
477 if (! ((*info->callbacks->undefined_symbol)
478 (info, h->root.root.string, input_bfd,
479 input_section, rel->r_offset, TRUE)))
480 return FALSE;
481 relocation = 0;
482 }
483 }
484
485 r = elf32_h8_final_link_relocate (r_type, input_bfd, output_bfd,
486 input_section,
487 contents, rel->r_offset,
488 relocation, rel->r_addend,
489 info, sec, h == NULL);
490
491 if (r != bfd_reloc_ok)
492 {
493 const char *name;
494 const char *msg = (const char *) 0;
495 arelent bfd_reloc;
496 reloc_howto_type *howto;
497
498 elf32_h8_info_to_howto (input_bfd, &bfd_reloc, rel);
499 howto = bfd_reloc.howto;
500
501 if (h != NULL)
502 name = h->root.root.string;
503 else
504 {
505 name = (bfd_elf_string_from_elf_section
506 (input_bfd, symtab_hdr->sh_link, sym->st_name));
507 if (name == NULL || *name == '\0')
508 name = bfd_section_name (input_bfd, sec);
509 }
510
511 switch (r)
512 {
513 case bfd_reloc_overflow:
514 if (! ((*info->callbacks->reloc_overflow)
515 (info, name, howto->name, (bfd_vma) 0,
516 input_bfd, input_section, rel->r_offset)))
517 return FALSE;
518 break;
519
520 case bfd_reloc_undefined:
521 if (! ((*info->callbacks->undefined_symbol)
522 (info, name, input_bfd, input_section,
523 rel->r_offset, TRUE)))
524 return FALSE;
525 break;
526
527 case bfd_reloc_outofrange:
528 msg = _("internal error: out of range error");
529 goto common_error;
530
531 case bfd_reloc_notsupported:
532 msg = _("internal error: unsupported relocation error");
533 goto common_error;
534
535 case bfd_reloc_dangerous:
536 msg = _("internal error: dangerous error");
537 goto common_error;
538
539 default:
540 msg = _("internal error: unknown error");
541 /* fall through */
542
543 common_error:
544 if (!((*info->callbacks->warning)
545 (info, msg, name, input_bfd, input_section,
546 rel->r_offset)))
547 return FALSE;
548 break;
549 }
550 }
551 }
552
553 return TRUE;
554 }
555
556 /* Object files encode the specific H8 model they were compiled
557 for in the ELF flags field.
558
559 Examine that field and return the proper BFD machine type for
560 the object file. */
561 static unsigned long
562 elf32_h8_mach (flags)
563 flagword flags;
564 {
565 switch (flags & EF_H8_MACH)
566 {
567 case E_H8_MACH_H8300:
568 default:
569 return bfd_mach_h8300;
570
571 case E_H8_MACH_H8300H:
572 return bfd_mach_h8300h;
573
574 case E_H8_MACH_H8300S:
575 return bfd_mach_h8300s;
576
577 case E_H8_MACH_H8300HN:
578 return bfd_mach_h8300hn;
579
580 case E_H8_MACH_H8300SN:
581 return bfd_mach_h8300sn;
582
583 case E_H8_MACH_H8300SX:
584 return bfd_mach_h8300sx;
585 }
586 }
587
588 /* The final processing done just before writing out a H8 ELF object
589 file. We use this opportunity to encode the BFD machine type
590 into the flags field in the object file. */
591
592 static void
593 elf32_h8_final_write_processing (abfd, linker)
594 bfd *abfd;
595 bfd_boolean linker ATTRIBUTE_UNUSED;
596 {
597 unsigned long val;
598
599 switch (bfd_get_mach (abfd))
600 {
601 default:
602 case bfd_mach_h8300:
603 val = E_H8_MACH_H8300;
604 break;
605
606 case bfd_mach_h8300h:
607 val = E_H8_MACH_H8300H;
608 break;
609
610 case bfd_mach_h8300s:
611 val = E_H8_MACH_H8300S;
612 break;
613
614 case bfd_mach_h8300hn:
615 val = E_H8_MACH_H8300HN;
616 break;
617
618 case bfd_mach_h8300sn:
619 val = E_H8_MACH_H8300SN;
620 break;
621
622 case bfd_mach_h8300sx:
623 val = E_H8_MACH_H8300SX;
624 break;
625 }
626
627 elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH);
628 elf_elfheader (abfd)->e_flags |= val;
629 }
630
631 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
632 record the encoded machine type found in the ELF flags. */
633
634 static bfd_boolean
635 elf32_h8_object_p (abfd)
636 bfd *abfd;
637 {
638 bfd_default_set_arch_mach (abfd, bfd_arch_h8300,
639 elf32_h8_mach (elf_elfheader (abfd)->e_flags));
640 return TRUE;
641 }
642
643 /* Merge backend specific data from an object file to the output
644 object file when linking. The only data we need to copy at this
645 time is the architecture/machine information. */
646
647 static bfd_boolean
648 elf32_h8_merge_private_bfd_data (ibfd, obfd)
649 bfd *ibfd;
650 bfd *obfd;
651 {
652 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
653 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
654 return TRUE;
655
656 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
657 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
658 {
659 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
660 bfd_get_mach (ibfd)))
661 return FALSE;
662 }
663
664 return TRUE;
665 }
666
667 /* This function handles relaxing for the H8..
668
669 There's a few relaxing opportunites available on the H8:
670
671 jmp/jsr:24 -> bra/bsr:8 2 bytes
672 The jmp may be completely eliminated if the previous insn is a
673 conditional branch to the insn after the jump. In that case
674 we invert the branch and delete the jump and save 4 bytes.
675
676 bCC:16 -> bCC:8 2 bytes
677 bsr:16 -> bsr:8 2 bytes
678
679 mov.b:16 -> mov.b:8 2 bytes
680 mov.b:24/32 -> mov.b:8 4 bytes
681
682 mov.[bwl]:24/32 -> mov.[bwl]:16 2 bytes */
683
684 static bfd_boolean
685 elf32_h8_relax_section (abfd, sec, link_info, again)
686 bfd *abfd;
687 asection *sec;
688 struct bfd_link_info *link_info;
689 bfd_boolean *again;
690 {
691 Elf_Internal_Shdr *symtab_hdr;
692 Elf_Internal_Rela *internal_relocs;
693 Elf_Internal_Rela *irel, *irelend;
694 bfd_byte *contents = NULL;
695 Elf_Internal_Sym *isymbuf = NULL;
696 static asection *last_input_section = NULL;
697 static Elf_Internal_Rela *last_reloc = NULL;
698
699 /* Assume nothing changes. */
700 *again = FALSE;
701
702 /* We don't have to do anything for a relocateable link, if
703 this section does not have relocs, or if this is not a
704 code section. */
705 if (link_info->relocateable
706 || (sec->flags & SEC_RELOC) == 0
707 || sec->reloc_count == 0
708 || (sec->flags & SEC_CODE) == 0)
709 return TRUE;
710
711 /* If this is the first time we have been called for this section,
712 initialize the cooked size. */
713 if (sec->_cooked_size == 0)
714 sec->_cooked_size = sec->_raw_size;
715
716 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
717
718 /* Get a copy of the native relocations. */
719 internal_relocs = (_bfd_elf_link_read_relocs
720 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
721 link_info->keep_memory));
722 if (internal_relocs == NULL)
723 goto error_return;
724
725 if (sec != last_input_section)
726 last_reloc = NULL;
727
728 last_input_section = sec;
729
730 /* Walk through the relocs looking for relaxing opportunities. */
731 irelend = internal_relocs + sec->reloc_count;
732 for (irel = internal_relocs; irel < irelend; irel++)
733 {
734 bfd_vma symval;
735
736 /* Keep track of the previous reloc so that we can delete
737 some long jumps created by the compiler. */
738 if (irel != internal_relocs)
739 last_reloc = irel - 1;
740
741 if (ELF32_R_TYPE (irel->r_info) != R_H8_DIR24R8
742 && ELF32_R_TYPE (irel->r_info) != R_H8_PCREL16
743 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR16A8
744 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR24A8
745 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR32A16)
746 continue;
747
748 /* Get the section contents if we haven't done so already. */
749 if (contents == NULL)
750 {
751 /* Get cached copy if it exists. */
752 if (elf_section_data (sec)->this_hdr.contents != NULL)
753 contents = elf_section_data (sec)->this_hdr.contents;
754 else
755 {
756 /* Go get them off disk. */
757 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
758 if (contents == NULL)
759 goto error_return;
760
761 if (! bfd_get_section_contents (abfd, sec, contents,
762 (file_ptr) 0, sec->_raw_size))
763 goto error_return;
764 }
765 }
766
767 /* Read this BFD's local symbols if we haven't done so already. */
768 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
769 {
770 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
771 if (isymbuf == NULL)
772 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
773 symtab_hdr->sh_info, 0,
774 NULL, NULL, NULL);
775 if (isymbuf == NULL)
776 goto error_return;
777 }
778
779 /* Get the value of the symbol referred to by the reloc. */
780 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
781 {
782 /* A local symbol. */
783 Elf_Internal_Sym *isym;
784 asection *sym_sec;
785
786 isym = isymbuf + ELF32_R_SYM (irel->r_info);
787 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
788 symval = isym->st_value;
789 /* If the reloc is absolute, it will not have
790 a symbol or section associated with it. */
791 if (sym_sec)
792 symval += sym_sec->output_section->vma
793 + sym_sec->output_offset;
794 }
795 else
796 {
797 unsigned long indx;
798 struct elf_link_hash_entry *h;
799
800 /* An external symbol. */
801 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
802 h = elf_sym_hashes (abfd)[indx];
803 BFD_ASSERT (h != NULL);
804 if (h->root.type != bfd_link_hash_defined
805 && h->root.type != bfd_link_hash_defweak)
806 {
807 /* This appears to be a reference to an undefined
808 symbol. Just ignore it--it will be caught by the
809 regular reloc processing. */
810 continue;
811 }
812
813 symval = (h->root.u.def.value
814 + h->root.u.def.section->output_section->vma
815 + h->root.u.def.section->output_offset);
816 }
817
818 /* For simplicity of coding, we are going to modify the section
819 contents, the section relocs, and the BFD symbol table. We
820 must tell the rest of the code not to free up this
821 information. It would be possible to instead create a table
822 of changes which have to be made, as is done in coff-mips.c;
823 that would be more work, but would require less memory when
824 the linker is run. */
825 switch (ELF32_R_TYPE (irel->r_info))
826 {
827 /* Try to turn a 24 bit absolute branch/call into an 8 bit
828 pc-relative branch/call. */
829 case R_H8_DIR24R8:
830 {
831 bfd_vma value = symval + irel->r_addend;
832 bfd_vma dot, gap;
833
834 /* Get the address of this instruction. */
835 dot = (sec->output_section->vma
836 + sec->output_offset + irel->r_offset - 1);
837
838 /* Compute the distance from this insn to the branch target. */
839 gap = value - dot;
840
841 /* If the distance is within -126..+130 inclusive, then we can
842 relax this jump. +130 is valid since the target will move
843 two bytes closer if we do relax this branch. */
844 if ((int) gap >= -126 && (int) gap <= 130)
845 {
846 unsigned char code;
847
848 /* Note that we've changed the relocs, section contents,
849 etc. */
850 elf_section_data (sec)->relocs = internal_relocs;
851 elf_section_data (sec)->this_hdr.contents = contents;
852 symtab_hdr->contents = (unsigned char *) isymbuf;
853
854 /* Get the instruction code being relaxed. */
855 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
856
857 /* If the previous instruction conditionally jumped around
858 this instruction, we may be able to reverse the condition
859 and redirect the previous instruction to the target of
860 this instruction.
861
862 Such sequences are used by the compiler to deal with
863 long conditional branches.
864
865 Only perform this optimisation for jumps (code 0x5a) not
866 subroutine calls, as otherwise it could transform:
867
868 mov.w r0,r0
869 beq .L1
870 jsr @_bar
871 .L1: rts
872 _bar: rts
873 into:
874 mov.w r0,r0
875 bne _bar
876 rts
877 _bar: rts
878
879 which changes the call (jsr) into a branch (bne). */
880 if (code == 0x5a
881 && (int) gap <= 130
882 && (int) gap >= -128
883 && last_reloc
884 && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
885 && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
886 {
887 bfd_vma last_value;
888 asection *last_sym_sec;
889 Elf_Internal_Sym *last_sym;
890
891 /* We will need to examine the symbol used by the
892 previous relocation. */
893
894 last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
895 last_sym_sec
896 = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
897 last_value = (last_sym->st_value
898 + last_sym_sec->output_section->vma
899 + last_sym_sec->output_offset);
900
901 /* Verify that the previous relocation was for a
902 branch around this instruction and that no symbol
903 exists at the current location. */
904 if (last_value == dot + 4
905 && last_reloc->r_offset + 2 == irel->r_offset
906 && ! elf32_h8_symbol_address_p (abfd, sec, dot))
907 {
908 /* We can eliminate this jump. Twiddle the
909 previous relocation as necessary. */
910 irel->r_info
911 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
912 ELF32_R_TYPE (R_H8_NONE));
913
914 last_reloc->r_info
915 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
916 ELF32_R_TYPE (R_H8_PCREL8));
917 last_reloc->r_addend = irel->r_addend;
918
919 code = bfd_get_8 (abfd,
920 contents + last_reloc->r_offset - 1);
921 code ^= 1;
922 bfd_put_8 (abfd,
923 code,
924 contents + last_reloc->r_offset - 1);
925
926 /* Delete four bytes of data. */
927 if (!elf32_h8_relax_delete_bytes (abfd, sec,
928 irel->r_offset - 1,
929 4))
930 goto error_return;
931
932 *again = TRUE;
933 break;
934 }
935 }
936
937 if (code == 0x5e)
938 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);
939 else if (code == 0x5a)
940 bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1);
941 else
942 abort ();
943
944 /* Fix the relocation's type. */
945 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
946 R_H8_PCREL8);
947
948 /* Delete two bytes of data. */
949 if (!elf32_h8_relax_delete_bytes (abfd, sec,
950 irel->r_offset + 1, 2))
951 goto error_return;
952
953 /* That will change things, so, we should relax again.
954 Note that this is not required, and it may be slow. */
955 *again = TRUE;
956 }
957 break;
958 }
959
960 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
961 branch. */
962 case R_H8_PCREL16:
963 {
964 bfd_vma value = symval + irel->r_addend;
965 bfd_vma dot;
966 bfd_vma gap;
967
968 /* Get the address of this instruction. */
969 dot = (sec->output_section->vma
970 + sec->output_offset
971 + irel->r_offset - 2);
972
973 gap = value - dot;
974
975 /* If the distance is within -126..+130 inclusive, then we can
976 relax this jump. +130 is valid since the target will move
977 two bytes closer if we do relax this branch. */
978 if ((int) gap >= -126 && (int) gap <= 130)
979 {
980 unsigned char code;
981
982 /* Note that we've changed the relocs, section contents,
983 etc. */
984 elf_section_data (sec)->relocs = internal_relocs;
985 elf_section_data (sec)->this_hdr.contents = contents;
986 symtab_hdr->contents = (unsigned char *) isymbuf;
987
988 /* Get the opcode. */
989 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
990
991 if (code == 0x58)
992 {
993 /* bCC:16 -> bCC:8 */
994 /* Get the condition code from the original insn. */
995 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
996 code &= 0xf0;
997 code >>= 4;
998 code |= 0x40;
999 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
1000 }
1001 else if (code == 0x5c)
1002 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);
1003 else
1004 abort ();
1005
1006 /* Fix the relocation's type. */
1007 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1008 R_H8_PCREL8);
1009 irel->r_offset--;
1010
1011 /* Delete two bytes of data. */
1012 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1013 irel->r_offset + 1, 2))
1014 goto error_return;
1015
1016 /* That will change things, so, we should relax again.
1017 Note that this is not required, and it may be slow. */
1018 *again = TRUE;
1019 }
1020 break;
1021 }
1022
1023 /* This is a 16 bit absolute address in a "mov.b" insn, which may
1024 become an 8 bit absolute address if its in the right range. */
1025 case R_H8_DIR16A8:
1026 {
1027 bfd_vma value = symval + irel->r_addend;
1028
1029 if ((bfd_get_mach (abfd) == bfd_mach_h8300
1030 && value >= 0xff00
1031 && value <= 0xffff)
1032 || ((bfd_get_mach (abfd) == bfd_mach_h8300h
1033 /* FIXME: h8300hn? */
1034 || bfd_get_mach (abfd) == bfd_mach_h8300s
1035 /* FIXME: h8300sn? */
1036 || bfd_get_mach (abfd) == bfd_mach_h8300sx)
1037 && value >= 0xffff00
1038 && value <= 0xffffff))
1039 {
1040 unsigned char code;
1041
1042 /* Note that we've changed the relocs, section contents,
1043 etc. */
1044 elf_section_data (sec)->relocs = internal_relocs;
1045 elf_section_data (sec)->this_hdr.contents = contents;
1046 symtab_hdr->contents = (unsigned char *) isymbuf;
1047
1048 /* Get the opcode. */
1049 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1050
1051 /* Sanity check. */
1052 if (code != 0x6a)
1053 abort ();
1054
1055 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1056
1057 if ((code & 0xf0) == 0x00)
1058 bfd_put_8 (abfd,
1059 (code & 0xf) | 0x20,
1060 contents + irel->r_offset - 2);
1061 else if ((code & 0xf0) == 0x80)
1062 bfd_put_8 (abfd,
1063 (code & 0xf) | 0x30,
1064 contents + irel->r_offset - 2);
1065 else
1066 abort ();
1067
1068 /* Fix the relocation's type. */
1069 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1070 R_H8_DIR8);
1071
1072 /* Delete two bytes of data. */
1073 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1074 irel->r_offset + 1, 2))
1075 goto error_return;
1076
1077 /* That will change things, so, we should relax again.
1078 Note that this is not required, and it may be slow. */
1079 *again = TRUE;
1080 }
1081 break;
1082 }
1083
1084 /* This is a 24 bit absolute address in a "mov.b" insn, which may
1085 become an 8 bit absolute address if its in the right range. */
1086 case R_H8_DIR24A8:
1087 {
1088 bfd_vma value = symval + irel->r_addend;
1089
1090 if ((bfd_get_mach (abfd) == bfd_mach_h8300
1091 && value >= 0xff00
1092 && value <= 0xffff)
1093 || ((bfd_get_mach (abfd) == bfd_mach_h8300h
1094 /* FIXME: h8300hn? */
1095 || bfd_get_mach (abfd) == bfd_mach_h8300s
1096 /* FIXME: h8300sn? */
1097 || bfd_get_mach (abfd) == bfd_mach_h8300sx)
1098 && value >= 0xffff00
1099 && value <= 0xffffff))
1100 {
1101 bfd_boolean skip = FALSE;
1102 unsigned char code;
1103
1104 /* Note that we've changed the relocs, section contents,
1105 etc. */
1106 elf_section_data (sec)->relocs = internal_relocs;
1107 elf_section_data (sec)->this_hdr.contents = contents;
1108 symtab_hdr->contents = (unsigned char *) isymbuf;
1109
1110 /* Get the opcode. */
1111 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1112
1113 /* Sanity check. */
1114 if (code != 0x6a)
1115 abort ();
1116
1117 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1118
1119 switch (code & 0xf0)
1120 {
1121 case 0x00:
1122 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1123 contents + irel->r_offset - 2);
1124 break;
1125 case 0x80:
1126 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1127 contents + irel->r_offset - 2);
1128 break;
1129 case 0x20:
1130 case 0xa0:
1131 /* Skip 32bit versions. */
1132 skip = TRUE;
1133 break;
1134 default:
1135 abort ();
1136 }
1137
1138 if (skip)
1139 break;
1140
1141 /* Fix the relocation's type. */
1142 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1143 R_H8_DIR8);
1144
1145 /* Delete two bytes of data. */
1146 if (!elf32_h8_relax_delete_bytes (abfd, sec, irel->r_offset, 2))
1147 goto error_return;
1148
1149 /* That will change things, so, we should relax again.
1150 Note that this is not required, and it may be slow. */
1151 *again = TRUE;
1152 }
1153 }
1154
1155 /* FALLTHRU */
1156
1157 /* This is a 24/32bit absolute address in a "mov" insn, which may
1158 become a 16bit absoulte address if it is in the right range. */
1159 case R_H8_DIR32A16:
1160 {
1161 bfd_vma value = symval + irel->r_addend;
1162
1163 if (value <= 0x7fff || value >= 0xff8000)
1164 {
1165 unsigned char code;
1166
1167 /* Note that we've changed the relocs, section contents,
1168 etc. */
1169 elf_section_data (sec)->relocs = internal_relocs;
1170 elf_section_data (sec)->this_hdr.contents = contents;
1171 symtab_hdr->contents = (unsigned char *) isymbuf;
1172
1173 /* Get the opcode. */
1174 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1175
1176 /* We just need to turn off bit 0x20. */
1177 code &= ~0x20;
1178
1179 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1180
1181 /* Fix the relocation's type. */
1182 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1183 R_H8_DIR16A8);
1184
1185 /* Delete two bytes of data. */
1186 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1187 irel->r_offset + 1, 2))
1188 goto error_return;
1189
1190 /* That will change things, so, we should relax again.
1191 Note that this is not required, and it may be slow. */
1192 *again = TRUE;
1193 }
1194 break;
1195 }
1196
1197 default:
1198 break;
1199 }
1200 }
1201
1202 if (isymbuf != NULL
1203 && symtab_hdr->contents != (unsigned char *) isymbuf)
1204 {
1205 if (! link_info->keep_memory)
1206 free (isymbuf);
1207 else
1208 symtab_hdr->contents = (unsigned char *) isymbuf;
1209 }
1210
1211 if (contents != NULL
1212 && elf_section_data (sec)->this_hdr.contents != contents)
1213 {
1214 if (! link_info->keep_memory)
1215 free (contents);
1216 else
1217 {
1218 /* Cache the section contents for elf_link_input_bfd. */
1219 elf_section_data (sec)->this_hdr.contents = contents;
1220 }
1221 }
1222
1223 if (internal_relocs != NULL
1224 && elf_section_data (sec)->relocs != internal_relocs)
1225 free (internal_relocs);
1226
1227 return TRUE;
1228
1229 error_return:
1230 if (isymbuf != NULL
1231 && symtab_hdr->contents != (unsigned char *) isymbuf)
1232 free (isymbuf);
1233 if (contents != NULL
1234 && elf_section_data (sec)->this_hdr.contents != contents)
1235 free (contents);
1236 if (internal_relocs != NULL
1237 && elf_section_data (sec)->relocs != internal_relocs)
1238 free (internal_relocs);
1239 return FALSE;
1240 }
1241
1242 /* Delete some bytes from a section while relaxing. */
1243
1244 static bfd_boolean
1245 elf32_h8_relax_delete_bytes (abfd, sec, addr, count)
1246 bfd *abfd;
1247 asection *sec;
1248 bfd_vma addr;
1249 int count;
1250 {
1251 Elf_Internal_Shdr *symtab_hdr;
1252 unsigned int sec_shndx;
1253 bfd_byte *contents;
1254 Elf_Internal_Rela *irel, *irelend;
1255 Elf_Internal_Rela *irelalign;
1256 Elf_Internal_Sym *isym;
1257 Elf_Internal_Sym *isymend;
1258 bfd_vma toaddr;
1259 struct elf_link_hash_entry **sym_hashes;
1260 struct elf_link_hash_entry **end_hashes;
1261 unsigned int symcount;
1262
1263 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1264
1265 contents = elf_section_data (sec)->this_hdr.contents;
1266
1267 /* The deletion must stop at the next ALIGN reloc for an aligment
1268 power larger than the number of bytes we are deleting. */
1269
1270 irelalign = NULL;
1271 toaddr = sec->_cooked_size;
1272
1273 irel = elf_section_data (sec)->relocs;
1274 irelend = irel + sec->reloc_count;
1275
1276 /* Actually delete the bytes. */
1277 memmove (contents + addr, contents + addr + count,
1278 (size_t) (toaddr - addr - count));
1279 sec->_cooked_size -= count;
1280
1281 /* Adjust all the relocs. */
1282 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1283 {
1284 /* Get the new reloc address. */
1285 if ((irel->r_offset > addr
1286 && irel->r_offset < toaddr))
1287 irel->r_offset -= count;
1288 }
1289
1290 /* Adjust the local symbols defined in this section. */
1291 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1292 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1293 isymend = isym + symtab_hdr->sh_info;
1294 for (; isym < isymend; isym++)
1295 {
1296 if (isym->st_shndx == sec_shndx
1297 && isym->st_value > addr
1298 && isym->st_value < toaddr)
1299 isym->st_value -= count;
1300 }
1301
1302 /* Now adjust the global symbols defined in this section. */
1303 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1304 - symtab_hdr->sh_info);
1305 sym_hashes = elf_sym_hashes (abfd);
1306 end_hashes = sym_hashes + symcount;
1307 for (; sym_hashes < end_hashes; sym_hashes++)
1308 {
1309 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1310 if ((sym_hash->root.type == bfd_link_hash_defined
1311 || sym_hash->root.type == bfd_link_hash_defweak)
1312 && sym_hash->root.u.def.section == sec
1313 && sym_hash->root.u.def.value > addr
1314 && sym_hash->root.u.def.value < toaddr)
1315 {
1316 sym_hash->root.u.def.value -= count;
1317 }
1318 }
1319
1320 return TRUE;
1321 }
1322
1323 /* Return TRUE if a symbol exists at the given address, else return
1324 FALSE. */
1325 static bfd_boolean
1326 elf32_h8_symbol_address_p (abfd, sec, addr)
1327 bfd *abfd;
1328 asection *sec;
1329 bfd_vma addr;
1330 {
1331 Elf_Internal_Shdr *symtab_hdr;
1332 unsigned int sec_shndx;
1333 Elf_Internal_Sym *isym;
1334 Elf_Internal_Sym *isymend;
1335 struct elf_link_hash_entry **sym_hashes;
1336 struct elf_link_hash_entry **end_hashes;
1337 unsigned int symcount;
1338
1339 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1340
1341 /* Examine all the symbols. */
1342 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1343 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1344 isymend = isym + symtab_hdr->sh_info;
1345 for (; isym < isymend; isym++)
1346 {
1347 if (isym->st_shndx == sec_shndx
1348 && isym->st_value == addr)
1349 return TRUE;
1350 }
1351
1352 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1353 - symtab_hdr->sh_info);
1354 sym_hashes = elf_sym_hashes (abfd);
1355 end_hashes = sym_hashes + symcount;
1356 for (; sym_hashes < end_hashes; sym_hashes++)
1357 {
1358 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1359 if ((sym_hash->root.type == bfd_link_hash_defined
1360 || sym_hash->root.type == bfd_link_hash_defweak)
1361 && sym_hash->root.u.def.section == sec
1362 && sym_hash->root.u.def.value == addr)
1363 return TRUE;
1364 }
1365
1366 return FALSE;
1367 }
1368
1369 /* This is a version of bfd_generic_get_relocated_section_contents
1370 which uses elf32_h8_relocate_section. */
1371
1372 static bfd_byte *
1373 elf32_h8_get_relocated_section_contents (output_bfd, link_info, link_order,
1374 data, relocateable, symbols)
1375 bfd *output_bfd;
1376 struct bfd_link_info *link_info;
1377 struct bfd_link_order *link_order;
1378 bfd_byte *data;
1379 bfd_boolean relocateable;
1380 asymbol **symbols;
1381 {
1382 Elf_Internal_Shdr *symtab_hdr;
1383 asection *input_section = link_order->u.indirect.section;
1384 bfd *input_bfd = input_section->owner;
1385 asection **sections = NULL;
1386 Elf_Internal_Rela *internal_relocs = NULL;
1387 Elf_Internal_Sym *isymbuf = NULL;
1388
1389 /* We only need to handle the case of relaxing, or of having a
1390 particular set of section contents, specially. */
1391 if (relocateable
1392 || elf_section_data (input_section)->this_hdr.contents == NULL)
1393 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1394 link_order, data,
1395 relocateable,
1396 symbols);
1397
1398 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1399
1400 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1401 (size_t) input_section->_raw_size);
1402
1403 if ((input_section->flags & SEC_RELOC) != 0
1404 && input_section->reloc_count > 0)
1405 {
1406 asection **secpp;
1407 Elf_Internal_Sym *isym, *isymend;
1408 bfd_size_type amt;
1409
1410 internal_relocs = (_bfd_elf_link_read_relocs
1411 (input_bfd, input_section, (PTR) NULL,
1412 (Elf_Internal_Rela *) NULL, FALSE));
1413 if (internal_relocs == NULL)
1414 goto error_return;
1415
1416 if (symtab_hdr->sh_info != 0)
1417 {
1418 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1419 if (isymbuf == NULL)
1420 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1421 symtab_hdr->sh_info, 0,
1422 NULL, NULL, NULL);
1423 if (isymbuf == NULL)
1424 goto error_return;
1425 }
1426
1427 amt = symtab_hdr->sh_info;
1428 amt *= sizeof (asection *);
1429 sections = (asection **) bfd_malloc (amt);
1430 if (sections == NULL && amt != 0)
1431 goto error_return;
1432
1433 isymend = isymbuf + symtab_hdr->sh_info;
1434 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1435 {
1436 asection *isec;
1437
1438 if (isym->st_shndx == SHN_UNDEF)
1439 isec = bfd_und_section_ptr;
1440 else if (isym->st_shndx == SHN_ABS)
1441 isec = bfd_abs_section_ptr;
1442 else if (isym->st_shndx == SHN_COMMON)
1443 isec = bfd_com_section_ptr;
1444 else
1445 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1446
1447 *secpp = isec;
1448 }
1449
1450 if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1451 input_section, data, internal_relocs,
1452 isymbuf, sections))
1453 goto error_return;
1454
1455 if (sections != NULL)
1456 free (sections);
1457 if (isymbuf != NULL
1458 && symtab_hdr->contents != (unsigned char *) isymbuf)
1459 free (isymbuf);
1460 if (elf_section_data (input_section)->relocs != internal_relocs)
1461 free (internal_relocs);
1462 }
1463
1464 return data;
1465
1466 error_return:
1467 if (sections != NULL)
1468 free (sections);
1469 if (isymbuf != NULL
1470 && symtab_hdr->contents != (unsigned char *) isymbuf)
1471 free (isymbuf);
1472 if (internal_relocs != NULL
1473 && elf_section_data (input_section)->relocs != internal_relocs)
1474 free (internal_relocs);
1475 return NULL;
1476 }
1477
1478
1479 #define TARGET_BIG_SYM bfd_elf32_h8300_vec
1480 #define TARGET_BIG_NAME "elf32-h8300"
1481 #define ELF_ARCH bfd_arch_h8300
1482 #define ELF_MACHINE_CODE EM_H8_300
1483 #define ELF_MAXPAGESIZE 0x1
1484 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1485 #define elf_info_to_howto elf32_h8_info_to_howto
1486 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1487
1488 /* So we can set/examine bits in e_flags to get the specific
1489 H8 architecture in use. */
1490 #define elf_backend_final_write_processing \
1491 elf32_h8_final_write_processing
1492 #define elf_backend_object_p \
1493 elf32_h8_object_p
1494 #define bfd_elf32_bfd_merge_private_bfd_data \
1495 elf32_h8_merge_private_bfd_data
1496
1497 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1498 defaults to using _bfd_generic_link_hash_table_create, but
1499 elflink.h:bfd_elf32_size_dynamic_sections uses
1500 dynobj = elf_hash_table (info)->dynobj;
1501 and thus requires an elf hash table. */
1502 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1503
1504 /* Use an H8 specific linker, not the ELF generic linker. */
1505 #define elf_backend_relocate_section elf32_h8_relocate_section
1506 #define elf_backend_rela_normal 1
1507
1508 /* And relaxing stuff. */
1509 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1510 #define bfd_elf32_bfd_get_relocated_section_contents \
1511 elf32_h8_get_relocated_section_contents
1512
1513
1514 #include "elf32-target.h"