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