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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [bfd/] [elf-m10300.c] - Blame information for rev 578

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

Line No. Rev Author Line
1 578 markom
/* Matsushita 10300 specific support for 32-bit ELF
2
   Copyright 1996, 1997, 1998, 1999, 2000, 2001
3
   Free Software Foundation, Inc.
4
 
5
This file is part of BFD, the Binary File Descriptor library.
6
 
7
This program is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 2 of the License, or
10
(at your option) any later version.
11
 
12
This program is distributed in the hope that it will be useful,
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
GNU General Public License for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with this program; if not, write to the Free Software
19
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
 
21
#include "bfd.h"
22
#include "sysdep.h"
23
#include "libbfd.h"
24
#include "elf-bfd.h"
25
#include "elf/mn10300.h"
26
 
27
struct elf32_mn10300_link_hash_entry {
28
  /* The basic elf link hash table entry.  */
29
  struct elf_link_hash_entry root;
30
 
31
  /* For function symbols, the number of times this function is
32
     called directly (ie by name).  */
33
  unsigned int direct_calls;
34
 
35
  /* For function symbols, the size of this function's stack
36
     (if <= 255 bytes).  We stuff this into "call" instructions
37
     to this target when it's valid and profitable to do so.
38
 
39
     This does not include stack allocated by movm!  */
40
  unsigned char stack_size;
41
 
42
  /* For function symbols, arguments (if any) for movm instruction
43
     in the prologue.  We stuff this value into "call" instructions
44
     to the target when it's valid and profitable to do so.  */
45
  unsigned char movm_args;
46
 
47
  /* For funtion symbols, the amount of stack space that would be allocated
48
     by the movm instruction.  This is redundant with movm_args, but we
49
     add it to the hash table to avoid computing it over and over.  */
50
  unsigned char movm_stack_size;
51
 
52
/* When set, convert all "call" instructions to this target into "calls"
53
   instructions.  */
54
#define MN10300_CONVERT_CALL_TO_CALLS 0x1
55
 
56
/* Used to mark functions which have had redundant parts of their
57
   prologue deleted.  */
58
#define MN10300_DELETED_PROLOGUE_BYTES 0x2
59
  unsigned char flags;
60
};
61
 
62
/* We derive a hash table from the main elf linker hash table so
63
   we can store state variables and a secondary hash table without
64
   resorting to global variables.  */
65
struct elf32_mn10300_link_hash_table {
66
  /* The main hash table.  */
67
  struct elf_link_hash_table root;
68
 
69
  /* A hash table for static functions.  We could derive a new hash table
70
     instead of using the full elf32_mn10300_link_hash_table if we wanted
71
     to save some memory.  */
72
  struct elf32_mn10300_link_hash_table *static_hash_table;
73
 
74
  /* Random linker state flags.  */
75
#define MN10300_HASH_ENTRIES_INITIALIZED 0x1
76
  char flags;
77
};
78
 
79
/* For MN10300 linker hash table.  */
80
 
81
/* Get the MN10300 ELF linker hash table from a link_info structure.  */
82
 
83
#define elf32_mn10300_hash_table(p) \
84
  ((struct elf32_mn10300_link_hash_table *) ((p)->hash))
85
 
86
#define elf32_mn10300_link_hash_traverse(table, func, info)             \
87
  (elf_link_hash_traverse                                               \
88
   (&(table)->root,                                                     \
89
    (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \
90
    (info)))
91
 
92
static struct bfd_hash_entry *elf32_mn10300_link_hash_newfunc
93
  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
94
static struct bfd_link_hash_table *elf32_mn10300_link_hash_table_create
95
  PARAMS ((bfd *));
96
 
97
static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
98
  PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
99
static void mn10300_info_to_howto
100
  PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
101
static boolean mn10300_elf_check_relocs
102
  PARAMS ((bfd *, struct bfd_link_info *, asection *,
103
           const Elf_Internal_Rela *));
104
static asection *mn10300_elf_gc_mark_hook
105
  PARAMS ((bfd *, struct bfd_link_info *info, Elf_Internal_Rela *,
106
           struct elf_link_hash_entry *, Elf_Internal_Sym *));
107
static boolean mn10300_elf_relax_delete_bytes
108
  PARAMS ((bfd *, asection *, bfd_vma, int));
109
static boolean mn10300_elf_symbol_address_p
110
  PARAMS ((bfd *, asection *, Elf32_External_Sym *, bfd_vma));
111
static boolean elf32_mn10300_finish_hash_table_entry
112
  PARAMS ((struct bfd_hash_entry *, PTR));
113
static void compute_function_info
114
  PARAMS ((bfd *, struct elf32_mn10300_link_hash_entry *,
115
           bfd_vma, unsigned char *));
116
 
117
/* We have to use RELA instructions since md_apply_fix3 in the assembler
118
   does absolutely nothing.  */
119
#define USE_RELA
120
 
121
static reloc_howto_type elf_mn10300_howto_table[] = {
122
  /* Dummy relocation.  Does nothing.  */
123
  HOWTO (R_MN10300_NONE,
124
         0,
125
         2,
126
         16,
127
         false,
128
         0,
129
         complain_overflow_bitfield,
130
         bfd_elf_generic_reloc,
131
         "R_MN10300_NONE",
132
         false,
133
         0,
134
         0,
135
         false),
136
  /* Standard 32 bit reloc.  */
137
  HOWTO (R_MN10300_32,
138
         0,
139
         2,
140
         32,
141
         false,
142
         0,
143
         complain_overflow_bitfield,
144
         bfd_elf_generic_reloc,
145
         "R_MN10300_32",
146
         false,
147
         0xffffffff,
148
         0xffffffff,
149
         false),
150
  /* Standard 16 bit reloc.  */
151
  HOWTO (R_MN10300_16,
152
         0,
153
         1,
154
         16,
155
         false,
156
         0,
157
         complain_overflow_bitfield,
158
         bfd_elf_generic_reloc,
159
         "R_MN10300_16",
160
         false,
161
         0xffff,
162
         0xffff,
163
         false),
164
  /* Standard 8 bit reloc.  */
165
  HOWTO (R_MN10300_8,
166
         0,
167
         0,
168
         8,
169
         false,
170
         0,
171
         complain_overflow_bitfield,
172
         bfd_elf_generic_reloc,
173
         "R_MN10300_8",
174
         false,
175
         0xff,
176
         0xff,
177
         false),
178
  /* Standard 32bit pc-relative reloc.  */
179
  HOWTO (R_MN10300_PCREL32,
180
         0,
181
         2,
182
         32,
183
         true,
184
         0,
185
         complain_overflow_bitfield,
186
         bfd_elf_generic_reloc,
187
         "R_MN10300_PCREL32",
188
         false,
189
         0xffffffff,
190
         0xffffffff,
191
         true),
192
  /* Standard 16bit pc-relative reloc.  */
193
  HOWTO (R_MN10300_PCREL16,
194
         0,
195
         1,
196
         16,
197
         true,
198
         0,
199
         complain_overflow_bitfield,
200
         bfd_elf_generic_reloc,
201
         "R_MN10300_PCREL16",
202
         false,
203
         0xffff,
204
         0xffff,
205
         true),
206
  /* Standard 8 pc-relative reloc.  */
207
  HOWTO (R_MN10300_PCREL8,
208
         0,
209
         0,
210
         8,
211
         true,
212
         0,
213
         complain_overflow_bitfield,
214
         bfd_elf_generic_reloc,
215
         "R_MN10300_PCREL8",
216
         false,
217
         0xff,
218
         0xff,
219
         true),
220
 
221
  /* GNU extension to record C++ vtable hierarchy */
222
  HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
223
         0,                      /* rightshift */
224
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
225
         0,                      /* bitsize */
226
         false,                 /* pc_relative */
227
         0,                      /* bitpos */
228
         complain_overflow_dont, /* complain_on_overflow */
229
         NULL,                  /* special_function */
230
         "R_MN10300_GNU_VTINHERIT", /* name */
231
         false,                 /* partial_inplace */
232
         0,                      /* src_mask */
233
         0,                      /* dst_mask */
234
         false),                /* pcrel_offset */
235
 
236
  /* GNU extension to record C++ vtable member usage */
237
  HOWTO (R_MN10300_GNU_VTENTRY, /* type */
238
         0,                      /* rightshift */
239
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
240
         0,                      /* bitsize */
241
         false,                 /* pc_relative */
242
         0,                      /* bitpos */
243
         complain_overflow_dont, /* complain_on_overflow */
244
         NULL,                  /* special_function */
245
         "R_MN10300_GNU_VTENTRY", /* name */
246
         false,                 /* partial_inplace */
247
         0,                      /* src_mask */
248
         0,                      /* dst_mask */
249
         false),                /* pcrel_offset */
250
 
251
  /* Standard 24 bit reloc.  */
252
  HOWTO (R_MN10300_24,
253
         0,
254
         2,
255
         24,
256
         false,
257
         0,
258
         complain_overflow_bitfield,
259
         bfd_elf_generic_reloc,
260
         "R_MN10300_24",
261
         false,
262
         0xffffff,
263
         0xffffff,
264
         false),
265
};
266
 
267
struct mn10300_reloc_map {
268
  bfd_reloc_code_real_type bfd_reloc_val;
269
  unsigned char elf_reloc_val;
270
};
271
 
