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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [elf32-m32c.c] - Blame information for rev 299

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

Line No. Rev Author Line
1 14 khays
/* M16C/M32C specific support for 32-bit ELF.
2 148 khays
   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 14 khays
   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
 
21
#include "sysdep.h"
22
#include "bfd.h"
23
#include "libbfd.h"
24
#include "elf-bfd.h"
25
#include "elf/m32c.h"
26
#include "libiberty.h"
27
 
28
/* Forward declarations.  */
29
static reloc_howto_type * m32c_reloc_type_lookup
30
  (bfd *, bfd_reloc_code_real_type);
31
static void m32c_info_to_howto_rela
32
  (bfd *, arelent *, Elf_Internal_Rela *);
33
static bfd_boolean m32c_elf_relocate_section
34
  (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
35
static bfd_boolean m32c_elf_check_relocs
36
  (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
37
static bfd_boolean m32c_elf_relax_delete_bytes (bfd *, asection *, bfd_vma, int);
38
#ifdef DEBUG
39
char * m32c_get_reloc (long reloc);
40
void dump_symtab (bfd *, void *, void *);
41
#endif
42
static bfd_boolean m32c_elf_relax_section
43
(bfd *abfd, asection *sec, struct bfd_link_info *link_info, bfd_boolean *again);
44
 
45
 
46
static reloc_howto_type m32c_elf_howto_table [] =
47
{
48
  /* This reloc does nothing.  */
49
  HOWTO (R_M32C_NONE,           /* type */
50
         0,                      /* rightshift */
51
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
52
         32,                    /* bitsize */
53
         FALSE,                 /* pc_relative */
54
         0,                      /* bitpos */
55
         complain_overflow_bitfield, /* complain_on_overflow */
56
         bfd_elf_generic_reloc, /* special_function */
57
         "R_M32C_NONE",         /* name */
58
         FALSE,                 /* partial_inplace */
59
         0,                      /* src_mask */
60
         0,                      /* dst_mask */
61
         FALSE),                /* pcrel_offset */
62
 
63
  /* GCC intentionally overflows these next two in order to work
64
     around limitations in the addressing modes, so don't complain
65
     about overflow.  */
66
  HOWTO (R_M32C_16,             /* type */
67
         0,                      /* rightshift */
68
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
69
         16,                    /* bitsize */
70
         FALSE,                 /* pc_relative */
71
         0,                      /* bitpos */
72
         complain_overflow_dont, /* complain_on_overflow */
73
         bfd_elf_generic_reloc, /* special_function */
74
         "R_M32C_16",           /* name */
75
         FALSE,                 /* partial_inplace */
76
         0,                      /* src_mask */
77
         0xffff,                /* dst_mask */
78
         FALSE),                /* pcrel_offset */
79
 
80
  HOWTO (R_M32C_24,             /* type */
81
         0,                      /* rightshift */
82
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
83
         24,                    /* bitsize */
84
         FALSE,                 /* pc_relative */
85
         0,                      /* bitpos */
86
         complain_overflow_dont, /* complain_on_overflow */
87
         bfd_elf_generic_reloc, /* special_function */
88
         "R_M32C_24",           /* name */
89
         FALSE,                 /* partial_inplace */
90
         0,                      /* src_mask */
91
         0xffffff,              /* dst_mask */
92
         FALSE),                /* pcrel_offset */
93
 
94
  HOWTO (R_M32C_32,             /* type */
95
         0,                      /* rightshift */
96
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
97
         32,                    /* bitsize */
98
         FALSE,                 /* pc_relative */
99
         0,                      /* bitpos */
100
         complain_overflow_bitfield, /* complain_on_overflow */
101
         bfd_elf_generic_reloc, /* special_function */
102
         "R_M32C_32",           /* name */
103
         FALSE,                 /* partial_inplace */
104
         0,                      /* src_mask */
105
         0xffffffff,            /* dst_mask */
106
         FALSE),                /* pcrel_offset */
107
 
108
  HOWTO (R_M32C_8_PCREL,        /* type */
109
         0,                      /* rightshift */
110
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
111
         8,                     /* bitsize */
112
         TRUE,                  /* pc_relative */
113
         0,                      /* bitpos */
114
         complain_overflow_signed, /* complain_on_overflow */
115
         bfd_elf_generic_reloc, /* special_function */
116
         "R_M32C_8_PCREL",      /* name */
117
         FALSE,                 /* partial_inplace */
118
         0,              /* src_mask */
119
         0xff,                  /* dst_mask */
120
         TRUE),                 /* pcrel_offset */
121
 
122
  HOWTO (R_M32C_16_PCREL,       /* type */
123
         0,                      /* rightshift */
124
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
125
         16,                    /* bitsize */
126
         TRUE,                  /* pc_relative */
127
         0,                      /* bitpos */
128
         complain_overflow_signed, /* complain_on_overflow */
129
         bfd_elf_generic_reloc, /* special_function */
130
         "R_M32C_16_PCREL",     /* name */
131
         FALSE,                 /* partial_inplace */
132
         0,              /* src_mask */
133
         0xffff,                /* dst_mask */
134
         TRUE),                 /* pcrel_offset */
135
 
136
  HOWTO (R_M32C_8,              /* type */
137
         0,                      /* rightshift */
138
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
139
         8,                     /* bitsize */
140
         FALSE,                 /* pc_relative */
141
         0,                      /* bitpos */
142
         complain_overflow_unsigned, /* complain_on_overflow */
143
         bfd_elf_generic_reloc, /* special_function */
144
         "R_M32C_8",            /* name */
145
         FALSE,                 /* partial_inplace */
146
         0,              /* src_mask */
147
         0xff,                  /* dst_mask */
148
         FALSE),                /* pcrel_offset */
149
 
150
  HOWTO (R_M32C_LO16,           /* type */
151
         0,                      /* rightshift */
152
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
153
         16,                    /* bitsize */
154
         FALSE,                 /* pc_relative */
155
         0,                      /* bitpos */
156
         complain_overflow_dont, /* complain_on_overflow */
157
         bfd_elf_generic_reloc, /* special_function */
158
         "R_M32C_LO16",         /* name */
159
         FALSE,                 /* partial_inplace */
160
         0,              /* src_mask */
161
         0xffff,                /* dst_mask */
162
         FALSE),                /* pcrel_offset */
163
 
164
  HOWTO (R_M32C_HI8,            /* type */
165
         0,                      /* rightshift */
166
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
167
         8,                     /* bitsize */
168
         FALSE,                 /* pc_relative */
169
         0,                      /* bitpos */
170
         complain_overflow_dont, /* complain_on_overflow */
171
         bfd_elf_generic_reloc, /* special_function */
172
         "R_M32C_HI8",          /* name */
173
         FALSE,                 /* partial_inplace */
174
         0,              /* src_mask */
175
         0xff,                  /* dst_mask */
176
         FALSE),                /* pcrel_offset */
177
 
178
  HOWTO (R_M32C_HI16,           /* type */
179
         0,                      /* rightshift */
180
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
181
         16,                    /* bitsize */
182
         FALSE,                 /* pc_relative */
183
         0,                      /* bitpos */
184
         complain_overflow_dont, /* complain_on_overflow */
185
         bfd_elf_generic_reloc, /* special_function */
186
         "R_M32C_HI16",         /* name */
187
         FALSE,                 /* partial_inplace */
188
         0,              /* src_mask */
189
         0xffff,                /* dst_mask */
190
         FALSE),                /* pcrel_offset */
191
 
192
  HOWTO (R_M32C_RL_JUMP,        /* type */
193
         0,                      /* rightshift */
194
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
195
         0,                      /* bitsize */
196
         FALSE,                 /* pc_relative */
197
         0,                      /* bitpos */
198
         complain_overflow_signed, /* complain_on_overflow */
199
         bfd_elf_generic_reloc, /* special_function */
200
         "R_M32C_RL_JUMP",      /* name */
201
         FALSE,                 /* partial_inplace */
202
         0,              /* src_mask */
203
         0,                      /* dst_mask */
204
         FALSE),                /* pcrel_offset */
205
 
206
  HOWTO (R_M32C_RL_1ADDR,       /* type */
207
         0,                      /* rightshift */
208
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
209
         0,                      /* bitsize */
210
         FALSE,                 /* pc_relative */
211
         0,                      /* bitpos */
212
         complain_overflow_signed, /* complain_on_overflow */
213
         bfd_elf_generic_reloc, /* special_function */
214
         "R_M32C_RL_1ADDR",     /* name */
215
         FALSE,                 /* partial_inplace */
216
         0,              /* src_mask */
217
         0,                      /* dst_mask */
218
         FALSE),                /* pcrel_offset */
219
 
220
  HOWTO (R_M32C_RL_2ADDR,       /* type */
221
         0,                      /* rightshift */
222
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
223
         0,                      /* bitsize */
224
         FALSE,                 /* pc_relative */
225
         0,                      /* bitpos */
226
         complain_overflow_signed, /* complain_on_overflow */
227
         bfd_elf_generic_reloc, /* special_function */
228
         "R_M32C_RL_2ADDR",     /* name */
229
         FALSE,                 /* partial_inplace */
230
         0,              /* src_mask */
231
         0,                      /* dst_mask */
232
         FALSE),                /* pcrel_offset */
233
 
234
};
235
 
236
/* Map BFD reloc types to M32C ELF reloc types.  */
237
 
238
struct m32c_reloc_map
239
{
240
  bfd_reloc_code_real_type bfd_reloc_val;
241
  unsigned int m32c_reloc_val;
242
};
243
 
244
static const struct m32c_reloc_map m32c_reloc_map [] =
245
{
246
  { BFD_RELOC_NONE,             R_M32C_NONE },
247
  { BFD_RELOC_16,               R_M32C_16 },
248
  { BFD_RELOC_24,               R_M32C_24 },
249
  { BFD_RELOC_32,               R_M32C_32 },
250
  { BFD_RELOC_8_PCREL,          R_M32C_8_PCREL },
251
  { BFD_RELOC_16_PCREL,         R_M32C_16_PCREL },
252
  { BFD_RELOC_8,                R_M32C_8 },
253
  { BFD_RELOC_LO16,             R_M32C_LO16 },
254
  { BFD_RELOC_HI16,             R_M32C_HI16 },
255
  { BFD_RELOC_M32C_HI8,         R_M32C_HI8 },
256
  { BFD_RELOC_M32C_RL_JUMP,     R_M32C_RL_JUMP },
257
  { BFD_RELOC_M32C_RL_1ADDR,    R_M32C_RL_1ADDR },
258
  { BFD_RELOC_M32C_RL_2ADDR,    R_M32C_RL_2ADDR }
259
};
260
 
261
static reloc_howto_type *
262
m32c_reloc_type_lookup
263
    (bfd *                    abfd ATTRIBUTE_UNUSED,
264
     bfd_reloc_code_real_type code)
265
{
266
  unsigned int i;
267
 
268
  for (i = ARRAY_SIZE (m32c_reloc_map); --i;)
269
    if (m32c_reloc_map [i].bfd_reloc_val == code)
270
      return & m32c_elf_howto_table [m32c_reloc_map[i].m32c_reloc_val];
271
 
272
  return NULL;
273
}
274
 
275
static reloc_howto_type *
276
m32c_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
277
{
278
  unsigned int i;
279
 
280
  for (i = 0;
281
       i < sizeof (m32c_elf_howto_table) / sizeof (m32c_elf_howto_table[0]);
282
       i++)
283
    if (m32c_elf_howto_table[i].name != NULL
284
        && strcasecmp (m32c_elf_howto_table[i].name, r_name) == 0)
285
      return &m32c_elf_howto_table[i];
286
 
287
  return NULL;
288
}
289
 
290
/* Set the howto pointer for an M32C ELF reloc.  */
291
 
292
static void
293
m32c_info_to_howto_rela
294
    (bfd *               abfd ATTRIBUTE_UNUSED,
295
     arelent *           cache_ptr,
296
     Elf_Internal_Rela * dst)
297
{
298
  unsigned int r_type;
299
 
300
  r_type = ELF32_R_TYPE (dst->r_info);
301
  BFD_ASSERT (r_type < (unsigned int) R_M32C_max);
302
  cache_ptr->howto = & m32c_elf_howto_table [r_type];
303
}
304
 
305
 
306
 
307
/* Relocate an M32C ELF section.
308
   There is some attempt to make this function usable for many architectures,
309
   both USE_REL and USE_RELA ['twould be nice if such a critter existed],
310
   if only to serve as a learning tool.
311
 
312
   The RELOCATE_SECTION function is called by the new ELF backend linker
313
   to handle the relocations for a section.
314
 
315
   The relocs are always passed as Rela structures; if the section
316
   actually uses Rel structures, the r_addend field will always be
317
   zero.
318
 
319
   This function is responsible for adjusting the section contents as
320
   necessary, and (if using Rela relocs and generating a relocatable
321
   output file) adjusting the reloc addend as necessary.
322
 
323
   This function does not have to worry about setting the reloc
324
   address or the reloc symbol index.
325
 
326
   LOCAL_SYMS is a pointer to the swapped in local symbols.
327
 
328
   LOCAL_SECTIONS is an array giving the section in the input file
329
   corresponding to the st_shndx field of each local symbol.
330
 
331
   The global hash table entry for the global symbols can be found
332
   via elf_sym_hashes (input_bfd).
333
 
334
   When generating relocatable output, this function must handle
335
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
336
   going to be the section symbol corresponding to the output
337
   section, which means that the addend must be adjusted
338
   accordingly.  */
339
 
340
static bfd_boolean
341
m32c_elf_relocate_section
342
    (bfd *                   output_bfd ATTRIBUTE_UNUSED,
343
     struct bfd_link_info *  info,
344
     bfd *                   input_bfd,
345
     asection *              input_section,
346
     bfd_byte *              contents,
347
     Elf_Internal_Rela *     relocs,
348
     Elf_Internal_Sym *      local_syms,
349
     asection **             local_sections)
350
{
351
  Elf_Internal_Shdr *           symtab_hdr;
352
  struct elf_link_hash_entry ** sym_hashes;
353
  Elf_Internal_Rela *           rel;
354
  Elf_Internal_Rela *           relend;
355
  bfd *dynobj;
356
  asection *splt;
357
 
358
  symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
359
  sym_hashes = elf_sym_hashes (input_bfd);
360
  relend     = relocs + input_section->reloc_count;
361
 
362
  dynobj = elf_hash_table (info)->dynobj;
363
  splt = NULL;
364
  if (dynobj != NULL)
365
    splt = bfd_get_section_by_name (dynobj, ".plt");
366
 
367
  for (rel = relocs; rel < relend; rel ++)
368
    {
369
      reloc_howto_type *           howto;
370
      unsigned long                r_symndx;
371
      Elf_Internal_Sym *           sym;
372
      asection *                   sec;
373
      struct elf_link_hash_entry * h;
374
      bfd_vma                      relocation;
375
      bfd_reloc_status_type        r;
376
      const char *                 name = NULL;
377
      int                          r_type;
378
 
379
      r_type = ELF32_R_TYPE (rel->r_info);
380
 
381
      /* These are only used for relaxing; we don't actually relocate
382
         anything with them, so skip them.  */
383
      if (r_type == R_M32C_RL_JUMP
384
          || r_type == R_M32C_RL_1ADDR
385
          || r_type == R_M32C_RL_2ADDR)
386
        continue;
387
 
388
      r_symndx = ELF32_R_SYM (rel->r_info);
389
 
390
      howto  = m32c_elf_howto_table + ELF32_R_TYPE (rel->r_info);
391
      h      = NULL;
392
      sym    = NULL;
393
      sec    = NULL;
394
      relocation = 0;
395
 
396
      if (r_symndx < symtab_hdr->sh_info)
397
        {
398
          sym = local_syms + r_symndx;
399
          sec = local_sections [r_symndx];
400
          relocation = (sec->output_section->vma
401
                        + sec->output_offset
402
                        + sym->st_value);
403
 
404
          name = bfd_elf_string_from_elf_section
405
            (input_bfd, symtab_hdr->sh_link, sym->st_name);
406
          name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
407
        }
408
      else
409
        {
410
          h = sym_hashes [r_symndx - symtab_hdr->sh_info];
411
 
412
          while (h->root.type == bfd_link_hash_indirect
413
                 || h->root.type == bfd_link_hash_warning)
414
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
415
 
416
          name = h->root.root.string;
417
 
418
          if (h->root.type == bfd_link_hash_defined
419
              || h->root.type == bfd_link_hash_defweak)
420
            {
421
              sec = h->root.u.def.section;
422
              relocation = (h->root.u.def.value
423
                            + sec->output_section->vma
424
                            + sec->output_offset);
425
            }
426
          else if (h->root.type == bfd_link_hash_undefweak)
427
            ;
428
          else if (!info->relocatable)
429
            {
430
              if (! ((*info->callbacks->undefined_symbol)
431
                     (info, h->root.root.string, input_bfd,
432
                      input_section, rel->r_offset, TRUE)))
433
                return FALSE;
434
            }
435
        }
436
 
437
      if (sec != NULL && elf_discarded_section (sec))
438
        RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
439
                                         rel, relend, howto, contents);
440
 
441
      if (info->relocatable)
442
        {
443
          /* This is a relocatable link.  We don't have to change
444
             anything, unless the reloc is against a section symbol,
445
             in which case we have to adjust according to where the
446
             section symbol winds up in the output section.  */
447
          if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
448
            rel->r_addend += sec->output_offset;
449
          continue;
450
        }
451
 
452
      switch (ELF32_R_TYPE (rel->r_info))
453
        {
454
        case R_M32C_16:
455
          {
456
            bfd_vma *plt_offset;
457
 
458
            if (h != NULL)
459
              plt_offset = &h->plt.offset;
460
            else
461
              plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
462
 
463
            /*      printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)",
464
                    relocation, *plt_offset);*/
465
            if (relocation <= 0xffff)
466
              {
467
                /* If the symbol is in range for a 16-bit address, we should
468
                   have deallocated the plt entry in relax_section.  */
469
                BFD_ASSERT (*plt_offset == (bfd_vma) -1);
470
              }
471
            else
472
              {
473
                /* If the symbol is out of range for a 16-bit address,
474
                   we must have allocated a plt entry.  */
475
                BFD_ASSERT (*plt_offset != (bfd_vma) -1);
476
 
477
                /* If this is the first time we've processed this symbol,
478
                   fill in the plt entry with the correct symbol address.  */
479
                if ((*plt_offset & 1) == 0)
480
                  {
481
                    unsigned int x;
482
 
483
                    x = 0x000000fc;  /* jmpf */
484
                    x |= (relocation << 8) & 0xffffff00;
485
                    bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
486
                    *plt_offset |= 1;
487
                  }
488
 
489
                relocation = (splt->output_section->vma
490
                              + splt->output_offset
491
                              + (*plt_offset & -2));
492
                if (name)
493
                {
494
                  char *newname = bfd_malloc (strlen(name)+5);
495
                  strcpy (newname, name);
496
                  strcat(newname, ".plt");
497
                  _bfd_generic_link_add_one_symbol (info,
498
                                                    input_bfd,
499
                                                    newname,
500
                                                    BSF_FUNCTION | BSF_WEAK,
501
                                                    splt,
502
                                                    (*plt_offset & -2),
503
                                                    0,
504
                                                    1,
505
                                                    0,
506
                                                    0);
507
                }
508
              }
509
          }
510
          break;
511
 
512
        case R_M32C_HI8:
513
        case R_M32C_HI16:
514
          relocation >>= 16;
515
          break;
516
        }
517
 
518
#if 0
519
      printf ("relocate %s at %06lx relocation %06lx addend %ld  ",
520
              m32c_elf_howto_table[ELF32_R_TYPE(rel->r_info)].name,
521
              rel->r_offset + input_section->output_section->vma + input_section->output_offset,
522
              relocation, rel->r_addend);
523
      {
524
        int i;
525
        for (i=0; i<4; i++)
526
          printf (" %02x", contents[rel->r_offset+i]);
527
        printf ("\n");
528
      }
529
#endif
530
      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
531
                                    contents, rel->r_offset, relocation,
532
                                    rel->r_addend);
533
 
534
      if (r != bfd_reloc_ok)
535
        {
536
          const char * msg = (const char *) NULL;
537
 
538
          switch (r)
539
            {
540
            case bfd_reloc_overflow:
541
              r = info->callbacks->reloc_overflow
542
                (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
543
                 input_bfd, input_section, rel->r_offset);
544
              break;
545
 
546
            case bfd_reloc_undefined:
547
              r = info->callbacks->undefined_symbol
548
                (info, name, input_bfd, input_section, rel->r_offset,
549
                 TRUE);
550
              break;
551
 
552
            case bfd_reloc_outofrange:
553
              msg = _("internal error: out of range error");
554
              break;
555
 
556
            case bfd_reloc_notsupported:
557
              msg = _("internal error: unsupported relocation error");
558
              break;
559
 
560
            case bfd_reloc_dangerous:
561
              msg = _("internal error: dangerous relocation");
562
              break;
563
 
564
            default:
565
              msg = _("internal error: unknown error");
566
              break;
567
            }
568
 
569
          if (msg)
570
            r = info->callbacks->warning
571
              (info, msg, name, input_bfd, input_section, rel->r_offset);
572
 
573
          if (! r)
574
            return FALSE;
575
        }
576
    }
577
 
578
  return TRUE;
579
}
580
 
