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