272
static const struct mn10300_reloc_map mn10300_reloc_map[] = {
273
  { BFD_RELOC_NONE, R_MN10300_NONE, },
274
  { BFD_RELOC_32, R_MN10300_32, },
275
  { BFD_RELOC_16, R_MN10300_16, },
276
  { BFD_RELOC_8, R_MN10300_8, },
277
  { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
278
  { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
279
  { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
280
  { BFD_RELOC_24, R_MN10300_24, },
281
  { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
282
  { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
283
};
284
 
285
static reloc_howto_type *
286
bfd_elf32_bfd_reloc_type_lookup (abfd, code)
287
     bfd *abfd ATTRIBUTE_UNUSED;
288
     bfd_reloc_code_real_type code;
289
{
290
  unsigned int i;
291
 
292
  for (i = 0;
293
       i < sizeof (mn10300_reloc_map) / sizeof (struct mn10300_reloc_map);
294
       i++)
295
    {
296
      if (mn10300_reloc_map[i].bfd_reloc_val == code)
297
        return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
298
    }
299
 
300
  return NULL;
301
}
302
 
303
/* Set the howto pointer for an MN10300 ELF reloc.  */
304
 
305
static void
306
mn10300_info_to_howto (abfd, cache_ptr, dst)
307
     bfd *abfd ATTRIBUTE_UNUSED;
308
     arelent *cache_ptr;
309
     Elf32_Internal_Rela *dst;
310
{
311
  unsigned int r_type;
312
 
313
  r_type = ELF32_R_TYPE (dst->r_info);
314
  BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
315
  cache_ptr->howto = &elf_mn10300_howto_table[r_type];
316
}
317
 
318
/* Look through the relocs for a section during the first phase.
319
   Since we don't do .gots or .plts, we just need to consider the
320
   virtual table relocs for gc.  */
321
 
322
static boolean
323
mn10300_elf_check_relocs (abfd, info, sec, relocs)
324
     bfd *abfd;
325
     struct bfd_link_info *info;
326
     asection *sec;
327
     const Elf_Internal_Rela *relocs;
328
{
329
  Elf_Internal_Shdr *symtab_hdr;
330
  struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
331
  const Elf_Internal_Rela *rel;
332
  const Elf_Internal_Rela *rel_end;
333
 
334
  if (info->relocateable)
335
    return true;
336
 
337
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
338
  sym_hashes = elf_sym_hashes (abfd);
339
  sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
340
  if (!elf_bad_symtab (abfd))
341
    sym_hashes_end -= symtab_hdr->sh_info;
342
 
343
  rel_end = relocs + sec->reloc_count;
344
  for (rel = relocs; rel < rel_end; rel++)
345
    {
346
      struct elf_link_hash_entry *h;
347
      unsigned long r_symndx;
348
 
349
      r_symndx = ELF32_R_SYM (rel->r_info);
350
      if (r_symndx < symtab_hdr->sh_info)
351
        h = NULL;
352
      else
353
        h = sym_hashes[r_symndx - symtab_hdr->sh_info];
354
 
355
      switch (ELF32_R_TYPE (rel->r_info))
356
        {
357
        /* This relocation describes the C++ object vtable hierarchy.
358
           Reconstruct it for later use during GC.  */
359
        case R_MN10300_GNU_VTINHERIT:
360
          if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
361
            return false;
362
          break;
363
 
364
        /* This relocation describes which C++ vtable entries are actually
365
           used.  Record for later use during GC.  */
366
        case R_MN10300_GNU_VTENTRY:
367
          if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
368
            return false;
369
          break;
370
        }
371
    }
372
 
373
  return true;
374
}
375
 
376
/* Return the section that should be marked against GC for a given
377
   relocation.  */
378
 
379
static asection *
380
mn10300_elf_gc_mark_hook (abfd, info, rel, h, sym)
381
     bfd *abfd;
382
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
383
     Elf_Internal_Rela *rel;
384
     struct elf_link_hash_entry *h;
385
     Elf_Internal_Sym *sym;
386
{
387
  if (h != NULL)
388
    {
389
      switch (ELF32_R_TYPE (rel->r_info))
390
        {
391
        case R_MN10300_GNU_VTINHERIT:
392
        case R_MN10300_GNU_VTENTRY:
393
          break;
394
 
395
        default:
396
          switch (h->root.type)
397
            {
398
            case bfd_link_hash_defined:
399
            case bfd_link_hash_defweak:
400
              return h->root.u.def.section;
401
 
402
            case bfd_link_hash_common:
403
              return h->root.u.c.p->section;
404
 
405
            default:
406
              break;
407
            }
408
        }
409
    }
410
  else
411
    {
412
      if (!(elf_bad_symtab (abfd)
413
            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
414
          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
415
                && sym->st_shndx != SHN_COMMON))
416
        {
417
          return bfd_section_from_elf_index (abfd, sym->st_shndx);
418
        }
419
    }
420
 
421
  return NULL;
422
}
423
 
424
/* Perform a relocation as part of a final link.  */
425
static bfd_reloc_status_type
426
mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
427
                                 input_section, contents, offset, value,
428
                                 addend, info, sym_sec, is_local)
429
     reloc_howto_type *howto;
430
     bfd *input_bfd;
431
     bfd *output_bfd ATTRIBUTE_UNUSED;
432
     asection *input_section;
433
     bfd_byte *contents;
434
     bfd_vma offset;
435
     bfd_vma value;
436
     bfd_vma addend;
437
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
438
     asection *sym_sec ATTRIBUTE_UNUSED;
439
     int is_local ATTRIBUTE_UNUSED;
440
{
441
  unsigned long r_type = howto->type;
442
  bfd_byte *hit_data = contents + offset;
443
 
444
  switch (r_type)
445
    {
446
    case R_MN10300_NONE:
447
      return bfd_reloc_ok;
448
 
449
    case R_MN10300_32:
450
      value += addend;
451
      bfd_put_32 (input_bfd, value, hit_data);
452
      return bfd_reloc_ok;
453
 
454
    case R_MN10300_24:
455
      value += addend;
456
 
457
      if ((long) value > 0x7fffff || (long) value < -0x800000)
458
        return bfd_reloc_overflow;
459
 
460
      bfd_put_8 (input_bfd, value & 0xff, hit_data);
461
      bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
462
      bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
463
      return bfd_reloc_ok;
464
 
465
    case R_MN10300_16:
466
      value += addend;
467
 
468
      if ((long) value > 0x7fff || (long) value < -0x8000)
469
        return bfd_reloc_overflow;
470
 
471
      bfd_put_16 (input_bfd, value, hit_data);
472
      return bfd_reloc_ok;
473
 
474
    case R_MN10300_8:
475
      value += addend;
476
 
477
      if ((long) value > 0x7f || (long) value < -0x80)
478
        return bfd_reloc_overflow;
479
 
480
      bfd_put_8 (input_bfd, value, hit_data);
481
      return bfd_reloc_ok;
482
 
483
    case R_MN10300_PCREL8:
484
      value -= (input_section->output_section->vma
485
                + input_section->output_offset);
486
      value -= offset;
487
      value += addend;
488
 
489
      if ((long) value > 0xff || (long) value < -0x100)
490
        return bfd_reloc_overflow;
491
 
492
      bfd_put_8 (input_bfd, value, hit_data);
493
      return bfd_reloc_ok;
494
 
495
    case R_MN10300_PCREL16:
496
      value -= (input_section->output_section->vma
497
                + input_section->output_offset);
498
      value -= offset;
499
      value += addend;
500
 
501
      if ((long) value > 0xffff || (long) value < -0x10000)
502
        return bfd_reloc_overflow;
503
 
504
      bfd_put_16 (input_bfd, value, hit_data);
505
      return bfd_reloc_ok;
506
 
507
    case R_MN10300_PCREL32:
508
      value -= (input_section->output_section->vma
509
                + input_section->output_offset);
510
      value -= offset;
511
      value += addend;
512
 
513
      bfd_put_32 (input_bfd, value, hit_data);
514
      return bfd_reloc_ok;
515
 
516
    case R_MN10300_GNU_VTINHERIT:
517
    case R_MN10300_GNU_VTENTRY:
518
      return bfd_reloc_ok;
519
 
520
    default:
521
      return bfd_reloc_notsupported;
522
    }
523
}
524
 
525
/* Relocate an MN10300 ELF section.  */
526
static boolean
527
mn10300_elf_relocate_section (output_bfd, info, input_bfd, input_section,
528
                              contents, relocs, local_syms, local_sections)
529
     bfd *output_bfd;
530
     struct bfd_link_info *info;
531
     bfd *input_bfd;
532
     asection *input_section;
533
     bfd_byte *contents;
534
     Elf_Internal_Rela *relocs;
535
     Elf_Internal_Sym *local_syms;
536
     asection **local_sections;
537
{
538
  Elf_Internal_Shdr *symtab_hdr;
539
  struct elf32_mn10300_link_hash_entry **sym_hashes;
540
  Elf_Internal_Rela *rel, *relend;
541
 
542
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
543
  sym_hashes = (struct elf32_mn10300_link_hash_entry **)
544
                 (elf_sym_hashes (input_bfd));
545
 
546
  rel = relocs;
547
  relend = relocs + input_section->reloc_count;
548
  for (; rel < relend; rel++)
549
    {
550
      int r_type;
551
      reloc_howto_type *howto;
552
      unsigned long r_symndx;
553
      Elf_Internal_Sym *sym;
554
      asection *sec;
555
      struct elf32_mn10300_link_hash_entry *h;
556
      bfd_vma relocation;
557
      bfd_reloc_status_type r;
558
 
559
      r_symndx = ELF32_R_SYM (rel->r_info);
560
      r_type = ELF32_R_TYPE (rel->r_info);
561
      howto = elf_mn10300_howto_table + r_type;
562
 
563
      /* Just skip the vtable gc relocs.  */
564
      if (r_type == R_MN10300_GNU_VTINHERIT
565
          || r_type == R_MN10300_GNU_VTENTRY)
566
        continue;
567
 
568
      if (info->relocateable)
569
        {
570
          /* This is a relocateable link.  We don't have to change
571
             anything, unless the reloc is against a section symbol,
572
             in which case we have to adjust according to where the
573
             section symbol winds up in the output section.  */
574
          if (r_symndx < symtab_hdr->sh_info)
575
            {
576
              sym = local_syms + r_symndx;
577
              if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
578
                {
579
                  sec = local_sections[r_symndx];
580
                  rel->r_addend += sec->output_offset + sym->st_value;
581
                }
582
            }
583
 
584
          continue;
585
        }
586
 
587
      /* This is a final link.  */
588
      h = NULL;
589
      sym = NULL;
590
      sec = NULL;
591
      if (r_symndx < symtab_hdr->sh_info)
592
        {
593
          sym = local_syms + r_symndx;
594
          sec = local_sections[r_symndx];
595
          relocation = (sec->output_section->vma
596
                        + sec->output_offset
597
                        + sym->st_value);
598
        }
599
      else
600
        {
601
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
602
          while (h->root.type == bfd_link_hash_indirect
603
                 || h->root.type == bfd_link_hash_warning)
604
            h = (struct elf32_mn10300_link_hash_entry *) h->root.root.u.i.link;
605
          if (h->root.root.type == bfd_link_hash_defined
606
              || h->root.root.type == bfd_link_hash_defweak)
607
            {
608
              sec = h->root.root.u.def.section;
609
              relocation = (h->root.root.u.def.value
610
                            + sec->output_section->vma
611
                            + sec->output_offset);
612
            }
613
          else if (h->root.root.type == bfd_link_hash_undefweak)
614
            relocation = 0;
615
          else
616
            {
617
              if (! ((*info->callbacks->undefined_symbol)
618
                     (info, h->root.root.root.string, input_bfd,
619
                      input_section, rel->r_offset, true)))
620
                return false;
621
              relocation = 0;
622
            }
623
        }
624
 
625
      r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
626
                                           input_section,
627
                                           contents, rel->r_offset,
628
                                           relocation, rel->r_addend,
629
                                           info, sec, h == NULL);
630
 
631
      if (r != bfd_reloc_ok)
632
        {
633
          const char *name;
634
          const char *msg = (const char *) 0;
635
 
636
          if (h != NULL)
637
            name = h->root.root.root.string;
638
          else
639
            {
640
              name = (bfd_elf_string_from_elf_section
641
                      (input_bfd, symtab_hdr->sh_link, sym->st_name));
642
              if (name == NULL || *name == '\0')
643
                name = bfd_section_name (input_bfd, sec);
644
            }
645
 
646
          switch (r)
647
            {
648
            case bfd_reloc_overflow:
649
              if (! ((*info->callbacks->reloc_overflow)
650
                     (info, name, howto->name, (bfd_vma) 0,
651
                      input_bfd, input_section, rel->r_offset)))
652
                return false;
653
              break;
654
 
655
            case bfd_reloc_undefined:
656
              if (! ((*info->callbacks->undefined_symbol)
657
                     (info, name, input_bfd, input_section,
658
                      rel->r_offset, true)))
659
                return false;
660
              break;
661
 
662
            case bfd_reloc_outofrange:
663
              msg = _("internal error: out of range error");
664
              goto common_error;
665
 
666
            case bfd_reloc_notsupported:
667
              msg = _("internal error: unsupported relocation error");
668
              goto common_error;
669
 
670
            case bfd_reloc_dangerous:
671
              msg = _("internal error: dangerous error");
672
              goto common_error;
673
 
674
            default:
675
              msg = _("internal error: unknown error");
676
              /* fall through */
677
 
678
            common_error:
679
              if (!((*info->callbacks->warning)
680
                    (info, msg, name, input_bfd, input_section,
681
                     rel->r_offset)))
682
                return false;
683
              break;
684
            }
685
        }
686
    }
687
 
688
  return true;
689
}
690
 
691
/* Finish initializing one hash table entry.  */
692
static boolean
693
elf32_mn10300_finish_hash_table_entry (gen_entry, in_args)
694
     struct bfd_hash_entry *gen_entry;
695
     PTR in_args ATTRIBUTE_UNUSED;
696
{
697
  struct elf32_mn10300_link_hash_entry *entry;
698
  unsigned int byte_count = 0;
699
 
700
  entry = (struct elf32_mn10300_link_hash_entry *) gen_entry;
701
 
702
  /* If we already know we want to convert "call" to "calls" for calls
703
     to this symbol, then return now.  */
704
  if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
705
    return true;
706
 
707
  /* If there are no named calls to this symbol, or there's nothing we
708
     can move from the function itself into the "call" instruction, then
709
     note that all "call" instructions should be converted into "calls"
710
     instructions and return.  */
711
  if (entry->direct_calls == 0
712
      || (entry->stack_size == 0 && entry->movm_args == 0))
713
    {
714
      /* Make a note that we should convert "call" instructions to "calls"
715
         instructions for calls to this symbol.  */
716
      entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
717
      return true;
718
    }
719
 
720
  /* We may be able to move some instructions from the function itself into
721
     the "call" instruction.  Count how many bytes we might be able to
722
     eliminate in the function itself.  */
723
 
724
  /* A movm instruction is two bytes.  */
725
  if (entry->movm_args)
726
    byte_count += 2;
727
 
728
  /* Count the insn to allocate stack space too.  */
729
  if (entry->stack_size > 0 && entry->stack_size <= 128)
730
    byte_count += 3;
731
  else if (entry->stack_size > 0 && entry->stack_size < 256)
732
    byte_count += 4;
733
 
734
  /* If using "call" will result in larger code, then turn all
735
     the associated "call" instructions into "calls" instrutions.  */
736
  if (byte_count < entry->direct_calls)
737
    entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
738
 
739
  /* This routine never fails.  */
740
  return true;
741
}
742
 
743
/* This function handles relaxing for the mn10300.
744
 
745
   There's quite a few relaxing opportunites available on the mn10300:
746
 
747
        * calls:32 -> calls:16                                     2 bytes
748
        * call:32  -> call:16                                      2 bytes
749
 
750
        * call:32 -> calls:32                                      1 byte
751
        * call:16 -> calls:16                                      1 byte
752
                * These are done anytime using "calls" would result
753
                in smaller code, or when necessary to preserve the
754
                meaning of the program.
755
 
756
        * call:32                                                  varies
757
        * call:16
758
                * In some circumstances we can move instructions
759
                from a function prologue into a "call" instruction.
760
                This is only done if the resulting code is no larger
761
                than the original code.
762
 
763
        * jmp:32 -> jmp:16                                         2 bytes
764
        * jmp:16 -> bra:8                                          1 byte
765
 
766
                * If the previous instruction is a conditional branch
767
                around the jump/bra, we may be able to reverse its condition
768
                and change its target to the jump's target.  The jump/bra
769
                can then be deleted.                               2 bytes
770
 
771
        * mov abs32 -> mov abs16                                   1 or 2 bytes
772
 
773
        * Most instructions which accept imm32 can relax to imm16  1 or 2 bytes
774
        - Most instructions which accept imm16 can relax to imm8   1 or 2 bytes
775
 
776
        * Most instructions which accept d32 can relax to d16      1 or 2 bytes
777
        - Most instructions which accept d16 can relax to d8       1 or 2 bytes
778
 
779
        We don't handle imm16->imm8 or d16->d8 as they're very rare
780
        and somewhat more difficult to support.  */
781
 
782
static boolean
783
mn10300_elf_relax_section (abfd, sec, link_info, again)
784
     bfd *abfd;
785
     asection *sec;
786
     struct bfd_link_info *link_info;
787
     boolean *again;
788
{
789
  Elf_Internal_Shdr *symtab_hdr;
790
  Elf_Internal_Rela *internal_relocs = NULL;
791
  Elf_Internal_Rela *free_relocs = NULL;
792
  Elf_Internal_Rela *irel, *irelend;
793
  bfd_byte *contents = NULL;
794
  bfd_byte *free_contents = NULL;
795
  Elf32_External_Sym *extsyms = NULL;
796
  Elf32_External_Sym *free_extsyms = NULL;
797
  struct elf32_mn10300_link_hash_table *hash_table;
798
 
799
  /* Assume nothing changes.  */
800
  *again = false;
801
 
802
  /* We need a pointer to the mn10300 specific hash table.  */
803
  hash_table = elf32_mn10300_hash_table (link_info);
804
 
805
  /* Initialize fields in each hash table entry the first time through.  */
806
  if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
807
    {
808
      bfd *input_bfd;
809
 
810
      /* Iterate over all the input bfds.  */
811
      for (input_bfd = link_info->input_bfds;
812
           input_bfd != NULL;
813
           input_bfd = input_bfd->link_next)
814
        {
815
          asection *section;
816
 
817
          /* We're going to need all the symbols for each bfd.  */
818
          symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
819
 
820
          /* Get cached copy if it exists.  */
821
          if (symtab_hdr->contents != NULL)
822
            extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
823
          else
824
            {
825
              /* Go get them off disk.  */
826
              extsyms = ((Elf32_External_Sym *)
827
                         bfd_malloc (symtab_hdr->sh_size));
828
              if (extsyms == NULL)
829
                goto error_return;
830
              free_extsyms = extsyms;
831
              if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
832
                  || (bfd_read (extsyms, 1, symtab_hdr->sh_size, input_bfd)
833
                      != symtab_hdr->sh_size))
834
                goto error_return;
835
            }
836
 
837
          /* Iterate over each section in this bfd.  */
838
          for (section = input_bfd->sections;
839
               section != NULL;
840
               section = section->next)
841
            {
842
              struct elf32_mn10300_link_hash_entry *hash;
843
              Elf_Internal_Sym *sym;
844
              asection *sym_sec = NULL;
845
              const char *sym_name;
846
              char *new_name;
847
 
848
              /* Get cached copy of section contents if it exists.  */
849
              if (elf_section_data (section)->this_hdr.contents != NULL)
850
                contents = elf_section_data (section)->this_hdr.contents;
851
              else if (section->_raw_size != 0)
852
                {
853
                  /* Go get them off disk.  */
854
                  contents = (bfd_byte *) bfd_malloc (section->_raw_size);
855
                  if (contents == NULL)
856
                    goto error_return;
857
                  free_contents = contents;
858
 
859
                  if (!bfd_get_section_contents (input_bfd, section,
860
                                                 contents, (file_ptr) 0,
861
                                                 section->_raw_size))
862
                    goto error_return;
863
                }
864
              else
865
                {
866
                  contents = NULL;
867
                  free_contents = NULL;
868
                }
869
 
870
              /* If there aren't any relocs, then there's nothing to do.  */
871
              if ((section->flags & SEC_RELOC) != 0
872
                  && section->reloc_count != 0)
873
                {
874
 
875
                  /* Get a copy of the native relocations.  */
876
                  internal_relocs = (_bfd_elf32_link_read_relocs
877
                                     (input_bfd, section, (PTR) NULL,
878
                                      (Elf_Internal_Rela *) NULL,
879
                                      link_info->keep_memory));
880
                  if (internal_relocs == NULL)
881
                    goto error_return;
882
                  if (! link_info->keep_memory)
883
                    free_relocs = internal_relocs;
884
 
885
                  /* Now examine each relocation.  */
886
                  irel = internal_relocs;
887
                  irelend = irel + section->reloc_count;
888
                  for (; irel < irelend; irel++)
889
                    {
890
                      long r_type;
891
                      unsigned long r_index;
892
                      unsigned char code;
893
 
894
                      r_type = ELF32_R_TYPE (irel->r_info);
895
                      r_index = ELF32_R_SYM (irel->r_info);
896
 
897
                      if (r_type < 0 || r_type >= (int) R_MN10300_MAX)
898
                        goto error_return;
899
 
900
                      /* We need the name and hash table entry of the target
901
                         symbol!  */
902
                      hash = NULL;
903
                      sym = NULL;
904
                      sym_sec = NULL;
905
 
906
                      if (r_index < symtab_hdr->sh_info)
907
                        {
908
                          /* A local symbol.  */
909
                          Elf_Internal_Sym isym;
910
 
911
                          bfd_elf32_swap_symbol_in (input_bfd,
912
                                                    extsyms + r_index, &isym);
913
 
914
                          if (isym.st_shndx == SHN_UNDEF)
915
                            sym_sec = bfd_und_section_ptr;
916
                          else if (isym.st_shndx > 0
917
                                   && isym.st_shndx < SHN_LORESERVE)
918
                            sym_sec
919
                              = bfd_section_from_elf_index (input_bfd,
920
                                                            isym.st_shndx);
921
                          else if (isym.st_shndx == SHN_ABS)
922
                            sym_sec = bfd_abs_section_ptr;
923
                          else if (isym.st_shndx == SHN_COMMON)
924
                            sym_sec = bfd_com_section_ptr;
925
 
926
                          sym_name = bfd_elf_string_from_elf_section (input_bfd,
927
                                                           symtab_hdr->sh_link,
928
                                                           isym.st_name);
929
 
930
                          /* If it isn't a function, then we don't care
931
                             about it.  */
932
                          if (r_index < symtab_hdr->sh_info
933
                              && ELF_ST_TYPE (isym.st_info) != STT_FUNC)
934
                            continue;
935
 
936
                          /* Tack on an ID so we can uniquely identify this
937
                             local symbol in the global hash table.  */
938
                          new_name = bfd_malloc (strlen (sym_name) + 10);
939
                          if (new_name == 0)
940
                            goto error_return;
941
 
942
                          sprintf (new_name, "%s_%08x",
943
                                   sym_name, (int) sym_sec);
944
                          sym_name = new_name;
945
 
946
                          hash = (struct elf32_mn10300_link_hash_entry *)
947
                                   elf_link_hash_lookup (&hash_table->static_hash_table->root,
948
                                                         sym_name, true,
949
                                                         true, false);
950
                          free (new_name);
951
                        }
952
                      else
953
                        {
954
                          r_index -= symtab_hdr->sh_info;
955
                          hash = (struct elf32_mn10300_link_hash_entry *)
956
                                   elf_sym_hashes (input_bfd)[r_index];
957
                        }
958
 
959
                      /* If this is not a "call" instruction, then we
960
                         should convert "call" instructions to "calls"
961
                         instructions.  */
962
                      code = bfd_get_8 (input_bfd,
963
                                        contents + irel->r_offset - 1);
964
                      if (code != 0xdd && code != 0xcd)
965
                        hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
966
 
967
                      /* If this is a jump/call, then bump the direct_calls
968
                         counter.  Else force "call" to "calls" conversions.  */
969
                      if (r_type == R_MN10300_PCREL32
970
                          || r_type == R_MN10300_PCREL16)
971
                        hash->direct_calls++;
972
                      else
973
                        hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
974
                    }
975
                }
976
 
977
              /* Now look at the actual contents to get the stack size,
978
                 and a list of what registers were saved in the prologue
979
                 (ie movm_args).  */
980
              if ((section->flags & SEC_CODE) != 0)
981
                {
982
 
983
                  Elf32_External_Sym *esym, *esymend;
984
                  int idx, shndx;
985
 
986
                  shndx = _bfd_elf_section_from_bfd_section (input_bfd,
987
                                                             section);
988
 
989
                  /* Look at each function defined in this section and
990
                     update info for that function.  */
991
                  esym = extsyms;
992
                  esymend = esym + symtab_hdr->sh_info;
993
                  for (; esym < esymend; esym++)
994
                    {
995
                      Elf_Internal_Sym isym;
996
 
997
                      bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
998
                      if (isym.st_shndx == shndx
999
                          && ELF_ST_TYPE (isym.st_info) == STT_FUNC)
1000
                        {
1001
                          if (isym.st_shndx == SHN_UNDEF)
1002
                            sym_sec = bfd_und_section_ptr;
1003
                          else if (isym.st_shndx > 0
1004
                                   && isym.st_shndx < SHN_LORESERVE)
1005
                            sym_sec
1006
                              = bfd_section_from_elf_index (input_bfd,
1007
                                                            isym.st_shndx);
1008
                          else if (isym.st_shndx == SHN_ABS)
1009
                            sym_sec = bfd_abs_section_ptr;
1010
                          else if (isym.st_shndx == SHN_COMMON)
1011
                            sym_sec = bfd_com_section_ptr;
1012
 
1013
                          sym_name = bfd_elf_string_from_elf_section (input_bfd,
1014
                                                        symtab_hdr->sh_link,
1015
                                                        isym.st_name);
1016
 
1017
                          /* Tack on an ID so we can uniquely identify this
1018
                             local symbol in the global hash table.  */
1019
                          new_name = bfd_malloc (strlen (sym_name) + 10);
1020
                          if (new_name == 0)
1021
                            goto error_return;
1022
 
1023
                          sprintf (new_name, "%s_%08x",
1024
                                   sym_name, (int) sym_sec);
1025
                          sym_name = new_name;
1026
 
1027
                          hash = (struct elf32_mn10300_link_hash_entry *)
1028
                                    elf_link_hash_lookup (&hash_table->static_hash_table->root,
1029
                                                          sym_name, true,
1030
                                                          true, false);
1031
                          free (new_name);
1032
                          compute_function_info (input_bfd, hash,
1033
                                                 isym.st_value, contents);
1034
                        }
1035
                    }
1036
 
1037
                  esym = extsyms + symtab_hdr->sh_info;
1038
                  esymend = extsyms + (symtab_hdr->sh_size
1039
                                       / sizeof (Elf32_External_Sym));
1040
                  for (idx = 0; esym < esymend; esym++, idx++)
1041
                    {
1042
                      Elf_Internal_Sym isym;
1043
 
1044
                      bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1045
                      hash = (struct elf32_mn10300_link_hash_entry *)
1046
                               elf_sym_hashes (input_bfd)[idx];
1047
                      if (isym.st_shndx == shndx
1048
                          && ELF_ST_TYPE (isym.st_info) == STT_FUNC
1049
                          && (hash)->root.root.u.def.section == section
1050
                          && ((hash)->root.root.type == bfd_link_hash_defined
1051
                              || (hash)->root.root.type == bfd_link_hash_defweak))
1052
                        compute_function_info (input_bfd, hash,
1053
                                               (hash)->root.root.u.def.value,
1054
                                               contents);
1055
                    }
1056
                }
1057
 
1058
              /* Cache or free any memory we allocated for the relocs.  */
1059
              if (free_relocs != NULL)
1060
                {
1061
                  free (free_relocs);
1062
                  free_relocs = NULL;
1063
                }
1064
 
1065
              /* Cache or free any memory we allocated for the contents.  */
1066
              if (free_contents != NULL)
1067
                {
1068
                  if (! link_info->keep_memory)
1069
                    free (free_contents);
1070
                  else
1071
                    {
1072
                      /* Cache the section contents for elf_link_input_bfd.  */
1073
                      elf_section_data (section)->this_hdr.contents = contents;
1074
                    }
1075
                  free_contents = NULL;
1076
                }
1077
            }
1078
 
1079
          /* Cache or free any memory we allocated for the symbols.  */
1080
          if (free_extsyms != NULL)
1081
            {
1082
              if (! link_info->keep_memory)
1083
                free (free_extsyms);
1084
              else
1085
                {
1086
                  /* Cache the symbols for elf_link_input_bfd.  */
1087
                  symtab_hdr->contents = extsyms;
1088
                }
1089
              free_extsyms = NULL;
1090
            }
1091
        }
1092
 
1093
      /* Now iterate on each symbol in the hash table and perform
1094
         the final initialization steps on each.  */
1095
      elf32_mn10300_link_hash_traverse (hash_table,
1096
                                        elf32_mn10300_finish_hash_table_entry,
1097
                                        NULL);
1098
      elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
1099
                                        elf32_mn10300_finish_hash_table_entry,
1100
                                        NULL);
1101
 
1102
      /* All entries in the hash table are fully initialized.  */
1103
      hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
1104
 
1105
      /* Now that everything has been initialized, go through each
1106
         code section and delete any prologue insns which will be
1107
         redundant because their operations will be performed by
1108
         a "call" instruction.  */
1109
      for (input_bfd = link_info->input_bfds;
1110
           input_bfd != NULL;
1111
           input_bfd = input_bfd->link_next)
1112
        {
1113
          asection *section;
1114
 
1115
          /* We're going to need all the symbols for each bfd.  */
1116
          symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1117
 
1118
          /* Get cached copy if it exists.  */
1119
          if (symtab_hdr->contents != NULL)
1120
            extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1121
          else
1122
            {
1123
              /* Go get them off disk.  */
1124
              extsyms = ((Elf32_External_Sym *)
1125
                         bfd_malloc (symtab_hdr->sh_size));
1126
              if (extsyms == NULL)
1127
                goto error_return;
1128
              free_extsyms = extsyms;
1129
              if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1130
                  || (bfd_read (extsyms, 1, symtab_hdr->sh_size, input_bfd)
1131
                      != symtab_hdr->sh_size))
1132
                goto error_return;
1133
            }
1134
 
1135
          /* Walk over each section in this bfd.  */
1136
          for (section = input_bfd->sections;
1137
               section != NULL;
1138
               section = section->next)
1139
            {
1140
              int shndx;
1141
              Elf32_External_Sym *esym, *esymend;
1142
              int idx;
1143
 
1144
              /* Skip non-code sections and empty sections.  */
1145
              if ((section->flags & SEC_CODE) == 0 || section->_raw_size == 0)
1146
                continue;
1147
 
1148
              if (section->reloc_count != 0)
1149
                {
1150
                  /* Get a copy of the native relocations.  */
1151
                  internal_relocs = (_bfd_elf32_link_read_relocs
1152
                                     (input_bfd, section, (PTR) NULL,
1153
                                      (Elf_Internal_Rela *) NULL,
1154
                                      link_info->keep_memory));
1155
                  if (internal_relocs == NULL)
1156
                    goto error_return;
1157
                  if (! link_info->keep_memory)
1158
                    free_relocs = internal_relocs;
1159
                }
1160
 
1161
              /* Get cached copy of section contents if it exists.  */
1162
              if (elf_section_data (section)->this_hdr.contents != NULL)
1163
                contents = elf_section_data (section)->this_hdr.contents;
1164
              else
1165
                {
1166
                  /* Go get them off disk.  */
1167
                  contents = (bfd_byte *) bfd_malloc (section->_raw_size);
1168
                  if (contents == NULL)
1169
                    goto error_return;
1170
                  free_contents = contents;
1171
 
1172
                  if (!bfd_get_section_contents (input_bfd, section,
1173
                                                 contents, (file_ptr) 0,
1174
                                                 section->_raw_size))
1175
                    goto error_return;
1176
                }
1177
 
1178
              shndx = _bfd_elf_section_from_bfd_section (input_bfd, section);
1179
 
1180
              /* Now look for any function in this section which needs
1181
                 insns deleted from its prologue.  */
1182
              esym = extsyms;
1183
              esymend = esym + symtab_hdr->sh_info;
1184
              for (; esym < esymend; esym++)
1185
                {
1186
                  Elf_Internal_Sym isym;
1187
                  struct elf32_mn10300_link_hash_entry *sym_hash;
1188
                  asection *sym_sec = NULL;
1189
                  const char *sym_name;
1190
                  char *new_name;
1191
 
1192
                  bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1193
 
1194
                  if (isym.st_shndx != shndx)
1195
                    continue;
1196
 
1197
                  if (isym.st_shndx == SHN_UNDEF)
1198
                    sym_sec = bfd_und_section_ptr;
1199
                  else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1200
                    sym_sec
1201
                      = bfd_section_from_elf_index (input_bfd, isym.st_shndx);
1202
                  else if (isym.st_shndx == SHN_ABS)
1203
                    sym_sec = bfd_abs_section_ptr;
1204
                  else if (isym.st_shndx == SHN_COMMON)
1205
                    sym_sec = bfd_com_section_ptr;
1206
                  else
1207
                    abort ();
1208
 
1209
                  sym_name = bfd_elf_string_from_elf_section (input_bfd,
1210
                                                        symtab_hdr->sh_link,
1211
                                                        isym.st_name);
1212
 
1213
                  /* Tack on an ID so we can uniquely identify this
1214
                     local symbol in the global hash table.  */
1215
                  new_name = bfd_malloc (strlen (sym_name) + 10);
1216
                  if (new_name == 0)
1217
                    goto error_return;
1218
                  sprintf (new_name, "%s_%08x", sym_name, (int) sym_sec);
1219
                  sym_name = new_name;
1220
 
1221
                  sym_hash = (struct elf32_mn10300_link_hash_entry *)
1222
                            elf_link_hash_lookup (&hash_table->static_hash_table->root,
1223
                                                  sym_name, false,
1224
                                                  false, false);
1225
 
1226
                  free (new_name);
1227
                  if (sym_hash == NULL)
1228
                    continue;
1229
 
1230
                  if (! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1231
                      && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1232
                    {
1233
                      int bytes = 0;
1234
 
1235
                      /* Note that we've changed things.  */
1236
                      elf_section_data (section)->relocs = internal_relocs;
1237
                      free_relocs = NULL;
1238
 
1239
                      elf_section_data (section)->this_hdr.contents = contents;
1240
                      free_contents = NULL;
1241
 
1242
                      symtab_hdr->contents = (bfd_byte *) extsyms;
1243
                      free_extsyms = NULL;
1244
 
1245
                      /* Count how many bytes we're going to delete.  */
1246
                      if (sym_hash->movm_args)
1247
                        bytes += 2;
1248
 
1249
                      if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1250
                        bytes += 3;
1251
                      else if (sym_hash->stack_size
1252
                               && sym_hash->stack_size < 256)
1253
                        bytes += 4;
1254
 
1255
                      /* Note that we've deleted prologue bytes for this
1256
                         function.  */
1257
                      sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1258
 
1259
                      /* Actually delete the bytes.  */
1260
                      if (!mn10300_elf_relax_delete_bytes (input_bfd,
1261
                                                           section,
1262
                                                           isym.st_value,
1263
                                                           bytes))
1264
                        goto error_return;
1265
 
1266
                      /* Something changed.  Not strictly necessary, but
1267
                         may lead to more relaxing opportunities.  */
1268
                      *again = true;
1269
                    }
1270
                }
1271
 
1272
              /* Look for any global functions in this section which
1273
                 need insns deleted from their prologues.  */
1274
              esym = extsyms + symtab_hdr->sh_info;
1275
              esymend = extsyms + (symtab_hdr->sh_size
1276
                                   / sizeof (Elf32_External_Sym));
1277
              for (idx = 0; esym < esymend; esym++, idx++)
1278
                {
1279
                  Elf_Internal_Sym isym;
1280
                  struct elf32_mn10300_link_hash_entry *sym_hash;
1281
 
1282
                  bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1283
                  sym_hash = (struct elf32_mn10300_link_hash_entry *)
1284
                               (elf_sym_hashes (input_bfd)[idx]);
1285
                  if (isym.st_shndx == shndx
1286
                      && (sym_hash)->root.root.u.def.section == section
1287
                      && ! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1288
                      && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1289
                    {
1290
                      int bytes = 0;
1291
 
1292
                      /* Note that we've changed things.  */
1293
                      elf_section_data (section)->relocs = internal_relocs;
1294
                      free_relocs = NULL;
1295
 
1296
                      elf_section_data (section)->this_hdr.contents = contents;
1297
                      free_contents = NULL;
1298
 
1299
                      symtab_hdr->contents = (bfd_byte *) extsyms;
1300
                      free_extsyms = NULL;
1301
 
1302
                      /* Count how many bytes we're going to delete.  */
1303
                      if (sym_hash->movm_args)
1304
                        bytes += 2;
1305
 
1306
                      if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1307
                        bytes += 3;
1308
                      else if (sym_hash->stack_size
1309
                               && sym_hash->stack_size < 256)
1310
                        bytes += 4;
1311
 
1312
                      /* Note that we've deleted prologue bytes for this
1313
                         function.  */
1314
                      sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1315
 
1316
                      /* Actually delete the bytes.  */
1317
                      if (!mn10300_elf_relax_delete_bytes (input_bfd,
1318
                                                           section,
1319
                                                           (sym_hash)->root.root.u.def.value,
1320
                                                           bytes))
1321
                        goto error_return;
1322
 
1323
                      /* Something changed.  Not strictly necessary, but
1324
                         may lead to more relaxing opportunities.  */
1325
                      *again = true;
1326
                    }
1327
                }
1328
 
1329
              /* Cache or free any memory we allocated for the relocs.  */
1330
              if (free_relocs != NULL)
1331
                {
1332
                  free (free_relocs);
1333
                  free_relocs = NULL;
1334
                }
1335
 
1336
              /* Cache or free any memory we allocated for the contents.  */
1337
              if (free_contents != NULL)
1338
                {
1339
                  if (! link_info->keep_memory)
1340
                    free (free_contents);
1341
                  else
1342
                    {
1343
                      /* Cache the section contents for elf_link_input_bfd.  */
1344
                      elf_section_data (section)->this_hdr.contents = contents;
1345
                    }
1346
                  free_contents = NULL;
1347
                }
1348
            }
1349
 
1350
          /* Cache or free any memory we allocated for the symbols.  */
1351
          if (free_extsyms != NULL)
1352
            {
1353
              if (! link_info->keep_memory)
1354
                free (free_extsyms);
1355
              else
1356
                {
1357
                  /* Cache the symbols for elf_link_input_bfd.  */
1358
                  symtab_hdr->contents = extsyms;
1359
                }
1360
              free_extsyms = NULL;
1361
            }
1362
        }
1363
    }
1364
 
1365
  /* (Re)initialize for the basic instruction shortening/relaxing pass.  */
1366
  contents = NULL;
1367
  extsyms = NULL;
1368
  internal_relocs = NULL;
1369
  free_relocs = NULL;
1370
  free_contents = NULL;
1371
  free_extsyms = NULL;
1372
 
1373
  /* We don't have to do anything for a relocateable link, if
1374
     this section does not have relocs, or if this is not a
1375
     code section.  */
1376
  if (link_info->relocateable
1377
      || (sec->flags & SEC_RELOC) == 0
1378
      || sec->reloc_count == 0
1379
      || (sec->flags & SEC_CODE) == 0)
1380
    return true;
1381
 
1382
  /* If this is the first time we have been called for this section,
1383
     initialize the cooked size.  */
1384
  if (sec->_cooked_size == 0)
1385
    sec->_cooked_size = sec->_raw_size;
1386
 
1387
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1388
 
1389
  /* Get a copy of the native relocations.  */
1390
  internal_relocs = (_bfd_elf32_link_read_relocs
1391
                     (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1392
                      link_info->keep_memory));
1393
  if (internal_relocs == NULL)
1394
    goto error_return;
1395
  if (! link_info->keep_memory)
1396
    free_relocs = internal_relocs;
1397
 
1398
  /* Walk through them looking for relaxing opportunities.  */
1399
  irelend = internal_relocs + sec->reloc_count;
1400
  for (irel = internal_relocs; irel < irelend; irel++)
1401
    {
1402
      bfd_vma symval;
1403
      struct elf32_mn10300_link_hash_entry *h = NULL;
1404
 
1405
      /* If this isn't something that can be relaxed, then ignore
1406
         this reloc.  */
1407
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
1408
          || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
1409
          || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
1410
        continue;
1411
 
1412
      /* Get the section contents if we haven't done so already.  */
1413
      if (contents == NULL)
1414
        {
1415
          /* Get cached copy if it exists.  */
1416
          if (elf_section_data (sec)->this_hdr.contents != NULL)
1417
            contents = elf_section_data (sec)->this_hdr.contents;
1418
          else
1419
            {
1420
              /* Go get them off disk.  */
1421
              contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1422
              if (contents == NULL)
1423
                goto error_return;
1424
              free_contents = contents;
1425
 
1426
              if (! bfd_get_section_contents (abfd, sec, contents,
1427
                                              (file_ptr) 0, sec->_raw_size))
1428
                goto error_return;
1429
            }
1430
        }
1431
 
1432
      /* Read this BFD's symbols if we haven't done so already.  */
1433
      if (extsyms == NULL)
1434
        {
1435
          /* Get cached copy if it exists.  */
1436
          if (symtab_hdr->contents != NULL)
1437
            extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1438
          else
1439
            {
1440
              /* Go get them off disk.  */
1441
              extsyms = ((Elf32_External_Sym *)
1442
                         bfd_malloc (symtab_hdr->sh_size));
1443
              if (extsyms == NULL)
1444
                goto error_return;
1445
              free_extsyms = extsyms;
1446
              if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1447
                  || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1448
                      != symtab_hdr->sh_size))
1449
                goto error_return;
1450
            }
1451
        }
1452
 
1453
      /* Get the value of the symbol referred to by the reloc.  */
1454
      if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1455
        {
1456
          Elf_Internal_Sym isym;
1457
          asection *sym_sec = NULL;
1458
          const char *sym_name;
1459
          char *new_name;
1460
 
1461
          /* A local symbol.  */
1462
          bfd_elf32_swap_symbol_in (abfd,
1463
                                    extsyms + ELF32_R_SYM (irel->r_info),
1464
                                    &isym);
1465
 
1466
          if (isym.st_shndx == SHN_UNDEF)
1467
            sym_sec = bfd_und_section_ptr;
1468
          else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1469
            sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1470
          else if (isym.st_shndx == SHN_ABS)
1471
            sym_sec = bfd_abs_section_ptr;
1472
          else if (isym.st_shndx == SHN_COMMON)
1473
            sym_sec = bfd_com_section_ptr;
1474
          else
1475
            abort ();
1476
 
1477
          symval = (isym.st_value
1478
                    + sym_sec->output_section->vma
1479
                    + sym_sec->output_offset);
1480
          sym_name = bfd_elf_string_from_elf_section (abfd,
1481
                                                      symtab_hdr->sh_link,
1482
                                                      isym.st_name);
1483
 
1484
          /* Tack on an ID so we can uniquely identify this
1485
             local symbol in the global hash table.  */
1486
          new_name = bfd_malloc (strlen (sym_name) + 10);
1487
          if (new_name == 0)
1488
            goto error_return;
1489
          sprintf (new_name, "%s_%08x", sym_name, (int) sym_sec);
1490
          sym_name = new_name;
1491
 
1492
          h = (struct elf32_mn10300_link_hash_entry *)
1493
                elf_link_hash_lookup (&hash_table->static_hash_table->root,
1494
                                      sym_name, false, false, false);
1495
          free (new_name);
1496
        }
1497
      else
1498
        {
1499
          unsigned long indx;
1500
 
1501
          /* An external symbol.  */
1502
          indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1503
          h = (struct elf32_mn10300_link_hash_entry *)
1504
                (elf_sym_hashes (abfd)[indx]);
1505
          BFD_ASSERT (h != NULL);
1506
          if (h->root.root.type != bfd_link_hash_defined
1507
              && h->root.root.type != bfd_link_hash_defweak)
1508
            {
1509
              /* This appears to be a reference to an undefined
1510
                symbol.  Just ignore it--it will be caught by the
1511
                regular reloc processing.  */
1512
              continue;
1513
            }
1514
 
1515
          symval = (h->root.root.u.def.value
1516
                    + h->root.root.u.def.section->output_section->vma
1517
                    + h->root.root.u.def.section->output_offset);
1518
        }
1519
 
1520
      /* For simplicity of coding, we are going to modify the section
1521
         contents, the section relocs, and the BFD symbol table.  We
1522
         must tell the rest of the code not to free up this
1523
         information.  It would be possible to instead create a table
1524
         of changes which have to be made, as is done in coff-mips.c;
1525
         that would be more work, but would require less memory when
1526
         the linker is run.  */
1527
 
1528
      /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
1529
         branch/call, also deal with "call" -> "calls" conversions and
1530
         insertion of prologue data into "call" instructions.  */
1531
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32)
1532
        {
1533
          bfd_vma value = symval;
1534
 
1535
          /* If we've got a "call" instruction that needs to be turned
1536
             into a "calls" instruction, do so now.  It saves a byte.  */
1537
          if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
1538
            {
1539
              unsigned char code;
1540
 
1541
              /* Get the opcode.  */
1542
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1543
 
1544
              /* Make sure we're working with a "call" instruction!  */
1545
              if (code == 0xdd)
1546
                {
1547
                  /* Note that we've changed the relocs, section contents,
1548
                     etc.  */
1549
                  elf_section_data (sec)->relocs = internal_relocs;
1550
                  free_relocs = NULL;
1551
 
1552
                  elf_section_data (sec)->this_hdr.contents = contents;
1553
                  free_contents = NULL;
1554
 
1555
                  symtab_hdr->contents = (bfd_byte *) extsyms;
1556
                  free_extsyms = NULL;
1557
 
1558
                  /* Fix the opcode.  */
1559
                  bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
1560
                  bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
1561
 
1562
                  /* Fix irel->r_offset and irel->r_addend.  */
1563
                  irel->r_offset += 1;
1564
                  irel->r_addend += 1;
1565
 
1566
                  /* Delete one byte of data.  */
1567
                  if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1568
                                                       irel->r_offset + 3, 1))
1569
                    goto error_return;
1570
 
1571
                  /* That will change things, so, we should relax again.
1572
                     Note that this is not required, and it may be slow.  */
1573
                  *again = true;
1574
                }
1575
            }