581
/* We support 16-bit pointers to code above 64k by generating a thunk
582
   below 64k containing a JMP instruction to the final address.  */
583
 
584
static bfd_boolean
585
m32c_elf_check_relocs
586
    (bfd *                     abfd,
587
     struct bfd_link_info *    info,
588
     asection *                sec,
589
     const Elf_Internal_Rela * relocs)
590
{
591
  Elf_Internal_Shdr *           symtab_hdr;
592
  struct elf_link_hash_entry ** sym_hashes;
593
  const Elf_Internal_Rela *     rel;
594
  const Elf_Internal_Rela *     rel_end;
595
  bfd_vma *local_plt_offsets;
596
  asection *splt;
597
  bfd *dynobj;
598
 
599
  if (info->relocatable)
600
    return TRUE;
601
 
602
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
603
  sym_hashes = elf_sym_hashes (abfd);
604
  local_plt_offsets = elf_local_got_offsets (abfd);
605
  splt = NULL;
606
  dynobj = elf_hash_table(info)->dynobj;
607
 
608
  rel_end = relocs + sec->reloc_count;
609
  for (rel = relocs; rel < rel_end; rel++)
610
    {
611
      struct elf_link_hash_entry *h;
612
      unsigned long r_symndx;
613
      bfd_vma *offset;
614
 
615
      r_symndx = ELF32_R_SYM (rel->r_info);
616
      if (r_symndx < symtab_hdr->sh_info)
617
        h = NULL;
618
      else
619
        {
620
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
621
          while (h->root.type == bfd_link_hash_indirect
622
                 || h->root.type == bfd_link_hash_warning)
623
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
624
        }
625
 
626
      switch (ELF32_R_TYPE (rel->r_info))
627
        {
628
          /* This relocation describes a 16-bit pointer to a function.
629
             We may need to allocate a thunk in low memory; reserve memory
630
             for it now.  */
631
        case R_M32C_16:
632
          if (dynobj == NULL)
633
            elf_hash_table (info)->dynobj = dynobj = abfd;
634
          if (splt == NULL)
635
            {
636
              splt = bfd_get_section_by_name (dynobj, ".plt");
637
              if (splt == NULL)
638
                {
639
                  flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
640
                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
641
                                    | SEC_READONLY | SEC_CODE);
642
                  splt = bfd_make_section_with_flags (dynobj, ".plt", flags);
643
                  if (splt == NULL
644
                      || ! bfd_set_section_alignment (dynobj, splt, 1))
645
                    return FALSE;
646
                }
647
            }
648
 
649
          if (h != NULL)
650
            offset = &h->plt.offset;
651
          else
652
            {
653
              if (local_plt_offsets == NULL)
654
                {
655
                  size_t size;
656
                  unsigned int i;
657
 
658
                  size = symtab_hdr->sh_info * sizeof (bfd_vma);
659
                  local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
660
                  if (local_plt_offsets == NULL)
661
                    return FALSE;
662
                  elf_local_got_offsets (abfd) = local_plt_offsets;
663
 
664
                  for (i = 0; i < symtab_hdr->sh_info; i++)
665
                    local_plt_offsets[i] = (bfd_vma) -1;
666
                }
667
              offset = &local_plt_offsets[r_symndx];
668
            }
669
 
670
          if (*offset == (bfd_vma) -1)
671
            {
672
              *offset = splt->size;
673
              splt->size += 4;
674
            }
675
          break;
676
        }
677
    }
