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