1576
          else if (h)
1577
            {
1578
              /* We've got a "call" instruction which needs some data
1579
                 from target function filled in.  */
1580
              unsigned char code;
1581
 
1582
              /* Get the opcode.  */
1583
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1584
 
1585
              /* Insert data from the target function into the "call"
1586
                 instruction if needed.  */
1587
              if (code == 0xdd)
1588
                {
1589
                  bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
1590
                  bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
1591
                             contents + irel->r_offset + 5);
1592
                }
1593
            }
1594
 
1595
          /* Deal with pc-relative gunk.  */
1596
          value -= (sec->output_section->vma + sec->output_offset);
1597
          value -= irel->r_offset;
1598
          value += irel->r_addend;
1599
 
1600
          /* See if the value will fit in 16 bits, note the high value is
1601
             0x7fff + 2 as the target will be two bytes closer if we are
1602
             able to relax.  */
1603
          if ((long) value < 0x8001 && (long) value > -0x8000)
1604
            {
1605
              unsigned char code;
1606
 
1607
              /* Get the opcode.  */
1608
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1609
 
1610
              if (code != 0xdc && code != 0xdd && code != 0xff)
1611
                continue;
1612
 
1613
              /* Note that we've changed the relocs, section contents, etc.  */
1614
              elf_section_data (sec)->relocs = internal_relocs;
1615
              free_relocs = NULL;
1616
 
1617
              elf_section_data (sec)->this_hdr.contents = contents;
1618
              free_contents = NULL;
1619
 
1620
              symtab_hdr->contents = (bfd_byte *) extsyms;
1621
              free_extsyms = NULL;
1622
 
1623
              /* Fix the opcode.  */
1624
              if (code == 0xdc)
1625
                bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
1626
              else if (code == 0xdd)
1627
                bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
1628
              else if (code == 0xff)
1629
                bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
1630
 
1631
              /* Fix the relocation's type.  */
1632
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1633
                                           R_MN10300_PCREL16);