678
 
679
  return TRUE;
680
}
681
 
682
/* This must exist if dynobj is ever set.  */
683
 
684
static bfd_boolean
685
m32c_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
686
                                  struct bfd_link_info *info)
687
{
688
  bfd *dynobj;
689
  asection *splt;
690
 
691
  /* As an extra sanity check, verify that all plt entries have
692
     been filled in.  */
693
 
694
  if ((dynobj = elf_hash_table (info)->dynobj) != NULL
695
      && (splt = bfd_get_section_by_name (dynobj, ".plt")) != NULL)
696
    {
697
      bfd_byte *contents = splt->contents;
698
      unsigned int i, size = splt->size;
699
      for (i = 0; i < size; i += 4)
700
        {
701
          unsigned int x = bfd_get_32 (dynobj, contents + i);
702
          BFD_ASSERT (x != 0);
703
        }
704
    }
705
 
706
  return TRUE;
707
}
708
 
709
static bfd_boolean
710
m32c_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
711
                               struct bfd_link_info *info)
712
{
713
  bfd *dynobj;
714
  asection *splt;
715
 
716
  if (info->relocatable)
717
    return TRUE;
718
 
719
  dynobj = elf_hash_table (info)->dynobj;
720
  if (dynobj == NULL)
721
    return TRUE;
722
 
723
  splt = bfd_get_section_by_name (dynobj, ".plt");
724
  BFD_ASSERT (splt != NULL);
725
 
726
  splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
727
  if (splt->contents == NULL)
728
    return FALSE;
729
 
730
  return TRUE;
731
}
732
 
733
/* Function to set the ELF flag bits.  */
734
 
735
static bfd_boolean
736
m32c_elf_set_private_flags (bfd *abfd, flagword flags)
737
{
738
  elf_elfheader (abfd)->e_flags = flags;
739
  elf_flags_init (abfd) = TRUE;
740
  return TRUE;
741
}
742
 
743
/* Merge backend specific data from an object file to the output
744
   object file when linking.  */
745
 
