projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
elf_swap_symbol_in args should be "const PTR", not "const PTR *".
[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
684 */
685
686 static boolean
687 elf32_h8_relax_section (abfd, sec, link_info, again)
688 bfd *abfd;
689 asection *sec;
690 struct bfd_link_info *link_info;
691 boolean *again;
692 {
693 Elf_Internal_Shdr *symtab_hdr;
694 Elf_Internal_Shdr *shndx_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 Elf_External_Sym_Shndx *shndx_buf = NULL;
703 static asection *last_input_section = NULL;
704 static Elf_Internal_Rela *last_reloc = NULL;
705
706 /* Assume nothing changes. */
707 *again = false;
708
709 /* We don't have to do anything for a relocateable link, if
710 this section does not have relocs, or if this is not a
711 code section. */
712 if (link_info->relocateable
713 || (sec->flags & SEC_RELOC) == 0
714 || sec->reloc_count == 0
715 || (sec->flags & SEC_CODE) == 0)
716 return true;
717
718 /* If this is the first time we have been called for this section,
719 initialize the cooked size. */
720 if (sec->_cooked_size == 0)
721 sec->_cooked_size = sec->_raw_size;
722
723 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
724 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
725
726 /* Get a copy of the native relocations. */
727 internal_relocs = (_bfd_elf32_link_read_relocs
728 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
729 link_info->keep_memory));
730 if (internal_relocs == NULL)
731 goto error_return;
732 if (! link_info->keep_memory)
733 free_relocs = internal_relocs;
734
735 if (sec != last_input_section)
736 last_reloc = NULL;
737
738 last_input_section = sec;
739
740 /* Walk through the relocs looking for relaxing opportunities. */
741 irelend = internal_relocs + sec->reloc_count;
742 for (irel = internal_relocs; irel < irelend; irel++)
743 {
744 bfd_vma symval;
745
746 /* Keep track of the previous reloc so that we can delete
747 some long jumps created by the compiler. */
748 if (irel != internal_relocs)
749 last_reloc = irel - 1;
750
751 /* Get the section contents if we haven't done so already. */
752 if (contents == NULL)
753 {
754 /* Get cached copy if it exists. */
755 if (elf_section_data (sec)->this_hdr.contents != NULL)
756 contents = elf_section_data (sec)->this_hdr.contents;
757 else
758 {
759 /* Go get them off disk. */
760 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
761 if (contents == NULL)
762 goto error_return;
763 free_contents = contents;
764
765 if (! bfd_get_section_contents (abfd, sec, contents,
766 (file_ptr) 0, sec->_raw_size))
767 goto error_return;
768 }
769 }
770
771 /* Read this BFD's local symbols if we haven't done so already. */
772 if (extsyms == NULL)
773 {
774 /* Get cached copy if it exists. */
775 if (symtab_hdr->contents != NULL)
776 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
777 else
778 {
779 /* Go get them off disk. */
780 bfd_size_type amt;
781
782 amt = symtab_hdr->sh_info * sizeof (Elf32_External_Sym);
783 extsyms = (Elf32_External_Sym *) bfd_malloc (amt);
784 if (extsyms == NULL)
785 goto error_return;
786 free_extsyms = extsyms;
787 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
788 || bfd_bread ((PTR) extsyms, amt, abfd) != amt)
789 goto error_return;
790 symtab_hdr->contents = (PTR) extsyms;
791 }
792
793 if (shndx_hdr->sh_size != 0)
794 {
795 bfd_size_type amt;
796
797 amt = symtab_hdr->sh_info * sizeof (Elf_External_Sym_Shndx);
798 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
799 if (shndx_buf == NULL)
800 goto error_return;
801 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
802 || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
803 goto error_return;
804 shndx_hdr->contents = (PTR) shndx_buf;
805 }
806 }
807
808 /* Get the value of the symbol referred to by the reloc. */
809 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
810 {
811 Elf32_External_Sym *esym;
812 Elf_External_Sym_Shndx *shndx;
813 Elf_Internal_Sym isym;
814 asection *sym_sec;
815
816 /* A local symbol. */
817 esym = extsyms + ELF32_R_SYM (irel->r_info);
818 shndx = shndx_buf + (shndx_buf ? ELF32_R_SYM (irel->r_info) : 0);
819 bfd_elf32_swap_symbol_in (abfd, (const PTR) esym, (const PTR) shndx,
820 &isym);
821
822 sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
823 symval = (isym.st_value
824 + sym_sec->output_section->vma
825 + sym_sec->output_offset);
826 }
827 else
828 {
829 unsigned long indx;
830 struct elf_link_hash_entry *h;
831
832 /* An external symbol. */
833 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
834 h = elf_sym_hashes (abfd)[indx];
835 BFD_ASSERT (h != NULL);
836 if (h->root.type != bfd_link_hash_defined
837 && h->root.type != bfd_link_hash_defweak)
838 {
839 /* This appears to be a reference to an undefined
840 symbol. Just ignore it--it will be caught by the
841 regular reloc processing. */
842 continue;
843 }
844
845 symval = (h->root.u.def.value
846 + h->root.u.def.section->output_section->vma
847 + h->root.u.def.section->output_offset);
848 }
849
850 /* For simplicity of coding, we are going to modify the section
851 contents, the section relocs, and the BFD symbol table. We
852 must tell the rest of the code not to free up this
853 information. It would be possible to instead create a table
854 of changes which have to be made, as is done in coff-mips.c;
855 that would be more work, but would require less memory when
856 the linker is run. */
857 switch (ELF32_R_TYPE (irel->r_info))
858 {
859 /* Try to turn a 24 bit absolute branch/call into an 8 bit
860 pc-relative branch/call. */
861 case R_H8_DIR24R8:
862 {
863 bfd_vma value = symval + irel->r_addend;
864 bfd_vma dot, gap;
865
866 /* Get the address of this instruction. */
867 dot = (sec->output_section->vma
868 + sec->output_offset + irel->r_offset - 1);
869
870 /* Compute the distance from this insn to the branch target. */
871 gap = value - dot;
872
873 /* If the distance is within -126..+130 inclusive, then we can
874 relax this jump. +130 is valid since the target will move
875 two bytes closer if we do relax this branch. */
876 if ((int) gap >= -126 && (int) gap <= 130)
877 {
878 unsigned char code;
879
880 /* Note that we've changed the relocs, section contents,
881 etc. */
882 elf_section_data (sec)->relocs = internal_relocs;
883 free_relocs = NULL;
884
885 elf_section_data (sec)->this_hdr.contents = contents;
886 free_contents = NULL;
887
888 free_extsyms = NULL;
889
890 /* If the previous instruction conditionally jumped around
891 this instruction, we may be able to reverse the condition
892 and redirect the previous instruction to the target of
893 this instruction.
894
895 Such sequences are used by the compiler to deal with
896 long conditional branches. */
897 if ((int) gap <= 130
898 && (int) gap >= -128
899 && last_reloc
900 && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
901 && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
902 {
903 Elf32_External_Sym *esym;
904 Elf_External_Sym_Shndx *shndx;
905 bfd_vma last_value;
906 asection *last_sym_sec;
907 Elf_Internal_Sym last_symbol;
908
909 /* We will need to examine the symbol used by the
910 previous relocation. */
911
912 esym = extsyms + ELF32_R_SYM (last_reloc->r_info);
913 shndx = shndx_buf;
914 if (shndx != NULL)
915 shndx += ELF32_R_SYM (last_reloc->r_info);
916 bfd_elf32_swap_symbol_in (abfd, (const PTR) esym,
917 (const PTR) shndx,
918 &last_symbol);
919
920 last_sym_sec
921 = bfd_section_from_elf_index (abfd, last_symbol.st_shndx);
922 last_value = (last_symbol.st_value
923 + last_sym_sec->output_section->vma
924 + last_sym_sec->output_offset);
925
926 /* Verify that the previous relocation was for a
927 branch around this instruction and that no symbol
928 exists at the current location. */
929 if (last_value == dot + 4
930 && last_reloc->r_offset + 2 == irel->r_offset
931 && ! elf32_h8_symbol_address_p (abfd, sec, dot))
932 {
933 /* We can eliminate this jump. Twiddle the
934 previous relocation as necessary. */
935 irel->r_info
936 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
937 ELF32_R_TYPE (R_H8_NONE));
938
939 last_reloc->r_info
940 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
941 ELF32_R_TYPE (R_H8_PCREL8));
942 last_reloc->r_addend = irel->r_addend;
943
944
945 code = bfd_get_8 (abfd,
946 contents + last_reloc->r_offset - 1);
947 code ^= 1;
948 bfd_put_8 (abfd,
949 code,
950 contents + last_reloc->r_offset - 1);
951
952 /* Delete four bytes of data. */
953 if (!elf32_h8_relax_delete_bytes (abfd, sec,
954 irel->r_offset - 1,
955 4))
956 goto error_return;
957
958 *again = true;
959 break;
960 }
961 }
962
963 /* We could not eliminate this jump, so just shorten it. */
964 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
965
966 if (code == 0x5e)
967 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);
968 else if (code == 0x5a)
969 bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1);
970 else
971 abort ();
972
973 /* Fix the relocation's type. */
974 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
975 R_H8_PCREL8);
976
977 /* Delete two bytes of data. */
978 if (!elf32_h8_relax_delete_bytes (abfd, sec,
979 irel->r_offset + 1, 2))
980 goto error_return;
981
982 /* That will change things, so, we should relax again.
983 Note that this is not required, and it may be slow. */
984 *again = true;
985 }
986 break;
987 }
988
989 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
990 branch. */
991 case R_H8_PCREL16:
992 {
993 bfd_vma value = symval + irel->r_addend;
994 bfd_vma dot;
995 bfd_vma gap;
996
997 /* Get the address of this instruction. */
998 dot = (sec->output_section->vma
999 + sec->output_offset
1000 + irel->r_offset - 2);
1001
1002 gap = value - dot;
1003
1004 /* If the distance is within -126..+130 inclusive, then we can
1005 relax this jump. +130 is valid since the target will move
1006 two bytes closer if we do relax this branch. */
1007 if ((int)gap >= -126 && (int)gap <= 130)
1008 {
1009 unsigned char code;
1010
1011 /* Note that we've changed the relocs, section contents,
1012 etc. */
1013 elf_section_data (sec)->relocs = internal_relocs;
1014 free_relocs = NULL;
1015
1016 elf_section_data (sec)->this_hdr.contents = contents;
1017 free_contents = NULL;
1018
1019 free_extsyms = NULL;
1020
1021 /* Get the opcode. */
1022 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1023
1024 if (code == 0x58)
1025 {
1026 /* bCC:16 -> bCC:8 */
1027 /* Get the condition code from the original insn. */
1028 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1029 code &= 0xf0;
1030 code >>= 4;
1031 code |= 0x40;
1032 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
1033 }
1034 else if (code == 0x5c)
1035 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);
1036 else
1037 abort ();
1038
1039 /* Fix the relocation's type. */
1040 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1041 R_H8_PCREL8);
1042 irel->r_offset--;
1043
1044 /* Delete two bytes of data. */
1045 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1046 irel->r_offset + 1, 2))
1047 goto error_return;
1048
1049 /* That will change things, so, we should relax again.
1050 Note that this is not required, and it may be slow. */
1051 *again = true;
1052 }
1053 break;
1054 }
1055
1056 /* This is a 16 bit absolute address in a "mov.b" insn, which may
1057 become an 8 bit absolute address if its in the right range. */
1058 case R_H8_DIR16A8:
1059 {
1060 bfd_vma value = symval + irel->r_addend;
1061
1062 if ((bfd_get_mach (abfd) == bfd_mach_h8300
1063 && value >= 0xff00
1064 && value <= 0xffff)
1065 || ((bfd_get_mach (abfd) == bfd_mach_h8300h
1066 || bfd_get_mach (abfd) == bfd_mach_h8300s)
1067 && value >= 0xffff00
1068 && value <= 0xffffff))
1069 {
1070 unsigned char code;
1071
1072 /* Note that we've changed the relocs, section contents,
1073 etc. */
1074 elf_section_data (sec)->relocs = internal_relocs;
1075 free_relocs = NULL;
1076
1077 elf_section_data (sec)->this_hdr.contents = contents;
1078 free_contents = NULL;
1079
1080 free_extsyms = NULL;
1081
1082 /* Get the opcode. */
1083 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1084
1085 /* Sanity check. */
1086 if (code != 0x6a)
1087 abort ();
1088
1089 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1090
1091 if ((code & 0xf0) == 0x00)
1092 bfd_put_8 (abfd,
1093 (code & 0xf) | 0x20,
1094 contents + irel->r_offset - 2);
1095 else if ((code & 0xf0) == 0x80)
1096 bfd_put_8 (abfd,
1097 (code & 0xf) | 0x30,
1098 contents + irel->r_offset - 2);
1099 else
1100 abort ();
1101
1102 /* Fix the relocation's type. */
1103 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1104 R_H8_DIR8);
1105
1106 /* Delete two bytes of data. */
1107 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1108 irel->r_offset + 1, 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 break;
1116 }
1117
1118 /* This is a 24 bit absolute address in a "mov.b" insn, which may
1119 become an 8 bit absolute address if its in the right range. */
1120 case R_H8_DIR24A8:
1121 {
1122 bfd_vma value = symval + irel->r_addend;
1123
1124 if ((bfd_get_mach (abfd) == bfd_mach_h8300
1125 && value >= 0xff00
1126 && value <= 0xffff)
1127 || ((bfd_get_mach (abfd) == bfd_mach_h8300h
1128 || bfd_get_mach (abfd) == bfd_mach_h8300s)
1129 && value >= 0xffff00
1130 && value <= 0xffffff))
1131 {
1132 unsigned char code;
1133
1134 /* Note that we've changed the relocs, section contents,
1135 etc. */
1136 elf_section_data (sec)->relocs = internal_relocs;
1137 free_relocs = NULL;
1138
1139 elf_section_data (sec)->this_hdr.contents = contents;
1140 free_contents = NULL;
1141
1142 free_extsyms = NULL;
1143
1144 /* Get the opcode. */
1145 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1146
1147 /* Sanity check. */
1148 if (code != 0x6a)
1149 abort ();
1150
1151 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1152
1153 if ((code & 0xf0) == 0x00)
1154 bfd_put_8 (abfd,
1155 (code & 0xf) | 0x20,
1156 contents + irel->r_offset - 2);
1157 else if ((code & 0xf0) == 0x80)
1158 bfd_put_8 (abfd,
1159 (code & 0xf) | 0x30,
1160 contents + irel->r_offset - 2);
1161 else
1162 abort ();
1163
1164 /* Fix the relocation's type. */
1165 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1166 R_H8_DIR8);
1167
1168 /* Delete two bytes of data. */
1169 if (!elf32_h8_relax_delete_bytes (abfd, sec, irel->r_offset, 2))
1170 goto error_return;
1171
1172 /* That will change things, so, we should relax again.
1173 Note that this is not required, and it may be slow. */
1174 *again = true;
1175 }
1176 }
1177
1178 /* FALLTHRU */
1179
1180 /* This is a 24/32bit absolute address in a "mov" insn, which may
1181 become a 16bit absoulte address if it is in the right range. */
1182 case R_H8_DIR32A16:
1183 {
1184 bfd_vma value = symval + irel->r_addend;
1185
1186 if (value <= 0x7fff || value >= 0xff8000)
1187 {
1188 unsigned char code;
1189
1190 /* Note that we've changed the relocs, section contents,
1191 etc. */
1192 elf_section_data (sec)->relocs = internal_relocs;
1193 free_relocs = NULL;
1194
1195 elf_section_data (sec)->this_hdr.contents = contents;
1196 free_contents = NULL;
1197
1198 free_extsyms = NULL;
1199
1200 /* Get the opcode. */
1201 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1202
1203 /* We just need to turn off bit 0x20. */
1204 code &= ~0x20;
1205
1206 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1207
1208 /* Fix the relocation's type. */
1209 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1210 R_H8_DIR16A8);
1211
1212 /* Delete two bytes of data. */
1213 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1214 irel->r_offset + 1, 2))
1215 goto error_return;
1216
1217 /* That will change things, so, we should relax again.
1218 Note that this is not required, and it may be slow. */
1219 *again = true;
1220 }
1221 break;
1222 }
1223
1224 default:
1225 break;
1226 }
1227 }
1228
1229 if (free_relocs != NULL)
1230 {
1231 free (free_relocs);
1232 free_relocs = NULL;
1233 }
1234
1235 if (free_contents != NULL)
1236 {
1237 if (! link_info->keep_memory)
1238 free (free_contents);
1239 else
1240 {
1241 /* Cache the section contents for elf_link_input_bfd. */
1242 elf_section_data (sec)->this_hdr.contents = contents;
1243 }
1244 free_contents = NULL;
1245 }
1246
1247 if (shndx_buf != NULL)
1248 {
1249 shndx_hdr->contents = NULL;
1250 free (shndx_buf);
1251 }
1252
1253 if (free_extsyms != NULL)
1254 {
1255 if (! link_info->keep_memory)
1256 {
1257 symtab_hdr->contents = NULL;
1258 free (free_extsyms);
1259 }
1260 }
1261
1262 return true;
1263
1264 error_return:
1265 if (free_relocs != NULL)
1266 free (free_relocs);
1267 if (free_contents != NULL)
1268 free (free_contents);
1269 if (shndx_buf != NULL)
1270 {
1271 shndx_hdr->contents = NULL;
1272 free (shndx_buf);
1273 }
1274 if (free_extsyms != NULL)
1275 {
1276 symtab_hdr->contents = NULL;
1277 free (free_extsyms);
1278 }
1279 return false;
1280 }
1281
1282 /* Delete some bytes from a section while relaxing. */
1283
1284 static boolean
1285 elf32_h8_relax_delete_bytes (abfd, sec, addr, count)
1286 bfd *abfd;
1287 asection *sec;
1288 bfd_vma addr;
1289 int count;
1290 {
1291 Elf_Internal_Shdr *symtab_hdr;
1292 Elf_Internal_Shdr *shndx_hdr;
1293 Elf32_External_Sym *extsyms;
1294 unsigned int sec_shndx;
1295 bfd_byte *contents;
1296 Elf_Internal_Rela *irel, *irelend;
1297 Elf_Internal_Rela *irelalign;
1298 bfd_vma toaddr;
1299 Elf32_External_Sym *esym, *esymend;
1300 Elf_External_Sym_Shndx *shndx;
1301 struct elf_link_hash_entry **sym_hashes;
1302 struct elf_link_hash_entry **end_hashes;
1303 unsigned int symcount;
1304
1305 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1306 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1307
1308 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1309
1310 contents = elf_section_data (sec)->this_hdr.contents;
1311
1312 /* The deletion must stop at the next ALIGN reloc for an aligment
1313 power larger than the number of bytes we are deleting. */
1314
1315 irelalign = NULL;
1316 toaddr = sec->_cooked_size;
1317
1318 irel = elf_section_data (sec)->relocs;
1319 irelend = irel + sec->reloc_count;
1320
1321 /* Actually delete the bytes. */
1322 memmove (contents + addr, contents + addr + count,
1323 (size_t) (toaddr - addr - count));
1324 sec->_cooked_size -= count;
1325
1326 /* Adjust all the relocs. */
1327 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1328 {
1329 /* Get the new reloc address. */
1330 if ((irel->r_offset > addr
1331 && irel->r_offset < toaddr))
1332 irel->r_offset -= count;
1333 }
1334
1335 /* Adjust the local symbols defined in this section. */
1336 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1337 shndx = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
1338 esym = extsyms;
1339 esymend = esym + symtab_hdr->sh_info;
1340 for (; esym < esymend; esym++, shndx = (shndx ? shndx + 1 : NULL))
1341 {
1342 Elf_Internal_Sym isym;
1343 Elf_External_Sym_Shndx dummy;
1344
1345 bfd_elf32_swap_symbol_in (abfd, (const PTR) esym, (const PTR) shndx,
1346 &isym);
1347
1348 if (isym.st_shndx == sec_shndx
1349 && isym.st_value > addr
1350 && isym.st_value < toaddr)
1351 {
1352 isym.st_value -= count;
1353 bfd_elf32_swap_symbol_out (abfd, &isym, esym, &dummy);
1354 }
1355 }
1356
1357 /* Now adjust the global symbols defined in this section. */
1358 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1359 - symtab_hdr->sh_info);
1360 sym_hashes = elf_sym_hashes (abfd);
1361 end_hashes = sym_hashes + symcount;
1362 for (; sym_hashes < end_hashes; sym_hashes++)
1363 {
1364 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1365 if ((sym_hash->root.type == bfd_link_hash_defined
1366 || sym_hash->root.type == bfd_link_hash_defweak)
1367 && sym_hash->root.u.def.section == sec
1368 && sym_hash->root.u.def.value > addr
1369 && sym_hash->root.u.def.value < toaddr)
1370 {
1371 sym_hash->root.u.def.value -= count;
1372 }
1373 }
1374
1375 return true;
1376 }
1377
1378 /* Return true if a symbol exists at the given address, else return
1379 false. */
1380 static boolean
1381 elf32_h8_symbol_address_p (abfd, sec, addr)
1382 bfd *abfd;
1383 asection *sec;
1384 bfd_vma addr;
1385 {
1386 Elf_Internal_Shdr *symtab_hdr;
1387 Elf_Internal_Shdr *shndx_hdr;
1388 unsigned int sec_shndx;
1389 Elf32_External_Sym *esym, *esymend;
1390 Elf_External_Sym_Shndx *shndx;
1391 struct elf_link_hash_entry **sym_hashes;
1392 struct elf_link_hash_entry **end_hashes;
1393 unsigned int symcount;
1394
1395 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1396
1397 /* Examine all the symbols. */
1398 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1399 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1400 shndx = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
1401 esym = (Elf32_External_Sym *) symtab_hdr->contents;
1402 esymend = esym + symtab_hdr->sh_info;
1403 for (; esym < esymend; esym++, shndx = (shndx ? shndx + 1 : NULL))
1404 {
1405 Elf_Internal_Sym isym;
1406
1407 bfd_elf32_swap_symbol_in (abfd, (const PTR) esym, (const PTR) shndx,
1408 &isym);
1409
1410 if (isym.st_shndx == sec_shndx
1411 && isym.st_value == addr)
1412 return true;
1413 }
1414
1415 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1416 - symtab_hdr->sh_info);
1417 sym_hashes = elf_sym_hashes (abfd);
1418 end_hashes = sym_hashes + symcount;
1419 for (; sym_hashes < end_hashes; sym_hashes++)
1420 {
1421 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1422 if ((sym_hash->root.type == bfd_link_hash_defined
1423 || sym_hash->root.type == bfd_link_hash_defweak)
1424 && sym_hash->root.u.def.section == sec
1425 && sym_hash->root.u.def.value == addr)
1426 return true;
1427 }
1428
1429 return false;
1430 }
1431
1432 /* This is a version of bfd_generic_get_relocated_section_contents
1433 which uses elf32_h8_relocate_section. */
1434
1435 static bfd_byte *
1436 elf32_h8_get_relocated_section_contents (output_bfd, link_info, link_order,
1437 data, relocateable, symbols)
1438 bfd *output_bfd;
1439 struct bfd_link_info *link_info;
1440 struct bfd_link_order *link_order;
1441 bfd_byte *data;
1442 boolean relocateable;
1443 asymbol **symbols;
1444 {
1445 Elf_Internal_Shdr *symtab_hdr;
1446 Elf_Internal_Shdr *shndx_hdr;
1447 asection *input_section = link_order->u.indirect.section;
1448 bfd *input_bfd = input_section->owner;
1449 asection **sections = NULL;
1450 Elf_Internal_Rela *internal_relocs = NULL;
1451 Elf32_External_Sym *external_syms = NULL;
1452 Elf_External_Sym_Shndx *shndx_buf = NULL;
1453 Elf_External_Sym_Shndx *shndx;
1454 Elf_Internal_Sym *internal_syms = NULL;
1455
1456 /* We only need to handle the case of relaxing, or of having a
1457 particular set of section contents, specially. */
1458 if (relocateable
1459 || elf_section_data (input_section)->this_hdr.contents == NULL)
1460 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1461 link_order, data,
1462 relocateable,
1463 symbols);
1464
1465 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1466 shndx_hdr = &elf_tdata (input_bfd)->symtab_shndx_hdr;
1467
1468 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1469 (size_t) input_section->_raw_size);
1470
1471 if ((input_section->flags & SEC_RELOC) != 0
1472 && input_section->reloc_count > 0)
1473 {
1474 Elf_Internal_Sym *isymp;
1475 asection **secpp;
1476 Elf32_External_Sym *esym, *esymend;
1477 bfd_size_type amt;
1478
1479 if (symtab_hdr->contents != NULL)
1480 external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
1481 else if (symtab_hdr->sh_info != 0)
1482 {
1483 amt = symtab_hdr->sh_info;
1484 amt *= sizeof (Elf32_External_Sym);
1485 external_syms = (Elf32_External_Sym *) bfd_malloc (amt);
1486 if (external_syms == NULL)
1487 goto error_return;
1488 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1489 || bfd_bread ((PTR) external_syms, amt, input_bfd) != amt)
1490 goto error_return;
1491 }
1492
1493 if (symtab_hdr->sh_info != 0 && shndx_hdr->sh_size != 0)
1494 {
1495 amt = symtab_hdr->sh_info;
1496 amt *= sizeof (Elf_External_Sym_Shndx);
1497 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
1498 if (shndx_buf == NULL)
1499 goto error_return;
1500 if (bfd_seek (input_bfd, shndx_hdr->sh_offset, SEEK_SET) != 0
1501 || bfd_bread ((PTR) shndx_buf, amt, input_bfd) != amt)
1502 goto error_return;
1503 }
1504
1505 internal_relocs = (_bfd_elf32_link_read_relocs
1506 (input_bfd, input_section, (PTR) NULL,
1507 (Elf_Internal_Rela *) NULL, false));
1508 if (internal_relocs == NULL)
1509 goto error_return;
1510
1511 amt = symtab_hdr->sh_info;
1512 amt *= sizeof (Elf_Internal_Sym);
1513 internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
1514 if (internal_syms == NULL && amt != 0)
1515 goto error_return;
1516
1517 amt = symtab_hdr->sh_info;
1518 amt *= sizeof (asection *);
1519 sections = (asection **) bfd_malloc (amt);
1520 if (sections == NULL && amt != 0)
1521 goto error_return;
1522
1523 for (isymp = internal_syms, secpp = sections, shndx = shndx_buf,
1524 esym = external_syms, esymend = esym + symtab_hdr->sh_info;
1525 esym < esymend;
1526 ++esym, ++isymp, ++secpp, shndx = (shndx ? shndx + 1 : NULL))
1527 {
1528 asection *isec;
1529
1530 bfd_elf32_swap_symbol_in (input_bfd, (const PTR) esym,
1531 (const PTR) shndx, isymp);
1532
1533 if (isymp->st_shndx == SHN_UNDEF)
1534 isec = bfd_und_section_ptr;
1535 else if (isymp->st_shndx == SHN_ABS)
1536 isec = bfd_abs_section_ptr;
1537 else if (isymp->st_shndx == SHN_COMMON)
1538 isec = bfd_com_section_ptr;
1539 else
1540 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
1541
1542 *secpp = isec;
1543 }
1544
1545 if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1546 input_section, data, internal_relocs,
1547 internal_syms, sections))
1548 goto error_return;
1549
1550 if (sections != NULL)
1551 free (sections);
1552 if (internal_syms != NULL)
1553 free (internal_syms);
1554 if (shndx_buf != NULL)
1555 free (shndx_buf);
1556 if (external_syms != NULL && symtab_hdr->contents == NULL)
1557 free (external_syms);
1558 if (internal_relocs != elf_section_data (input_section)->relocs)
1559 free (internal_relocs);
1560 }
1561
1562 return data;
1563
1564 error_return:
1565 if (internal_relocs != NULL
1566 && internal_relocs != elf_section_data (input_section)->relocs)
1567 free (internal_relocs);
1568 if (shndx_buf != NULL)
1569 free (shndx_buf);
1570 if (external_syms != NULL && symtab_hdr->contents == NULL)
1571 free (external_syms);
1572 if (internal_syms != NULL)
1573 free (internal_syms);
1574 if (sections != NULL)
1575 free (sections);
1576 return NULL;
1577 }
1578
1579
1580 #define TARGET_BIG_SYM bfd_elf32_h8300_vec
1581 #define TARGET_BIG_NAME "elf32-h8300"
1582 #define ELF_ARCH bfd_arch_h8300
1583 #define ELF_MACHINE_CODE EM_H8_300
1584 #define ELF_MAXPAGESIZE 0x1
1585 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1586 #define elf_info_to_howto elf32_h8_info_to_howto
1587 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1588
1589 /* So we can set/examine bits in e_flags to get the specific
1590 H8 architecture in use. */
1591 #define elf_backend_final_write_processing \
1592 elf32_h8_final_write_processing
1593 #define elf_backend_object_p \
1594 elf32_h8_object_p
1595 #define bfd_elf32_bfd_merge_private_bfd_data \
1596 elf32_h8_merge_private_bfd_data
1597
1598 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1599 defaults to using _bfd_generic_link_hash_table_create, but
1600 elflink.h:bfd_elf32_size_dynamic_sections uses
1601 dynobj = elf_hash_table (info)->dynobj;
1602 and thus requires an elf hash table. */
1603 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1604
1605 /* Use an H8 specific linker, not the ELF generic linker. */
1606 #define elf_backend_relocate_section elf32_h8_relocate_section
1607
1608 /* And relaxing stuff. */
1609 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1610 #define bfd_elf32_bfd_get_relocated_section_contents \
1611 elf32_h8_get_relocated_section_contents
1612
1613
1614 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.061605 seconds and 5 git commands to generate.