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