1634
 
1635
              /* Delete two bytes of data.  */
1636
              if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1637
                                                   irel->r_offset + 1, 2))
1638
                goto error_return;
1639
 
1640
              /* That will change things, so, we should relax again.
1641
                 Note that this is not required, and it may be slow.  */
1642
              *again = true;
1643
            }
1644
        }
1645
 
1646
      /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
1647
         branch.  */
1648
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
1649
        {
1650
          bfd_vma value = symval;
1651
 
1652
          /* If we've got a "call" instruction that needs to be turned
1653
             into a "calls" instruction, do so now.  It saves a byte.  */
1654
          if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
1655
            {
1656
              unsigned char code;
1657
 
1658
              /* Get the opcode.  */
1659
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1660
 
1661
              /* Make sure we're working with a "call" instruction!  */
1662
              if (code == 0xcd)
1663
                {
1664
                  /* Note that we've changed the relocs, section contents,
1665
                     etc.  */
1666
                  elf_section_data (sec)->relocs = internal_relocs;
1667
                  free_relocs = NULL;
1668
 
1669
                  elf_section_data (sec)->this_hdr.contents = contents;
1670
                  free_contents = NULL;
1671
 
1672
                  symtab_hdr->contents = (bfd_byte *) extsyms;
1673
                  free_extsyms = NULL;
1674
 
1675
                  /* Fix the opcode.  */
1676
                  bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
1677
                  bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
1678
 
1679
                  /* Fix irel->r_offset and irel->r_addend.  */
1680
                  irel->r_offset += 1;
1681
                  irel->r_addend += 1;
1682
 
1683
                  /* Delete one byte of data.  */
1684
                  if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1685
                                                       irel->r_offset + 1, 1))
1686
                    goto error_return;
1687
 
1688
                  /* That will change things, so, we should relax again.
1689
                     Note that this is not required, and it may be slow.  */
1690
                  *again = true;
1691
                }
