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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [bfd/] [elf32-m32c.c] - Blame information for rev 818

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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