OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [bfd/] [elf32-h8300.c] - Blame information for rev 834

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.