1692
            }
1693
          else if (h)
1694
            {
1695
              unsigned char code;
1696
 
1697
              /* Get the opcode.  */
1698
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1699
 
1700
              /* Insert data from the target function into the "call"
1701
                 instruction if needed.  */
1702
              if (code == 0xcd)
1703
                {
1704
                  bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
1705
                  bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
1706
                             contents + irel->r_offset + 3);
1707
                }
1708
            }
1709
 
1710
          /* Deal with pc-relative gunk.  */
1711
          value -= (sec->output_section->vma + sec->output_offset);
1712
          value -= irel->r_offset;
1713
          value += irel->r_addend;
1714
 
1715
          /* See if the value will fit in 8 bits, note the high value is
1716
             0x7f + 1 as the target will be one bytes closer if we are
1717
             able to relax.  */
1718
          if ((long) value < 0x80 && (long) value > -0x80)
1719
            {
1720
              unsigned char code;
1721
 
1722
              /* Get the opcode.  */
1723
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1724
 
1725
              if (code != 0xcc)
1726
                continue;
1727
 
1728
              /* Note that we've changed the relocs, section contents, etc.  */
1729
              elf_section_data (sec)->relocs = internal_relocs;
1730
              free_relocs = NULL;
1731
 
1732
              elf_section_data (sec)->this_hdr.contents = contents;
1733
              free_contents = NULL;
1734
 
1735
              symtab_hdr->contents = (bfd_byte *) extsyms;
1736
              free_extsyms = NULL;
1737
 
1738
              /* Fix the opcode.  */
1739
              bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
1740
 
1741
              /* Fix the relocation's type.  */
1742
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1743
                                           R_MN10300_PCREL8);
1744
 
1745
              /* Delete one byte of data.  */
1746
              if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1747
                                                   irel->r_offset + 1, 1))
1748
                goto error_return;
1749
 
1750
              /* That will change things, so, we should relax again.
1751
                 Note that this is not required, and it may be slow.  */
1752
              *again = true;
1753
            }
1754
        }
1755
 
1756
      /* Try to eliminate an unconditional 8 bit pc-relative branch
1757
         which immediately follows a conditional 8 bit pc-relative
1758
         branch around the unconditional branch.
1759
 
1760
            original:           new:
1761
            bCC lab1            bCC' lab2
1762
            bra lab2
1763
           lab1:               lab1:
1764
 
1765
         This happens when the bCC can't reach lab2 at assembly time,
1766
         but due to other relaxations it can reach at link time.  */
1767
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
1768
        {
1769
          Elf_Internal_Rela *nrel;
1770
          bfd_vma value = symval;
1771
          unsigned char code;
1772
 
1773
          /* Deal with pc-relative gunk.  */
1774
          value -= (sec->output_section->vma + sec->output_offset);
1775
          value -= irel->r_offset;
1776
          value += irel->r_addend;
1777
 
1778
          /* Do nothing if this reloc is the last byte in the section.  */
1779
          if (irel->r_offset == sec->_cooked_size)
1780
            continue;
1781
 
1782
          /* See if the next instruction is an unconditional pc-relative
1783
             branch, more often than not this test will fail, so we
1784
             test it first to speed things up.  */
1785
          code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1786
          if (code != 0xca)
1787
            continue;
1788
 
1789
          /* Also make sure the next relocation applies to the next
1790
             instruction and that it's a pc-relative 8 bit branch.  */
1791
          nrel = irel + 1;
1792
          if (nrel == irelend
1793
              || irel->r_offset + 2 != nrel->r_offset
1794
              || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
1795
            continue;
1796
 
1797
          /* Make sure our destination immediately follows the
1798
             unconditional branch.  */
1799
          if (symval != (sec->output_section->vma + sec->output_offset
1800
                         + irel->r_offset + 3))
1801
            continue;
1802
 
1803
          /* Now make sure we are a conditional branch.  This may not
1804
             be necessary, but why take the chance.
1805
 
1806
             Note these checks assume that R_MN10300_PCREL8 relocs
1807
             only occur on bCC and bCCx insns.  If they occured
1808
             elsewhere, we'd need to know the start of this insn
1809
             for this check to be accurate.  */
1810
          code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1811
          if (code != 0xc0 && code != 0xc1 && code != 0xc2
1812
              && code != 0xc3 && code != 0xc4 && code != 0xc5
1813
              && code != 0xc6 && code != 0xc7 && code != 0xc8
1814
              && code != 0xc9 && code != 0xe8 && code != 0xe9
1815
              && code != 0xea && code != 0xeb)
1816
            continue;
1817
 
1818
          /* We also have to be sure there is no symbol/label
1819
             at the unconditional branch.  */
1820
          if (mn10300_elf_symbol_address_p (abfd, sec, extsyms,
1821
                                            irel->r_offset + 1))
1822
            continue;
1823
 
1824
          /* Note that we've changed the relocs, section contents, etc.  */
1825
          elf_section_data (sec)->relocs = internal_relocs;
1826
          free_relocs = NULL;
1827
 
1828
          elf_section_data (sec)->this_hdr.contents = contents;
1829
          free_contents = NULL;
1830
 
1831
          symtab_hdr->contents = (bfd_byte *) extsyms;
1832
          free_extsyms = NULL;
1833
 
1834
          /* Reverse the condition of the first branch.  */
1835
          switch (code)
1836
            {
1837
            case 0xc8:
1838
              code = 0xc9;
1839
              break;
1840
            case 0xc9:
1841
              code = 0xc8;
1842
              break;
1843
            case 0xc0:
1844
              code = 0xc2;
1845
              break;
1846
            case 0xc2:
1847
              code = 0xc0;
1848
              break;
1849
            case 0xc3:
1850
              code = 0xc1;
1851
              break;
1852
            case 0xc1:
1853
              code = 0xc3;
1854
              break;
1855
            case 0xc4:
1856
              code = 0xc6;
1857
              break;
1858
            case 0xc6:
1859
              code = 0xc4;
1860
              break;
1861
            case 0xc7:
1862
              code = 0xc5;
1863
              break;
1864
            case 0xc5:
1865
              code = 0xc7;
1866
              break;
1867
            case 0xe8:
1868
              code = 0xe9;
1869
              break;
1870
            case 0x9d:
1871
              code = 0xe8;
1872
              break;
1873
            case 0xea:
1874
              code = 0xeb;
1875
              break;
1876
            case 0xeb:
1877
              code = 0xea;
1878
              break;
1879
            }
1880
          bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1881
 
1882
          /* Set the reloc type and symbol for the first branch
1883
             from the second branch.  */
1884
          irel->r_info = nrel->r_info;
1885
 
1886
          /* Make the reloc for the second branch a null reloc.  */
1887
          nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
1888
                                       R_MN10300_NONE);
1889
 
1890
          /* Delete two bytes of data.  */
1891
          if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1892
                                               irel->r_offset + 1, 2))
