projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
s/boolean/bfd_boolean/ s/true/TRUE/ s/false/FALSE/. Simplify
[deliverable/binutils-gdb.git] / bfd / elf32-h8300.c
1 /* Generic support for 32-bit ELF
2 Copyright 1993, 1995, 1998, 1999, 2001, 2002
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/h8.h"
26
27 static reloc_howto_type *elf32_h8_reloc_type_lookup
28 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
29 static void elf32_h8_info_to_howto
30 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
31 static void elf32_h8_info_to_howto_rel
32 PARAMS ((bfd *, arelent *, 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_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 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->relocateable)
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 }
578
579 /* The final processing done just before writing out a H8 ELF object
580 file. We use this opportunity to encode the BFD machine type
581 into the flags field in the object file. */
582
583 static void
584 elf32_h8_final_write_processing (abfd, linker)
585 bfd *abfd;
586 bfd_boolean linker ATTRIBUTE_UNUSED;
587 {
588 unsigned long val;
589
590 switch (bfd_get_mach (abfd))
591 {
592 default:
593 case bfd_mach_h8300:
594 val = E_H8_MACH_H8300;
595 break;
596
597 case bfd_mach_h8300h:
598 val = E_H8_MACH_H8300H;
599 break;
600
601 case bfd_mach_h8300s:
602 val = E_H8_MACH_H8300S;
603 break;
604 }
605
606 elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH);
607 elf_elfheader (abfd)->e_flags |= val;
608 }
609
610 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
611 record the encoded machine type found in the ELF flags. */
612
613 static bfd_boolean
614 elf32_h8_object_p (abfd)
615 bfd *abfd;
616 {
617 bfd_default_set_arch_mach (abfd, bfd_arch_h8300,
618 elf32_h8_mach (elf_elfheader (abfd)->e_flags));
619 return TRUE;
620 }
621
622 /* Merge backend specific data from an object file to the output
623 object file when linking. The only data we need to copy at this
624 time is the architecture/machine information. */
625
626 static bfd_boolean
627 elf32_h8_merge_private_bfd_data (ibfd, obfd)
628 bfd *ibfd;
629 bfd *obfd;
630 {
631 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
632 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
633 return TRUE;
634
635 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
636 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
637 {
638 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
639 bfd_get_mach (ibfd)))
640 return FALSE;
641 }
642
643 return TRUE;
644 }
645
646 /* This function handles relaxing for the H8..
647
648 There's a few relaxing opportunites available on the H8:
649
650 jmp/jsr:24 -> bra/bsr:8 2 bytes
651 The jmp may be completely eliminated if the previous insn is a
652 conditional branch to the insn after the jump. In that case
653 we invert the branch and delete the jump and save 4 bytes.
654
655 bCC:16 -> bCC:8 2 bytes
656 bsr:16 -> bsr:8 2 bytes
657
658 mov.b:16 -> mov.b:8 2 bytes
659 mov.b:24/32 -> mov.b:8 4 bytes
660
661 mov.[bwl]:24/32 -> mov.[bwl]:16 2 bytes */
662
663 static bfd_boolean
664 elf32_h8_relax_section (abfd, sec, link_info, again)
665 bfd *abfd;
666 asection *sec;
667 struct bfd_link_info *link_info;
668 bfd_boolean *again;
669 {
670 Elf_Internal_Shdr *symtab_hdr;
671 Elf_Internal_Rela *internal_relocs;
672 Elf_Internal_Rela *irel, *irelend;
673 bfd_byte *contents = NULL;
674 Elf_Internal_Sym *isymbuf = NULL;
675 static asection *last_input_section = NULL;
676 static Elf_Internal_Rela *last_reloc = NULL;
677
678 /* Assume nothing changes. */
679 *again = FALSE;
680
681 /* We don't have to do anything for a relocateable link, if
682 this section does not have relocs, or if this is not a
683 code section. */
684 if (link_info->relocateable
685 || (sec->flags & SEC_RELOC) == 0
686 || sec->reloc_count == 0
687 || (sec->flags & SEC_CODE) == 0)
688 return TRUE;
689
690 /* If this is the first time we have been called for this section,
691 initialize the cooked size. */
692 if (sec->_cooked_size == 0)
693 sec->_cooked_size = sec->_raw_size;
694
695 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
696
697 /* Get a copy of the native relocations. */
698 internal_relocs = (_bfd_elf32_link_read_relocs
699 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
700 link_info->keep_memory));
701 if (internal_relocs == NULL)
702 goto error_return;
703
704 if (sec != last_input_section)
705 last_reloc = NULL;
706
707 last_input_section = sec;
708
709 /* Walk through the relocs looking for relaxing opportunities. */
710 irelend = internal_relocs + sec->reloc_count;
711 for (irel = internal_relocs; irel < irelend; irel++)
712 {
713 bfd_vma symval;
714
715 /* Keep track of the previous reloc so that we can delete
716 some long jumps created by the compiler. */
717 if (irel != internal_relocs)
718 last_reloc = irel - 1;
719
720 if (ELF32_R_TYPE (irel->r_info) != R_H8_DIR24R8
721 && ELF32_R_TYPE (irel->r_info) != R_H8_PCREL16
722 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR16A8
723 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR24A8
724 && ELF32_R_TYPE (irel->r_info) != R_H8_DIR32A16)
725 continue;
726
727 /* Get the section contents if we haven't done so already. */
728 if (contents == NULL)
729 {
730 /* Get cached copy if it exists. */
731 if (elf_section_data (sec)->this_hdr.contents != NULL)
732 contents = elf_section_data (sec)->this_hdr.contents;
733 else
734 {
735 /* Go get them off disk. */
736 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
737 if (contents == NULL)
738 goto error_return;
739
740 if (! bfd_get_section_contents (abfd, sec, contents,
741 (file_ptr) 0, sec->_raw_size))
742 goto error_return;
743 }
744 }
745
746 /* Read this BFD's local symbols if we haven't done so already. */
747 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
748 {
749 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
750 if (isymbuf == NULL)
751 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
752 symtab_hdr->sh_info, 0,
753 NULL, NULL, NULL);
754 if (isymbuf == NULL)
755 goto error_return;
756 }
757
758 /* Get the value of the symbol referred to by the reloc. */
759 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
760 {
761 /* A local symbol. */
762 Elf_Internal_Sym *isym;
763 asection *sym_sec;
764
765 isym = isymbuf + ELF32_R_SYM (irel->r_info);
766 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
767 symval = (isym->st_value
768 + sym_sec->output_section->vma
769 + sym_sec->output_offset);
770 }
771 else
772 {
773 unsigned long indx;
774 struct elf_link_hash_entry *h;
775
776 /* An external symbol. */
777 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
778 h = elf_sym_hashes (abfd)[indx];
779 BFD_ASSERT (h != NULL);
780 if (h->root.type != bfd_link_hash_defined
781 && h->root.type != bfd_link_hash_defweak)
782 {
783 /* This appears to be a reference to an undefined
784 symbol. Just ignore it--it will be caught by the
785 regular reloc processing. */
786 continue;
787 }
788
789 symval = (h->root.u.def.value
790 + h->root.u.def.section->output_section->vma
791 + h->root.u.def.section->output_offset);
792 }
793
794 /* For simplicity of coding, we are going to modify the section
795 contents, the section relocs, and the BFD symbol table. We
796 must tell the rest of the code not to free up this
797 information. It would be possible to instead create a table
798 of changes which have to be made, as is done in coff-mips.c;
799 that would be more work, but would require less memory when
800 the linker is run. */
801 switch (ELF32_R_TYPE (irel->r_info))
802 {
803 /* Try to turn a 24 bit absolute branch/call into an 8 bit
804 pc-relative branch/call. */
805 case R_H8_DIR24R8:
806 {
807 bfd_vma value = symval + irel->r_addend;
808 bfd_vma dot, gap;
809
810 /* Get the address of this instruction. */
811 dot = (sec->output_section->vma
812 + sec->output_offset + irel->r_offset - 1);
813
814 /* Compute the distance from this insn to the branch target. */
815 gap = value - dot;
816
817 /* If the distance is within -126..+130 inclusive, then we can
818 relax this jump. +130 is valid since the target will move
819 two bytes closer if we do relax this branch. */
820 if ((int) gap >= -126 && (int) gap <= 130)
821 {
822 unsigned char code;
823
824 /* Note that we've changed the relocs, section contents,
825 etc. */
826 elf_section_data (sec)->relocs = internal_relocs;
827 elf_section_data (sec)->this_hdr.contents = contents;
828 symtab_hdr->contents = (unsigned char *) isymbuf;
829
830 /* Get the instruction code being relaxed. */
831 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
832
833 /* If the previous instruction conditionally jumped around
834 this instruction, we may be able to reverse the condition
835 and redirect the previous instruction to the target of
836 this instruction.
837
838 Such sequences are used by the compiler to deal with
839 long conditional branches.
840
841 Only perform this optimisation for jumps (code 0x5a) not
842 subroutine calls, as otherwise it could transform:
843
844 mov.w r0,r0
845 beq .L1
846 jsr @_bar
847 .L1: rts
848 _bar: rts
849 into:
850 mov.w r0,r0
851 bne _bar
852 rts
853 _bar: rts
854
855 which changes the call (jsr) into a branch (bne). */
856 if (code == 0x5a
857 && (int) gap <= 130
858 && (int) gap >= -128
859 && last_reloc
860 && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
861 && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
862 {
863 bfd_vma last_value;
864 asection *last_sym_sec;
865 Elf_Internal_Sym *last_sym;
866
867 /* We will need to examine the symbol used by the
868 previous relocation. */
869
870 last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
871 last_sym_sec
872 = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
873 last_value = (last_sym->st_value
874 + last_sym_sec->output_section->vma
875 + last_sym_sec->output_offset);
876
877 /* Verify that the previous relocation was for a
878 branch around this instruction and that no symbol
879 exists at the current location. */
880 if (last_value == dot + 4
881 && last_reloc->r_offset + 2 == irel->r_offset
882 && ! elf32_h8_symbol_address_p (abfd, sec, dot))
883 {
884 /* We can eliminate this jump. Twiddle the
885 previous relocation as necessary. */
886 irel->r_info
887 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
888 ELF32_R_TYPE (R_H8_NONE));
889
890 last_reloc->r_info
891 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
892 ELF32_R_TYPE (R_H8_PCREL8));
893 last_reloc->r_addend = irel->r_addend;
894
895 code = bfd_get_8 (abfd,
896 contents + last_reloc->r_offset - 1);
897 code ^= 1;
898 bfd_put_8 (abfd,
899 code,
900 contents + last_reloc->r_offset - 1);
901
902 /* Delete four bytes of data. */
903 if (!elf32_h8_relax_delete_bytes (abfd, sec,
904 irel->r_offset - 1,
905 4))
906 goto error_return;
907
908 *again = TRUE;
909 break;
910 }
911 }
912
913 if (code == 0x5e)
914 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);
915 else if (code == 0x5a)
916 bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1);
917 else
918 abort ();
919
920 /* Fix the relocation's type. */
921 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
922 R_H8_PCREL8);
923
924 /* Delete two bytes of data. */
925 if (!elf32_h8_relax_delete_bytes (abfd, sec,
926 irel->r_offset + 1, 2))
927 goto error_return;
928
929 /* That will change things, so, we should relax again.
930 Note that this is not required, and it may be slow. */
931 *again = TRUE;
932 }
933 break;
934 }
935
936 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
937 branch. */
938 case R_H8_PCREL16:
939 {
940 bfd_vma value = symval + irel->r_addend;
941 bfd_vma dot;
942 bfd_vma gap;
943
944 /* Get the address of this instruction. */
945 dot = (sec->output_section->vma
946 + sec->output_offset
947 + irel->r_offset - 2);
948
949 gap = value - dot;
950
951 /* If the distance is within -126..+130 inclusive, then we can
952 relax this jump. +130 is valid since the target will move
953 two bytes closer if we do relax this branch. */
954 if ((int) gap >= -126 && (int) gap <= 130)
955 {
956 unsigned char code;
957
958 /* Note that we've changed the relocs, section contents,
959 etc. */
960 elf_section_data (sec)->relocs = internal_relocs;
961 elf_section_data (sec)->this_hdr.contents = contents;
962 symtab_hdr->contents = (unsigned char *) isymbuf;
963
964 /* Get the opcode. */
965 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
966
967 if (code == 0x58)
968 {
969 /* bCC:16 -> bCC:8 */
970 /* Get the condition code from the original insn. */
971 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
972 code &= 0xf0;
973 code >>= 4;
974 code |= 0x40;
975 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
976 }
977 else if (code == 0x5c)
978 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);
979 else
980 abort ();
981
982 /* Fix the relocation's type. */
983 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
984 R_H8_PCREL8);
985 irel->r_offset--;
986
987 /* Delete two bytes of data. */
988 if (!elf32_h8_relax_delete_bytes (abfd, sec,
989 irel->r_offset + 1, 2))
990 goto error_return;
991
992 /* That will change things, so, we should relax again.
993 Note that this is not required, and it may be slow. */
994 *again = TRUE;
995 }
996 break;
997 }
998
999 /* This is a 16 bit absolute address in a "mov.b" insn, which may
1000 become an 8 bit absolute address if its in the right range. */
1001 case R_H8_DIR16A8:
1002 {
1003 bfd_vma value = symval + irel->r_addend;
1004
1005 if ((bfd_get_mach (abfd) == bfd_mach_h8300
1006 && value >= 0xff00
1007 && value <= 0xffff)
1008 || ((bfd_get_mach (abfd) == bfd_mach_h8300h
1009 || bfd_get_mach (abfd) == bfd_mach_h8300s)
1010 && value >= 0xffff00
1011 && value <= 0xffffff))
1012 {
1013 unsigned char code;
1014
1015 /* Note that we've changed the relocs, section contents,
1016 etc. */
1017 elf_section_data (sec)->relocs = internal_relocs;
1018 elf_section_data (sec)->this_hdr.contents = contents;
1019 symtab_hdr->contents = (unsigned char *) isymbuf;
1020
1021 /* Get the opcode. */
1022 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1023
1024 /* Sanity check. */
1025 if (code != 0x6a)
1026 abort ();
1027
1028 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1029
1030 if ((code & 0xf0) == 0x00)
1031 bfd_put_8 (abfd,
1032 (code & 0xf) | 0x20,
1033 contents + irel->r_offset - 2);
1034 else if ((code & 0xf0) == 0x80)
1035 bfd_put_8 (abfd,
1036 (code & 0xf) | 0x30,
1037 contents + irel->r_offset - 2);
1038 else
1039 abort ();
1040
1041 /* Fix the relocation's type. */
1042 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1043 R_H8_DIR8);
1044
1045 /* Delete two bytes of data. */
1046 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1047 irel->r_offset + 1, 2))
1048 goto error_return;
1049
1050 /* That will change things, so, we should relax again.
1051 Note that this is not required, and it may be slow. */
1052 *again = TRUE;
1053 }
1054 break;
1055 }
1056
1057 /* This is a 24 bit absolute address in a "mov.b" insn, which may
1058 become an 8 bit absolute address if its in the right range. */
1059 case R_H8_DIR24A8:
1060 {
1061 bfd_vma value = symval + irel->r_addend;
1062
1063 if ((bfd_get_mach (abfd) == bfd_mach_h8300
1064 && value >= 0xff00
1065 && value <= 0xffff)
1066 || ((bfd_get_mach (abfd) == bfd_mach_h8300h
1067 || bfd_get_mach (abfd) == bfd_mach_h8300s)
1068 && value >= 0xffff00
1069 && value <= 0xffffff))
1070 {
1071 unsigned char code;
1072
1073 /* Note that we've changed the relocs, section contents,
1074 etc. */
1075 elf_section_data (sec)->relocs = internal_relocs;
1076 elf_section_data (sec)->this_hdr.contents = contents;
1077 symtab_hdr->contents = (unsigned char *) isymbuf;
1078
1079 /* Get the opcode. */
1080 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1081
1082 /* Sanity check. */
1083 if (code != 0x6a)
1084 abort ();
1085
1086 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1087
1088 if ((code & 0xf0) == 0x00)
1089 bfd_put_8 (abfd,
1090 (code & 0xf) | 0x20,
1091 contents + irel->r_offset - 2);
1092 else if ((code & 0xf0) == 0x80)
1093 bfd_put_8 (abfd,
1094 (code & 0xf) | 0x30,
1095 contents + irel->r_offset - 2);
1096 else
1097 abort ();
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
1103 /* Delete two bytes of data. */
1104 if (!elf32_h8_relax_delete_bytes (abfd, sec, irel->r_offset, 2))
1105 goto error_return;
1106
1107 /* That will change things, so, we should relax again.
1108 Note that this is not required, and it may be slow. */
1109 *again = TRUE;
1110 }
1111 }
1112
1113 /* FALLTHRU */
1114
1115 /* This is a 24/32bit absolute address in a "mov" insn, which may
1116 become a 16bit absoulte address if it is in the right range. */
1117 case R_H8_DIR32A16:
1118 {
1119 bfd_vma value = symval + irel->r_addend;
1120
1121 if (value <= 0x7fff || value >= 0xff8000)
1122 {
1123 unsigned char code;
1124
1125 /* Note that we've changed the relocs, section contents,
1126 etc. */
1127 elf_section_data (sec)->relocs = internal_relocs;
1128 elf_section_data (sec)->this_hdr.contents = contents;
1129 symtab_hdr->contents = (unsigned char *) isymbuf;
1130
1131 /* Get the opcode. */
1132 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1133
1134 /* We just need to turn off bit 0x20. */
1135 code &= ~0x20;
1136
1137 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1138
1139 /* Fix the relocation's type. */
1140 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1141 R_H8_DIR16A8);
1142
1143 /* Delete two bytes of data. */
1144 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1145 irel->r_offset + 1, 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 break;
1153 }
1154
1155 default:
1156 break;
1157 }
1158 }
1159
1160 if (isymbuf != NULL
1161 && symtab_hdr->contents != (unsigned char *) isymbuf)
1162 {
1163 if (! link_info->keep_memory)
1164 free (isymbuf);
1165 else
1166 symtab_hdr->contents = (unsigned char *) isymbuf;
1167 }
1168
1169 if (contents != NULL
1170 && elf_section_data (sec)->this_hdr.contents != contents)
1171 {
1172 if (! link_info->keep_memory)
1173 free (contents);
1174 else
1175 {
1176 /* Cache the section contents for elf_link_input_bfd. */
1177 elf_section_data (sec)->this_hdr.contents = contents;
1178 }
1179 }
1180
1181 if (internal_relocs != NULL
1182 && elf_section_data (sec)->relocs != internal_relocs)
1183 free (internal_relocs);
1184
1185 return TRUE;
1186
1187 error_return:
1188 if (isymbuf != NULL
1189 && symtab_hdr->contents != (unsigned char *) isymbuf)
1190 free (isymbuf);
1191 if (contents != NULL
1192 && elf_section_data (sec)->this_hdr.contents != contents)
1193 free (contents);
1194 if (internal_relocs != NULL
1195 && elf_section_data (sec)->relocs != internal_relocs)
1196 free (internal_relocs);
1197 return FALSE;
1198 }
1199
1200 /* Delete some bytes from a section while relaxing. */
1201
1202 static bfd_boolean
1203 elf32_h8_relax_delete_bytes (abfd, sec, addr, count)
1204 bfd *abfd;
1205 asection *sec;
1206 bfd_vma addr;
1207 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 (abfd, sec, addr)
1285 bfd *abfd;
1286 asection *sec;
1287 bfd_vma addr;
1288 {
1289 Elf_Internal_Shdr *symtab_hdr;
1290 unsigned int sec_shndx;
1291 Elf_Internal_Sym *isym;
1292 Elf_Internal_Sym *isymend;
1293 struct elf_link_hash_entry **sym_hashes;
1294 struct elf_link_hash_entry **end_hashes;
1295 unsigned int symcount;
1296
1297 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1298
1299 /* Examine all the symbols. */
1300 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1301 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1302 isymend = isym + symtab_hdr->sh_info;
1303 for (; isym < isymend; isym++)
1304 {
1305 if (isym->st_shndx == sec_shndx
1306 && isym->st_value == addr)
1307 return TRUE;
1308 }
1309
1310 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1311 - symtab_hdr->sh_info);
1312 sym_hashes = elf_sym_hashes (abfd);
1313 end_hashes = sym_hashes + symcount;
1314 for (; sym_hashes < end_hashes; sym_hashes++)
1315 {
1316 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1317 if ((sym_hash->root.type == bfd_link_hash_defined
1318 || sym_hash->root.type == bfd_link_hash_defweak)
1319 && sym_hash->root.u.def.section == sec
1320 && sym_hash->root.u.def.value == addr)
1321 return TRUE;
1322 }
1323
1324 return FALSE;
1325 }
1326
1327 /* This is a version of bfd_generic_get_relocated_section_contents
1328 which uses elf32_h8_relocate_section. */
1329
1330 static bfd_byte *
1331 elf32_h8_get_relocated_section_contents (output_bfd, link_info, link_order,
1332 data, relocateable, symbols)
1333 bfd *output_bfd;
1334 struct bfd_link_info *link_info;
1335 struct bfd_link_order *link_order;
1336 bfd_byte *data;
1337 bfd_boolean relocateable;
1338 asymbol **symbols;
1339 {
1340 Elf_Internal_Shdr *symtab_hdr;
1341 asection *input_section = link_order->u.indirect.section;
1342 bfd *input_bfd = input_section->owner;
1343 asection **sections = NULL;
1344 Elf_Internal_Rela *internal_relocs = NULL;
1345 Elf_Internal_Sym *isymbuf = NULL;
1346
1347 /* We only need to handle the case of relaxing, or of having a
1348 particular set of section contents, specially. */
1349 if (relocateable
1350 || elf_section_data (input_section)->this_hdr.contents == NULL)
1351 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1352 link_order, data,
1353 relocateable,
1354 symbols);
1355
1356 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1357
1358 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1359 (size_t) input_section->_raw_size);
1360
1361 if ((input_section->flags & SEC_RELOC) != 0
1362 && input_section->reloc_count > 0)
1363 {
1364 asection **secpp;
1365 Elf_Internal_Sym *isym, *isymend;
1366 bfd_size_type amt;
1367
1368 internal_relocs = (_bfd_elf32_link_read_relocs
1369 (input_bfd, input_section, (PTR) NULL,
1370 (Elf_Internal_Rela *) NULL, FALSE));
1371 if (internal_relocs == NULL)
1372 goto error_return;
1373
1374 if (symtab_hdr->sh_info != 0)
1375 {
1376 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1377 if (isymbuf == NULL)
1378 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1379 symtab_hdr->sh_info, 0,
1380 NULL, NULL, NULL);
1381 if (isymbuf == NULL)
1382 goto error_return;
1383 }
1384
1385 amt = symtab_hdr->sh_info;
1386 amt *= sizeof (asection *);
1387 sections = (asection **) bfd_malloc (amt);
1388 if (sections == NULL && amt != 0)
1389 goto error_return;
1390
1391 isymend = isymbuf + symtab_hdr->sh_info;
1392 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1393 {
1394 asection *isec;
1395
1396 if (isym->st_shndx == SHN_UNDEF)
1397 isec = bfd_und_section_ptr;
1398 else if (isym->st_shndx == SHN_ABS)
1399 isec = bfd_abs_section_ptr;
1400 else if (isym->st_shndx == SHN_COMMON)
1401 isec = bfd_com_section_ptr;
1402 else
1403 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1404
1405 *secpp = isec;
1406 }
1407
1408 if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1409 input_section, data, internal_relocs,
1410 isymbuf, sections))
1411 goto error_return;
1412
1413 if (sections != NULL)
1414 free (sections);
1415 if (isymbuf != NULL
1416 && symtab_hdr->contents != (unsigned char *) isymbuf)
1417 free (isymbuf);
1418 if (elf_section_data (input_section)->relocs != internal_relocs)
1419 free (internal_relocs);
1420 }
1421
1422 return data;
1423
1424 error_return:
1425 if (sections != NULL)
1426 free (sections);
1427 if (isymbuf != NULL
1428 && symtab_hdr->contents != (unsigned char *) isymbuf)
1429 free (isymbuf);
1430 if (internal_relocs != NULL
1431 && elf_section_data (input_section)->relocs != internal_relocs)
1432 free (internal_relocs);
1433 return NULL;
1434 }
1435
1436
1437 #define TARGET_BIG_SYM bfd_elf32_h8300_vec
1438 #define TARGET_BIG_NAME "elf32-h8300"
1439 #define ELF_ARCH bfd_arch_h8300
1440 #define ELF_MACHINE_CODE EM_H8_300
1441 #define ELF_MAXPAGESIZE 0x1
1442 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1443 #define elf_info_to_howto elf32_h8_info_to_howto
1444 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1445
1446 /* So we can set/examine bits in e_flags to get the specific
1447 H8 architecture in use. */
1448 #define elf_backend_final_write_processing \
1449 elf32_h8_final_write_processing
1450 #define elf_backend_object_p \
1451 elf32_h8_object_p
1452 #define bfd_elf32_bfd_merge_private_bfd_data \
1453 elf32_h8_merge_private_bfd_data
1454
1455 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1456 defaults to using _bfd_generic_link_hash_table_create, but
1457 elflink.h:bfd_elf32_size_dynamic_sections uses
1458 dynobj = elf_hash_table (info)->dynobj;
1459 and thus requires an elf hash table. */
1460 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1461
1462 /* Use an H8 specific linker, not the ELF generic linker. */
1463 #define elf_backend_relocate_section elf32_h8_relocate_section
1464 #define elf_backend_rela_normal 1
1465
1466 /* And relaxing stuff. */
1467 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1468 #define bfd_elf32_bfd_get_relocated_section_contents \
1469 elf32_h8_get_relocated_section_contents
1470
1471
1472 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.071872 seconds and 4 git commands to generate.