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