1893
            goto error_return;
1894
 
1895
          /* That will change things, so, we should relax again.
1896
             Note that this is not required, and it may be slow.  */
1897
          *again = true;
1898
        }
1899
 
1900
      /* Try to turn a 24 immediate, displacement or absolute address
1901
         into a 8 immediate, displacement or absolute address.  */
1902
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
1903
        {
1904
          bfd_vma value = symval;
1905
          value += irel->r_addend;
1906
 
1907
          /* See if the value will fit in 8 bits.  */
1908
          if ((long) value < 0x7f && (long) value > -0x80)
1909
            {
1910
              unsigned char code;
1911
 
1912
              /* AM33 insns which have 24 operands are 6 bytes long and
1913
                 will have 0xfd as the first byte.  */
1914
 
1915
              /* Get the first opcode.  */
1916
              code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
1917
 
1918
              if (code == 0xfd)
1919
                {
1920
                  /* Get the second opcode.  */
1921
                  code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1922
 
1923
                  /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
1924
                     equivalent instructions exists.  */
1925
                  if (code != 0x6b && code != 0x7b
1926
                      && code != 0x8b && code != 0x9b
1927
                      && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
1928
                          || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
1929
                          || (code & 0x0f) == 0x0e))
1930
                    {
1931
                      /* Not safe if the high bit is on as relaxing may
1932
                         move the value out of high mem and thus not fit
1933
                         in a signed 8bit value.  This is currently over
1934
                         conservative.  */
1935
                      if ((value & 0x80) == 0)
1936
                        {
1937
                          /* Note that we've changed the relocation contents,
1938
                             etc.  */
1939
                          elf_section_data (sec)->relocs = internal_relocs;
1940
                          free_relocs = NULL;
1941
 
1942
                          elf_section_data (sec)->this_hdr.contents = contents;
1943
                          free_contents = NULL;
1944
 
1945
                          symtab_hdr->contents = (bfd_byte *) extsyms;
1946
                          free_extsyms = NULL;
1947
 
1948
                          /* Fix the opcode.  */
1949
                          bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
1950
                          bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
1951
 
1952
                          /* Fix the relocation's type.  */
1953
                          irel->r_info =
1954
                            ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1955
                                          R_MN10300_8);
1956
 
1957
                          /* Delete two bytes of data.  */
1958
                          if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1959
                                                               irel->r_offset + 1, 2))
1960
                            goto error_return;
1961
 
1962
                          /* That will change things, so, we should relax
1963
                             again.  Note that this is not required, and it
1964
                             may be slow.  */
1965
                          *again = true;
1966
                          break;
1967
                        }
1968
                    }
1969
                }
1970
            }
1971
        }
1972
 
1973
      /* Try to turn a 32bit immediate, displacement or absolute address
1974
         into a 16bit immediate, displacement or absolute address.  */
1975
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32)
1976
        {
1977
          bfd_vma value = symval;
1978
          value += irel->r_addend;
1979
 
1980
          /* See if the value will fit in 24 bits.
1981
             We allow any 16bit match here.  We prune those we can't
1982
             handle below.  */
1983
          if ((long) value < 0x7fffff && (long) value > -0x800000)
1984
            {
1985
              unsigned char code;
1986
 
1987
              /* AM33 insns which have 32bit operands are 7 bytes long and
1988
                 will have 0xfe as the first byte.  */
1989
 
1990
              /* Get the first opcode.  */
1991
              code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
1992
 
1993
              if (code == 0xfe)
1994
                {
1995
                  /* Get the second opcode.  */
1996
                  code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1997
 
1998
                  /* All the am33 32 -> 24 relaxing possibilities.  */
1999
                  /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
2000
                     equivalent instructions exists.  */
2001
                  if (code != 0x6b && code != 0x7b
2002
                      && code != 0x8b && code != 0x9b
2003
                      && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
2004
                          || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
2005
                          || (code & 0x0f) == 0x0e))
2006
                    {
2007
                      /* Not safe if the high bit is on as relaxing may
2008
                         move the value out of high mem and thus not fit
2009
                         in a signed 16bit value.  This is currently over
2010
                         conservative.  */
2011
                      if ((value & 0x8000) == 0)
2012
                        {
2013
                          /* Note that we've changed the relocation contents,
2014
                             etc.  */
2015
                          elf_section_data (sec)->relocs = internal_relocs;
2016
                          free_relocs = NULL;
2017
 
2018
                          elf_section_data (sec)->this_hdr.contents = contents;
2019
                          free_contents = NULL;
2020
 
2021
                          symtab_hdr->contents = (bfd_byte *) extsyms;
2022
                          free_extsyms = NULL;
2023
 
2024
                          /* Fix the opcode.  */
2025
                          bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
2026
                          bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2027
 
2028
                          /* Fix the relocation's type.  */
2029
                          irel->r_info =
2030
                            ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2031
                                          R_MN10300_24);
2032
 
2033
                          /* Delete one byte of data.  */
2034
                          if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2035
                                                               irel->r_offset + 3, 1))
2036
                            goto error_return;
2037
 
2038
                          /* That will change things, so, we should relax
2039
                             again.  Note that this is not required, and it
2040
                             may be slow.  */
2041
                          *again = true;
2042
                          break;
2043
                        }
2044
                    }
2045
                }
2046
            }
2047
 
2048
          /* See if the value will fit in 16 bits.
2049
             We allow any 16bit match here.  We prune those we can't
2050
             handle below.  */
2051
          if ((long) value < 0x7fff && (long) value > -0x8000)
2052
            {
2053
              unsigned char code;
2054
 
2055
              /* Most insns which have 32bit operands are 6 bytes long;
2056
                 exceptions are pcrel insns and bit insns.
2057
 
2058
                 We handle pcrel insns above.  We don't bother trying
2059
                 to handle the bit insns here.
2060
 
2061
                 The first byte of the remaining insns will be 0xfc.  */
2062
 
2063
              /* Get the first opcode.  */
2064
              code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
2065
 
2066
              if (code != 0xfc)
2067
                continue;
2068
 
2069
              /* Get the second opcode.  */
2070
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2071
 
2072
              if ((code & 0xf0) < 0x80)
2073
                switch (code & 0xf0)
2074
                  {
2075
                  /* mov (d32,am),dn   -> mov (d32,am),dn
2076
                     mov dm,(d32,am)   -> mov dn,(d32,am)
2077
                     mov (d32,am),an   -> mov (d32,am),an
2078
                     mov dm,(d32,am)   -> mov dn,(d32,am)
2079
                     movbu (d32,am),dn -> movbu (d32,am),dn
2080
                     movbu dm,(d32,am) -> movbu dn,(d32,am)
2081
                     movhu (d32,am),dn -> movhu (d32,am),dn
2082
                     movhu dm,(d32,am) -> movhu dn,(d32,am) */
2083
                  case 0x00:
2084
                  case 0x10:
2085
                  case 0x20:
2086
                  case 0x30:
2087
                  case 0x40:
2088
                  case 0x50:
2089
                  case 0x60:
2090
                  case 0x70:
2091
                    /* Not safe if the high bit is on as relaxing may
2092
                       move the value out of high mem and thus not fit
2093
                       in a signed 16bit value.  */
2094
                    if (code == 0xcc
2095
                        && (value & 0x8000))
2096
                      continue;
2097
 
2098
                    /* Note that we've changed the relocation contents, etc.  */
2099
                    elf_section_data (sec)->relocs = internal_relocs;
2100
                    free_relocs = NULL;
2101
 
2102
                    elf_section_data (sec)->this_hdr.contents = contents;
2103
                    free_contents = NULL;
2104
 
2105
                    symtab_hdr->contents = (bfd_byte *) extsyms;
2106
                    free_extsyms = NULL;
2107
 
2108
                    /* Fix the opcode.  */
2109
                    bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2110
                    bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2111
 
2112
                    /* Fix the relocation's type.  */
2113
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2114
                                                 R_MN10300_16);
2115
 
2116
                    /* Delete two bytes of data.  */
2117
                    if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2118
                                                         irel->r_offset + 2, 2))
2119
                      goto error_return;
2120
 
2121
                    /* That will change things, so, we should relax again.
2122
                       Note that this is not required, and it may be slow.  */
2123
                    *again = true;
2124
                    break;
2125
                  }
2126
              else if ((code & 0xf0) == 0x80
2127
                       || (code & 0xf0) == 0x90)
2128
                switch (code & 0xf3)
2129
                  {
2130
                  /* mov dn,(abs32)   -> mov dn,(abs16)
2131
                     movbu dn,(abs32) -> movbu dn,(abs16)
2132
                     movhu dn,(abs32) -> movhu dn,(abs16)  */
2133
                  case 0x81:
2134
                  case 0x82:
2135
                  case 0x83:
2136
                    /* Note that we've changed the relocation contents, etc.  */
2137
                    elf_section_data (sec)->relocs = internal_relocs;
2138
                    free_relocs = NULL;
2139
 
2140
                    elf_section_data (sec)->this_hdr.contents = contents;
2141
                    free_contents = NULL;
2142
 
2143
                    symtab_hdr->contents = (bfd_byte *) extsyms;
2144
                    free_extsyms = NULL;
2145
 
2146
                    if ((code & 0xf3) == 0x81)
2147
                      code = 0x01 + (code & 0x0c);
2148
                    else if ((code & 0xf3) == 0x82)
2149
                      code = 0x02 + (code & 0x0c);
2150
                    else if ((code & 0xf3) == 0x83)
2151
                      code = 0x03 + (code & 0x0c);
2152
                    else
2153
                      abort ();
2154
 
2155
                    /* Fix the opcode.  */
2156
                    bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2157
 
2158
                    /* Fix the relocation's type.  */
2159
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2160
                                                 R_MN10300_16);
2161
 
2162
                    /* The opcode got shorter too, so we have to fix the
2163
                       addend and offset too!  */
2164
                    irel->r_offset -= 1;
2165
 
2166
                    /* Delete three bytes of data.  */
2167
                    if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2168
                                                         irel->r_offset + 1, 3))
2169
                      goto error_return;
2170
 
2171
                    /* That will change things, so, we should relax again.
2172
                       Note that this is not required, and it may be slow.  */
2173
                    *again = true;
2174
                    break;
2175
 
2176
                  /* mov am,(abs32)    -> mov am,(abs16)
2177
                     mov am,(d32,sp)   -> mov am,(d16,sp)
2178
                     mov dm,(d32,sp)   -> mov dm,(d32,sp)
2179
                     movbu dm,(d32,sp) -> movbu dm,(d32,sp)
2180
                     movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
2181
                  case 0x80:
2182
                  case 0x90:
2183
                  case 0x91:
2184
                  case 0x92:
2185
                  case 0x93:
2186
                    /* sp-based offsets are zero-extended.  */
2187
                    if (code >= 0x90 && code <= 0x93
2188
                        && (long)value < 0)
2189
                      continue;
2190
 
2191
                    /* Note that we've changed the relocation contents, etc.  */
2192
                    elf_section_data (sec)->relocs = internal_relocs;
2193
                    free_relocs = NULL;
2194
 
2195
                    elf_section_data (sec)->this_hdr.contents = contents;
2196
                    free_contents = NULL;
2197
 
2198
                    symtab_hdr->contents = (bfd_byte *) extsyms;
2199
                    free_extsyms = NULL;
2200
 
2201
                    /* Fix the opcode.  */
2202
                    bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2203
                    bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2204
 
2205
                    /* Fix the relocation's type.  */
2206
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2207
                                                 R_MN10300_16);
2208
 
2209
                    /* Delete two bytes of data.  */
2210
                    if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2211
                                                         irel->r_offset + 2, 2))
2212
                      goto error_return;
2213
 
2214
                    /* That will change things, so, we should relax again.
2215
                       Note that this is not required, and it may be slow.  */
2216
                    *again = true;
2217
                    break;
2218
                  }
2219
              else if ((code & 0xf0) < 0xf0)
2220
                switch (code & 0xfc)
2221
                  {
2222
                  /* mov imm32,dn     -> mov imm16,dn
2223
                     mov imm32,an     -> mov imm16,an
2224
                     mov (abs32),dn   -> mov (abs16),dn
2225
                     movbu (abs32),dn -> movbu (abs16),dn
2226
                     movhu (abs32),dn -> movhu (abs16),dn  */
2227
                  case 0xcc:
2228
                  case 0xdc:
2229
                  case 0xa4:
2230
                  case 0xa8:
2231
                  case 0xac:
2232
                    /* Not safe if the high bit is on as relaxing may
2233
                       move the value out of high mem and thus not fit
2234
                       in a signed 16bit value.  */
2235
                    if (code == 0xcc
2236
                        && (value & 0x8000))
2237
                      continue;
2238
 
2239
                    /* mov imm16, an zero-extends the immediate.  */
2240
                    if (code == 0xdc
2241
                        && (long)value < 0)
2242
                      continue;
2243
 
2244
                    /* Note that we've changed the relocation contents, etc.  */
2245
                    elf_section_data (sec)->relocs = internal_relocs;
2246
                    free_relocs = NULL;
2247
 
2248
                    elf_section_data (sec)->this_hdr.contents = contents;
2249
                    free_contents = NULL;
2250
 
2251
                    symtab_hdr->contents = (bfd_byte *) extsyms;
2252
                    free_extsyms = NULL;
2253
 
2254
                    if ((code & 0xfc) == 0xcc)
2255
                      code = 0x2c + (code & 0x03);
2256
                    else if ((code & 0xfc) == 0xdc)
2257
                      code = 0x24 + (code & 0x03);
2258
                    else if ((code & 0xfc) == 0xa4)
2259
                      code = 0x30 + (code & 0x03);
2260
                    else if ((code & 0xfc) == 0xa8)
2261
                      code = 0x34 + (code & 0x03);
2262
                    else if ((code & 0xfc) == 0xac)
2263
                      code = 0x38 + (code & 0x03);
2264
                    else
2265
                      abort ();
2266
 
2267
                    /* Fix the opcode.  */
2268
                    bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2269
 
2270
                    /* Fix the relocation's type.  */
2271
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2272
                                                 R_MN10300_16);