746
static bfd_boolean
747
m32c_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
748
{
749
  flagword old_flags, old_partial;
750
  flagword new_flags, new_partial;
751
  bfd_boolean error = FALSE;
752
  char new_opt[80];
753
  char old_opt[80];
754
 
755
  new_opt[0] = old_opt[0] = '\0';
756
  new_flags = elf_elfheader (ibfd)->e_flags;
757
  old_flags = elf_elfheader (obfd)->e_flags;
758
 
759
#ifdef DEBUG
760
  (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
761
                         old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
762
                         bfd_get_filename (ibfd));
763
#endif
764
 
765
  if (!elf_flags_init (obfd))
766
    {
767
      /* First call, no flags set.  */
768
      elf_flags_init (obfd) = TRUE;
769
      elf_elfheader (obfd)->e_flags = new_flags;
770
    }
771
 
772
  else if (new_flags == old_flags)
773
    /* Compatible flags are ok.  */
774
    ;
775
 
776
  else          /* Possibly incompatible flags.  */
777
    {
778
      /* Warn if different cpu is used (allow a specific cpu to override
779
         the generic cpu).  */
780
      new_partial = (new_flags & EF_M32C_CPU_MASK);
781
      old_partial = (old_flags & EF_M32C_CPU_MASK);
782
      if (new_partial == old_partial)
783
        ;
784
 
785
      else
786
        {
787
          switch (new_partial)
788
            {
789
            default:              strcat (new_opt, " -m16c");   break;
790
            case EF_M32C_CPU_M16C:      strcat (new_opt, " -m16c");  break;
791
            case EF_M32C_CPU_M32C:  strcat (new_opt, " -m32c");  break;
792
            }
793
 
794
          switch (old_partial)
795
            {
796
            default:              strcat (old_opt, " -m16c");   break;
797
            case EF_M32C_CPU_M16C:      strcat (old_opt, " -m16c");  break;
798
            case EF_M32C_CPU_M32C:  strcat (old_opt, " -m32c");  break;
799
            }
800
        }
801
 
802
      /* Print out any mismatches from above.  */
803
      if (new_opt[0])
804
        {
805
          error = TRUE;
806
          (*_bfd_error_handler)
807
            (_("%s: compiled with %s and linked with modules compiled with %s"),
808
             bfd_get_filename (ibfd), new_opt, old_opt);
809
        }
810
 
811
      new_flags &= ~ EF_M32C_ALL_FLAGS;
812
      old_flags &= ~ EF_M32C_ALL_FLAGS;
813
 
814
      /* Warn about any other mismatches.  */
815
      if (new_flags != old_flags)
816
        {
817
          error = TRUE;
818
          (*_bfd_error_handler)
819
            (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
820
             bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
821
        }
822
    }
823
 
824
  if (error)
825
    bfd_set_error (bfd_error_bad_value);
826
 
827
  return !error;
828
}
829
 
830
 
831
static bfd_boolean
832
m32c_elf_print_private_bfd_data (bfd *abfd, PTR ptr)
833
{
834
  FILE *file = (FILE *) ptr;
835
  flagword flags;
836
 
837
  BFD_ASSERT (abfd != NULL && ptr != NULL);
838
 
839
  /* Print normal ELF private data.  */
840
  _bfd_elf_print_private_bfd_data (abfd, ptr);
841
 
842
  flags = elf_elfheader (abfd)->e_flags;
843
  fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
844
 
845
  switch (flags & EF_M32C_CPU_MASK)
846
    {
847
    default:                                                    break;
848
    case EF_M32C_CPU_M16C:      fprintf (file, " -m16c");       break;
849
    case EF_M32C_CPU_M32C:  fprintf (file, " -m32c");   break;
850
    }
851
 
852
  fputc ('\n', file);
853
  return TRUE;
854
}
855
 
856
/* Return the MACH for an e_flags value.  */
857
 
858
static int
859
elf32_m32c_machine (bfd *abfd)
860
{
861
  switch (elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK)
862
    {
863
    case EF_M32C_CPU_M16C:      return bfd_mach_m16c;
864
    case EF_M32C_CPU_M32C:      return bfd_mach_m32c;
865
    }
866
 
867
  return bfd_mach_m16c;
868
}
869
 
870
static bfd_boolean
871
m32c_elf_object_p (bfd *abfd)
872
{
873
  bfd_default_set_arch_mach (abfd, bfd_arch_m32c,
874
                             elf32_m32c_machine (abfd));
875
  return TRUE;
876
}
877
 
878
 
879
#ifdef DEBUG
880
void
881
dump_symtab (bfd * abfd, void *internal_syms, void *external_syms)
882
{
883
  size_t locsymcount;
884
  Elf_Internal_Sym *isymbuf;
885
  Elf_Internal_Sym *isymend;
886
  Elf_Internal_Sym *isym;
887
  Elf_Internal_Shdr *symtab_hdr;
888
  bfd_boolean free_internal = 0, free_external = 0;
889
  char * st_info_str;
890
  char * st_info_stb_str;
891
  char * st_other_str;
892
  char * st_shndx_str;
893
 
894
  if (! internal_syms)
895
    {
896
      internal_syms = bfd_malloc (1000);
897
      free_internal = 1;
898
    }
899
  if (! external_syms)
900
    {
901
      external_syms = bfd_malloc (1000);
902
      free_external = 1;
903
    }
904
 
905
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
906
  locsymcount = symtab_hdr->sh_size / get_elf_backend_data(abfd)->s->sizeof_sym;
907
  if (free_internal)
908
    isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
909
                                    symtab_hdr->sh_info, 0,
910
                                    internal_syms, external_syms, NULL);
911
  else
912
    isymbuf = internal_syms;
913
  isymend = isymbuf + locsymcount;
914
 
915
  for (isym = isymbuf ; isym < isymend ; isym++)
916
    {
917
      switch (ELF_ST_TYPE (isym->st_info))
918
        {
919
        case STT_FUNC: st_info_str = "STT_FUNC";
920
        case STT_SECTION: st_info_str = "STT_SECTION";
921
        case STT_FILE: st_info_str = "STT_FILE";
922
        case STT_OBJECT: st_info_str = "STT_OBJECT";
923
        case STT_TLS: st_info_str = "STT_TLS";
924
        default: st_info_str = "";
925
        }
926
      switch (ELF_ST_BIND (isym->st_info))
927
        {
928
        case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
929
        case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
930
        default: st_info_stb_str = "";
931
        }
932
      switch (ELF_ST_VISIBILITY (isym->st_other))
933
        {
934
        case STV_DEFAULT: st_other_str = "STV_DEFAULT";
935
        case STV_INTERNAL: st_other_str = "STV_INTERNAL";
936
        case STV_PROTECTED: st_other_str = "STV_PROTECTED";
937
        default: st_other_str = "";
938
        }
939
      switch (isym->st_shndx)
940
        {
941
        case SHN_ABS: st_shndx_str = "SHN_ABS";
942
        case SHN_COMMON: st_shndx_str = "SHN_COMMON";
943
        case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
944
        default: st_shndx_str = "";
945
        }
946
 
947
      printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
948
              "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
949
              isym,
950
              (unsigned long) isym->st_value,
951
              (unsigned long) isym->st_size,
952
              isym->st_name,
953
              bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
954
                                               isym->st_name),
955
              isym->st_info, st_info_str, st_info_stb_str,
956
              isym->st_other, st_other_str,
957
              isym->st_shndx, st_shndx_str);
958
    }
959
  if (free_internal)
960
    free (internal_syms);
961
  if (free_external)
962
    free (external_syms);
963
}
964
 
965
char *
966
m32c_get_reloc (long reloc)
967
{
968
  if (0 <= reloc && reloc < R_M32C_max)
969
    return m32c_elf_howto_table[reloc].name;
970
  else
971
    return "";
972
}
973
#endif /* DEBUG */
974
 
975
/* Handle relaxing.  */
976
 
977
/* A subroutine of m32c_elf_relax_section.  If the global symbol H
978
   is within the low 64k, remove any entry for it in the plt.  */
979
 
980
struct relax_plt_data
981
{
982
  asection *splt;
983
  bfd_boolean *again;
984
};
985
 
986
static bfd_boolean
987
m32c_relax_plt_check (struct elf_link_hash_entry *h,
988
                      PTR xdata)
989
{
990
  struct relax_plt_data *data = (struct relax_plt_data *) xdata;
991
 
992
  if (h->plt.offset != (bfd_vma) -1)
993
    {
994
      bfd_vma address;
995
 
996
      if (h->root.type == bfd_link_hash_undefined
997
          || h->root.type == bfd_link_hash_undefweak)
998
        address = 0;
999
      else
1000
        address = (h->root.u.def.section->output_section->vma
1001
                   + h->root.u.def.section->output_offset
1002
                   + h->root.u.def.value);
1003
 
1004
      if (address <= 0xffff)
1005
        {
1006
          h->plt.offset = -1;
1007
          data->splt->size -= 4;
1008
          *data->again = TRUE;
1009
        }
1010
    }
1011
 
1012
  return TRUE;
1013
}
1014
 
1015
/* A subroutine of m32c_elf_relax_section.  If the global symbol H
1016
   previously had a plt entry, give it a new entry offset.  */
1017
 
1018
static bfd_boolean
1019
m32c_relax_plt_realloc (struct elf_link_hash_entry *h,
1020
                        PTR xdata)
1021
{
1022
  bfd_vma *entry = (bfd_vma *) xdata;
1023
 
1024
  if (h->plt.offset != (bfd_vma) -1)
1025
    {
1026
      h->plt.offset = *entry;
1027
      *entry += 4;
1028
    }
1029
 
1030
  return TRUE;
1031
}
1032
 
1033
static bfd_boolean
1034
m32c_elf_relax_plt_section (bfd *dynobj,
1035
                            asection *splt,
1036
                            struct bfd_link_info *info,
1037
                            bfd_boolean *again)
