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