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