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