2273
 
2274
                    /* The opcode got shorter too, so we have to fix the
2275
                       addend and offset too!  */
2276
                    irel->r_offset -= 1;
2277
 
2278
                    /* Delete three bytes of data.  */
2279
                    if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2280
                                                         irel->r_offset + 1, 3))
2281
                      goto error_return;
2282
 
2283
                    /* That will change things, so, we should relax again.
2284
                       Note that this is not required, and it may be slow.  */
2285
                    *again = true;
2286
                    break;
2287
 
2288
                  /* mov (abs32),an    -> mov (abs16),an
2289
                     mov (d32,sp),an   -> mov (d16,sp),an
2290
                     mov (d32,sp),dn   -> mov (d16,sp),dn
2291
                     movbu (d32,sp),dn -> movbu (d16,sp),dn
2292
                     movhu (d32,sp),dn -> movhu (d16,sp),dn
2293
                     add imm32,dn      -> add imm16,dn
2294
                     cmp imm32,dn      -> cmp imm16,dn
2295
                     add imm32,an      -> add imm16,an
2296
                     cmp imm32,an      -> cmp imm16,an
2297
                     and imm32,dn      -> and imm16,dn
2298
                     or imm32,dn       -> or imm16,dn
2299
                     xor imm32,dn      -> xor imm16,dn
2300
                     btst imm32,dn     -> btst imm16,dn */
2301
 
2302
                  case 0xa0:
2303
                  case 0xb0:
2304
                  case 0xb1:
2305
                  case 0xb2:
2306
                  case 0xb3:
2307
                  case 0xc0:
2308
                  case 0xc8:
2309
 
2310
                  case 0xd0:
2311
                  case 0xd8:
2312
                  case 0xe0:
2313
                  case 0xe1:
2314
                  case 0xe2:
2315
                  case 0xe3:
2316
                    /* cmp imm16, an zero-extends the immediate.  */
2317
                    if (code == 0xdc
2318
                        && (long)value < 0)
2319
                      continue;
2320
 
2321
                    /* So do sp-based offsets.  */
2322
                    if (code >= 0xb0 && code <= 0xb3
2323
                        && (long)value < 0)
2324
                      continue;
2325
 
2326
                    /* Note that we've changed the relocation contents, etc.  */
2327
                    elf_section_data (sec)->relocs = internal_relocs;
2328
                    free_relocs = NULL;
2329
 
2330
                    elf_section_data (sec)->this_hdr.contents = contents;
2331
                    free_contents = NULL;
2332
 
2333
                    symtab_hdr->contents = (bfd_byte *) extsyms;
2334
                    free_extsyms = NULL;
2335
 
2336
                    /* Fix the opcode.  */
2337
                    bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2338
                    bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2339
 
2340
                    /* Fix the relocation's type.  */
2341
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2342
                                                 R_MN10300_16);
2343
 
2344
                    /* Delete two bytes of data.  */
2345
                    if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2346
                                                         irel->r_offset + 2, 2))
2347
                      goto error_return;
2348
 
2349
                    /* That will change things, so, we should relax again.
2350
                       Note that this is not required, and it may be slow.  */
2351
                    *again = true;
2352
                    break;
2353
                  }
2354
              else if (code == 0xfe)
2355
                {
2356
                  /* add imm32,sp -> add imm16,sp  */
2357
 
2358
                  /* Note that we've changed the relocation contents, etc.  */
2359
                  elf_section_data (sec)->relocs = internal_relocs;
2360
                  free_relocs = NULL;
2361
 
2362
                  elf_section_data (sec)->this_hdr.contents = contents;
2363
                  free_contents = NULL;
2364
 
2365
                  symtab_hdr->contents = (bfd_byte *) extsyms;
2366
                  free_extsyms = NULL;
2367
 
2368
                  /* Fix the opcode.  */
2369
                  bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2370
                  bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
2371
 
2372
                  /* Fix the relocation's type.  */
2373
                  irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2374
                                               R_MN10300_16);
2375
 
2376
                  /* Delete two bytes of data.  */
2377
                  if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2378
                                                       irel->r_offset + 2, 2))
2379
                    goto error_return;
2380
 
2381
                  /* That will change things, so, we should relax again.
2382
                     Note that this is not required, and it may be slow.  */
2383
                  *again = true;
2384
                  break;
2385
                }
2386
            }
2387
        }
2388
    }
2389
 
2390
  if (free_relocs != NULL)
2391
    {
2392
      free (free_relocs);
2393
      free_relocs = NULL;
2394
    }
2395
 
2396
  if (free_contents != NULL)
2397
    {
2398
      if (! link_info->keep_memory)
2399
        free (free_contents);
2400
      else
2401
        {
2402
          /* Cache the section contents for elf_link_input_bfd.  */
2403
          elf_section_data (sec)->this_hdr.contents = contents;
2404
        }
2405
      free_contents = NULL;
2406
    }
2407
 
2408
  if (free_extsyms != NULL)
2409
    {
2410
      if (! link_info->keep_memory)
2411
        free (free_extsyms);
2412
      else
2413
        {
2414
          /* Cache the symbols for elf_link_input_bfd.  */
2415
          symtab_hdr->contents = extsyms;
2416
        }
2417
      free_extsyms = NULL;
2418
    }
2419
 
2420
  return true;
2421
 
2422
 error_return:
2423
  if (free_relocs != NULL)
2424
    free (free_relocs);
2425
  if (free_contents != NULL)
2426
    free (free_contents);
2427
  if (free_extsyms != NULL)
2428
    free (free_extsyms);
2429
  return false;
2430
}
2431
 
2432
/* Compute the stack size and movm arguments for the function
2433
   referred to by HASH at address ADDR in section with
2434
   contents CONTENTS, store the information in the hash table.  */
2435
static void
2436
compute_function_info (abfd, hash, addr, contents)
2437
     bfd *abfd;
2438
     struct elf32_mn10300_link_hash_entry *hash;
2439
     bfd_vma addr;
2440
     unsigned char *contents;
2441
{
2442
  unsigned char byte1, byte2;
2443
  /* We only care about a very small subset of the possible prologue
2444
     sequences here.  Basically we look for:
2445
 
2446
     movm [d2,d3,a2,a3],sp (optional)
2447
     add <size>,sp (optional, and only for sizes which fit in an unsigned
2448
                    8 bit number)
2449
 
2450
     If we find anything else, we quit.  */
2451
 
2452
  /* Look for movm [regs],sp */
2453
  byte1 = bfd_get_8 (abfd, contents + addr);
2454
  byte2 = bfd_get_8 (abfd, contents + addr + 1);
2455
 
2456
  if (byte1 == 0xcf)
2457
    {
2458
      hash->movm_args = byte2;
2459
      addr += 2;
2460
      byte1 = bfd_get_8 (abfd, contents + addr);
2461
      byte2 = bfd_get_8 (abfd, contents + addr + 1);
2462
    }
2463
 
2464
  /* Now figure out how much stack space will be allocated by the movm
2465
     instruction.  We need this kept separate from the funtion's normal
2466
     stack space.  */
2467
  if (hash->movm_args)
2468
    {
2469
      /* Space for d2.  */
2470
      if (hash->movm_args & 0x80)
2471
        hash->movm_stack_size += 4;
2472
 
2473
      /* Space for d3.  */
2474
      if (hash->movm_args & 0x40)
2475
        hash->movm_stack_size += 4;
2476
 
2477
      /* Space for a2.  */
2478
      if (hash->movm_args & 0x20)
2479
        hash->movm_stack_size += 4;
2480
 
2481
      /* Space for a3.  */
2482
      if (hash->movm_args & 0x10)
2483
        hash->movm_stack_size += 4;
2484
 
2485
      /* "other" space.  d0, d1, a0, a1, mdr, lir, lar, 4 byte pad.  */
2486
      if (hash->movm_args & 0x08)
2487
        hash->movm_stack_size += 8 * 4;
2488
 
2489
      if (bfd_get_mach (abfd) == bfd_mach_am33)
2490
        {
2491
          /* "exother" space.  e0, e1, mdrq, mcrh, mcrl, mcvf */
2492
          if (hash->movm_args & 0x1)
2493
            hash->movm_stack_size += 6 * 4;
2494
 
2495
          /* exreg1 space.  e4, e5, e6, e7 */
2496
          if (hash->movm_args & 0x2)
2497
            hash->movm_stack_size += 4 * 4;
2498
 
2499
          /* exreg0 space.  e2, e3  */
2500
          if (hash->movm_args & 0x4)
2501
            hash->movm_stack_size += 2 * 4;
2502
        }
2503
    }
2504
 
2505
  /* Now look for the two stack adjustment variants.  */
2506
  if (byte1 == 0xf8 && byte2 == 0xfe)
2507
    {
2508
      int temp = bfd_get_8 (abfd, contents + addr + 2);
2509
      temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
2510
 
2511
      hash->stack_size = -temp;
2512
    }
2513
  else if (byte1 == 0xfa && byte2 == 0xfe)
2514
    {
2515
      int temp = bfd_get_16 (abfd, contents + addr + 2);
2516
      temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
2517
      temp = -temp;
2518
 
2519
      if (temp < 255)
2520
        hash->stack_size = temp;
2521
    }
2522
 
2523
  /* If the total stack to be allocated by the call instruction is more
2524
     than 255 bytes, then we can't remove the stack adjustment by using
2525
     "call" (we might still be able to remove the "movm" instruction.  */
2526
  if (hash->stack_size + hash->movm_stack_size > 255)
2527
    hash->stack_size = 0;
2528
 
2529
  return;
2530
}
2531
 
2532
/* Delete some bytes from a section while relaxing.  */
2533
 
2534
static boolean
2535
mn10300_elf_relax_delete_bytes (abfd, sec, addr, count)
2536
     bfd *abfd;
2537
     asection *sec;
2538
     bfd_vma addr;
2539
     int count;
2540
{
2541
  Elf_Internal_Shdr *symtab_hdr;
2542
  Elf32_External_Sym *extsyms;
2543
  int shndx, index;
2544
  bfd_byte *contents;
2545
  Elf_Internal_Rela *irel, *irelend;
2546
  Elf_Internal_Rela *irelalign;
2547
  bfd_vma toaddr;
2548
  Elf32_External_Sym *esym, *esymend;
2549
  struct elf32_mn10300_link_hash_entry *sym_hash;
2550
 
2551
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2552
  extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
2553
 
2554
  shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2555
 
2556
  contents = elf_section_data (sec)->this_hdr.contents;
2557
 
2558
  /* The deletion must stop at the next ALIGN reloc for an aligment
2559
     power larger than the number of bytes we are deleting.  */
2560
 
2561
  irelalign = NULL;
2562
  toaddr = sec->_cooked_size;
2563
 
2564
  irel = elf_section_data (sec)->relocs;
2565
  irelend = irel + sec->reloc_count;
2566
 
2567
  /* Actually delete the bytes.  */
2568
  memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2569
  sec->_cooked_size -= count;
2570
 
2571
  /* Adjust all the relocs.  */
2572
  for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2573
    {
2574
      /* Get the new reloc address.  */
2575
      if ((irel->r_offset > addr
2576
           && irel->r_offset < toaddr))
2577
        irel->r_offset -= count;
2578
    }
2579
 
2580
  /* Adjust the local symbols defined in this section.  */
2581
  esym = extsyms;
2582
  esymend = esym + symtab_hdr->sh_info;
2583
  for (; esym < esymend; esym++)
2584
    {
2585
      Elf_Internal_Sym isym;
2586
 
2587
      bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2588
 
2589
      if (isym.st_shndx == shndx
2590
          && isym.st_value > addr
2591
          && isym.st_value < toaddr)
2592
        {
2593
          isym.st_value -= count;
2594
          bfd_elf32_swap_symbol_out (abfd, &isym, esym);
2595
        }
2596
    }
2597
 
2598
  /* Now adjust the global symbols defined in this section.  */
2599
  esym = extsyms + symtab_hdr->sh_info;
2600
  esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
2601
  for (index = 0; esym < esymend; esym++, index++)
2602
    {
2603
      Elf_Internal_Sym isym;
2604
 
2605
      bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2606
      sym_hash = (struct elf32_mn10300_link_hash_entry *)
2607
                   (elf_sym_hashes (abfd)[index]);
2608
      if (isym.st_shndx == shndx
2609
          && ((sym_hash)->root.root.type == bfd_link_hash_defined
2610
              || (sym_hash)->root.root.type == bfd_link_hash_defweak)
2611
          && (sym_hash)->root.root.u.def.section == sec
2612
          && (sym_hash)->root.root.u.def.value > addr
2613
          && (sym_hash)->root.root.u.def.value < toaddr)
2614
        {
2615
          (sym_hash)->root.root.u.def.value -= count;
2616
        }
2617
    }
2618
 
2619
  return true;
2620
}
2621
 