1038
{
1039
  struct relax_plt_data relax_plt_data;
1040
  bfd *ibfd;
1041
 
1042
  /* Assume nothing changes.  */
1043
  *again = FALSE;
1044
 
1045
  if (info->relocatable)
1046
    return TRUE;
1047
 
1048
  /* We only relax the .plt section at the moment.  */
1049
  if (dynobj != elf_hash_table (info)->dynobj
1050
      || strcmp (splt->name, ".plt") != 0)
1051
    return TRUE;
1052
 
1053
  /* Quick check for an empty plt.  */
1054
  if (splt->size == 0)
1055
    return TRUE;
1056
 
1057
  /* Map across all global symbols; see which ones happen to
1058
     fall in the low 64k.  */
1059
  relax_plt_data.splt = splt;
1060
  relax_plt_data.again = again;
1061
  elf_link_hash_traverse (elf_hash_table (info), m32c_relax_plt_check,
1062
                          &relax_plt_data);
1063
 
1064
  /* Likewise for local symbols, though that's somewhat less convenient
1065
     as we have to walk the list of input bfds and swap in symbol data.  */
1066
  for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1067
    {
1068
      bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1069
      Elf_Internal_Shdr *symtab_hdr;
1070
      Elf_Internal_Sym *isymbuf = NULL;
1071
      unsigned int idx;
1072
 
1073
      if (! local_plt_offsets)
1074
        continue;
1075
 
1076
      symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1077
      if (symtab_hdr->sh_info != 0)
1078
        {
1079
          isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1080
          if (isymbuf == NULL)
1081
            isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1082
                                            symtab_hdr->sh_info, 0,
1083
                                            NULL, NULL, NULL);
1084
          if (isymbuf == NULL)
1085
            return FALSE;
1086
        }
1087
 
1088
      for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1089
        {
1090
          Elf_Internal_Sym *isym;
1091
          asection *tsec;
1092
          bfd_vma address;
1093
 
1094
          if (local_plt_offsets[idx] == (bfd_vma) -1)
1095
            continue;
1096
 
1097
          isym = &isymbuf[idx];
1098
          if (isym->st_shndx == SHN_UNDEF)
1099
            continue;
1100
          else if (isym->st_shndx == SHN_ABS)
1101
            tsec = bfd_abs_section_ptr;
1102
          else if (isym->st_shndx == SHN_COMMON)
1103
            tsec = bfd_com_section_ptr;
1104
          else
1105
            tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1106
 
1107
          address = (tsec->output_section->vma
1108
                     + tsec->output_offset
1109
                     + isym->st_value);
1110
          if (address <= 0xffff)
1111
            {
1112
              local_plt_offsets[idx] = -1;
1113
              splt->size -= 4;
1114
              *again = TRUE;
1115
            }
1116
        }
1117
 
1118
      if (isymbuf != NULL
1119
          && symtab_hdr->contents != (unsigned char *) isymbuf)
1120
        {
1121
          if (! info->keep_memory)
1122
            free (isymbuf);
1123
          else
1124
            {
1125
              /* Cache the symbols for elf_link_input_bfd.  */
1126
              symtab_hdr->contents = (unsigned char *) isymbuf;
1127
            }
1128
        }
1129
    }
1130
 
1131
  /* If we changed anything, walk the symbols again to reallocate
1132
     .plt entry addresses.  */
1133
  if (*again && splt->size > 0)
1134
    {
1135
      bfd_vma entry = 0;
1136
 
1137
      elf_link_hash_traverse (elf_hash_table (info),
1138
                              m32c_relax_plt_realloc, &entry);
1139
 
1140
      for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1141
        {
1142
          bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1143
          unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1144
          unsigned int idx;
1145
 
1146
          if (! local_plt_offsets)
1147
            continue;
1148
 
1149
          for (idx = 0; idx < nlocals; ++idx)
1150
            if (local_plt_offsets[idx] != (bfd_vma) -1)
1151
              {
1152
                local_plt_offsets[idx] = entry;
1153
                entry += 4;
1154
              }
1155
        }
1156
    }
1157
 
1158
  return TRUE;
1159
}
1160
 
1161
static int
1162
compare_reloc (const void *e1, const void *e2)
1163
{
1164
  const Elf_Internal_Rela *i1 = (const Elf_Internal_Rela *) e1;
1165
  const Elf_Internal_Rela *i2 = (const Elf_Internal_Rela *) e2;
1166
 
1167
  if (i1->r_offset == i2->r_offset)
1168
    return 0;
1169
  else
1170
    return i1->r_offset < i2->r_offset ? -1 : 1;
1171
}
1172
 
1173
#define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
1174
static bfd_vma
1175
m32c_offset_for_reloc (bfd *abfd,
1176
                       Elf_Internal_Rela *rel,
1177
                       Elf_Internal_Shdr *symtab_hdr,
1178
                       Elf_External_Sym_Shndx *shndx_buf ATTRIBUTE_UNUSED,
1179
                       Elf_Internal_Sym *intsyms)
1180
{
1181
  bfd_vma symval;
1182
 
1183
  /* Get the value of the symbol referred to by the reloc.  */
1184
  if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1185
    {
1186
      /* A local symbol.  */
1187
      Elf_Internal_Sym *isym;
1188
      asection *ssec;
1189
 
1190
      isym = intsyms + ELF32_R_SYM (rel->r_info);
1191
      ssec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1192
      symval = isym->st_value;
1193
      if (ssec)
1194
        symval += ssec->output_section->vma
1195
          + ssec->output_offset;
1196
    }
1197
  else
1198
    {
1199
      unsigned long indx;
1200
      struct elf_link_hash_entry *h;
1201
 
1202
      /* An external symbol.  */
1203
      indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1204
      h = elf_sym_hashes (abfd)[indx];
1205
      BFD_ASSERT (h != NULL);
1206
 
1207
      if (h->root.type != bfd_link_hash_defined
1208
          && h->root.type != bfd_link_hash_defweak)
1209
        /* This appears to be a reference to an undefined
1210
           symbol.  Just ignore it--it will be caught by the
1211
           regular reloc processing.  */
1212
        return 0;
1213
 
1214
      symval = (h->root.u.def.value
1215
                + h->root.u.def.section->output_section->vma
1216
                + h->root.u.def.section->output_offset);
1217
    }
1218
  return symval;
1219
}
1220
 
1221
static int bytes_saved = 0;
1222
 
1223
static int bytes_to_reloc[] = {
1224
  R_M32C_NONE,
1225
  R_M32C_8,
1226
  R_M32C_16,
1227
  R_M32C_24,
1228
  R_M32C_32
1229
};
1230
 
1231
/* What we use the bits in a relax reloc addend (R_M32C_RL_*) for.  */
1232
 
1233
/* Mask for the number of relocs associated with this insn.  */
1234
#define RLA_RELOCS              0x0000000f
1235
/* Number of bytes gas emitted (before gas's relaxing) */
1236
#define RLA_NBYTES              0x00000ff0
1237
 
1238
/* If the displacement is within the given range and the new encoding
1239
   differs from the old encoding (the index), then the insn can be
1240
   relaxed to the new encoding.  */
1241
typedef struct {
1242
  int bytes;
1243
  unsigned int max_disp;
1244
  unsigned char new_encoding;
1245
} EncodingTable;
1246
 
1247
static EncodingTable m16c_addr_encodings[] = {
1248
  { 0,   0,  0 }, /* R0 */
1249
  { 0,   0,  1 }, /* R1 */
1250
  { 0,   0,  2 }, /* R2 */
1251
  { 0,   0,  3 }, /* R3 */
1252
  { 0,   0,  4 }, /* A0 */
1253
  { 0,   0,  5 }, /* A1 */
1254
  { 0,   0,  6 }, /* [A0] */
1255
  { 0,   0,  7 }, /* [A1] */
1256
  { 1,   0,  6 }, /* udsp:8[A0] */
1257
  { 1,   0,  7 }, /* udsp:8[A1] */
1258
  { 1,   0, 10 }, /* udsp:8[SB] */
1259
  { 1,   0, 11 }, /* sdsp:8[FB] */
1260
  { 2, 255,  8 }, /* udsp:16[A0] */
1261
  { 2, 255,  9 }, /* udsp:16[A1] */
1262
  { 2, 255, 10 }, /* udsp:16[SB] */
1263
  { 2,   0, 15 }, /* abs:16 */
1264
};
1265
 
1266
static EncodingTable m16c_jmpaddr_encodings[] = {
1267
  { 0,   0,  0 }, /* R0 */
1268
  { 0,   0,  1 }, /* R1 */
1269
  { 0,   0,  2 }, /* R2 */
1270
  { 0,   0,  3 }, /* R3 */
1271
  { 0,   0,  4 }, /* A0 */
1272
  { 0,   0,  5 }, /* A1 */
1273
  { 0,   0,  6 }, /* [A0] */
1274
  { 0,   0,  7 }, /* [A1] */
1275
  { 1,   0,  6 }, /* udsp:8[A0] */
1276
  { 1,   0,  7 }, /* udsp:8[A1] */
1277
  { 1,   0, 10 }, /* udsp:8[SB] */
1278
  { 1,   0, 11 }, /* sdsp:8[FB] */
1279
  { 3, 255,  8 }, /* udsp:20[A0] */
1280
  { 3, 255,  9 }, /* udsp:20[A1] */
1281
  { 2, 255, 10 }, /* udsp:16[SB] */
1282
  { 2,   0, 15 }, /* abs:16 */
1283
};
1284
 
1285
static EncodingTable m32c_addr_encodings[] = {
1286
  { 0,     0,  0 }, /* [A0] */
1287
  { 0,     0,  1 }, /* [A1] */
1288
  { 0,     0,  2 }, /* A0 */
1289
  { 0,     0,  3 }, /* A1 */
1290
  { 1,     0,  0 }, /* udsp:8[A0] */
1291
  { 1,     0,  1 }, /* udsp:8[A1] */
1292
  { 1,     0,  6 }, /* udsp:8[SB] */
1293
  { 1,     0,  7 }, /* sdsp:8[FB] */
1294
  { 2,   255,  4 }, /* udsp:16[A0] */
1295
  { 2,   255,  5 }, /* udsp:16[A1] */
1296
  { 2,   255,  6 }, /* udsp:16[SB] */
1297
  { 2,   127,  7 }, /* sdsp:16[FB] */
1298
  { 3, 65535, 8 }, /* udsp:24[A0] */
1299
  { 3, 65535, 9 }, /* udsp:24[A1] */
1300
  { 3, 65535, 15 }, /* abs24 */
1301
  { 2,     0, 15 }, /* abs16 */
1302
  { 0,     0, 16 }, /* R2 */
1303
  { 0,     0, 17 }, /* R3 */
1304
  { 0,     0, 18 }, /* R0 */
1305
  { 0,     0, 19 }, /* R1 */
1306
  { 0,     0, 20 }, /*  */
1307
  { 0,     0, 21 }, /*  */
1308
  { 0,     0, 22 }, /*  */
1309
  { 0,     0, 23 }, /*  */
1310
  { 0,     0, 24 }, /*  */
1311
  { 0,     0, 25 }, /*  */
1312
  { 0,     0, 26 }, /*  */
1313
  { 0,     0, 27 }, /*  */
1314
  { 0,     0, 28 }, /*  */
1315
  { 0,     0, 29 }, /*  */
1316
  { 0,     0, 30 }, /*  */
1317
  { 0,     0, 31 }, /*  */
1318
};
1319
 
