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