2622
/* Return true if a symbol exists at the given address, else return
2623
   false.  */
2624
static boolean
2625
mn10300_elf_symbol_address_p (abfd, sec, extsyms, addr)
2626
     bfd *abfd;
2627
     asection *sec;
2628
     Elf32_External_Sym *extsyms;
2629
     bfd_vma addr;
2630
{
2631
  Elf_Internal_Shdr *symtab_hdr;
2632
  int shndx;
2633
  Elf32_External_Sym *esym, *esymend;
2634
  struct elf32_mn10300_link_hash_entry **sym_hash, **sym_hash_end;
2635
 
2636
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2637
  shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2638
 
2639
  /* Examine all the symbols.  */
2640
  esym = extsyms;
2641
  esymend = esym + symtab_hdr->sh_info;
2642
  for (; esym < esymend; esym++)
2643
    {
2644
      Elf_Internal_Sym isym;
2645
 
2646
      bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2647
 
2648
      if (isym.st_shndx == shndx
2649
          && isym.st_value == addr)
2650
        return true;
2651
    }
2652
 
2653
  sym_hash = (struct elf32_mn10300_link_hash_entry **) (elf_sym_hashes (abfd));
2654
  sym_hash_end = (sym_hash
2655
                  + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2656
                     - symtab_hdr->sh_info));
2657
  for (; sym_hash < sym_hash_end; sym_hash++)
2658
    {
2659
      if (((*sym_hash)->root.root.type == bfd_link_hash_defined
2660
           || (*sym_hash)->root.root.type == bfd_link_hash_defweak)
2661
          && (*sym_hash)->root.root.u.def.section == sec
2662
          && (*sym_hash)->root.root.u.def.value == addr)
2663
        return true;
2664
    }
2665
  return false;
2666
}
2667
 
2668
/* This is a version of bfd_generic_get_relocated_section_contents
2669
   which uses mn10300_elf_relocate_section.  */
2670
 
2671
static bfd_byte *
2672
mn10300_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
2673
                                            data, relocateable, symbols)
2674
     bfd *output_bfd;
2675
     struct bfd_link_info *link_info;
2676
     struct bfd_link_order *link_order;
2677
     bfd_byte *data;
2678
     boolean relocateable;
2679
     asymbol **symbols;
2680
{
2681
  Elf_Internal_Shdr *symtab_hdr;
2682
  asection *input_section = link_order->u.indirect.section;
2683
  bfd *input_bfd = input_section->owner;
2684
  asection **sections = NULL;
2685
  Elf_Internal_Rela *internal_relocs = NULL;
2686
  Elf32_External_Sym *external_syms = NULL;
2687
  Elf_Internal_Sym *internal_syms = NULL;
2688
 
2689
  /* We only need to handle the case of relaxing, or of having a
2690
     particular set of section contents, specially.  */
2691
  if (relocateable
2692
      || elf_section_data (input_section)->this_hdr.contents == NULL)
2693
    return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2694
                                                       link_order, data,
2695
                                                       relocateable,
2696
                                                       symbols);
2697
 
2698
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2699
 
2700
  memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2701
          input_section->_raw_size);
2702
 
2703
  if ((input_section->flags & SEC_RELOC) != 0
2704
      && input_section->reloc_count > 0)
2705
    {
2706
      Elf_Internal_Sym *isymp;
2707
      asection **secpp;
2708
      Elf32_External_Sym *esym, *esymend;
2709
 
2710
      if (symtab_hdr->contents != NULL)
2711
        external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
2712
      else
2713
        {
2714
          external_syms = ((Elf32_External_Sym *)
2715
                           bfd_malloc (symtab_hdr->sh_info
2716
                                       * sizeof (Elf32_External_Sym)));
2717
          if (external_syms == NULL && symtab_hdr->sh_info > 0)
2718
            goto error_return;
2719
          if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2720
              || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
2721
                            symtab_hdr->sh_info, input_bfd)
2722
                  != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
2723
            goto error_return;
2724
        }
2725
 
2726
      internal_relocs = (_bfd_elf32_link_read_relocs
2727
                         (input_bfd, input_section, (PTR) NULL,
2728
                          (Elf_Internal_Rela *) NULL, false));
2729
      if (internal_relocs == NULL)
2730
        goto error_return;
2731
 
2732
      internal_syms = ((Elf_Internal_Sym *)
2733
                       bfd_malloc (symtab_hdr->sh_info
2734
                                   * sizeof (Elf_Internal_Sym)));
2735
      if (internal_syms == NULL && symtab_hdr->sh_info > 0)
2736
        goto error_return;
2737
 
2738
      sections = (asection **) bfd_malloc (symtab_hdr->sh_info
2739
                                           * sizeof (asection *));
2740
      if (sections == NULL && symtab_hdr->sh_info > 0)
2741
        goto error_return;
2742
 
2743
      isymp = internal_syms;
2744
      secpp = sections;
2745
      esym = external_syms;
2746
      esymend = esym + symtab_hdr->sh_info;
2747
      for (; esym < esymend; ++esym, ++isymp, ++secpp)
2748
        {
2749
          asection *isec;
2750
 
2751
          bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
2752
 
2753
          if (isymp->st_shndx == SHN_UNDEF)
2754
            isec = bfd_und_section_ptr;
2755
          else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
2756
            isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
2757
          else if (isymp->st_shndx == SHN_ABS)
2758
            isec = bfd_abs_section_ptr;
2759
          else if (isymp->st_shndx == SHN_COMMON)
2760
            isec = bfd_com_section_ptr;
2761
          else
2762
            {
2763
              /* Who knows?  */
2764
              isec = NULL;
2765
            }
2766
 
2767
          *secpp = isec;
2768
        }
2769
 
2770
      if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
2771
                                     input_section, data, internal_relocs,
2772
                                     internal_syms, sections))
2773
        goto error_return;
2774
 
2775
      if (sections != NULL)
2776
        free (sections);
2777
      sections = NULL;
2778
      if (internal_syms != NULL)
2779
        free (internal_syms);
2780
      internal_syms = NULL;
2781
      if (external_syms != NULL && symtab_hdr->contents == NULL)
2782
        free (external_syms);
2783
      external_syms = NULL;
2784
      if (internal_relocs != elf_section_data (input_section)->relocs)
2785
        free (internal_relocs);
2786
      internal_relocs = NULL;
2787
    }
2788
 
2789
  return data;
2790
 
2791
 error_return:
2792
  if (internal_relocs != NULL
2793
      && internal_relocs != elf_section_data (input_section)->relocs)
2794
    free (internal_relocs);
2795
  if (external_syms != NULL && symtab_hdr->contents == NULL)
2796
    free (external_syms);
2797
  if (internal_syms != NULL)
2798
    free (internal_syms);
2799
  if (sections != NULL)
2800
    free (sections);
2801
  return NULL;
2802
}
2803
 
2804
/* Assorted hash table functions.  */
2805
 
2806
/* Initialize an entry in the link hash table.  */
2807
 
2808
/* Create an entry in an MN10300 ELF linker hash table.  */
2809
 
2810
static struct bfd_hash_entry *
2811
elf32_mn10300_link_hash_newfunc (entry, table, string)
2812
     struct bfd_hash_entry *entry;
2813
     struct bfd_hash_table *table;
2814
     const char *string;
2815
{
2816
  struct elf32_mn10300_link_hash_entry *ret =
2817
    (struct elf32_mn10300_link_hash_entry *) entry;
2818
 
2819
  /* Allocate the structure if it has not already been allocated by a
2820
     subclass.  */
2821
  if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2822
    ret = ((struct elf32_mn10300_link_hash_entry *)
2823
           bfd_hash_allocate (table,
2824
                              sizeof (struct elf32_mn10300_link_hash_entry)));
2825
  if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2826
    return (struct bfd_hash_entry *) ret;
2827
 
2828
  /* Call the allocation method of the superclass.  */
2829
  ret = ((struct elf32_mn10300_link_hash_entry *)
2830
         _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2831
                                     table, string));
2832
  if (ret != (struct elf32_mn10300_link_hash_entry *) NULL)
2833
    {
2834
      ret->direct_calls = 0;
2835
      ret->stack_size = 0;
2836
      ret->movm_stack_size = 0;
2837
      ret->flags = 0;
2838
      ret->movm_args = 0;
2839
    }
2840
 
2841
  return (struct bfd_hash_entry *) ret;
2842
}
2843
 
2844
/* Create an mn10300 ELF linker hash table.  */
2845
 
2846
static struct bfd_link_hash_table *
2847
elf32_mn10300_link_hash_table_create (abfd)
2848
     bfd *abfd;
2849
{
2850
  struct elf32_mn10300_link_hash_table *ret;
2851
 
2852
  ret = ((struct elf32_mn10300_link_hash_table *)
2853
         bfd_alloc (abfd, sizeof (struct elf32_mn10300_link_hash_table)));
2854
  if (ret == (struct elf32_mn10300_link_hash_table *) NULL)
2855
    return NULL;
2856
 
2857
  if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
2858
                                       elf32_mn10300_link_hash_newfunc))
2859
    {
2860
      bfd_release (abfd, ret);
2861
      return NULL;
2862
    }
2863
 
2864
  ret->flags = 0;
2865
  ret->static_hash_table
2866
    = ((struct elf32_mn10300_link_hash_table *)
2867
       bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
2868
  if (ret->static_hash_table == NULL)
2869
    {
2870
      bfd_release (abfd, ret);
2871
      return NULL;
2872
    }
2873
 
2874
  if (! _bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
2875
                                       elf32_mn10300_link_hash_newfunc))
2876
    {
2877
      bfd_release (abfd, ret->static_hash_table);
2878
      bfd_release (abfd, ret);
2879
      return NULL;
2880
    }
2881
  return &ret->root.root;
2882
}
2883
 
2884
static int
2885
elf_mn10300_mach (flags)
2886
     flagword flags;
2887
{
2888
  switch (flags & EF_MN10300_MACH)
2889
    {
2890
    case E_MN10300_MACH_MN10300:
2891
    default:
2892
      return bfd_mach_mn10300;
2893
 
2894
    case E_MN10300_MACH_AM33:
2895
      return bfd_mach_am33;
2896
    }
2897
}
2898
 
2899
/* The final processing done just before writing out a MN10300 ELF object
2900
   file.  This gets the MN10300 architecture right based on the machine
2901
   number.  */
2902
 
2903
void
2904
_bfd_mn10300_elf_final_write_processing (abfd, linker)
2905
     bfd *abfd;
2906
     boolean linker ATTRIBUTE_UNUSED;
2907
{
2908
  unsigned long val;
2909
 
2910
  switch (bfd_get_mach (abfd))
2911
    {
2912
    default:
2913
    case bfd_mach_mn10300:
2914
      val = E_MN10300_MACH_MN10300;
2915
      break;
2916
 
2917
    case bfd_mach_am33:
2918
      val = E_MN10300_MACH_AM33;
2919
      break;
2920
    }
2921
 
2922
  elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
2923
  elf_elfheader (abfd)->e_flags |= val;
2924
}
2925
 
2926
boolean
2927
_bfd_mn10300_elf_object_p (abfd)
2928
     bfd *abfd;
2929
{
2930
  bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
2931
                             elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
2932
  return true;
2933
}
2934
 
2935
/* Merge backend specific data from an object file to the output
2936
   object file when linking.  */
2937
 
2938
boolean
2939
_bfd_mn10300_elf_merge_private_bfd_data (ibfd, obfd)
2940
     bfd *ibfd;
2941
     bfd *obfd;
2942
{
2943
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2944
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2945
    return true;
2946
 
2947
  if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2948
      && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
2949
    {
2950
      if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2951
                               bfd_get_mach (ibfd)))
2952
        return false;
2953
    }
2954
 
2955
  return true;
2956
}
2957
 
2958
#define TARGET_LITTLE_SYM       bfd_elf32_mn10300_vec
2959
#define TARGET_LITTLE_NAME      "elf32-mn10300"
2960
#define ELF_ARCH                bfd_arch_mn10300
2961
#define ELF_MACHINE_CODE        EM_CYGNUS_MN10300
2962
#define ELF_MAXPAGESIZE         0x1000
2963
 
2964
#define elf_info_to_howto               mn10300_info_to_howto
2965
#define elf_info_to_howto_rel           0
2966
#define elf_backend_can_gc_sections     1
2967
#define elf_backend_check_relocs        mn10300_elf_check_relocs
2968
#define elf_backend_gc_mark_hook        mn10300_elf_gc_mark_hook
2969
#define elf_backend_relocate_section    mn10300_elf_relocate_section
2970
#define bfd_elf32_bfd_relax_section     mn10300_elf_relax_section
2971
#define bfd_elf32_bfd_get_relocated_section_contents \
2972
                                mn10300_elf_get_relocated_section_contents
2973
#define bfd_elf32_bfd_link_hash_table_create \
2974
                                elf32_mn10300_link_hash_table_create
2975
 
2976
#define elf_symbol_leading_char '_'
2977
 
2978
/* So we can set bits in e_flags.  */
2979
#define elf_backend_final_write_processing \
2980
                                        _bfd_mn10300_elf_final_write_processing
2981
#define elf_backend_object_p            _bfd_mn10300_elf_object_p
2982
 
2983
#define bfd_elf32_bfd_merge_private_bfd_data \
2984
                                        _bfd_mn10300_elf_merge_private_bfd_data
2985
 
2986
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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