1320
static bfd_boolean
1321
m32c_elf_relax_section
1322
    (bfd *                  abfd,
1323
     asection *             sec,
1324
     struct bfd_link_info * link_info,
1325
     bfd_boolean *          again)
1326
{
1327
  Elf_Internal_Shdr *symtab_hdr;
1328
  Elf_Internal_Shdr *shndx_hdr;
1329
  Elf_Internal_Rela *internal_relocs;
1330
  Elf_Internal_Rela *free_relocs = NULL;
1331
  Elf_Internal_Rela *irel, *irelend, *srel;
1332
  bfd_byte * contents = NULL;
1333
  bfd_byte * free_contents = NULL;
1334
  Elf_Internal_Sym *intsyms = NULL;
1335
  Elf_Internal_Sym *free_intsyms = NULL;
1336
  Elf_External_Sym_Shndx *shndx_buf = NULL;
1337
  int machine;
1338
 
1339
  if (abfd == elf_hash_table (link_info)->dynobj
1340
      && strcmp (sec->name, ".plt") == 0)
1341
    return m32c_elf_relax_plt_section (abfd, sec, link_info, again);
1342
 
1343
  /* Assume nothing changes.  */
1344
  *again = FALSE;
1345
 
1346
  machine = elf32_m32c_machine (abfd);
1347
 
1348
  /* We don't have to do anything for a relocatable link, if
1349
     this section does not have relocs, or if this is not a
1350
     code section.  */
1351
  if (link_info->relocatable
1352
      || (sec->flags & SEC_RELOC) == 0
1353
      || sec->reloc_count == 0
1354
      || (sec->flags & SEC_CODE) == 0)
1355
    return TRUE;
1356
 
1357
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1358
  shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1359
 
1360
  /* Get the section contents.  */
1361
  if (elf_section_data (sec)->this_hdr.contents != NULL)
1362
    contents = elf_section_data (sec)->this_hdr.contents;
1363
  /* Go get them off disk.  */
1364
  else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1365
    goto error_return;
1366
 
1367
  /* Read this BFD's symbols.  */
1368
  /* Get cached copy if it exists.  */
1369
  if (symtab_hdr->contents != NULL)
1370
    {
1371
      intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
1372
    }
1373
  else
1374
    {
1375
      intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
1376
      symtab_hdr->contents = (bfd_byte *) intsyms;
1377
    }
1378
 
1379
  if (shndx_hdr->sh_size != 0)
1380
    {
1381
      bfd_size_type amt;
1382
 
1383
      amt = symtab_hdr->sh_info;
1384
      amt *= sizeof (Elf_External_Sym_Shndx);
1385
      shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
1386
      if (shndx_buf == NULL)
1387
        goto error_return;
1388
      if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
1389
          || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
1390
        goto error_return;
1391
      shndx_hdr->contents = (bfd_byte *) shndx_buf;
1392
    }
1393
 
1394
  /* Get a copy of the native relocations.  */
1395
  internal_relocs = (_bfd_elf_link_read_relocs
1396
                     (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1397
                      link_info->keep_memory));
1398
  if (internal_relocs == NULL)
1399
    goto error_return;
1400
  if (! link_info->keep_memory)
1401
    free_relocs = internal_relocs;
1402
 
1403
  /* The RL_ relocs must be just before the operand relocs they go
1404
     with, so we must sort them to guarantee this.  */
1405
  qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
1406
         compare_reloc);
1407
 
1408
  /* Walk through them looking for relaxing opportunities.  */
1409
  irelend = internal_relocs + sec->reloc_count;
1410
 
1411
  for (irel = internal_relocs; irel < irelend; irel++)
