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