1412
    {
1413
      bfd_vma symval;
1414
      unsigned char *insn, *gap, *einsn;
1415
      bfd_vma pc;
1416
      bfd_signed_vma pcrel;
1417
      int relax_relocs;
1418
      int gap_size;
1419
      int new_type;
1420
      int posn;
1421
      int enc;
1422
      EncodingTable *enctbl;
1423
      EncodingTable *e;
1424
 
1425
      if (ELF32_R_TYPE(irel->r_info) != R_M32C_RL_JUMP
1426
          && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_1ADDR
1427
          && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_2ADDR)
1428
        continue;
1429
 
1430
      srel = irel;
1431
 
1432
      /* There will always be room for the relaxed insn, since it is smaller
1433
         than the one it would replace.  */
1434
      BFD_ASSERT (irel->r_offset < sec->size);
1435
 
1436
      insn = contents + irel->r_offset;
1437
      relax_relocs = irel->r_addend % 16;
1438
 
1439
      /* Ok, we only have three relocs we care about, and they're all
1440
         fake.  The lower four bits of the addend is always the number
1441
         of following relocs (hence the qsort above) that are assigned
1442
         to this opcode.  The next 8 bits of the addend indicates the
1443
         number of bytes in the insn.  We use the rest of them
1444
         ourselves as flags for the more expensive operations (defines
1445
         above).  The three relocs are:
1446
 
1447
         RL_JUMP: This marks all direct jump insns.  We check the
1448
                displacement and replace them with shorter jumps if
1449
                they're in range.  We also use this to find JMP.S
1450
                insns and manually shorten them when we delete bytes.
1451
                We have to decode these insns to figure out what to
1452
                do.
1453
 
1454
         RL_1ADDR: This is a :G or :Q insn, which has a single
1455
                "standard" operand.  We have to extract the type
1456
                field, see if it's a wide displacement, then figure
1457
                out if we can replace it with a narrow displacement.
1458
                We don't have to decode these insns.
1459
 
1460
         RL_2ADDR: Similarly, but two "standard" operands.  Note that
1461
                r_addend may still be 1, as standard operands don't
1462
                always have displacements.  Gas shouldn't give us one
1463
                with zero operands, but since we don't know which one
1464
                has the displacement, we check them both anyway.
1465
 
1466
         These all point to the beginning of the insn itself, not the
1467
         operands.
1468
 
1469
         Note that we only relax one step at a time, relying on the
1470
         linker to call us repeatedly.  Thus, there is no code for
1471
         JMP.A->JMP.B although that will happen in two steps.
1472
         Likewise, for 2ADDR relaxes, we do one operand per cycle.
1473
      */
1474
 
1475
      /* Get the value of the symbol referred to by the reloc.  Just
1476
         in case this is the last reloc in the list, use the RL's
1477
         addend to choose between this reloc (no addend) or the next
1478
         (yes addend, which means at least one following reloc).  */
1479
      srel = irel + (relax_relocs ? 1 : 0);
1480
      symval = OFFSET_FOR_RELOC (srel);
1481
 
1482
      /* Setting gap_size nonzero is the flag which means "something
1483
         shrunk".  */
1484
      gap_size = 0;
1485
      gap = NULL;
1486
      new_type = ELF32_R_TYPE(srel->r_info);
1487
 
1488
      pc = sec->output_section->vma + sec->output_offset
1489
        + srel->r_offset;
1490
      pcrel = symval - pc + srel->r_addend;
1491
 
1492
      if (machine == bfd_mach_m16c)
1493
        {
1494
          /* R8C / M16C */
1495
 
1496
          switch (ELF32_R_TYPE(irel->r_info))
1497
            {
1498
 
1499
            case R_M32C_RL_JUMP:
1500
              switch (insn[0])
1501
                {
1502
                case 0xfe: /* jmp.b */
1503
                  if (pcrel >= 2 && pcrel <= 9)
1504
                    {
1505
                      /* Relax JMP.B -> JMP.S.  We need to get rid of
1506
                         the following reloc though. */
1507
                      insn[0] = 0x60 | (pcrel - 2);
1508
                      new_type = R_M32C_NONE;
1509
                      irel->r_addend = 0x10;
1510
                      gap_size = 1;
1511
                      gap = insn + 1;
1512
                    }
1513
                  break;
1514
 
1515
                case 0xf4: /* jmp.w */
1516
                  /* 128 is allowed because it will be one byte closer
1517
                     after relaxing.  Likewise for all other pc-rel
1518
                     jumps.  */
1519
                  if (pcrel <= 128 && pcrel >= -128)
1520
                    {
1521
                      /* Relax JMP.W -> JMP.B */
1522
                      insn[0] = 0xfe;
1523
                      insn[1] = 0;
1524
                      new_type = R_M32C_8_PCREL;
1525
                      gap_size = 1;
1526
                      gap = insn + 2;
1527
                    }
1528
                  break;
1529
 
1530
                case 0xfc: /* jmp.a */
1531
                  if (pcrel <= 32768 && pcrel >= -32768)
1532
                    {
1533
                      /* Relax JMP.A -> JMP.W */
1534
                      insn[0] = 0xf4;
1535
                      insn[1] = 0;
1536
                      insn[2] = 0;
1537
                      new_type = R_M32C_16_PCREL;
1538
                      gap_size = 1;
1539
                      gap = insn + 3;
1540
                    }
1541
                  break;
1542
 
1543
                case 0xfd: /* jsr.a */
1544
                  if (pcrel <= 32768 && pcrel >= -32768)
1545
                    {
1546
                      /* Relax JSR.A -> JSR.W */
1547
                      insn[0] = 0xf5;
1548
                      insn[1] = 0;
1549
                      insn[2] = 0;
1550
                      new_type = R_M32C_16_PCREL;
1551
                      gap_size = 1;
1552
                      gap = insn + 3;
1553
                    }
1554
                  break;
1555
                }
1556
              break;
1557
 
1558
            case R_M32C_RL_2ADDR:
1559
              /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
1560
 
1561
              enctbl = m16c_addr_encodings;
1562
              posn = 2;
1563
              enc = (insn[1] >> 4) & 0x0f;
1564
              e = & enctbl[enc];
1565
 
1566
              if (srel->r_offset == irel->r_offset + posn
1567
                  && e->new_encoding != enc
1568
                  && symval <= e->max_disp)
1569
                {
1570
                  insn[1] &= 0x0f;
1571
                  insn[1] |= e->new_encoding << 4;
1572
                  gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1573
                  gap = insn + posn + enctbl[e->new_encoding].bytes;
1574
                  new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1575
                  break;
1576
                }
1577
              if (relax_relocs == 2)
1578
                srel ++;
1579
              posn += e->bytes;
1580
 
1581
              goto try_1addr_16;
1582
 
1583
            case R_M32C_RL_1ADDR:
1584
              /* xxxx xxxx xxxx dest [disp] */
1585
 
1586
              enctbl = m16c_addr_encodings;
1587
              posn = 2;
1588
 
1589
              /* Check the opcode for jumps.  We know it's safe to
1590
                 do this because all 2ADDR insns are at least two
1591
                 bytes long.  */
1592
              enc = insn[0] * 256 + insn[1];
1593
              enc &= 0xfff0;
1594
              if (enc == 0x7d20
1595
                  || enc == 0x7d00
1596
                  || enc == 0x7d30
1597
                  || enc == 0x7d10)
1598
                {
1599
                  enctbl = m16c_jmpaddr_encodings;
1600
                }
1601
 
1602
            try_1addr_16:
1603
              /* srel, posn, and enc must be set here.  */
1604
 
1605
              symval = OFFSET_FOR_RELOC (srel);
1606
              enc = insn[1] & 0x0f;
1607
              e = & enctbl[enc];
1608
 
1609
              if (srel->r_offset == irel->r_offset + posn
1610
                  && e->new_encoding != enc
1611
                  && symval <= e->max_disp)
1612
                {
1613
                  insn[1] &= 0xf0;
1614
                  insn[1] |= e->new_encoding;
1615
                  gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1616
                  gap = insn + posn + enctbl[e->new_encoding].bytes;
1617
                  new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1618
                  break;
1619
                }
1620
 
1621
              break;
1622
 
1623
            } /* Ends switch (reloc type) for m16c.  */
1624
        }
1625
      else /* machine == bfd_mach_m32c */
1626
        {
1627
          /* M32CM / M32C */
1628
 
1629
          switch (ELF32_R_TYPE(irel->r_info))
1630
            {
1631
 
1632
            case R_M32C_RL_JUMP:
1633
              switch (insn[0])
1634
                {
1635
                case 0xbb: /* jmp.b */
1636
                  if (pcrel >= 2 && pcrel <= 9)
1637
                    {
1638
                      int p = pcrel - 2;
1639
                      /* Relax JMP.B -> JMP.S.  We need to get rid of
1640
                         the following reloc though. */
1641
                      insn[0] = 0x4a | ((p << 3) & 0x30) | (p & 1);
1642
                      new_type = R_M32C_NONE;
1643
                      irel->r_addend = 0x10;
1644
                      gap_size = 1;
1645
                      gap = insn + 1;
1646
                    }
1647
                  break;
1648
 
1649
                case 0xce: /* jmp.w */
1650
                  if (pcrel <= 128 && pcrel >= -128)
1651
                    {
1652
                      /* Relax JMP.W -> JMP.B */
1653
                      insn[0] = 0xbb;
1654
                      insn[1] = 0;
1655
                      new_type = R_M32C_8_PCREL;
1656
                      gap_size = 1;
1657
                      gap = insn + 2;
1658
                    }
1659
                  break;
1660
 
1661
                case 0xcc: /* jmp.a */
1662
                  if (pcrel <= 32768 && pcrel >= -32768)
1663
                    {
1664
                      /* Relax JMP.A -> JMP.W */
1665
                      insn[0] = 0xce;
1666
                      insn[1] = 0;
1667
                      insn[2] = 0;
1668
                      new_type = R_M32C_16_PCREL;
1669
                      gap_size = 1;
1670
                      gap = insn + 3;
1671
                    }
1672
                  break;
1673
 
1674
                case 0xcd: /* jsr.a */
1675
                  if (pcrel <= 32768 && pcrel >= -32768)
1676
                    {
1677
                      /* Relax JSR.A -> JSR.W */
1678
                      insn[0] = 0xcf;
1679
                      insn[1] = 0;
1680
                      insn[2] = 0;
1681
                      new_type = R_M32C_16_PCREL;
1682
                      gap_size = 1;
1683
                      gap = insn + 3;
1684
                    }
1685
                  break;
1686
                }
1687
              break;
1688
 
1689
            case R_M32C_RL_2ADDR:
1690
              /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
1691
 
1692
              einsn = insn;
1693
              posn = 2;
1694
              if (einsn[0] == 1)
1695
                {
1696
                  /* prefix; remove it as far as the RL reloc is concerned.  */
1697
                  einsn ++;
1698
                  posn ++;
1699
                }
1700
 
1701
              enctbl = m32c_addr_encodings;
1702
              enc = ((einsn[0] & 0x70) >> 2) | ((einsn[1] & 0x30) >> 4);
1703
              e = & enctbl[enc];
1704
 
1705
              if (srel->r_offset == irel->r_offset + posn
1706
                  && e->new_encoding != enc
1707
                  && symval <= e->max_disp)
1708
                {
1709
                  einsn[0] &= 0x8f;
1710
                  einsn[0] |= (e->new_encoding & 0x1c) << 2;
1711
                  einsn[1] &= 0xcf;
1712
                  einsn[1] |= (e->new_encoding & 0x03) << 4;
1713
                  gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1714
                  gap = insn + posn + enctbl[e->new_encoding].bytes;
1715
                  new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1716
                  break;
1717
                }
1718
              if (relax_relocs == 2)
1719
                  srel ++;
1720
              posn += e->bytes;
1721
 
1722
              goto try_1addr_32;
1723
 
1724
            case R_M32C_RL_1ADDR:
1725
              /* xxxx DDDx DDxx xxxx [disp] */
1726
 
1727
              einsn = insn;
1728
              posn = 2;
1729
              if (einsn[0] == 1)
1730
                {
1731
                  /* prefix; remove it as far as the RL reloc is concerned.  */
1732
                  einsn ++;
1733
                  posn ++;
1734
                }
1735
 
1736
              enctbl = m32c_addr_encodings;
1737
 
1738
            try_1addr_32:
1739
              /* srel, posn, and enc must be set here.  */
1740
 
1741
              symval = OFFSET_FOR_RELOC (srel);
1742
              enc = ((einsn[0] & 0x0e) << 1) |  ((einsn[1] & 0xc0) >> 6);
1743
              e = & enctbl[enc];
1744
 
1745
              if (srel->r_offset == irel->r_offset + posn
1746
                  && e->new_encoding != enc
1747
                  && symval <= e->max_disp)
1748
                {
1749
                  einsn[0] &= 0xf1;
1750
                  einsn[0] |= (e->new_encoding & 0x1c) >> 1;
1751
                  einsn[1] &= 0x3f;
1752
                  einsn[1] |= (e->new_encoding & 0x03) << 6;
1753
                  gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1754
                  gap = insn + posn + enctbl[e->new_encoding].bytes;
1755
                  new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1756
                  break;
1757
                }
1758
 
1759
              break;
1760
 
1761
            } /* Ends switch (reloc type) for m32c.  */
1762
        }
1763
 
1764
      if (gap_size == 0)
1765
        continue;
1766
 
1767
      *again = TRUE;
1768
 
1769
      srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), new_type);
1770
 
1771
      /* Note that we've changed the relocs, section contents, etc.  */
1772
      elf_section_data (sec)->relocs = internal_relocs;
1773
      free_relocs = NULL;
1774
 
1775
      elf_section_data (sec)->this_hdr.contents = contents;
1776
      free_contents = NULL;
1777
 
1778
      symtab_hdr->contents = (bfd_byte *) intsyms;
1779
      free_intsyms = NULL;
1780
 
1781
      bytes_saved += gap_size;
1782
 
1783
      if (! m32c_elf_relax_delete_bytes(abfd, sec, gap - contents, gap_size))
1784
        goto error_return;
1785
 
1786
    } /* next relocation */
1787
 
1788
  if (free_relocs != NULL)
1789
    {
1790
      free (free_relocs);
1791
      free_relocs = NULL;
1792
    }
1793
 
1794
  if (free_contents != NULL)
1795
    {
1796
      if (! link_info->keep_memory)
1797
        free (free_contents);
1798
      /* Cache the section contents for elf_link_input_bfd.  */
1799
      else
1800
        elf_section_data (sec)->this_hdr.contents = contents;
1801
 
1802
      free_contents = NULL;
1803
    }
1804
 
1805
  if (shndx_buf != NULL)
1806
    {
1807
      shndx_hdr->contents = NULL;
1808
      free (shndx_buf);
1809
    }
1810
 
1811
  if (free_intsyms != NULL)
1812
    {
1813
      if (! link_info->keep_memory)
1814
        free (free_intsyms);
1815
      /* Cache the symbols for elf_link_input_bfd.  */
1816
      else
1817
        {
1818
        symtab_hdr->contents = NULL /* (unsigned char *) intsyms*/;
1819
        }
1820
 
1821
      free_intsyms = NULL;
1822
    }
1823
 
1824
  return TRUE;
1825
 
1826
 error_return:
1827
  if (free_relocs != NULL)
1828
    free (free_relocs);
1829
  if (free_contents != NULL)
1830
    free (free_contents);
1831
  if (shndx_buf != NULL)
1832
    {
1833
      shndx_hdr->contents = NULL;
1834
      free (shndx_buf);
1835
    }
1836
  if (free_intsyms != NULL)
1837
    free (free_intsyms);
1838
  return FALSE;
1839
}
1840
 
1841
/* Delete some bytes from a section while relaxing.  */
1842
 
1843
static bfd_boolean
1844
m32c_elf_relax_delete_bytes
1845
 (bfd *      abfd,
1846
  asection * sec,
1847
  bfd_vma    addr,
1848
  int        count)
1849
{
1850
  Elf_Internal_Shdr *symtab_hdr;
1851
  Elf_Internal_Shdr *shndx_hdr;
1852
  int sec_shndx;
1853
  bfd_byte *contents;
1854
  Elf_Internal_Rela *irel;
1855
  Elf_Internal_Rela *irelend;
1856
  bfd_vma toaddr;
1857
  Elf_Internal_Sym *isym;
1858
  Elf_Internal_Sym *isymend;
1859
  Elf_Internal_Sym *intsyms;
1860
  Elf_External_Sym_Shndx *shndx_buf;
1861
  Elf_External_Sym_Shndx *shndx;
1862
  struct elf_link_hash_entry ** sym_hashes;
1863
  struct elf_link_hash_entry ** end_hashes;
1864
  unsigned int                  symcount;
1865
 
1866
  contents   = elf_section_data (sec)->this_hdr.contents;
1867
 
1868
  toaddr = sec->size;
1869
 
1870
  irel = elf_section_data (sec)->relocs;
1871
  irelend = irel + sec->reloc_count;
1872
 
1873
  /* Actually delete the bytes.  */
1874
  memmove (contents + addr, contents + addr + count, (size_t) (toaddr - addr - count));
1875
  sec->size -= count;
1876
 
1877
  /* Adjust all the relocs.  */
1878
  for (irel = elf_section_data (sec)->relocs; irel < irelend; irel ++)
1879
    {
1880
      /* Get the new reloc address.  */
1881
      if (irel->r_offset > addr && irel->r_offset < toaddr)
1882
        irel->r_offset -= count;
1883
 
1884
      if (ELF32_R_TYPE(irel->r_info) == R_M32C_RL_JUMP
1885
          && irel->r_addend == 0x10 /* one byte insn, no relocs */
1886
          && irel->r_offset + 1 < addr
1887
          && irel->r_offset + 7 > addr)
1888
        {
1889
          bfd_vma disp;
1890
          unsigned char *insn = &contents[irel->r_offset];
1891
          disp = *insn;
1892
          /* This is a JMP.S, which we have to manually update. */
1893
          if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
1894
            {
1895
              if ((*insn & 0xf8) != 0x60)
1896
                continue;
1897
              disp = (disp & 7);
1898
            }
1899
          else
1900
            {
1901
              if ((*insn & 0xce) != 0x4a)
1902
                continue;
1903
              disp = ((disp & 0x30) >> 3) | (disp & 1);
1904
            }
1905
          if (irel->r_offset + disp + 2 >= addr+count)
1906
            {
1907
              disp -= count;
1908
              if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
1909
                {
1910
                  *insn = (*insn & 0xf8) | disp;
1911
                }
1912
              else
1913
                {
1914
                  *insn = (*insn & 0xce) | ((disp & 6) << 3) | (disp & 1);
1915
                }
1916
            }
1917
        }
1918
    }
1919
 
1920
  /* Adjust the local symbols defined in this section.  */
1921
  symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1922
  intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
1923
  isym = intsyms;
1924
  isymend = isym + symtab_hdr->sh_info;
1925
 
1926
  sec_shndx  = _bfd_elf_section_from_bfd_section (abfd, sec);
1927
  shndx_hdr  = & elf_tdata (abfd)->symtab_shndx_hdr;
1928
  shndx_buf  = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
1929
  shndx = shndx_buf;
1930
 
1931
  for (; isym < isymend; isym++, shndx = (shndx ? shndx + 1 : NULL))
1932
    {
1933
      /* If the symbol is in the range of memory we just moved, we
1934
         have to adjust its value.  */
1935
      if ((int) isym->st_shndx == sec_shndx
1936
          && isym->st_value > addr
1937
          && isym->st_value < toaddr)
1938
        {
1939
          isym->st_value -= count;
1940
        }
1941
      /* If the symbol *spans* the bytes we just deleted (i.e. it's
1942
         *end* is in the moved bytes but it's *start* isn't), then we
1943
         must adjust its size.  */
1944
      if ((int) isym->st_shndx == sec_shndx
1945
            && isym->st_value < addr
1946
          && isym->st_value + isym->st_size > addr
1947
          && isym->st_value + isym->st_size < toaddr)
1948
        {
1949
          isym->st_size -= count;
1950
        }
1951
    }
1952
 
1953
  /* Now adjust the global symbols defined in this section.  */
1954
  symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1955
              - symtab_hdr->sh_info);
1956
  sym_hashes = elf_sym_hashes (abfd);
1957
  //  sym_hashes += symtab_hdr->sh_info;
1958
  end_hashes = sym_hashes + symcount;
1959
 
1960
  for (; sym_hashes < end_hashes; sym_hashes ++)
1961
    {
1962
      struct elf_link_hash_entry * sym_hash = * sym_hashes;
1963
 
1964
      if (sym_hash &&
1965
          (sym_hash->root.type == bfd_link_hash_defined
1966
           || sym_hash->root.type == bfd_link_hash_defweak)
1967
          && sym_hash->root.u.def.section == sec)
1968
        {
1969
          if (sym_hash->root.u.def.value > addr
1970
              && sym_hash->root.u.def.value < toaddr)
1971
            {
1972
              sym_hash->root.u.def.value -= count;
1973
            }
1974
          if (sym_hash->root.u.def.value < addr
1975
              && sym_hash->root.u.def.value + sym_hash->size > addr
1976
              && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1977
            {
1978
              sym_hash->size -= count;
1979
            }
1980
        }
1981
    }
1982
 
1983
  return TRUE;
1984
}
1985
 
1986
/* This is for versions of gcc prior to 4.3.  */
1987
static unsigned int
1988
_bfd_m32c_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1989
{
1990
  if ((elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK) == EF_M32C_CPU_M16C)
1991
    return 2;
1992
  return 4;
1993
}
1994
 
1995
 
1996
 
1997
#define ELF_ARCH                bfd_arch_m32c
1998
#define ELF_MACHINE_CODE        EM_M32C
1999
#define ELF_MACHINE_ALT1        EM_M32C_OLD
2000
#define ELF_MAXPAGESIZE         0x100
2001
 
2002
#if 0
2003
#define TARGET_BIG_SYM          bfd_elf32_m32c_vec
2004
#define TARGET_BIG_NAME         "elf32-m32c"
2005
#else
2006
#define TARGET_LITTLE_SYM               bfd_elf32_m32c_vec
2007
#define TARGET_LITTLE_NAME              "elf32-m32c"
2008
#endif
2009
 
2010
#define elf_info_to_howto_rel                   NULL
2011
#define elf_info_to_howto                       m32c_info_to_howto_rela
2012
#define elf_backend_object_p                    m32c_elf_object_p
2013
#define elf_backend_relocate_section            m32c_elf_relocate_section
2014
#define elf_backend_check_relocs                m32c_elf_check_relocs
2015
#define elf_backend_object_p                    m32c_elf_object_p
2016
#define elf_symbol_leading_char                 ('_')
2017
#define elf_backend_always_size_sections \
2018
  m32c_elf_always_size_sections
2019
#define elf_backend_finish_dynamic_sections \
2020
  m32c_elf_finish_dynamic_sections
2021
 
2022
#define elf_backend_can_gc_sections             1
2023
#define elf_backend_eh_frame_address_size _bfd_m32c_elf_eh_frame_address_size
2024
 
2025
#define bfd_elf32_bfd_reloc_type_lookup         m32c_reloc_type_lookup
2026
#define bfd_elf32_bfd_reloc_name_lookup m32c_reloc_name_lookup
2027
#define bfd_elf32_bfd_relax_section             m32c_elf_relax_section
2028
#define bfd_elf32_bfd_set_private_flags         m32c_elf_set_private_flags
2029
#define bfd_elf32_bfd_merge_private_bfd_data    m32c_elf_merge_private_bfd_data
2030
#define bfd_elf32_bfd_print_private_bfd_data    m32c_elf_print_private_bfd_data
2031
 
2032
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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