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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [elf-m10300.c] - Blame information for rev 225

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Matsushita 10300 specific support for 32-bit ELF
2
   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 225 jeremybenn
   2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4 24 jeremybenn
 
5
   This file is part of BFD, the Binary File Descriptor library.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
 
22
#include "sysdep.h"
23
#include "bfd.h"
24
#include "libbfd.h"
25
#include "elf-bfd.h"
26
#include "elf/mn10300.h"
27
#include "libiberty.h"
28
 
29
/* The mn10300 linker needs to keep track of the number of relocs that
30
   it decides to copy in check_relocs for each symbol.  This is so
31
   that it can discard PC relative relocs if it doesn't need them when
32
   linking with -Bsymbolic.  We store the information in a field
33
   extending the regular ELF linker hash table.  */
34
 
35
struct elf32_mn10300_link_hash_entry
36
{
37
  /* The basic elf link hash table entry.  */
38
  struct elf_link_hash_entry root;
39
 
40
  /* For function symbols, the number of times this function is
41
     called directly (ie by name).  */
42
  unsigned int direct_calls;
43
 
44
  /* For function symbols, the size of this function's stack
45
     (if <= 255 bytes).  We stuff this into "call" instructions
46
     to this target when it's valid and profitable to do so.
47
 
48
     This does not include stack allocated by movm!  */
49
  unsigned char stack_size;
50
 
51
  /* For function symbols, arguments (if any) for movm instruction
52
     in the prologue.  We stuff this value into "call" instructions
53
     to the target when it's valid and profitable to do so.  */
54
  unsigned char movm_args;
55
 
56
  /* For function symbols, the amount of stack space that would be allocated
57
     by the movm instruction.  This is redundant with movm_args, but we
58
     add it to the hash table to avoid computing it over and over.  */
59
  unsigned char movm_stack_size;
60
 
61
/* When set, convert all "call" instructions to this target into "calls"
62
   instructions.  */
63
#define MN10300_CONVERT_CALL_TO_CALLS 0x1
64
 
65
/* Used to mark functions which have had redundant parts of their
66
   prologue deleted.  */
67
#define MN10300_DELETED_PROLOGUE_BYTES 0x2
68
  unsigned char flags;
69
 
70
  /* Calculated value.  */
71
  bfd_vma value;
72
};
73
 
74
/* We derive a hash table from the main elf linker hash table so
75
   we can store state variables and a secondary hash table without
76
   resorting to global variables.  */
77
struct elf32_mn10300_link_hash_table
78
{
79
  /* The main hash table.  */
80
  struct elf_link_hash_table root;
81
 
82
  /* A hash table for static functions.  We could derive a new hash table
83
     instead of using the full elf32_mn10300_link_hash_table if we wanted
84
     to save some memory.  */
85
  struct elf32_mn10300_link_hash_table *static_hash_table;
86
 
87
  /* Random linker state flags.  */
88
#define MN10300_HASH_ENTRIES_INITIALIZED 0x1
89
  char flags;
90
};
91
 
92
#ifndef streq
93
#define streq(a, b) (strcmp ((a),(b)) == 0)
94
#endif
95
 
96
/* For MN10300 linker hash table.  */
97
 
98
/* Get the MN10300 ELF linker hash table from a link_info structure.  */
99
 
100
#define elf32_mn10300_hash_table(p) \
101
  ((struct elf32_mn10300_link_hash_table *) ((p)->hash))
102
 
103
#define elf32_mn10300_link_hash_traverse(table, func, info)             \
104
  (elf_link_hash_traverse                                               \
105
   (&(table)->root,                                                     \
106
    (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
107
    (info)))
108
 
109
static reloc_howto_type elf_mn10300_howto_table[] =
110
{
111
  /* Dummy relocation.  Does nothing.  */
112
  HOWTO (R_MN10300_NONE,
113
         0,
114
         2,
115
         16,
116
         FALSE,
117
         0,
118
         complain_overflow_bitfield,
119
         bfd_elf_generic_reloc,
120
         "R_MN10300_NONE",
121
         FALSE,
122
         0,
123
         0,
124
         FALSE),
125
  /* Standard 32 bit reloc.  */
126
  HOWTO (R_MN10300_32,
127
         0,
128
         2,
129
         32,
130
         FALSE,
131
         0,
132
         complain_overflow_bitfield,
133
         bfd_elf_generic_reloc,
134
         "R_MN10300_32",
135
         FALSE,
136
         0xffffffff,
137
         0xffffffff,
138
         FALSE),
139
  /* Standard 16 bit reloc.  */
140
  HOWTO (R_MN10300_16,
141
         0,
142
         1,
143
         16,
144
         FALSE,
145
         0,
146
         complain_overflow_bitfield,
147
         bfd_elf_generic_reloc,
148
         "R_MN10300_16",
149
         FALSE,
150
         0xffff,
151
         0xffff,
152
         FALSE),
153
  /* Standard 8 bit reloc.  */
154
  HOWTO (R_MN10300_8,
155
         0,
156
         0,
157
         8,
158
         FALSE,
159
         0,
160
         complain_overflow_bitfield,
161
         bfd_elf_generic_reloc,
162
         "R_MN10300_8",
163
         FALSE,
164
         0xff,
165
         0xff,
166
         FALSE),
167
  /* Standard 32bit pc-relative reloc.  */
168
  HOWTO (R_MN10300_PCREL32,
169
         0,
170
         2,
171
         32,
172
         TRUE,
173
         0,
174
         complain_overflow_bitfield,
175
         bfd_elf_generic_reloc,
176
         "R_MN10300_PCREL32",
177
         FALSE,
178
         0xffffffff,
179
         0xffffffff,
180
         TRUE),
181
  /* Standard 16bit pc-relative reloc.  */
182
  HOWTO (R_MN10300_PCREL16,
183
         0,
184
         1,
185
         16,
186
         TRUE,
187
         0,
188
         complain_overflow_bitfield,
189
         bfd_elf_generic_reloc,
190
         "R_MN10300_PCREL16",
191
         FALSE,
192
         0xffff,
193
         0xffff,
194
         TRUE),
195
  /* Standard 8 pc-relative reloc.  */
196
  HOWTO (R_MN10300_PCREL8,
197
         0,
198
         0,
199
         8,
200
         TRUE,
201
         0,
202
         complain_overflow_bitfield,
203
         bfd_elf_generic_reloc,
204
         "R_MN10300_PCREL8",
205
         FALSE,
206
         0xff,
207
         0xff,
208
         TRUE),
209
 
210
  /* GNU extension to record C++ vtable hierarchy.  */
211
  HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
212
         0,                      /* rightshift */
213
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
214
         0,                      /* bitsize */
215
         FALSE,                 /* pc_relative */
216
         0,                      /* bitpos */
217
         complain_overflow_dont, /* complain_on_overflow */
218
         NULL,                  /* special_function */
219
         "R_MN10300_GNU_VTINHERIT", /* name */
220
         FALSE,                 /* partial_inplace */
221
         0,                      /* src_mask */
222
         0,                      /* dst_mask */
223
         FALSE),                /* pcrel_offset */
224
 
225
  /* GNU extension to record C++ vtable member usage */
226
  HOWTO (R_MN10300_GNU_VTENTRY, /* type */
227
         0,                      /* rightshift */
228
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
229
         0,                      /* bitsize */
230
         FALSE,                 /* pc_relative */
231
         0,                      /* bitpos */
232
         complain_overflow_dont, /* complain_on_overflow */
233
         NULL,                  /* special_function */
234
         "R_MN10300_GNU_VTENTRY", /* name */
235
         FALSE,                 /* partial_inplace */
236
         0,                      /* src_mask */
237
         0,                      /* dst_mask */
238
         FALSE),                /* pcrel_offset */
239
 
240
  /* Standard 24 bit reloc.  */
241
  HOWTO (R_MN10300_24,
242
         0,
243
         2,
244
         24,
245
         FALSE,
246
         0,
247
         complain_overflow_bitfield,
248
         bfd_elf_generic_reloc,
249
         "R_MN10300_24",
250
         FALSE,
251
         0xffffff,
252
         0xffffff,
253
         FALSE),
254
  HOWTO (R_MN10300_GOTPC32,     /* type */
255
         0,                      /* rightshift */
256
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
257
         32,                    /* bitsize */
258
         TRUE,                  /* pc_relative */
259
         0,                      /* bitpos */
260
         complain_overflow_bitfield, /* complain_on_overflow */
261
         bfd_elf_generic_reloc, /* */
262
         "R_MN10300_GOTPC32",   /* name */
263
         FALSE,                 /* partial_inplace */
264
         0xffffffff,            /* src_mask */
265
         0xffffffff,            /* dst_mask */
266
         TRUE),                 /* pcrel_offset */
267
 
268
  HOWTO (R_MN10300_GOTPC16,     /* type */
269
         0,                      /* rightshift */
270
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
271
         16,                    /* bitsize */
272
         TRUE,                  /* pc_relative */
273
         0,                      /* bitpos */
274
         complain_overflow_bitfield, /* complain_on_overflow */
275
         bfd_elf_generic_reloc, /* */
276
         "R_MN10300_GOTPC16",   /* name */
277
         FALSE,                 /* partial_inplace */
278
         0xffff,                /* src_mask */
279
         0xffff,                /* dst_mask */
280
         TRUE),                 /* pcrel_offset */
281
 
282
  HOWTO (R_MN10300_GOTOFF32,    /* type */
283
         0,                      /* rightshift */
284
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
285
         32,                    /* bitsize */
286
         FALSE,                 /* pc_relative */
287
         0,                      /* bitpos */
288
         complain_overflow_bitfield, /* complain_on_overflow */
289
         bfd_elf_generic_reloc, /* */
290
         "R_MN10300_GOTOFF32",  /* name */
291
         FALSE,                 /* partial_inplace */
292
         0xffffffff,            /* src_mask */
293
         0xffffffff,            /* dst_mask */
294
         FALSE),                /* pcrel_offset */
295
 
296
  HOWTO (R_MN10300_GOTOFF24,    /* type */
297
         0,                      /* rightshift */
298
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
299
         24,                    /* bitsize */
300
         FALSE,                 /* pc_relative */
301
         0,                      /* bitpos */
302
         complain_overflow_bitfield, /* complain_on_overflow */
303
         bfd_elf_generic_reloc, /* */
304
         "R_MN10300_GOTOFF24",  /* name */
305
         FALSE,                 /* partial_inplace */
306
         0xffffff,              /* src_mask */
307
         0xffffff,              /* dst_mask */
308
         FALSE),                /* pcrel_offset */
309
 
310
  HOWTO (R_MN10300_GOTOFF16,    /* type */
311
         0,                      /* rightshift */
312
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
313
         16,                    /* bitsize */
314
         FALSE,                 /* pc_relative */
315
         0,                      /* bitpos */
316
         complain_overflow_bitfield, /* complain_on_overflow */
317
         bfd_elf_generic_reloc, /* */
318
         "R_MN10300_GOTOFF16",  /* name */
319
         FALSE,                 /* partial_inplace */
320
         0xffff,                /* src_mask */
321
         0xffff,                /* dst_mask */
322
         FALSE),                /* pcrel_offset */
323
 
324
  HOWTO (R_MN10300_PLT32,       /* type */
325
         0,                      /* rightshift */
326
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
327
         32,                    /* bitsize */
328
         TRUE,                  /* pc_relative */
329
         0,                      /* bitpos */
330
         complain_overflow_bitfield, /* complain_on_overflow */
331
         bfd_elf_generic_reloc, /* */
332
         "R_MN10300_PLT32",     /* name */
333
         FALSE,                 /* partial_inplace */
334
         0xffffffff,            /* src_mask */
335
         0xffffffff,            /* dst_mask */
336
         TRUE),                 /* pcrel_offset */
337
 
338
  HOWTO (R_MN10300_PLT16,       /* type */
339
         0,                      /* rightshift */
340
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
341
         16,                    /* bitsize */
342
         TRUE,                  /* pc_relative */
343
         0,                      /* bitpos */
344
         complain_overflow_bitfield, /* complain_on_overflow */
345
         bfd_elf_generic_reloc, /* */
346
         "R_MN10300_PLT16",     /* name */
347
         FALSE,                 /* partial_inplace */
348
         0xffff,                /* src_mask */
349
         0xffff,                /* dst_mask */
350
         TRUE),                 /* pcrel_offset */
351
 
352
  HOWTO (R_MN10300_GOT32,       /* type */
353
         0,                      /* rightshift */
354
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
355
         32,                    /* bitsize */
356
         FALSE,                 /* pc_relative */
357
         0,                      /* bitpos */
358
         complain_overflow_bitfield, /* complain_on_overflow */
359
         bfd_elf_generic_reloc, /* */
360
         "R_MN10300_GOT32",     /* name */
361
         FALSE,                 /* partial_inplace */
362
         0xffffffff,            /* src_mask */
363
         0xffffffff,            /* dst_mask */
364
         FALSE),                /* pcrel_offset */
365
 
366
  HOWTO (R_MN10300_GOT24,       /* type */
367
         0,                      /* rightshift */
368
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
369
         24,                    /* bitsize */
370
         FALSE,                 /* pc_relative */
371
         0,                      /* bitpos */
372
         complain_overflow_bitfield, /* complain_on_overflow */
373
         bfd_elf_generic_reloc, /* */
374
         "R_MN10300_GOT24",     /* name */
375
         FALSE,                 /* partial_inplace */
376
         0xffffffff,            /* src_mask */
377
         0xffffffff,            /* dst_mask */
378
         FALSE),                /* pcrel_offset */
379
 
380
  HOWTO (R_MN10300_GOT16,       /* type */
381
         0,                      /* rightshift */
382
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
383
         16,                    /* bitsize */
384
         FALSE,                 /* pc_relative */
385
         0,                      /* bitpos */
386
         complain_overflow_bitfield, /* complain_on_overflow */
387
         bfd_elf_generic_reloc, /* */
388
         "R_MN10300_GOT16",     /* name */
389
         FALSE,                 /* partial_inplace */
390
         0xffffffff,            /* src_mask */
391
         0xffffffff,            /* dst_mask */
392
         FALSE),                /* pcrel_offset */
393
 
394
  HOWTO (R_MN10300_COPY,        /* type */
395
         0,                      /* rightshift */
396
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
397
         32,                    /* bitsize */
398
         FALSE,                 /* pc_relative */
399
         0,                      /* bitpos */
400
         complain_overflow_bitfield, /* complain_on_overflow */
401
         bfd_elf_generic_reloc, /* */
402
         "R_MN10300_COPY",              /* name */
403
         FALSE,                 /* partial_inplace */
404
         0xffffffff,            /* src_mask */
405
         0xffffffff,            /* dst_mask */
406
         FALSE),                /* pcrel_offset */
407
 
408
  HOWTO (R_MN10300_GLOB_DAT,    /* type */
409
         0,                      /* rightshift */
410
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
411
         32,                    /* bitsize */
412
         FALSE,                 /* pc_relative */
413
         0,                      /* bitpos */
414
         complain_overflow_bitfield, /* complain_on_overflow */
415
         bfd_elf_generic_reloc, /* */
416
         "R_MN10300_GLOB_DAT",  /* name */
417
         FALSE,                 /* partial_inplace */
418
         0xffffffff,            /* src_mask */
419
         0xffffffff,            /* dst_mask */
420
         FALSE),                /* pcrel_offset */
421
 
422
  HOWTO (R_MN10300_JMP_SLOT,    /* type */
423
         0,                      /* rightshift */
424
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
425
         32,                    /* bitsize */
426
         FALSE,                 /* pc_relative */
427
         0,                      /* bitpos */
428
         complain_overflow_bitfield, /* complain_on_overflow */
429
         bfd_elf_generic_reloc, /* */
430
         "R_MN10300_JMP_SLOT",  /* name */
431
         FALSE,                 /* partial_inplace */
432
         0xffffffff,            /* src_mask */
433
         0xffffffff,            /* dst_mask */
434
         FALSE),                /* pcrel_offset */
435
 
436
  HOWTO (R_MN10300_RELATIVE,    /* type */
437
         0,                      /* rightshift */
438
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
439
         32,                    /* bitsize */
440
         FALSE,                 /* pc_relative */
441
         0,                      /* bitpos */
442
         complain_overflow_bitfield, /* complain_on_overflow */
443
         bfd_elf_generic_reloc, /* */
444
         "R_MN10300_RELATIVE",  /* name */
445
         FALSE,                 /* partial_inplace */
446
         0xffffffff,            /* src_mask */
447
         0xffffffff,            /* dst_mask */
448
         FALSE),                /* pcrel_offset */
449
 
450
  EMPTY_HOWTO (24),
451
  EMPTY_HOWTO (25),
452
  EMPTY_HOWTO (26),
453
  EMPTY_HOWTO (27),
454
  EMPTY_HOWTO (28),
455
  EMPTY_HOWTO (29),
456
  EMPTY_HOWTO (30),
457
  EMPTY_HOWTO (31),
458
  EMPTY_HOWTO (32),
459
 
460
  HOWTO (R_MN10300_SYM_DIFF,    /* type */
461
         0,                      /* rightshift */
462
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
463
         32,                    /* bitsize */
464
         FALSE,                 /* pc_relative */
465
         0,                      /* bitpos */
466
         complain_overflow_dont,/* complain_on_overflow */
467
         NULL,                  /* special handler.  */
468
         "R_MN10300_SYM_DIFF",  /* name */
469
         FALSE,                 /* partial_inplace */
470
         0xffffffff,            /* src_mask */
471
         0xffffffff,            /* dst_mask */
472
         FALSE),                /* pcrel_offset */
473
 
474
  HOWTO (R_MN10300_ALIGN,       /* type */
475
         0,                      /* rightshift */
476
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
477
         32,                    /* bitsize */
478
         FALSE,                 /* pc_relative */
479
         0,                      /* bitpos */
480
         complain_overflow_dont,/* complain_on_overflow */
481
         NULL,                  /* special handler.  */
482
         "R_MN10300_ALIGN",     /* name */
483
         FALSE,                 /* partial_inplace */
484
         0,                      /* src_mask */
485
         0,                      /* dst_mask */
486
         FALSE)                 /* pcrel_offset */
487
};
488
 
489
struct mn10300_reloc_map
490
{
491
  bfd_reloc_code_real_type bfd_reloc_val;
492
  unsigned char elf_reloc_val;
493
};
494
 
495
static const struct mn10300_reloc_map mn10300_reloc_map[] =
496
{
497
  { BFD_RELOC_NONE, R_MN10300_NONE, },
498
  { BFD_RELOC_32, R_MN10300_32, },
499
  { BFD_RELOC_16, R_MN10300_16, },
500
  { BFD_RELOC_8, R_MN10300_8, },
501
  { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
502
  { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
503
  { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
504
  { BFD_RELOC_24, R_MN10300_24, },
505
  { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
506
  { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
507
  { BFD_RELOC_32_GOT_PCREL, R_MN10300_GOTPC32 },
508
  { BFD_RELOC_16_GOT_PCREL, R_MN10300_GOTPC16 },
509
  { BFD_RELOC_32_GOTOFF, R_MN10300_GOTOFF32 },
510
  { BFD_RELOC_MN10300_GOTOFF24, R_MN10300_GOTOFF24 },
511
  { BFD_RELOC_16_GOTOFF, R_MN10300_GOTOFF16 },
512
  { BFD_RELOC_32_PLT_PCREL, R_MN10300_PLT32 },
513
  { BFD_RELOC_16_PLT_PCREL, R_MN10300_PLT16 },
514
  { BFD_RELOC_MN10300_GOT32, R_MN10300_GOT32 },
515
  { BFD_RELOC_MN10300_GOT24, R_MN10300_GOT24 },
516
  { BFD_RELOC_MN10300_GOT16, R_MN10300_GOT16 },
517
  { BFD_RELOC_MN10300_COPY, R_MN10300_COPY },
518
  { BFD_RELOC_MN10300_GLOB_DAT, R_MN10300_GLOB_DAT },
519
  { BFD_RELOC_MN10300_JMP_SLOT, R_MN10300_JMP_SLOT },
520
  { BFD_RELOC_MN10300_RELATIVE, R_MN10300_RELATIVE },
521
  { BFD_RELOC_MN10300_SYM_DIFF, R_MN10300_SYM_DIFF },
522
  { BFD_RELOC_MN10300_ALIGN, R_MN10300_ALIGN }
523
};
524
 
525
/* Create the GOT section.  */
526
 
527
static bfd_boolean
528
_bfd_mn10300_elf_create_got_section (bfd * abfd,
529
                                     struct bfd_link_info * info)
530
{
531
  flagword   flags;
532
  flagword   pltflags;
533
  asection * s;
534
  struct elf_link_hash_entry * h;
535
  const struct elf_backend_data * bed = get_elf_backend_data (abfd);
536
  int ptralign;
537
 
538
  /* This function may be called more than once.  */
539
  if (bfd_get_section_by_name (abfd, ".got") != NULL)
540
    return TRUE;
541
 
542
  switch (bed->s->arch_size)
543
    {
544
    case 32:
545
      ptralign = 2;
546
      break;
547
 
548
    case 64:
549
      ptralign = 3;
550
      break;
551
 
552
    default:
553
      bfd_set_error (bfd_error_bad_value);
554
      return FALSE;
555
    }
556
 
557
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
558
           | SEC_LINKER_CREATED);
559
 
560
  pltflags = flags;
561
  pltflags |= SEC_CODE;
562
  if (bed->plt_not_loaded)
563
    pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
564
  if (bed->plt_readonly)
565
    pltflags |= SEC_READONLY;
566
 
567
  s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
568
  if (s == NULL
569
      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
570
    return FALSE;
571
 
572
  /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
573
     .plt section.  */
574
  if (bed->want_plt_sym)
575
    {
576
      h = _bfd_elf_define_linkage_sym (abfd, info, s,
577
                                       "_PROCEDURE_LINKAGE_TABLE_");
578
      elf_hash_table (info)->hplt = h;
579
      if (h == NULL)
580
        return FALSE;
581
    }
582
 
583
  s = bfd_make_section_with_flags (abfd, ".got", flags);
584
  if (s == NULL
585
      || ! bfd_set_section_alignment (abfd, s, ptralign))
586
    return FALSE;
587
 
588
  if (bed->want_got_plt)
589
    {
590
      s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
591
      if (s == NULL
592
          || ! bfd_set_section_alignment (abfd, s, ptralign))
593
        return FALSE;
594
    }
595
 
596
  /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
597
     (or .got.plt) section.  We don't do this in the linker script
598
     because we don't want to define the symbol if we are not creating
599
     a global offset table.  */
600
  h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
601
  elf_hash_table (info)->hgot = h;
602
  if (h == NULL)
603
    return FALSE;
604
 
605
  /* The first bit of the global offset table is the header.  */
606
  s->size += bed->got_header_size;
607
 
608
  return TRUE;
609
}
610
 
611
static reloc_howto_type *
612
bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
613
                                 bfd_reloc_code_real_type code)
614
{
615
  unsigned int i;
616
 
617
  for (i = ARRAY_SIZE (mn10300_reloc_map); i--;)
618
    if (mn10300_reloc_map[i].bfd_reloc_val == code)
619
      return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
620
 
621
  return NULL;
622
}
623
 
624
static reloc_howto_type *
625
bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
626
                                 const char *r_name)
627
{
628
  unsigned int i;
629
 
630
  for (i = ARRAY_SIZE (elf_mn10300_howto_table); i--;)
631
    if (elf_mn10300_howto_table[i].name != NULL
632
        && strcasecmp (elf_mn10300_howto_table[i].name, r_name) == 0)
633
      return elf_mn10300_howto_table + i;
634
 
635
  return NULL;
636
}
637
 
638
/* Set the howto pointer for an MN10300 ELF reloc.  */
639
 
640
static void
641
mn10300_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
642
                       arelent *cache_ptr,
643
                       Elf_Internal_Rela *dst)
644
{
645
  unsigned int r_type;
646
 
647
  r_type = ELF32_R_TYPE (dst->r_info);
648
  BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
649
  cache_ptr->howto = elf_mn10300_howto_table + r_type;
650
}
651
 
652
/* Look through the relocs for a section during the first phase.
653
   Since we don't do .gots or .plts, we just need to consider the
654
   virtual table relocs for gc.  */
655
 
656
static bfd_boolean
657
mn10300_elf_check_relocs (bfd *abfd,
658
                          struct bfd_link_info *info,
659
                          asection *sec,
660
                          const Elf_Internal_Rela *relocs)
661
{
662
  bfd_boolean sym_diff_reloc_seen;
663
  Elf_Internal_Shdr *symtab_hdr;
664
  Elf_Internal_Sym * isymbuf = NULL;
665
  struct elf_link_hash_entry **sym_hashes;
666
  const Elf_Internal_Rela *rel;
667
  const Elf_Internal_Rela *rel_end;
668
  bfd *      dynobj;
669
  bfd_vma *  local_got_offsets;
670
  asection * sgot;
671
  asection * srelgot;
672
  asection * sreloc;
673
  bfd_boolean result = FALSE;
674
 
675
  sgot    = NULL;
676
  srelgot = NULL;
677
  sreloc  = NULL;
678
 
679
  if (info->relocatable)
680
    return TRUE;
681
 
682
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
683
  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
684
  sym_hashes = elf_sym_hashes (abfd);
685
 
686
  dynobj = elf_hash_table (info)->dynobj;
687
  local_got_offsets = elf_local_got_offsets (abfd);
688
  rel_end = relocs + sec->reloc_count;
689
  sym_diff_reloc_seen = FALSE;
690
 
691
  for (rel = relocs; rel < rel_end; rel++)
692
    {
693
      struct elf_link_hash_entry *h;
694
      unsigned long r_symndx;
695
      unsigned int r_type;
696
 
697
      r_symndx = ELF32_R_SYM (rel->r_info);
698
      if (r_symndx < symtab_hdr->sh_info)
699
        h = NULL;
700
      else
701
        {
702
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
703
          while (h->root.type == bfd_link_hash_indirect
704
                 || h->root.type == bfd_link_hash_warning)
705
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
706
        }
707
 
708
      r_type = ELF32_R_TYPE (rel->r_info);
709
 
710
      /* Some relocs require a global offset table.  */
711
      if (dynobj == NULL)
712
        {
713
          switch (r_type)
714
            {
715
            case R_MN10300_GOT32:
716
            case R_MN10300_GOT24:
717
            case R_MN10300_GOT16:
718
            case R_MN10300_GOTOFF32:
719
            case R_MN10300_GOTOFF24:
720
            case R_MN10300_GOTOFF16:
721
            case R_MN10300_GOTPC32:
722
            case R_MN10300_GOTPC16:
723
              elf_hash_table (info)->dynobj = dynobj = abfd;
724
              if (! _bfd_mn10300_elf_create_got_section (dynobj, info))
725
                goto fail;
726
              break;
727
 
728
            default:
729
              break;
730
            }
731
        }
732
 
733
      switch (r_type)
734
        {
735
        /* This relocation describes the C++ object vtable hierarchy.
736
           Reconstruct it for later use during GC.  */
737
        case R_MN10300_GNU_VTINHERIT:
738
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
739
            goto fail;
740
          break;
741
 
742
        /* This relocation describes which C++ vtable entries are actually
743
           used.  Record for later use during GC.  */
744
        case R_MN10300_GNU_VTENTRY:
745
          BFD_ASSERT (h != NULL);
746
          if (h != NULL
747
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
748
            goto fail;
749
          break;
750
 
751
        case R_MN10300_GOT32:
752
        case R_MN10300_GOT24:
753
        case R_MN10300_GOT16:
754
          /* This symbol requires a global offset table entry.  */
755
 
756
          if (sgot == NULL)
757
            {
758
              sgot = bfd_get_section_by_name (dynobj, ".got");
759
              BFD_ASSERT (sgot != NULL);
760
            }
761
 
762
          if (srelgot == NULL
763
              && (h != NULL || info->shared))
764
            {
765
              srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
766
              if (srelgot == NULL)
767
                {
768
                  srelgot = bfd_make_section_with_flags (dynobj,
769
                                                         ".rela.got",
770
                                                         (SEC_ALLOC
771
                                                          | SEC_LOAD
772
                                                          | SEC_HAS_CONTENTS
773
                                                          | SEC_IN_MEMORY
774
                                                          | SEC_LINKER_CREATED
775
                                                          | SEC_READONLY));
776
                  if (srelgot == NULL
777
                      || ! bfd_set_section_alignment (dynobj, srelgot, 2))
778
                    goto fail;
779
                }
780
            }
781
 
782
          if (h != NULL)
783
            {
784
              if (h->got.offset != (bfd_vma) -1)
785
                /* We have already allocated space in the .got.  */
786
                break;
787
 
788
              h->got.offset = sgot->size;
789
 
790
              /* Make sure this symbol is output as a dynamic symbol.  */
791
              if (h->dynindx == -1)
792
                {
793
                  if (! bfd_elf_link_record_dynamic_symbol (info, h))
794
                    goto fail;
795
                }
796
 
797
              srelgot->size += sizeof (Elf32_External_Rela);
798
            }
799
          else
800
            {
801
              /* This is a global offset table entry for a local
802
                 symbol.  */
803
              if (local_got_offsets == NULL)
804
                {
805
                  size_t       size;
806
                  unsigned int i;
807
 
808
                  size = symtab_hdr->sh_info * sizeof (bfd_vma);
809
                  local_got_offsets = bfd_alloc (abfd, size);
810
 
811
                  if (local_got_offsets == NULL)
812
                    goto fail;
813
 
814
                  elf_local_got_offsets (abfd) = local_got_offsets;
815
 
816
                  for (i = 0; i < symtab_hdr->sh_info; i++)
817
                    local_got_offsets[i] = (bfd_vma) -1;
818
                }
819
 
820
              if (local_got_offsets[r_symndx] != (bfd_vma) -1)
821
                /* We have already allocated space in the .got.  */
822
                break;
823
 
824
              local_got_offsets[r_symndx] = sgot->size;
825
 
826
              if (info->shared)
827
                /* If we are generating a shared object, we need to
828
                   output a R_MN10300_RELATIVE reloc so that the dynamic
829
                   linker can adjust this GOT entry.  */
830
                srelgot->size += sizeof (Elf32_External_Rela);
831
            }
832
 
833
          sgot->size += 4;
834
          break;
835
 
836
        case R_MN10300_PLT32:
837
        case R_MN10300_PLT16:
838
          /* This symbol requires a procedure linkage table entry.  We
839
             actually build the entry in adjust_dynamic_symbol,
840
             because this might be a case of linking PIC code which is
841
             never referenced by a dynamic object, in which case we
842
             don't need to generate a procedure linkage table entry
843
             after all.  */
844
 
845
          /* If this is a local symbol, we resolve it directly without
846
             creating a procedure linkage table entry.  */
847
          if (h == NULL)
848
            continue;
849
 
850
          if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
851
              || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
852
            break;
853
 
854
          h->needs_plt = 1;
855
          break;
856
 
857
        case R_MN10300_24:
858
        case R_MN10300_16:
859
        case R_MN10300_8:
860
        case R_MN10300_PCREL32:
861
        case R_MN10300_PCREL16:
862
        case R_MN10300_PCREL8:
863
          if (h != NULL)
864
            h->non_got_ref = 1;
865
          break;
866
 
867
        case R_MN10300_SYM_DIFF:
868
          sym_diff_reloc_seen = TRUE;
869
          break;
870
 
871
        case R_MN10300_32:
872
          if (h != NULL)
873
            h->non_got_ref = 1;
874
 
875
          /* If we are creating a shared library, then we
876
             need to copy the reloc into the shared library.  */
877
          if (info->shared
878
              && (sec->flags & SEC_ALLOC) != 0
879
              /* Do not generate a dynamic reloc for a
880
                 reloc associated with a SYM_DIFF operation.  */
881
              && ! sym_diff_reloc_seen)
882
            {
883
              asection * sym_section = NULL;
884
 
885
              /* Find the section containing the
886
                 symbol involved in the relocation.  */
887
              if (h == NULL)
888
                {
889
                  Elf_Internal_Sym * isym;
890
 
891
                  if (isymbuf == NULL)
892
                    isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
893
                                                    symtab_hdr->sh_info, 0,
894
                                                    NULL, NULL, NULL);
895
                  if (isymbuf)
896
                    {
897
                      isym = isymbuf + r_symndx;
898
                      /* All we care about is whether this local symbol is absolute.  */
899
                      if (isym->st_shndx == SHN_ABS)
900
                        sym_section = bfd_abs_section_ptr;
901
                    }
902
                }
903
              else
904
                {
905
                  if (h->root.type == bfd_link_hash_defined
906
                      || h->root.type == bfd_link_hash_defweak)
907
                    sym_section = h->root.u.def.section;
908
                }
909
 
910
              /* If the symbol is absolute then the relocation can
911
                 be resolved during linking and there is no need for
912
                 a dynamic reloc.  */
913
              if (sym_section != bfd_abs_section_ptr)
914
                {
915
                  /* When creating a shared object, we must copy these
916
                     reloc types into the output file.  We create a reloc
917
                     section in dynobj and make room for this reloc.  */
918
                  if (sreloc == NULL)
919
                    {
920 225 jeremybenn
                      sreloc = _bfd_elf_make_dynamic_reloc_section
921
                        (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
922
                      if (sreloc == NULL)
923 24 jeremybenn
                        goto fail;
924
                    }
925
 
926
                  sreloc->size += sizeof (Elf32_External_Rela);
927
                }
928
            }
929
 
930
          break;
931
        }
932
 
933
      if (ELF32_R_TYPE (rel->r_info) != R_MN10300_SYM_DIFF)
934
        sym_diff_reloc_seen = FALSE;
935
    }
936
 
937
  result = TRUE;
938
 fail:
939
  if (isymbuf != NULL)
940
    free (isymbuf);
941
 
942
  return result;
943
}
944
 
945
/* Return the section that should be marked against GC for a given
946
   relocation.  */
947
 
948
static asection *
949
mn10300_elf_gc_mark_hook (asection *sec,
950
                          struct bfd_link_info *info,
951
                          Elf_Internal_Rela *rel,
952
                          struct elf_link_hash_entry *h,
953
                          Elf_Internal_Sym *sym)
954
{
955
  if (h != NULL)
956
    switch (ELF32_R_TYPE (rel->r_info))
957
      {
958
      case R_MN10300_GNU_VTINHERIT:
959
      case R_MN10300_GNU_VTENTRY:
960
        return NULL;
961
      }
962
 
963
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
964
}
965
 
966
/* Perform a relocation as part of a final link.  */
967
 
968
static bfd_reloc_status_type
969
mn10300_elf_final_link_relocate (reloc_howto_type *howto,
970
                                 bfd *input_bfd,
971
                                 bfd *output_bfd ATTRIBUTE_UNUSED,
972
                                 asection *input_section,
973
                                 bfd_byte *contents,
974
                                 bfd_vma offset,
975
                                 bfd_vma value,
976
                                 bfd_vma addend,
977
                                 struct elf_link_hash_entry * h,
978
                                 unsigned long symndx,
979
                                 struct bfd_link_info *info,
980
                                 asection *sym_sec ATTRIBUTE_UNUSED,
981
                                 int is_local ATTRIBUTE_UNUSED)
982
{
983
  static asection *  sym_diff_section;
984
  static bfd_vma     sym_diff_value;
985
  bfd_boolean is_sym_diff_reloc;
986
  unsigned long r_type = howto->type;
987
  bfd_byte * hit_data = contents + offset;
988
  bfd *      dynobj;
989
  bfd_vma *  local_got_offsets;
990
  asection * sgot;
991
  asection * splt;
992
  asection * sreloc;
993
 
994
  dynobj = elf_hash_table (info)->dynobj;
995
  local_got_offsets = elf_local_got_offsets (input_bfd);
996
 
997
  sgot   = NULL;
998
  splt   = NULL;
999
  sreloc = NULL;
1000
 
1001
  switch (r_type)
1002
    {
1003
    case R_MN10300_24:
1004
    case R_MN10300_16:
1005
    case R_MN10300_8:
1006
    case R_MN10300_PCREL8:
1007
    case R_MN10300_PCREL16:
1008
    case R_MN10300_PCREL32:
1009
    case R_MN10300_GOTOFF32:
1010
    case R_MN10300_GOTOFF24:
1011
    case R_MN10300_GOTOFF16:
1012
      if (info->shared
1013
          && (input_section->flags & SEC_ALLOC) != 0
1014
          && h != NULL
1015
          && ! SYMBOL_REFERENCES_LOCAL (info, h))
1016
        return bfd_reloc_dangerous;
1017
    }
1018
 
1019
  is_sym_diff_reloc = FALSE;
1020
  if (sym_diff_section != NULL)
1021
    {
1022
      BFD_ASSERT (sym_diff_section == input_section);
1023
 
1024
      switch (r_type)
1025
        {
1026
        case R_MN10300_32:
1027
        case R_MN10300_24:
1028
        case R_MN10300_16:
1029
        case R_MN10300_8:
1030
          value -= sym_diff_value;
1031
          /* If we are computing a 32-bit value for the location lists
1032
             and the result is 0 then we add one to the value.  A zero
1033
             value can result because of linker relaxation deleteing
1034
             prologue instructions and using a value of 1 (for the begin
1035
             and end offsets in the location list entry) results in a
1036
             nul entry which does not prevent the following entries from
1037
             being parsed.  */
1038
          if (r_type == R_MN10300_32
1039
              && value == 0
1040
              && strcmp (input_section->name, ".debug_loc") == 0)
1041
            value = 1;
1042
          sym_diff_section = NULL;
1043
          is_sym_diff_reloc = TRUE;
1044
          break;
1045
 
1046
        default:
1047
          sym_diff_section = NULL;
1048
          break;
1049
        }
1050
    }
1051
 
1052
  switch (r_type)
1053
    {
1054
    case R_MN10300_SYM_DIFF:
1055
      BFD_ASSERT (addend == 0);
1056
      /* Cache the input section and value.
1057
         The offset is unreliable, since relaxation may
1058
         have reduced the following reloc's offset.  */
1059
      sym_diff_section = input_section;
1060
      sym_diff_value = value;
1061
      return bfd_reloc_ok;
1062
 
1063
    case R_MN10300_ALIGN:
1064
    case R_MN10300_NONE:
1065
      return bfd_reloc_ok;
1066
 
1067
    case R_MN10300_32:
1068
      if (info->shared
1069
          /* Do not generate relocs when an R_MN10300_32 has been used
1070
             with an R_MN10300_SYM_DIFF to compute a difference of two
1071
             symbols.  */
1072
          && is_sym_diff_reloc == FALSE
1073
          /* Also, do not generate a reloc when the symbol associated
1074
             with the R_MN10300_32 reloc is absolute - there is no
1075
             need for a run time computation in this case.  */
1076
          && sym_sec != bfd_abs_section_ptr
1077
          /* If the section is not going to be allocated at load time
1078
             then there is no need to generate relocs for it.  */
1079
          && (input_section->flags & SEC_ALLOC) != 0)
1080
        {
1081
          Elf_Internal_Rela outrel;
1082
          bfd_boolean skip, relocate;
1083
 
1084
          /* When generating a shared object, these relocations are
1085
             copied into the output file to be resolved at run
1086
             time.  */
1087
          if (sreloc == NULL)
1088
            {
1089 225 jeremybenn
              sreloc = _bfd_elf_get_dynamic_reloc_section
1090
                (input_bfd, input_section, /*rela?*/ TRUE);
1091
              if (sreloc == NULL)
1092 24 jeremybenn
                return FALSE;
1093
            }
1094
 
1095
          skip = FALSE;
1096
 
1097
          outrel.r_offset = _bfd_elf_section_offset (input_bfd, info,
1098
                                                     input_section, offset);
1099
          if (outrel.r_offset == (bfd_vma) -1)
1100
            skip = TRUE;
1101
 
1102
          outrel.r_offset += (input_section->output_section->vma
1103
                              + input_section->output_offset);
1104
 
1105
          if (skip)
1106
            {
1107
              memset (&outrel, 0, sizeof outrel);
1108
              relocate = FALSE;
1109
            }
1110
          else
1111
            {
1112
              /* h->dynindx may be -1 if this symbol was marked to
1113
                 become local.  */
1114
              if (h == NULL
1115
                  || SYMBOL_REFERENCES_LOCAL (info, h))
1116
                {
1117
                  relocate = TRUE;
1118
                  outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1119
                  outrel.r_addend = value + addend;
1120
                }
1121
              else
1122
                {
1123
                  BFD_ASSERT (h->dynindx != -1);
1124
                  relocate = FALSE;
1125
                  outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_32);
1126
                  outrel.r_addend = value + addend;
1127
                }
1128
            }
1129
 
1130
          bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1131
                                     (bfd_byte *) (((Elf32_External_Rela *) sreloc->contents)
1132
                                                   + sreloc->reloc_count));
1133
          ++sreloc->reloc_count;
1134
 
1135
          /* If this reloc is against an external symbol, we do
1136
             not want to fiddle with the addend.  Otherwise, we
1137
             need to include the symbol value so that it becomes
1138
             an addend for the dynamic reloc.  */
1139
          if (! relocate)
1140
            return bfd_reloc_ok;
1141
        }
1142
      value += addend;
1143
      bfd_put_32 (input_bfd, value, hit_data);
1144
      return bfd_reloc_ok;
1145
 
1146
    case R_MN10300_24:
1147
      value += addend;
1148
 
1149
      if ((long) value > 0x7fffff || (long) value < -0x800000)
1150
        return bfd_reloc_overflow;
1151
 
1152
      bfd_put_8 (input_bfd, value & 0xff, hit_data);
1153
      bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1154
      bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1155
      return bfd_reloc_ok;
1156
 
1157
    case R_MN10300_16:
1158
      value += addend;
1159
 
1160
      if ((long) value > 0x7fff || (long) value < -0x8000)
1161
        return bfd_reloc_overflow;
1162
 
1163
      bfd_put_16 (input_bfd, value, hit_data);
1164
      return bfd_reloc_ok;
1165
 
1166
    case R_MN10300_8:
1167
      value += addend;
1168
 
1169
      if ((long) value > 0x7f || (long) value < -0x80)
1170
        return bfd_reloc_overflow;
1171
 
1172
      bfd_put_8 (input_bfd, value, hit_data);
1173
      return bfd_reloc_ok;
1174
 
1175
    case R_MN10300_PCREL8:
1176
      value -= (input_section->output_section->vma
1177
                + input_section->output_offset);
1178
      value -= offset;
1179
      value += addend;
1180
 
1181 225 jeremybenn
      if ((long) value > 0x7f || (long) value < -0x80)
1182 24 jeremybenn
        return bfd_reloc_overflow;
1183
 
1184
      bfd_put_8 (input_bfd, value, hit_data);
1185
      return bfd_reloc_ok;
1186
 
1187
    case R_MN10300_PCREL16:
1188
      value -= (input_section->output_section->vma
1189
                + input_section->output_offset);
1190
      value -= offset;
1191
      value += addend;
1192
 
1193 225 jeremybenn
      if ((long) value > 0x7fff || (long) value < -0x8000)
1194 24 jeremybenn
        return bfd_reloc_overflow;
1195
 
1196
      bfd_put_16 (input_bfd, value, hit_data);
1197
      return bfd_reloc_ok;
1198
 
1199
    case R_MN10300_PCREL32:
1200
      value -= (input_section->output_section->vma
1201
                + input_section->output_offset);
1202
      value -= offset;
1203
      value += addend;
1204
 
1205
      bfd_put_32 (input_bfd, value, hit_data);
1206
      return bfd_reloc_ok;
1207
 
1208
    case R_MN10300_GNU_VTINHERIT:
1209
    case R_MN10300_GNU_VTENTRY:
1210
      return bfd_reloc_ok;
1211
 
1212
    case R_MN10300_GOTPC32:
1213
      /* Use global offset table as symbol value.  */
1214
      value = bfd_get_section_by_name (dynobj,
1215
                                       ".got")->output_section->vma;
1216
      value -= (input_section->output_section->vma
1217
                + input_section->output_offset);
1218
      value -= offset;
1219
      value += addend;
1220
 
1221
      bfd_put_32 (input_bfd, value, hit_data);
1222
      return bfd_reloc_ok;
1223
 
1224
    case R_MN10300_GOTPC16:
1225
      /* Use global offset table as symbol value.  */
1226
      value = bfd_get_section_by_name (dynobj,
1227
                                       ".got")->output_section->vma;
1228
      value -= (input_section->output_section->vma
1229
                + input_section->output_offset);
1230
      value -= offset;
1231
      value += addend;
1232
 
1233 225 jeremybenn
      if ((long) value > 0x7fff || (long) value < -0x8000)
1234 24 jeremybenn
        return bfd_reloc_overflow;
1235
 
1236
      bfd_put_16 (input_bfd, value, hit_data);
1237
      return bfd_reloc_ok;
1238
 
1239
    case R_MN10300_GOTOFF32:
1240
      value -= bfd_get_section_by_name (dynobj,
1241
                                        ".got")->output_section->vma;
1242
      value += addend;
1243
 
1244
      bfd_put_32 (input_bfd, value, hit_data);
1245
      return bfd_reloc_ok;
1246
 
1247
    case R_MN10300_GOTOFF24:
1248
      value -= bfd_get_section_by_name (dynobj,
1249
                                        ".got")->output_section->vma;
1250
      value += addend;
1251
 
1252
      if ((long) value > 0x7fffff || (long) value < -0x800000)
1253
        return bfd_reloc_overflow;
1254
 
1255
      bfd_put_8 (input_bfd, value, hit_data);
1256
      bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1257
      bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1258
      return bfd_reloc_ok;
1259
 
1260
    case R_MN10300_GOTOFF16:
1261
      value -= bfd_get_section_by_name (dynobj,
1262
                                        ".got")->output_section->vma;
1263
      value += addend;
1264
 
1265 225 jeremybenn
      if ((long) value > 0x7fff || (long) value < -0x8000)
1266 24 jeremybenn
        return bfd_reloc_overflow;
1267
 
1268
      bfd_put_16 (input_bfd, value, hit_data);
1269
      return bfd_reloc_ok;
1270
 
1271
    case R_MN10300_PLT32:
1272
      if (h != NULL
1273
          && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1274
          && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1275
          && h->plt.offset != (bfd_vma) -1)
1276
        {
1277
          asection * splt;
1278
 
1279
          splt = bfd_get_section_by_name (dynobj, ".plt");
1280
 
1281
          value = (splt->output_section->vma
1282
                   + splt->output_offset
1283
                   + h->plt.offset) - value;
1284
        }
1285
 
1286
      value -= (input_section->output_section->vma
1287
                + input_section->output_offset);
1288
      value -= offset;
1289
      value += addend;
1290
 
1291
      bfd_put_32 (input_bfd, value, hit_data);
1292
      return bfd_reloc_ok;
1293
 
1294
    case R_MN10300_PLT16:
1295
      if (h != NULL
1296
          && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1297
          && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1298
          && h->plt.offset != (bfd_vma) -1)
1299
        {
1300
          asection * splt;
1301
 
1302
          splt = bfd_get_section_by_name (dynobj, ".plt");
1303
 
1304
          value = (splt->output_section->vma
1305
                   + splt->output_offset
1306
                   + h->plt.offset) - value;
1307
        }
1308
 
1309
      value -= (input_section->output_section->vma
1310
                + input_section->output_offset);
1311
      value -= offset;
1312
      value += addend;
1313
 
1314 225 jeremybenn
      if ((long) value > 0x7fff || (long) value < -0x8000)
1315 24 jeremybenn
        return bfd_reloc_overflow;
1316
 
1317
      bfd_put_16 (input_bfd, value, hit_data);
1318
      return bfd_reloc_ok;
1319
 
1320
    case R_MN10300_GOT32:
1321
    case R_MN10300_GOT24:
1322
    case R_MN10300_GOT16:
1323
      {
1324
        asection * sgot;
1325
 
1326
        sgot = bfd_get_section_by_name (dynobj, ".got");
1327
 
1328
          if (h != NULL)
1329
            {
1330
              bfd_vma off;
1331
 
1332
              off = h->got.offset;
1333
              BFD_ASSERT (off != (bfd_vma) -1);
1334
 
1335
              if (! elf_hash_table (info)->dynamic_sections_created
1336
                  || SYMBOL_REFERENCES_LOCAL (info, h))
1337
                /* This is actually a static link, or it is a
1338
                   -Bsymbolic link and the symbol is defined
1339
                   locally, or the symbol was forced to be local
1340
                   because of a version file.  We must initialize
1341
                   this entry in the global offset table.
1342
 
1343
                   When doing a dynamic link, we create a .rela.got
1344
                   relocation entry to initialize the value.  This
1345
                   is done in the finish_dynamic_symbol routine.  */
1346
                bfd_put_32 (output_bfd, value,
1347
                            sgot->contents + off);
1348
 
1349
              value = sgot->output_offset + off;
1350
            }
1351
          else
1352
            {
1353
              bfd_vma off;
1354
 
1355
              off = elf_local_got_offsets (input_bfd)[symndx];
1356
 
1357
              bfd_put_32 (output_bfd, value, sgot->contents + off);
1358
 
1359
              if (info->shared)
1360
                {
1361
                  asection * srelgot;
1362
                  Elf_Internal_Rela outrel;
1363
 
1364
                  srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1365
                  BFD_ASSERT (srelgot != NULL);
1366
 
1367
                  outrel.r_offset = (sgot->output_section->vma
1368
                                     + sgot->output_offset
1369
                                     + off);
1370
                  outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1371
                  outrel.r_addend = value;
1372
                  bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1373
                                             (bfd_byte *) (((Elf32_External_Rela *)
1374
                                                            srelgot->contents)
1375
                                                           + srelgot->reloc_count));
1376
                  ++ srelgot->reloc_count;
1377
                }
1378
 
1379
              value = sgot->output_offset + off;
1380
            }
1381
      }
1382
 
1383
      value += addend;
1384
 
1385
      if (r_type == R_MN10300_GOT32)
1386
        {
1387
          bfd_put_32 (input_bfd, value, hit_data);
1388
          return bfd_reloc_ok;
1389
        }
1390
      else if (r_type == R_MN10300_GOT24)
1391
        {
1392
          if ((long) value > 0x7fffff || (long) value < -0x800000)
1393
            return bfd_reloc_overflow;
1394
 
1395
          bfd_put_8 (input_bfd, value & 0xff, hit_data);
1396
          bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1397
          bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1398
          return bfd_reloc_ok;
1399
        }
1400
      else if (r_type == R_MN10300_GOT16)
1401
        {
1402 225 jeremybenn
          if ((long) value > 0x7fff || (long) value < -0x8000)
1403 24 jeremybenn
            return bfd_reloc_overflow;
1404
 
1405
          bfd_put_16 (input_bfd, value, hit_data);
1406
          return bfd_reloc_ok;
1407
        }
1408
      /* Fall through.  */
1409
 
1410
    default:
1411
      return bfd_reloc_notsupported;
1412
    }
1413
}
1414
 
1415
/* Relocate an MN10300 ELF section.  */
1416
 
1417
static bfd_boolean
1418
mn10300_elf_relocate_section (bfd *output_bfd,
1419
                              struct bfd_link_info *info,
1420
                              bfd *input_bfd,
1421
                              asection *input_section,
1422
                              bfd_byte *contents,
1423
                              Elf_Internal_Rela *relocs,
1424
                              Elf_Internal_Sym *local_syms,
1425
                              asection **local_sections)
1426
{
1427
  Elf_Internal_Shdr *symtab_hdr;
1428
  struct elf_link_hash_entry **sym_hashes;
1429
  Elf_Internal_Rela *rel, *relend;
1430
 
1431
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1432
  sym_hashes = elf_sym_hashes (input_bfd);
1433
 
1434
  rel = relocs;
1435
  relend = relocs + input_section->reloc_count;
1436
  for (; rel < relend; rel++)
1437
    {
1438
      int r_type;
1439
      reloc_howto_type *howto;
1440
      unsigned long r_symndx;
1441
      Elf_Internal_Sym *sym;
1442
      asection *sec;
1443
      struct elf32_mn10300_link_hash_entry *h;
1444
      bfd_vma relocation;
1445
      bfd_reloc_status_type r;
1446
 
1447
      r_symndx = ELF32_R_SYM (rel->r_info);
1448
      r_type = ELF32_R_TYPE (rel->r_info);
1449
      howto = elf_mn10300_howto_table + r_type;
1450
 
1451
      /* Just skip the vtable gc relocs.  */
1452
      if (r_type == R_MN10300_GNU_VTINHERIT
1453
          || r_type == R_MN10300_GNU_VTENTRY)
1454
        continue;
1455
 
1456
      h = NULL;
1457
      sym = NULL;
1458
      sec = NULL;
1459
      if (r_symndx < symtab_hdr->sh_info)
1460
        {
1461
          sym = local_syms + r_symndx;
1462
          sec = local_sections[r_symndx];
1463
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1464
        }
1465
      else
1466
        {
1467
          bfd_boolean unresolved_reloc;
1468
          bfd_boolean warned;
1469
          struct elf_link_hash_entry *hh;
1470
 
1471
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1472
                                   r_symndx, symtab_hdr, sym_hashes,
1473
                                   hh, sec, relocation,
1474
                                   unresolved_reloc, warned);
1475
 
1476
          h = (struct elf32_mn10300_link_hash_entry *) hh;
1477
 
1478
          if ((h->root.root.type == bfd_link_hash_defined
1479
              || h->root.root.type == bfd_link_hash_defweak)
1480
              && (   r_type == R_MN10300_GOTPC32
1481
                  || r_type == R_MN10300_GOTPC16
1482
                  || ((   r_type == R_MN10300_PLT32
1483
                       || r_type == R_MN10300_PLT16)
1484
                      && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
1485
                      && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
1486
                      && h->root.plt.offset != (bfd_vma) -1)
1487
                  || ((   r_type == R_MN10300_GOT32
1488
                       || r_type == R_MN10300_GOT24
1489
                       || r_type == R_MN10300_GOT16)
1490
                      && elf_hash_table (info)->dynamic_sections_created
1491
                      && !SYMBOL_REFERENCES_LOCAL (info, hh))
1492
                  || (r_type == R_MN10300_32
1493
                      /* _32 relocs in executables force _COPY relocs,
1494
                         such that the address of the symbol ends up
1495
                         being local.  */
1496 225 jeremybenn
                      && !info->executable
1497 24 jeremybenn
                      && !SYMBOL_REFERENCES_LOCAL (info, hh)
1498
                      && ((input_section->flags & SEC_ALLOC) != 0
1499
                          /* DWARF will emit R_MN10300_32 relocations
1500
                             in its sections against symbols defined
1501
                             externally in shared libraries.  We can't
1502
                             do anything with them here.  */
1503
                          || ((input_section->flags & SEC_DEBUGGING) != 0
1504
                              && h->root.def_dynamic)))))
1505
            /* In these cases, we don't need the relocation
1506
               value.  We check specially because in some
1507
               obscure cases sec->output_section will be NULL.  */
1508
            relocation = 0;
1509
 
1510
          else if (!info->relocatable && unresolved_reloc)
1511
            (*_bfd_error_handler)
1512
              (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1513
               input_bfd,
1514
               input_section,
1515
               (long) rel->r_offset,
1516
               howto->name,
1517
               h->root.root.root.string);
1518
        }
1519
 
1520
      if (sec != NULL && elf_discarded_section (sec))
1521
        {
1522
          /* For relocs against symbols from removed linkonce sections,
1523
             or sections discarded by a linker script, we just want the
1524
             section contents zeroed.  Avoid any special processing.  */
1525
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1526
          rel->r_info = 0;
1527
          rel->r_addend = 0;
1528
          continue;
1529
        }
1530
 
1531
      if (info->relocatable)
1532
        continue;
1533
 
1534
      r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
1535
                                           input_section,
1536
                                           contents, rel->r_offset,
1537
                                           relocation, rel->r_addend,
1538
                                           (struct elf_link_hash_entry *) h,
1539
                                           r_symndx,
1540
                                           info, sec, h == NULL);
1541
 
1542
      if (r != bfd_reloc_ok)
1543
        {
1544
          const char *name;
1545
          const char *msg = NULL;
1546
 
1547
          if (h != NULL)
1548
            name = h->root.root.root.string;
1549
          else
1550
            {
1551
              name = (bfd_elf_string_from_elf_section
1552
                      (input_bfd, symtab_hdr->sh_link, sym->st_name));
1553
              if (name == NULL || *name == '\0')
1554
                name = bfd_section_name (input_bfd, sec);
1555
            }
1556
 
1557
          switch (r)
1558
            {
1559
            case bfd_reloc_overflow:
1560
              if (! ((*info->callbacks->reloc_overflow)
1561
                     (info, (h ? &h->root.root : NULL), name,
1562
                      howto->name, (bfd_vma) 0, input_bfd,
1563
                      input_section, rel->r_offset)))
1564
                return FALSE;
1565
              break;
1566
 
1567
            case bfd_reloc_undefined:
1568
              if (! ((*info->callbacks->undefined_symbol)
1569
                     (info, name, input_bfd, input_section,
1570
                      rel->r_offset, TRUE)))
1571
                return FALSE;
1572
              break;
1573
 
1574
            case bfd_reloc_outofrange:
1575
              msg = _("internal error: out of range error");
1576
              goto common_error;
1577
 
1578
            case bfd_reloc_notsupported:
1579
              msg = _("internal error: unsupported relocation error");
1580
              goto common_error;
1581
 
1582
            case bfd_reloc_dangerous:
1583
              if (r_type == R_MN10300_PCREL32)
1584
                msg = _("error: inappropriate relocation type for shared"
1585
                        " library (did you forget -fpic?)");
1586
              else
1587
                msg = _("internal error: suspicious relocation type used"
1588
                        " in shared library");
1589
              goto common_error;
1590
 
1591
            default:
1592
              msg = _("internal error: unknown error");
1593
              /* Fall through.  */
1594
 
1595
            common_error:
1596
              if (!((*info->callbacks->warning)
1597
                    (info, msg, name, input_bfd, input_section,
1598
                     rel->r_offset)))
1599
                return FALSE;
1600
              break;
1601
            }
1602
        }
1603
    }
1604
 
1605
  return TRUE;
1606
}
1607
 
1608
/* Finish initializing one hash table entry.  */
1609
 
1610
static bfd_boolean
1611
elf32_mn10300_finish_hash_table_entry (struct bfd_hash_entry *gen_entry,
1612
                                       void * in_args)
1613
{
1614
  struct elf32_mn10300_link_hash_entry *entry;
1615
  struct bfd_link_info *link_info = (struct bfd_link_info *) in_args;
1616
  unsigned int byte_count = 0;
1617
 
1618
  entry = (struct elf32_mn10300_link_hash_entry *) gen_entry;
1619
 
1620
  if (entry->root.root.type == bfd_link_hash_warning)
1621
    entry = (struct elf32_mn10300_link_hash_entry *) entry->root.root.u.i.link;
1622
 
1623
  /* If we already know we want to convert "call" to "calls" for calls
1624
     to this symbol, then return now.  */
1625
  if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
1626
    return TRUE;
1627
 
1628
  /* If there are no named calls to this symbol, or there's nothing we
1629
     can move from the function itself into the "call" instruction,
1630
     then note that all "call" instructions should be converted into
1631
     "calls" instructions and return.  If a symbol is available for
1632
     dynamic symbol resolution (overridable or overriding), avoid
1633
     custom calling conventions.  */
1634
  if (entry->direct_calls == 0
1635
      || (entry->stack_size == 0 && entry->movm_args == 0)
1636
      || (elf_hash_table (link_info)->dynamic_sections_created
1637
          && ELF_ST_VISIBILITY (entry->root.other) != STV_INTERNAL
1638
          && ELF_ST_VISIBILITY (entry->root.other) != STV_HIDDEN))
1639
    {
1640
      /* Make a note that we should convert "call" instructions to "calls"
1641
         instructions for calls to this symbol.  */
1642
      entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1643
      return TRUE;
1644
    }
1645
 
1646
  /* We may be able to move some instructions from the function itself into
1647
     the "call" instruction.  Count how many bytes we might be able to
1648
     eliminate in the function itself.  */
1649
 
1650
  /* A movm instruction is two bytes.  */
1651
  if (entry->movm_args)
1652
    byte_count += 2;
1653
 
1654
  /* Count the insn to allocate stack space too.  */
1655
  if (entry->stack_size > 0)
1656
    {
1657
      if (entry->stack_size <= 128)
1658
        byte_count += 3;
1659
      else
1660
        byte_count += 4;
1661
    }
1662
 
1663
  /* If using "call" will result in larger code, then turn all
1664
     the associated "call" instructions into "calls" instructions.  */
1665
  if (byte_count < entry->direct_calls)
1666
    entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1667
 
1668
  /* This routine never fails.  */
1669
  return TRUE;
1670
}
1671
 
1672
/* Used to count hash table entries.  */
1673
 
1674
static bfd_boolean
1675
elf32_mn10300_count_hash_table_entries (struct bfd_hash_entry *gen_entry ATTRIBUTE_UNUSED,
1676
                                        void * in_args)
1677
{
1678
  int *count = (int *) in_args;
1679
 
1680
  (*count) ++;
1681
  return TRUE;
1682
}
1683
 
1684
/* Used to enumerate hash table entries into a linear array.  */
1685
 
1686
static bfd_boolean
1687
elf32_mn10300_list_hash_table_entries (struct bfd_hash_entry *gen_entry,
1688
                                       void * in_args)
1689
{
1690
  struct bfd_hash_entry ***ptr = (struct bfd_hash_entry ***) in_args;
1691
 
1692
  **ptr = gen_entry;
1693
  (*ptr) ++;
1694
  return TRUE;
1695
}
1696
 
1697
/* Used to sort the array created by the above.  */
1698
 
1699
static int
1700
sort_by_value (const void *va, const void *vb)
1701
{
1702
  struct elf32_mn10300_link_hash_entry *a
1703
    = *(struct elf32_mn10300_link_hash_entry **) va;
1704
  struct elf32_mn10300_link_hash_entry *b
1705
    = *(struct elf32_mn10300_link_hash_entry **) vb;
1706
 
1707
  return a->value - b->value;
1708
}
1709
 
1710
/* Compute the stack size and movm arguments for the function
1711
   referred to by HASH at address ADDR in section with
1712
   contents CONTENTS, store the information in the hash table.  */
1713
 
1714
static void
1715
compute_function_info (bfd *abfd,
1716
                       struct elf32_mn10300_link_hash_entry *hash,
1717
                       bfd_vma addr,
1718
                       unsigned char *contents)
1719
{
1720
  unsigned char byte1, byte2;
1721
  /* We only care about a very small subset of the possible prologue
1722
     sequences here.  Basically we look for:
1723
 
1724
     movm [d2,d3,a2,a3],sp (optional)
1725
     add <size>,sp (optional, and only for sizes which fit in an unsigned
1726
                    8 bit number)
1727
 
1728
     If we find anything else, we quit.  */
1729
 
1730
  /* Look for movm [regs],sp.  */
1731
  byte1 = bfd_get_8 (abfd, contents + addr);
1732
  byte2 = bfd_get_8 (abfd, contents + addr + 1);
1733
 
1734
  if (byte1 == 0xcf)
1735
    {
1736
      hash->movm_args = byte2;
1737
      addr += 2;
1738
      byte1 = bfd_get_8 (abfd, contents + addr);
1739
      byte2 = bfd_get_8 (abfd, contents + addr + 1);
1740
    }
1741
 
1742
  /* Now figure out how much stack space will be allocated by the movm
1743
     instruction.  We need this kept separate from the function's normal
1744
     stack space.  */
1745
  if (hash->movm_args)
1746
    {
1747
      /* Space for d2.  */
1748
      if (hash->movm_args & 0x80)
1749
        hash->movm_stack_size += 4;
1750
 
1751
      /* Space for d3.  */
1752
      if (hash->movm_args & 0x40)
1753
        hash->movm_stack_size += 4;
1754
 
1755
      /* Space for a2.  */
1756
      if (hash->movm_args & 0x20)
1757
        hash->movm_stack_size += 4;
1758
 
1759
      /* Space for a3.  */
1760
      if (hash->movm_args & 0x10)
1761
        hash->movm_stack_size += 4;
1762
 
1763
      /* "other" space.  d0, d1, a0, a1, mdr, lir, lar, 4 byte pad.  */
1764
      if (hash->movm_args & 0x08)
1765
        hash->movm_stack_size += 8 * 4;
1766
 
1767
      if (bfd_get_mach (abfd) == bfd_mach_am33
1768
          || bfd_get_mach (abfd) == bfd_mach_am33_2)
1769
        {
1770
          /* "exother" space.  e0, e1, mdrq, mcrh, mcrl, mcvf */
1771
          if (hash->movm_args & 0x1)
1772
            hash->movm_stack_size += 6 * 4;
1773
 
1774
          /* exreg1 space.  e4, e5, e6, e7 */
1775
          if (hash->movm_args & 0x2)
1776
            hash->movm_stack_size += 4 * 4;
1777
 
1778
          /* exreg0 space.  e2, e3  */
1779
          if (hash->movm_args & 0x4)
1780
            hash->movm_stack_size += 2 * 4;
1781
        }
1782
    }
1783
 
1784
  /* Now look for the two stack adjustment variants.  */
1785
  if (byte1 == 0xf8 && byte2 == 0xfe)
1786
    {
1787
      int temp = bfd_get_8 (abfd, contents + addr + 2);
1788
      temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
1789
 
1790
      hash->stack_size = -temp;
1791
    }
1792
  else if (byte1 == 0xfa && byte2 == 0xfe)
1793
    {
1794
      int temp = bfd_get_16 (abfd, contents + addr + 2);
1795
      temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
1796
      temp = -temp;
1797
 
1798
      if (temp < 255)
1799
        hash->stack_size = temp;
1800
    }
1801
 
1802
  /* If the total stack to be allocated by the call instruction is more
1803
     than 255 bytes, then we can't remove the stack adjustment by using
1804
     "call" (we might still be able to remove the "movm" instruction.  */
1805
  if (hash->stack_size + hash->movm_stack_size > 255)
1806
    hash->stack_size = 0;
1807
}
1808
 
1809
/* Delete some bytes from a section while relaxing.  */
1810
 
1811
static bfd_boolean
1812
mn10300_elf_relax_delete_bytes (bfd *abfd,
1813
                                asection *sec,
1814
                                bfd_vma addr,
1815
                                int count)
1816
{
1817
  Elf_Internal_Shdr *symtab_hdr;
1818
  unsigned int sec_shndx;
1819
  bfd_byte *contents;
1820
  Elf_Internal_Rela *irel, *irelend;
1821
  Elf_Internal_Rela *irelalign;
1822
  bfd_vma toaddr;
1823
  Elf_Internal_Sym *isym, *isymend;
1824
  struct elf_link_hash_entry **sym_hashes;
1825
  struct elf_link_hash_entry **end_hashes;
1826
  unsigned int symcount;
1827
 
1828
  sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1829
 
1830
  contents = elf_section_data (sec)->this_hdr.contents;
1831
 
1832
  irelalign = NULL;
1833
  toaddr = sec->size;
1834
 
1835
  irel = elf_section_data (sec)->relocs;
1836
  irelend = irel + sec->reloc_count;
1837
 
1838
  if (sec->reloc_count > 0)
1839
    {
1840
      /* If there is an align reloc at the end of the section ignore it.
1841
         GAS creates these relocs for reasons of its own, and they just
1842
         serve to keep the section artifically inflated.  */
1843
      if (ELF32_R_TYPE ((irelend - 1)->r_info) == (int) R_MN10300_ALIGN)
1844
        --irelend;
1845
 
1846
      /* The deletion must stop at the next ALIGN reloc for an aligment
1847
         power larger than, or not a multiple of, the number of bytes we
1848
         are deleting.  */
1849
      for (; irel < irelend; irel++)
1850
        {
1851
          int alignment = 1 << irel->r_addend;
1852
 
1853
          if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
1854
              && irel->r_offset > addr
1855
              && irel->r_offset < toaddr
1856
              && (count < alignment
1857
                  || alignment % count != 0))
1858
            {
1859
              irelalign = irel;
1860
              toaddr = irel->r_offset;
1861
              break;
1862
            }
1863
        }
1864
    }
1865
 
1866
  /* Actually delete the bytes.  */
1867
  memmove (contents + addr, contents + addr + count,
1868
           (size_t) (toaddr - addr - count));
1869
 
1870
  /* Adjust the section's size if we are shrinking it, or else
1871
     pad the bytes between the end of the shrunken region and
1872
     the start of the next region with NOP codes.  */
1873
  if (irelalign == NULL)
1874
    {
1875
      sec->size -= count;
1876
      /* Include symbols at the end of the section, but
1877
         not at the end of a sub-region of the section.  */
1878
      toaddr ++;
1879
    }
1880
  else
1881
    {
1882
      int i;
1883
 
1884
#define NOP_OPCODE 0xcb
1885
 
1886
      for (i = 0; i < count; i ++)
1887
        bfd_put_8 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
1888
    }
1889
 
1890
  /* Adjust all the relocs.  */
1891
  for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1892
    {
1893
      /* Get the new reloc address.  */
1894
      if ((irel->r_offset > addr
1895
           && irel->r_offset < toaddr)
1896
          || (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
1897
              && irel->r_offset == toaddr))
1898
        irel->r_offset -= count;
1899
    }
1900
 
1901
  /* Adjust the local symbols in the section, reducing their value
1902
     by the number of bytes deleted.  Note - symbols within the deleted
1903
     region are moved to the address of the start of the region, which
1904
     actually means that they will address the byte beyond the end of
1905
     the region once the deletion has been completed.  */
1906
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1907
  isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1908
  for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1909
    {
1910
      if (isym->st_shndx == sec_shndx
1911
          && isym->st_value > addr
1912
          && isym->st_value < toaddr)
1913
        {
1914
          if (isym->st_value < addr + count)
1915
            isym->st_value = addr;
1916
          else
1917
            isym->st_value -= count;
1918
        }
1919
      /* Adjust the function symbol's size as well.  */
1920
      else if (isym->st_shndx == sec_shndx
1921
               && ELF_ST_TYPE (isym->st_info) == STT_FUNC
1922
               && isym->st_value + isym->st_size > addr
1923
               && isym->st_value + isym->st_size < toaddr)
1924
        isym->st_size -= count;
1925
    }
1926
 
1927
  /* Now adjust the global symbols defined in this section.  */
1928
  symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1929
              - symtab_hdr->sh_info);
1930
  sym_hashes = elf_sym_hashes (abfd);
1931
  end_hashes = sym_hashes + symcount;
1932
  for (; sym_hashes < end_hashes; sym_hashes++)
1933
    {
1934
      struct elf_link_hash_entry *sym_hash = *sym_hashes;
1935
 
1936
      if ((sym_hash->root.type == bfd_link_hash_defined
1937
           || sym_hash->root.type == bfd_link_hash_defweak)
1938
          && sym_hash->root.u.def.section == sec
1939
          && sym_hash->root.u.def.value > addr
1940
          && sym_hash->root.u.def.value < toaddr)
1941
        {
1942
          if (sym_hash->root.u.def.value < addr + count)
1943
            sym_hash->root.u.def.value = addr;
1944
          else
1945
            sym_hash->root.u.def.value -= count;
1946
        }
1947
      /* Adjust the function symbol's size as well.  */
1948
      else if (sym_hash->root.type == bfd_link_hash_defined
1949
               && sym_hash->root.u.def.section == sec
1950
               && sym_hash->type == STT_FUNC
1951
               && sym_hash->root.u.def.value + sym_hash->size > addr
1952
               && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1953
        sym_hash->size -= count;
1954
    }
1955
 
1956
  /* See if we can move the ALIGN reloc forward.
1957
     We have adjusted r_offset for it already.  */
1958
  if (irelalign != NULL)
1959
    {
1960
      bfd_vma alignto, alignaddr;
1961
 
1962
      if ((int) irelalign->r_addend > 0)
1963
        {
1964
          /* This is the old address.  */
1965
          alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
1966
          /* This is where the align points to now.  */
1967
          alignaddr = BFD_ALIGN (irelalign->r_offset,
1968
                                 1 << irelalign->r_addend);
1969
          if (alignaddr < alignto)
1970
            /* Tail recursion.  */
1971
            return mn10300_elf_relax_delete_bytes (abfd, sec, alignaddr,
1972
                                                   (int) (alignto - alignaddr));
1973
        }
1974
    }
1975
 
1976
  return TRUE;
1977
}
1978
 
1979
/* Return TRUE if a symbol exists at the given address, else return
1980
   FALSE.  */
1981
 
1982
static bfd_boolean
1983
mn10300_elf_symbol_address_p (bfd *abfd,
1984
                              asection *sec,
1985
                              Elf_Internal_Sym *isym,
1986
                              bfd_vma addr)
1987
{
1988
  Elf_Internal_Shdr *symtab_hdr;
1989
  unsigned int sec_shndx;
1990
  Elf_Internal_Sym *isymend;
1991
  struct elf_link_hash_entry **sym_hashes;
1992
  struct elf_link_hash_entry **end_hashes;
1993
  unsigned int symcount;
1994
 
1995
  sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1996
 
1997
  /* Examine all the symbols.  */
1998
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1999
  for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
2000
    if (isym->st_shndx == sec_shndx
2001
        && isym->st_value == addr)
2002
      return TRUE;
2003
 
2004
  symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2005
              - symtab_hdr->sh_info);
2006
  sym_hashes = elf_sym_hashes (abfd);
2007
  end_hashes = sym_hashes + symcount;
2008
  for (; sym_hashes < end_hashes; sym_hashes++)
2009
    {
2010
      struct elf_link_hash_entry *sym_hash = *sym_hashes;
2011
 
2012
      if ((sym_hash->root.type == bfd_link_hash_defined
2013
           || sym_hash->root.type == bfd_link_hash_defweak)
2014
          && sym_hash->root.u.def.section == sec
2015
          && sym_hash->root.u.def.value == addr)
2016
        return TRUE;
2017
    }
2018
 
2019
  return FALSE;
2020
}
2021
 
2022
/* This function handles relaxing for the mn10300.
2023
 
2024
   There are quite a few relaxing opportunities available on the mn10300:
2025
 
2026
        * calls:32 -> calls:16                                     2 bytes
2027
        * call:32  -> call:16                                      2 bytes
2028
 
2029
        * call:32 -> calls:32                                      1 byte
2030
        * call:16 -> calls:16                                      1 byte
2031
                * These are done anytime using "calls" would result
2032
                in smaller code, or when necessary to preserve the
2033
                meaning of the program.
2034
 
2035
        * call:32                                                  varies
2036
        * call:16
2037
                * In some circumstances we can move instructions
2038
                from a function prologue into a "call" instruction.
2039
                This is only done if the resulting code is no larger
2040
                than the original code.
2041
 
2042
        * jmp:32 -> jmp:16                                         2 bytes
2043
        * jmp:16 -> bra:8                                          1 byte
2044
 
2045
                * If the previous instruction is a conditional branch
2046
                around the jump/bra, we may be able to reverse its condition
2047
                and change its target to the jump's target.  The jump/bra
2048
                can then be deleted.                               2 bytes
2049
 
2050
        * mov abs32 -> mov abs16                                   1 or 2 bytes
2051
 
2052
        * Most instructions which accept imm32 can relax to imm16  1 or 2 bytes
2053
        - Most instructions which accept imm16 can relax to imm8   1 or 2 bytes
2054
 
2055
        * Most instructions which accept d32 can relax to d16      1 or 2 bytes
2056
        - Most instructions which accept d16 can relax to d8       1 or 2 bytes
2057
 
2058
        We don't handle imm16->imm8 or d16->d8 as they're very rare
2059
        and somewhat more difficult to support.  */
2060
 
2061
static bfd_boolean
2062
mn10300_elf_relax_section (bfd *abfd,
2063
                           asection *sec,
2064
                           struct bfd_link_info *link_info,
2065
                           bfd_boolean *again)
2066
{
2067
  Elf_Internal_Shdr *symtab_hdr;
2068
  Elf_Internal_Rela *internal_relocs = NULL;
2069
  Elf_Internal_Rela *irel, *irelend;
2070
  bfd_byte *contents = NULL;
2071
  Elf_Internal_Sym *isymbuf = NULL;
2072
  struct elf32_mn10300_link_hash_table *hash_table;
2073
  asection *section = sec;
2074
  bfd_vma align_gap_adjustment;
2075
 
2076 225 jeremybenn
  if (link_info->relocatable)
2077
    (*link_info->callbacks->einfo)
2078
      (_("%P%F: --relax and -r may not be used together\n"));
2079
 
2080 24 jeremybenn
  /* Assume nothing changes.  */
2081
  *again = FALSE;
2082
 
2083
  /* We need a pointer to the mn10300 specific hash table.  */
2084
  hash_table = elf32_mn10300_hash_table (link_info);
2085
 
2086
  /* Initialize fields in each hash table entry the first time through.  */
2087
  if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
2088
    {
2089
      bfd *input_bfd;
2090
 
2091
      /* Iterate over all the input bfds.  */
2092
      for (input_bfd = link_info->input_bfds;
2093
           input_bfd != NULL;
2094
           input_bfd = input_bfd->link_next)
2095
        {
2096
          /* We're going to need all the symbols for each bfd.  */
2097
          symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2098
          if (symtab_hdr->sh_info != 0)
2099
            {
2100
              isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2101
              if (isymbuf == NULL)
2102
                isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2103
                                                symtab_hdr->sh_info, 0,
2104
                                                NULL, NULL, NULL);
2105
              if (isymbuf == NULL)
2106
                goto error_return;
2107
            }
2108
 
2109
          /* Iterate over each section in this bfd.  */
2110
          for (section = input_bfd->sections;
2111
               section != NULL;
2112
               section = section->next)
2113
            {
2114
              struct elf32_mn10300_link_hash_entry *hash;
2115
              Elf_Internal_Sym *sym;
2116
              asection *sym_sec = NULL;
2117
              const char *sym_name;
2118
              char *new_name;
2119
 
2120
              /* If there's nothing to do in this section, skip it.  */
2121
              if (! ((section->flags & SEC_RELOC) != 0
2122
                     && section->reloc_count != 0))
2123
                continue;
2124
              if ((section->flags & SEC_ALLOC) == 0)
2125
                continue;
2126
 
2127
              /* Get cached copy of section contents if it exists.  */
2128
              if (elf_section_data (section)->this_hdr.contents != NULL)
2129
                contents = elf_section_data (section)->this_hdr.contents;
2130
              else if (section->size != 0)
2131
                {
2132
                  /* Go get them off disk.  */
2133
                  if (!bfd_malloc_and_get_section (input_bfd, section,
2134
                                                   &contents))
2135
                    goto error_return;
2136
                }
2137
              else
2138
                contents = NULL;
2139
 
2140
              /* If there aren't any relocs, then there's nothing to do.  */
2141
              if ((section->flags & SEC_RELOC) != 0
2142
                  && section->reloc_count != 0)
2143
                {
2144
                  /* Get a copy of the native relocations.  */
2145
                  internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2146
                                                               NULL, NULL,
2147
                                                               link_info->keep_memory);
2148
                  if (internal_relocs == NULL)
2149
                    goto error_return;
2150
 
2151
                  /* Now examine each relocation.  */
2152
                  irel = internal_relocs;
2153
                  irelend = irel + section->reloc_count;
2154
                  for (; irel < irelend; irel++)
2155
                    {
2156
                      long r_type;
2157
                      unsigned long r_index;
2158
                      unsigned char code;
2159
 
2160
                      r_type = ELF32_R_TYPE (irel->r_info);
2161
                      r_index = ELF32_R_SYM (irel->r_info);
2162
 
2163
                      if (r_type < 0 || r_type >= (int) R_MN10300_MAX)
2164
                        goto error_return;
2165
 
2166
                      /* We need the name and hash table entry of the target
2167
                         symbol!  */
2168
                      hash = NULL;
2169
                      sym = NULL;
2170
                      sym_sec = NULL;
2171
 
2172
                      if (r_index < symtab_hdr->sh_info)
2173
                        {
2174
                          /* A local symbol.  */
2175
                          Elf_Internal_Sym *isym;
2176
                          struct elf_link_hash_table *elftab;
2177
                          bfd_size_type amt;
2178
 
2179
                          isym = isymbuf + r_index;
2180
                          if (isym->st_shndx == SHN_UNDEF)
2181
                            sym_sec = bfd_und_section_ptr;
2182
                          else if (isym->st_shndx == SHN_ABS)
2183
                            sym_sec = bfd_abs_section_ptr;
2184
                          else if (isym->st_shndx == SHN_COMMON)
2185
                            sym_sec = bfd_com_section_ptr;
2186
                          else
2187
                            sym_sec
2188
                              = bfd_section_from_elf_index (input_bfd,
2189
                                                            isym->st_shndx);
2190
 
2191
                          sym_name
2192
                            = bfd_elf_string_from_elf_section (input_bfd,
2193
                                                               (symtab_hdr
2194
                                                                ->sh_link),
2195
                                                               isym->st_name);
2196
 
2197
                          /* If it isn't a function, then we don't care
2198
                             about it.  */
2199
                          if (ELF_ST_TYPE (isym->st_info) != STT_FUNC)
2200
                            continue;
2201
 
2202
                          /* Tack on an ID so we can uniquely identify this
2203
                             local symbol in the global hash table.  */
2204
                          amt = strlen (sym_name) + 10;
2205
                          new_name = bfd_malloc (amt);
2206
                          if (new_name == NULL)
2207
                            goto error_return;
2208
 
2209
                          sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2210
                          sym_name = new_name;
2211
 
2212
                          elftab = &hash_table->static_hash_table->root;
2213
                          hash = ((struct elf32_mn10300_link_hash_entry *)
2214
                                  elf_link_hash_lookup (elftab, sym_name,
2215
                                                        TRUE, TRUE, FALSE));
2216
                          free (new_name);
2217
                        }
2218
                      else
2219
                        {
2220
                          r_index -= symtab_hdr->sh_info;
2221
                          hash = (struct elf32_mn10300_link_hash_entry *)
2222
                                   elf_sym_hashes (input_bfd)[r_index];
2223
                        }
2224
 
2225
                      sym_name = hash->root.root.root.string;
2226
                      if ((section->flags & SEC_CODE) != 0)
2227
                        {
2228
                          /* If this is not a "call" instruction, then we
2229
                             should convert "call" instructions to "calls"
2230
                             instructions.  */
2231
                          code = bfd_get_8 (input_bfd,
2232
                                            contents + irel->r_offset - 1);
2233
                          if (code != 0xdd && code != 0xcd)
2234
                            hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2235
                        }
2236
 
2237
                      /* If this is a jump/call, then bump the
2238
                         direct_calls counter.  Else force "call" to
2239
                         "calls" conversions.  */
2240
                      if (r_type == R_MN10300_PCREL32
2241
                          || r_type == R_MN10300_PLT32
2242
                          || r_type == R_MN10300_PLT16
2243
                          || r_type == R_MN10300_PCREL16)
2244
                        hash->direct_calls++;
2245
                      else
2246
                        hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2247
                    }
2248
                }
2249
 
2250
              /* Now look at the actual contents to get the stack size,
2251
                 and a list of what registers were saved in the prologue
2252
                 (ie movm_args).  */
2253
              if ((section->flags & SEC_CODE) != 0)
2254
                {
2255
                  Elf_Internal_Sym *isym, *isymend;
2256
                  unsigned int sec_shndx;
2257
                  struct elf_link_hash_entry **hashes;
2258
                  struct elf_link_hash_entry **end_hashes;
2259
                  unsigned int symcount;
2260
 
2261
                  sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2262
                                                                 section);
2263
 
2264
                  symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2265
                              - symtab_hdr->sh_info);
2266
                  hashes = elf_sym_hashes (input_bfd);
2267
                  end_hashes = hashes + symcount;
2268
 
2269
                  /* Look at each function defined in this section and
2270
                     update info for that function.  */
2271
                  isymend = isymbuf + symtab_hdr->sh_info;
2272
                  for (isym = isymbuf; isym < isymend; isym++)
2273
                    {
2274
                      if (isym->st_shndx == sec_shndx
2275
                          && ELF_ST_TYPE (isym->st_info) == STT_FUNC)
2276
                        {
2277
                          struct elf_link_hash_table *elftab;
2278
                          bfd_size_type amt;
2279
                          struct elf_link_hash_entry **lhashes = hashes;
2280
 
2281
                          /* Skip a local symbol if it aliases a
2282
                             global one.  */
2283
                          for (; lhashes < end_hashes; lhashes++)
2284
                            {
2285
                              hash = (struct elf32_mn10300_link_hash_entry *) *lhashes;
2286
                              if ((hash->root.root.type == bfd_link_hash_defined
2287
                                   || hash->root.root.type == bfd_link_hash_defweak)
2288
                                  && hash->root.root.u.def.section == section
2289
                                  && hash->root.type == STT_FUNC
2290
                                  && hash->root.root.u.def.value == isym->st_value)
2291
                                break;
2292
                            }
2293
                          if (lhashes != end_hashes)
2294
                            continue;
2295
 
2296
                          if (isym->st_shndx == SHN_UNDEF)
2297
                            sym_sec = bfd_und_section_ptr;
2298
                          else if (isym->st_shndx == SHN_ABS)
2299
                            sym_sec = bfd_abs_section_ptr;
2300
                          else if (isym->st_shndx == SHN_COMMON)
2301
                            sym_sec = bfd_com_section_ptr;
2302
                          else
2303
                            sym_sec
2304
                              = bfd_section_from_elf_index (input_bfd,
2305
                                                            isym->st_shndx);
2306
 
2307
                          sym_name = (bfd_elf_string_from_elf_section
2308
                                      (input_bfd, symtab_hdr->sh_link,
2309
                                       isym->st_name));
2310
 
2311
                          /* Tack on an ID so we can uniquely identify this
2312
                             local symbol in the global hash table.  */
2313
                          amt = strlen (sym_name) + 10;
2314
                          new_name = bfd_malloc (amt);
2315
                          if (new_name == NULL)
2316
                            goto error_return;
2317
 
2318
                          sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2319
                          sym_name = new_name;
2320
 
2321
                          elftab = &hash_table->static_hash_table->root;
2322
                          hash = ((struct elf32_mn10300_link_hash_entry *)
2323
                                  elf_link_hash_lookup (elftab, sym_name,
2324
                                                        TRUE, TRUE, FALSE));
2325
                          free (new_name);
2326
                          compute_function_info (input_bfd, hash,
2327
                                                 isym->st_value, contents);
2328
                          hash->value = isym->st_value;
2329
                        }
2330
                    }
2331
 
2332
                  for (; hashes < end_hashes; hashes++)
2333
                    {
2334
                      hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2335
                      if ((hash->root.root.type == bfd_link_hash_defined
2336
                           || hash->root.root.type == bfd_link_hash_defweak)
2337
                          && hash->root.root.u.def.section == section
2338
                          && hash->root.type == STT_FUNC)
2339
                        compute_function_info (input_bfd, hash,
2340
                                               (hash)->root.root.u.def.value,
2341
                                               contents);
2342
                    }
2343
                }
2344
 
2345
              /* Cache or free any memory we allocated for the relocs.  */
2346
              if (internal_relocs != NULL
2347
                  && elf_section_data (section)->relocs != internal_relocs)
2348
                free (internal_relocs);
2349
              internal_relocs = NULL;
2350
 
2351
              /* Cache or free any memory we allocated for the contents.  */
2352
              if (contents != NULL
2353
                  && elf_section_data (section)->this_hdr.contents != contents)
2354
                {
2355
                  if (! link_info->keep_memory)
2356
                    free (contents);
2357
                  else
2358
                    {
2359
                      /* Cache the section contents for elf_link_input_bfd.  */
2360
                      elf_section_data (section)->this_hdr.contents = contents;
2361
                    }
2362
                }
2363
              contents = NULL;
2364
            }
2365
 
2366
          /* Cache or free any memory we allocated for the symbols.  */
2367
          if (isymbuf != NULL
2368
              && symtab_hdr->contents != (unsigned char *) isymbuf)
2369
            {
2370
              if (! link_info->keep_memory)
2371
                free (isymbuf);
2372
              else
2373
                {
2374
                  /* Cache the symbols for elf_link_input_bfd.  */
2375
                  symtab_hdr->contents = (unsigned char *) isymbuf;
2376
                }
2377
            }
2378
          isymbuf = NULL;
2379
        }
2380
 
2381
      /* Now iterate on each symbol in the hash table and perform
2382
         the final initialization steps on each.  */
2383
      elf32_mn10300_link_hash_traverse (hash_table,
2384
                                        elf32_mn10300_finish_hash_table_entry,
2385
                                        link_info);
2386
      elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2387
                                        elf32_mn10300_finish_hash_table_entry,
2388
                                        link_info);
2389
 
2390
      {
2391
        /* This section of code collects all our local symbols, sorts
2392
           them by value, and looks for multiple symbols referring to
2393
           the same address.  For those symbols, the flags are merged.
2394
           At this point, the only flag that can be set is
2395
           MN10300_CONVERT_CALL_TO_CALLS, so we simply OR the flags
2396
           together.  */
2397
        int static_count = 0, i;
2398
        struct elf32_mn10300_link_hash_entry **entries;
2399
        struct elf32_mn10300_link_hash_entry **ptr;
2400
 
2401
        elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2402
                                          elf32_mn10300_count_hash_table_entries,
2403
                                          &static_count);
2404
 
2405
        entries = bfd_malloc (static_count * sizeof (* ptr));
2406
 
2407
        ptr = entries;
2408
        elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2409
                                          elf32_mn10300_list_hash_table_entries,
2410
                                          & ptr);
2411
 
2412
        qsort (entries, static_count, sizeof (entries[0]), sort_by_value);
2413
 
2414
        for (i = 0; i < static_count - 1; i++)
2415
          if (entries[i]->value && entries[i]->value == entries[i+1]->value)
2416
            {
2417
              int v = entries[i]->flags;
2418
              int j;
2419
 
2420
              for (j = i + 1; j < static_count && entries[j]->value == entries[i]->value; j++)
2421
                v |= entries[j]->flags;
2422
 
2423
              for (j = i; j < static_count && entries[j]->value == entries[i]->value; j++)
2424
                entries[j]->flags = v;
2425
 
2426
              i = j - 1;
2427
            }
2428
      }
2429
 
2430
      /* All entries in the hash table are fully initialized.  */
2431
      hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
2432
 
2433
      /* Now that everything has been initialized, go through each
2434
         code section and delete any prologue insns which will be
2435
         redundant because their operations will be performed by
2436
         a "call" instruction.  */
2437
      for (input_bfd = link_info->input_bfds;
2438
           input_bfd != NULL;
2439
           input_bfd = input_bfd->link_next)
2440
        {
2441
          /* We're going to need all the local symbols for each bfd.  */
2442
          symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2443
          if (symtab_hdr->sh_info != 0)
2444
            {
2445
              isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2446
              if (isymbuf == NULL)
2447
                isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2448
                                                symtab_hdr->sh_info, 0,
2449
                                                NULL, NULL, NULL);
2450
              if (isymbuf == NULL)
2451
                goto error_return;
2452
            }
2453
 
2454
          /* Walk over each section in this bfd.  */
2455
          for (section = input_bfd->sections;
2456
               section != NULL;
2457
               section = section->next)
2458
            {
2459
              unsigned int sec_shndx;
2460
              Elf_Internal_Sym *isym, *isymend;
2461
              struct elf_link_hash_entry **hashes;
2462
              struct elf_link_hash_entry **end_hashes;
2463
              unsigned int symcount;
2464
 
2465
              /* Skip non-code sections and empty sections.  */
2466
              if ((section->flags & SEC_CODE) == 0 || section->size == 0)
2467
                continue;
2468
 
2469
              if (section->reloc_count != 0)
2470
                {
2471
                  /* Get a copy of the native relocations.  */
2472
                  internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2473
                                                               NULL, NULL,
2474
                                                               link_info->keep_memory);
2475
                  if (internal_relocs == NULL)
2476
                    goto error_return;
2477
                }
2478
 
2479
              /* Get cached copy of section contents if it exists.  */
2480
              if (elf_section_data (section)->this_hdr.contents != NULL)
2481
                contents = elf_section_data (section)->this_hdr.contents;
2482
              else
2483
                {
2484
                  /* Go get them off disk.  */
2485
                  if (!bfd_malloc_and_get_section (input_bfd, section,
2486
                                                   &contents))
2487
                    goto error_return;
2488
                }
2489
 
2490
              sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2491
                                                             section);
2492
 
2493
              /* Now look for any function in this section which needs
2494
                 insns deleted from its prologue.  */
2495
              isymend = isymbuf + symtab_hdr->sh_info;
2496
              for (isym = isymbuf; isym < isymend; isym++)
2497
                {
2498
                  struct elf32_mn10300_link_hash_entry *sym_hash;
2499
                  asection *sym_sec = NULL;
2500
                  const char *sym_name;
2501
                  char *new_name;
2502
                  struct elf_link_hash_table *elftab;
2503
                  bfd_size_type amt;
2504
 
2505
                  if (isym->st_shndx != sec_shndx)
2506
                    continue;
2507
 
2508
                  if (isym->st_shndx == SHN_UNDEF)
2509
                    sym_sec = bfd_und_section_ptr;
2510
                  else if (isym->st_shndx == SHN_ABS)
2511
                    sym_sec = bfd_abs_section_ptr;
2512
                  else if (isym->st_shndx == SHN_COMMON)
2513
                    sym_sec = bfd_com_section_ptr;
2514
                  else
2515
                    sym_sec
2516
                      = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2517
 
2518
                  sym_name
2519
                    = bfd_elf_string_from_elf_section (input_bfd,
2520
                                                       symtab_hdr->sh_link,
2521
                                                       isym->st_name);
2522
 
2523
                  /* Tack on an ID so we can uniquely identify this
2524
                     local symbol in the global hash table.  */
2525
                  amt = strlen (sym_name) + 10;
2526
                  new_name = bfd_malloc (amt);
2527
                  if (new_name == NULL)
2528
                    goto error_return;
2529
                  sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2530
                  sym_name = new_name;
2531
 
2532
                  elftab = & hash_table->static_hash_table->root;
2533
                  sym_hash = (struct elf32_mn10300_link_hash_entry *)
2534
                    elf_link_hash_lookup (elftab, sym_name,
2535
                                          FALSE, FALSE, FALSE);
2536
 
2537
                  free (new_name);
2538
                  if (sym_hash == NULL)
2539
                    continue;
2540
 
2541
                  if (! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2542
                      && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
2543
                    {
2544
                      int bytes = 0;
2545
 
2546
                      /* Note that we've changed things.  */
2547
                      elf_section_data (section)->relocs = internal_relocs;
2548
                      elf_section_data (section)->this_hdr.contents = contents;
2549
                      symtab_hdr->contents = (unsigned char *) isymbuf;
2550
 
2551
                      /* Count how many bytes we're going to delete.  */
2552
                      if (sym_hash->movm_args)
2553
                        bytes += 2;
2554
 
2555
                      if (sym_hash->stack_size > 0)
2556
                        {
2557
                          if (sym_hash->stack_size <= 128)
2558
                            bytes += 3;
2559
                          else
2560
                            bytes += 4;
2561
                        }
2562
 
2563
                      /* Note that we've deleted prologue bytes for this
2564
                         function.  */
2565
                      sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2566
 
2567
                      /* Actually delete the bytes.  */
2568
                      if (!mn10300_elf_relax_delete_bytes (input_bfd,
2569
                                                           section,
2570
                                                           isym->st_value,
2571
                                                           bytes))
2572
                        goto error_return;
2573
 
2574
                      /* Something changed.  Not strictly necessary, but
2575
                         may lead to more relaxing opportunities.  */
2576
                      *again = TRUE;
2577
                    }
2578
                }
2579
 
2580
              /* Look for any global functions in this section which
2581
                 need insns deleted from their prologues.  */
2582
              symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2583
                          - symtab_hdr->sh_info);
2584
              hashes = elf_sym_hashes (input_bfd);
2585
              end_hashes = hashes + symcount;
2586
              for (; hashes < end_hashes; hashes++)
2587
                {
2588
                  struct elf32_mn10300_link_hash_entry *sym_hash;
2589
 
2590
                  sym_hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2591
                  if ((sym_hash->root.root.type == bfd_link_hash_defined
2592
                       || sym_hash->root.root.type == bfd_link_hash_defweak)
2593
                      && sym_hash->root.root.u.def.section == section
2594
                      && ! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2595
                      && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
2596
                    {
2597
                      int bytes = 0;
2598
                      bfd_vma symval;
2599
 
2600
                      /* Note that we've changed things.  */
2601
                      elf_section_data (section)->relocs = internal_relocs;
2602
                      elf_section_data (section)->this_hdr.contents = contents;
2603
                      symtab_hdr->contents = (unsigned char *) isymbuf;
2604
 
2605
                      /* Count how many bytes we're going to delete.  */
2606
                      if (sym_hash->movm_args)
2607
                        bytes += 2;
2608
 
2609
                      if (sym_hash->stack_size > 0)
2610
                        {
2611
                          if (sym_hash->stack_size <= 128)
2612
                            bytes += 3;
2613
                          else
2614
                            bytes += 4;
2615
                        }
2616
 
2617
                      /* Note that we've deleted prologue bytes for this
2618
                         function.  */
2619
                      sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2620
 
2621
                      /* Actually delete the bytes.  */
2622
                      symval = sym_hash->root.root.u.def.value;
2623
                      if (!mn10300_elf_relax_delete_bytes (input_bfd,
2624
                                                           section,
2625
                                                           symval,
2626
                                                           bytes))
2627
                        goto error_return;
2628
 
2629
                      /* Something changed.  Not strictly necessary, but
2630
                         may lead to more relaxing opportunities.  */
2631
                      *again = TRUE;
2632
                    }
2633
                }
2634
 
2635
              /* Cache or free any memory we allocated for the relocs.  */
2636
              if (internal_relocs != NULL
2637
                  && elf_section_data (section)->relocs != internal_relocs)
2638
                free (internal_relocs);
2639
              internal_relocs = NULL;
2640
 
2641
              /* Cache or free any memory we allocated for the contents.  */
2642
              if (contents != NULL
2643
                  && elf_section_data (section)->this_hdr.contents != contents)
2644
                {
2645
                  if (! link_info->keep_memory)
2646
                    free (contents);
2647
                  else
2648
                    /* Cache the section contents for elf_link_input_bfd.  */
2649
                    elf_section_data (section)->this_hdr.contents = contents;
2650
                }
2651
              contents = NULL;
2652
            }
2653
 
2654
          /* Cache or free any memory we allocated for the symbols.  */
2655
          if (isymbuf != NULL
2656
              && symtab_hdr->contents != (unsigned char *) isymbuf)
2657
            {
2658
              if (! link_info->keep_memory)
2659
                free (isymbuf);
2660
              else
2661
                /* Cache the symbols for elf_link_input_bfd.  */
2662
                symtab_hdr->contents = (unsigned char *) isymbuf;
2663
            }
2664
          isymbuf = NULL;
2665
        }
2666
    }
2667
 
2668
  /* (Re)initialize for the basic instruction shortening/relaxing pass.  */
2669
  contents = NULL;
2670
  internal_relocs = NULL;
2671
  isymbuf = NULL;
2672
  /* For error_return.  */
2673
  section = sec;
2674
 
2675
  /* We don't have to do anything for a relocatable link, if
2676
     this section does not have relocs, or if this is not a
2677
     code section.  */
2678
  if (link_info->relocatable
2679
      || (sec->flags & SEC_RELOC) == 0
2680
      || sec->reloc_count == 0
2681
      || (sec->flags & SEC_CODE) == 0)
2682
    return TRUE;
2683
 
2684
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2685
 
2686
  /* Get a copy of the native relocations.  */
2687
  internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
2688
                                               link_info->keep_memory);
2689
  if (internal_relocs == NULL)
2690
    goto error_return;
2691
 
2692
  /* Scan for worst case alignment gap changes.  Note that this logic
2693
     is not ideal; what we should do is run this scan for every
2694
     opcode/address range and adjust accordingly, but that's
2695
     expensive.  Worst case is that for an alignment of N bytes, we
2696
     move by 2*N-N-1 bytes, assuming we have aligns of 1, 2, 4, 8, etc
2697
     all before it.  Plus, this still doesn't cover cross-section
2698
     jumps with section alignment.  */
2699
  irelend = internal_relocs + sec->reloc_count;
2700
  align_gap_adjustment = 0;
2701
  for (irel = internal_relocs; irel < irelend; irel++)
2702
    {
2703
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN)
2704
        {
2705
          bfd_vma adj = 1 << irel->r_addend;
2706
          bfd_vma aend = irel->r_offset;
2707
 
2708
          aend = BFD_ALIGN (aend, 1 << irel->r_addend);
2709
          adj = 2 * adj - adj - 1;
2710
 
2711
          /* Record the biggest adjustmnet.  Skip any alignment at the
2712
             end of our section.  */
2713
          if (align_gap_adjustment < adj
2714
              && aend < sec->output_section->vma + sec->output_offset + sec->size)
2715
            align_gap_adjustment = adj;
2716
        }
2717
    }
2718
 
2719
  /* Walk through them looking for relaxing opportunities.  */
2720
  irelend = internal_relocs + sec->reloc_count;
2721
  for (irel = internal_relocs; irel < irelend; irel++)
2722
    {
2723
      bfd_vma symval;
2724 225 jeremybenn
      bfd_signed_vma jump_offset;
2725
      asection *sym_sec = NULL;
2726 24 jeremybenn
      struct elf32_mn10300_link_hash_entry *h = NULL;
2727
 
2728
      /* If this isn't something that can be relaxed, then ignore
2729
         this reloc.  */
2730
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
2731
          || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
2732
          || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
2733
        continue;
2734
 
2735
      /* Get the section contents if we haven't done so already.  */
2736
      if (contents == NULL)
2737
        {
2738
          /* Get cached copy if it exists.  */
2739
          if (elf_section_data (sec)->this_hdr.contents != NULL)
2740
            contents = elf_section_data (sec)->this_hdr.contents;
2741
          else
2742
            {
2743
              /* Go get them off disk.  */
2744
              if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2745
                goto error_return;
2746
            }
2747
        }
2748
 
2749
      /* Read this BFD's symbols if we haven't done so already.  */
2750
      if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2751
        {
2752
          isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2753
          if (isymbuf == NULL)
2754
            isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2755
                                            symtab_hdr->sh_info, 0,
2756
                                            NULL, NULL, NULL);
2757
          if (isymbuf == NULL)
2758
            goto error_return;
2759
        }
2760
 
2761
      /* Get the value of the symbol referred to by the reloc.  */
2762
      if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2763
        {
2764
          Elf_Internal_Sym *isym;
2765
          const char *sym_name;
2766
          char *new_name;
2767
 
2768
          /* A local symbol.  */
2769
          isym = isymbuf + ELF32_R_SYM (irel->r_info);
2770
          if (isym->st_shndx == SHN_UNDEF)
2771
            sym_sec = bfd_und_section_ptr;
2772
          else if (isym->st_shndx == SHN_ABS)
2773
            sym_sec = bfd_abs_section_ptr;
2774
          else if (isym->st_shndx == SHN_COMMON)
2775
            sym_sec = bfd_com_section_ptr;
2776
          else
2777
            sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2778
 
2779
          sym_name = bfd_elf_string_from_elf_section (abfd,
2780
                                                      symtab_hdr->sh_link,
2781
                                                      isym->st_name);
2782
 
2783
          if ((sym_sec->flags & SEC_MERGE)
2784
              && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2785
            {
2786 225 jeremybenn
              symval = isym->st_value;
2787
 
2788
              /* GAS may reduce relocations against symbols in SEC_MERGE
2789
                 sections to a relocation against the section symbol when
2790
                 the original addend was zero.  When the reloc is against
2791
                 a section symbol we should include the addend in the
2792
                 offset passed to _bfd_merged_section_offset, since the
2793
                 location of interest is the original symbol.  On the
2794
                 other hand, an access to "sym+addend" where "sym" is not
2795
                 a section symbol should not include the addend;  Such an
2796
                 access is presumed to be an offset from "sym";  The
2797
                 location of interest is just "sym".  */
2798
              if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2799
                symval += irel->r_addend;
2800
 
2801 24 jeremybenn
              symval = _bfd_merged_section_offset (abfd, & sym_sec,
2802
                                                   elf_section_data (sym_sec)->sec_info,
2803
                                                   symval);
2804 225 jeremybenn
 
2805
              if (ELF_ST_TYPE (isym->st_info) != STT_SECTION)
2806
                symval += irel->r_addend;
2807
 
2808
              symval += sym_sec->output_section->vma
2809
                + sym_sec->output_offset - irel->r_addend;
2810 24 jeremybenn
            }
2811
          else
2812
            symval = (isym->st_value
2813
                      + sym_sec->output_section->vma
2814
                      + sym_sec->output_offset);
2815
 
2816
          /* Tack on an ID so we can uniquely identify this
2817
             local symbol in the global hash table.  */
2818
          new_name = bfd_malloc ((bfd_size_type) strlen (sym_name) + 10);
2819
          if (new_name == NULL)
2820
            goto error_return;
2821
          sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2822
          sym_name = new_name;
2823
 
2824
          h = (struct elf32_mn10300_link_hash_entry *)
2825
                elf_link_hash_lookup (&hash_table->static_hash_table->root,
2826
                                      sym_name, FALSE, FALSE, FALSE);
2827
          free (new_name);
2828
        }
2829
      else
2830
        {
2831
          unsigned long indx;
2832
 
2833
          /* An external symbol.  */
2834
          indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2835
          h = (struct elf32_mn10300_link_hash_entry *)
2836
                (elf_sym_hashes (abfd)[indx]);
2837
          BFD_ASSERT (h != NULL);
2838
          if (h->root.root.type != bfd_link_hash_defined
2839
              && h->root.root.type != bfd_link_hash_defweak)
2840
            /* This appears to be a reference to an undefined
2841
               symbol.  Just ignore it--it will be caught by the
2842
               regular reloc processing.  */
2843
            continue;
2844
 
2845
          /* Check for a reference to a discarded symbol and ignore it.  */
2846
          if (h->root.root.u.def.section->output_section == NULL)
2847
            continue;
2848
 
2849 225 jeremybenn
          sym_sec = h->root.root.u.def.section->output_section;
2850
 
2851 24 jeremybenn
          symval = (h->root.root.u.def.value
2852
                    + h->root.root.u.def.section->output_section->vma
2853
                    + h->root.root.u.def.section->output_offset);
2854
        }
2855
 
2856
      /* For simplicity of coding, we are going to modify the section
2857
         contents, the section relocs, and the BFD symbol table.  We
2858
         must tell the rest of the code not to free up this
2859
         information.  It would be possible to instead create a table
2860
         of changes which have to be made, as is done in coff-mips.c;
2861
         that would be more work, but would require less memory when
2862
         the linker is run.  */
2863
 
2864
      /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
2865
         branch/call, also deal with "call" -> "calls" conversions and
2866
         insertion of prologue data into "call" instructions.  */
2867
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32
2868
          || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32)
2869
        {
2870
          bfd_vma value = symval;
2871
 
2872
          if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32
2873
              && h != NULL
2874
              && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
2875
              && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
2876
              && h->root.plt.offset != (bfd_vma) -1)
2877
            {
2878
              asection * splt;
2879
 
2880
              splt = bfd_get_section_by_name (elf_hash_table (link_info)
2881
                                              ->dynobj, ".plt");
2882
 
2883
              value = ((splt->output_section->vma
2884
                        + splt->output_offset
2885
                        + h->root.plt.offset)
2886
                       - (sec->output_section->vma
2887
                          + sec->output_offset
2888
                          + irel->r_offset));
2889
            }
2890
 
2891
          /* If we've got a "call" instruction that needs to be turned
2892
             into a "calls" instruction, do so now.  It saves a byte.  */
2893
          if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2894
            {
2895
              unsigned char code;
2896
 
2897
              /* Get the opcode.  */
2898
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2899
 
2900
              /* Make sure we're working with a "call" instruction!  */
2901
              if (code == 0xdd)
2902
                {
2903
                  /* Note that we've changed the relocs, section contents,
2904
                     etc.  */
2905
                  elf_section_data (sec)->relocs = internal_relocs;
2906
                  elf_section_data (sec)->this_hdr.contents = contents;
2907
                  symtab_hdr->contents = (unsigned char *) isymbuf;
2908
 
2909
                  /* Fix the opcode.  */
2910
                  bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
2911
                  bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
2912
 
2913
                  /* Fix irel->r_offset and irel->r_addend.  */
2914
                  irel->r_offset += 1;
2915
                  irel->r_addend += 1;
2916
 
2917
                  /* Delete one byte of data.  */
2918
                  if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2919
                                                       irel->r_offset + 3, 1))
2920
                    goto error_return;
2921
 
2922
                  /* That will change things, so, we should relax again.
2923
                     Note that this is not required, and it may be slow.  */
2924
                  *again = TRUE;
2925
                }
2926
            }
2927
          else if (h)
2928
            {
2929
              /* We've got a "call" instruction which needs some data
2930
                 from target function filled in.  */
2931
              unsigned char code;
2932
 
2933
              /* Get the opcode.  */
2934
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2935
 
2936
              /* Insert data from the target function into the "call"
2937
                 instruction if needed.  */
2938
              if (code == 0xdd)
2939
                {
2940
                  bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
2941
                  bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
2942
                             contents + irel->r_offset + 5);
2943
                }
2944
            }
2945
 
2946
          /* Deal with pc-relative gunk.  */
2947
          value -= (sec->output_section->vma + sec->output_offset);
2948
          value -= irel->r_offset;
2949
          value += irel->r_addend;
2950
 
2951
          /* See if the value will fit in 16 bits, note the high value is
2952
             0x7fff + 2 as the target will be two bytes closer if we are
2953 225 jeremybenn
             able to relax, if it's in the same section.  */
2954
          if (sec->output_section == sym_sec->output_section)
2955
            jump_offset = 0x8001;
2956
          else
2957
            jump_offset = 0x7fff;
2958
 
2959 24 jeremybenn
          /* Account for jumps across alignment boundaries using
2960
             align_gap_adjustment.  */
2961 225 jeremybenn
          if ((bfd_signed_vma) value < jump_offset - (bfd_signed_vma) align_gap_adjustment
2962 24 jeremybenn
              && ((bfd_signed_vma) value > -0x8000 + (bfd_signed_vma) align_gap_adjustment))
2963
            {
2964
              unsigned char code;
2965
 
2966
              /* Get the opcode.  */
2967
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2968
 
2969
              if (code != 0xdc && code != 0xdd && code != 0xff)
2970
                continue;
2971
 
2972
              /* Note that we've changed the relocs, section contents, etc.  */
2973
              elf_section_data (sec)->relocs = internal_relocs;
2974
              elf_section_data (sec)->this_hdr.contents = contents;
2975
              symtab_hdr->contents = (unsigned char *) isymbuf;
2976
 
2977
              /* Fix the opcode.  */
2978
              if (code == 0xdc)
2979
                bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
2980
              else if (code == 0xdd)
2981
                bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
2982
              else if (code == 0xff)
2983
                bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2984
 
2985
              /* Fix the relocation's type.  */
2986
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2987
                                           (ELF32_R_TYPE (irel->r_info)
2988
                                            == (int) R_MN10300_PLT32)
2989
                                           ? R_MN10300_PLT16 :
2990
                                           R_MN10300_PCREL16);
2991
 
2992
              /* Delete two bytes of data.  */
2993
              if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2994
                                                   irel->r_offset + 1, 2))
2995
                goto error_return;
2996
 
2997
              /* That will change things, so, we should relax again.
2998
                 Note that this is not required, and it may be slow.  */
2999
              *again = TRUE;
3000
            }
3001
        }
3002
 
3003
      /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
3004
         branch.  */
3005
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
3006
        {
3007
          bfd_vma value = symval;
3008
 
3009
          /* If we've got a "call" instruction that needs to be turned
3010
             into a "calls" instruction, do so now.  It saves a byte.  */
3011
          if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
3012
            {
3013
              unsigned char code;
3014
 
3015
              /* Get the opcode.  */
3016
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3017
 
3018
              /* Make sure we're working with a "call" instruction!  */
3019
              if (code == 0xcd)
3020
                {
3021
                  /* Note that we've changed the relocs, section contents,
3022
                     etc.  */
3023
                  elf_section_data (sec)->relocs = internal_relocs;
3024
                  elf_section_data (sec)->this_hdr.contents = contents;
3025
                  symtab_hdr->contents = (unsigned char *) isymbuf;
3026
 
3027
                  /* Fix the opcode.  */
3028
                  bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
3029
                  bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
3030
 
3031
                  /* Fix irel->r_offset and irel->r_addend.  */
3032
                  irel->r_offset += 1;
3033
                  irel->r_addend += 1;
3034
 
3035
                  /* Delete one byte of data.  */
3036
                  if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3037
                                                       irel->r_offset + 1, 1))
3038
                    goto error_return;
3039
 
3040
                  /* That will change things, so, we should relax again.
3041
                     Note that this is not required, and it may be slow.  */
3042
                  *again = TRUE;
3043
                }
3044
            }
3045
          else if (h)
3046
            {
3047
              unsigned char code;
3048
 
3049
              /* Get the opcode.  */
3050
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3051
 
3052
              /* Insert data from the target function into the "call"
3053
                 instruction if needed.  */
3054
              if (code == 0xcd)
3055
                {
3056
                  bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
3057
                  bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
3058
                             contents + irel->r_offset + 3);
3059
                }
3060
            }
3061
 
3062
          /* Deal with pc-relative gunk.  */
3063
          value -= (sec->output_section->vma + sec->output_offset);
3064
          value -= irel->r_offset;
3065
          value += irel->r_addend;
3066
 
3067
          /* See if the value will fit in 8 bits, note the high value is
3068
             0x7f + 1 as the target will be one bytes closer if we are
3069
             able to relax.  */
3070
          if ((long) value < 0x80 && (long) value > -0x80)
3071
            {
3072
              unsigned char code;
3073
 
3074
              /* Get the opcode.  */
3075
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3076
 
3077
              if (code != 0xcc)
3078
                continue;
3079
 
3080
              /* Note that we've changed the relocs, section contents, etc.  */
3081
              elf_section_data (sec)->relocs = internal_relocs;
3082
              elf_section_data (sec)->this_hdr.contents = contents;
3083
              symtab_hdr->contents = (unsigned char *) isymbuf;
3084
 
3085
              /* Fix the opcode.  */
3086
              bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
3087
 
3088
              /* Fix the relocation's type.  */
3089
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3090
                                           R_MN10300_PCREL8);
3091
 
3092
              /* Delete one byte of data.  */
3093
              if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3094
                                                   irel->r_offset + 1, 1))
3095
                goto error_return;
3096
 
3097
              /* That will change things, so, we should relax again.
3098
                 Note that this is not required, and it may be slow.  */
3099
              *again = TRUE;
3100
            }
3101
        }
3102
 
3103
      /* Try to eliminate an unconditional 8 bit pc-relative branch
3104
         which immediately follows a conditional 8 bit pc-relative
3105
         branch around the unconditional branch.
3106
 
3107
            original:           new:
3108
            bCC lab1            bCC' lab2
3109
            bra lab2
3110
           lab1:               lab1:
3111
 
3112
         This happens when the bCC can't reach lab2 at assembly time,
3113
         but due to other relaxations it can reach at link time.  */
3114
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
3115
        {
3116
          Elf_Internal_Rela *nrel;
3117
          bfd_vma value = symval;
3118
          unsigned char code;
3119
 
3120
          /* Deal with pc-relative gunk.  */
3121
          value -= (sec->output_section->vma + sec->output_offset);
3122
          value -= irel->r_offset;
3123
          value += irel->r_addend;
3124
 
3125
          /* Do nothing if this reloc is the last byte in the section.  */
3126
          if (irel->r_offset == sec->size)
3127
            continue;
3128
 
3129
          /* See if the next instruction is an unconditional pc-relative
3130
             branch, more often than not this test will fail, so we
3131
             test it first to speed things up.  */
3132
          code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
3133
          if (code != 0xca)
3134
            continue;
3135
 
3136
          /* Also make sure the next relocation applies to the next
3137
             instruction and that it's a pc-relative 8 bit branch.  */
3138
          nrel = irel + 1;
3139
          if (nrel == irelend
3140
              || irel->r_offset + 2 != nrel->r_offset
3141
              || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
3142
            continue;
3143
 
3144
          /* Make sure our destination immediately follows the
3145
             unconditional branch.  */
3146
          if (symval != (sec->output_section->vma + sec->output_offset
3147
                         + irel->r_offset + 3))
3148
            continue;
3149
 
3150
          /* Now make sure we are a conditional branch.  This may not
3151
             be necessary, but why take the chance.
3152
 
3153
             Note these checks assume that R_MN10300_PCREL8 relocs
3154
             only occur on bCC and bCCx insns.  If they occured
3155
             elsewhere, we'd need to know the start of this insn
3156
             for this check to be accurate.  */
3157
          code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3158
          if (code != 0xc0 && code != 0xc1 && code != 0xc2
3159
              && code != 0xc3 && code != 0xc4 && code != 0xc5
3160
              && code != 0xc6 && code != 0xc7 && code != 0xc8
3161
              && code != 0xc9 && code != 0xe8 && code != 0xe9
3162
              && code != 0xea && code != 0xeb)
3163
            continue;
3164
 
3165
          /* We also have to be sure there is no symbol/label
3166
             at the unconditional branch.  */
3167
          if (mn10300_elf_symbol_address_p (abfd, sec, isymbuf,
3168
                                            irel->r_offset + 1))
3169
            continue;
3170
 
3171
          /* Note that we've changed the relocs, section contents, etc.  */
3172
          elf_section_data (sec)->relocs = internal_relocs;
3173
          elf_section_data (sec)->this_hdr.contents = contents;
3174
          symtab_hdr->contents = (unsigned char *) isymbuf;
3175
 
3176
          /* Reverse the condition of the first branch.  */
3177
          switch (code)
3178
            {
3179
            case 0xc8:
3180
              code = 0xc9;
3181
              break;
3182
            case 0xc9:
3183
              code = 0xc8;
3184
              break;
3185
            case 0xc0:
3186
              code = 0xc2;
3187
              break;
3188
            case 0xc2:
3189
              code = 0xc0;
3190
              break;
3191
            case 0xc3:
3192
              code = 0xc1;
3193
              break;
3194
            case 0xc1:
3195
              code = 0xc3;
3196
              break;
3197
            case 0xc4:
3198
              code = 0xc6;
3199
              break;
3200
            case 0xc6:
3201
              code = 0xc4;
3202
              break;
3203
            case 0xc7:
3204
              code = 0xc5;
3205
              break;
3206
            case 0xc5:
3207
              code = 0xc7;
3208
              break;
3209
            case 0xe8:
3210
              code = 0xe9;
3211
              break;
3212
            case 0x9d:
3213
              code = 0xe8;
3214
              break;
3215
            case 0xea:
3216
              code = 0xeb;
3217
              break;
3218
            case 0xeb:
3219
              code = 0xea;
3220
              break;
3221
            }
3222
          bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3223
 
3224
          /* Set the reloc type and symbol for the first branch
3225
             from the second branch.  */
3226
          irel->r_info = nrel->r_info;
3227
 
3228
          /* Make the reloc for the second branch a null reloc.  */
3229
          nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
3230
                                       R_MN10300_NONE);
3231
 
3232
          /* Delete two bytes of data.  */
3233
          if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3234
                                               irel->r_offset + 1, 2))
3235
            goto error_return;
3236
 
3237
          /* That will change things, so, we should relax again.
3238
             Note that this is not required, and it may be slow.  */
3239
          *again = TRUE;
3240
        }
3241
 
3242
      /* Try to turn a 24 immediate, displacement or absolute address
3243
         into a 8 immediate, displacement or absolute address.  */
3244
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
3245
        {
3246
          bfd_vma value = symval;
3247
          value += irel->r_addend;
3248
 
3249
          /* See if the value will fit in 8 bits.  */
3250
          if ((long) value < 0x7f && (long) value > -0x80)
3251
            {
3252
              unsigned char code;
3253
 
3254
              /* AM33 insns which have 24 operands are 6 bytes long and
3255
                 will have 0xfd as the first byte.  */
3256
 
3257
              /* Get the first opcode.  */
3258
              code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3259
 
3260
              if (code == 0xfd)
3261
                {
3262
                  /* Get the second opcode.  */
3263
                  code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3264
 
3265
                  /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3266
                     equivalent instructions exists.  */
3267
                  if (code != 0x6b && code != 0x7b
3268
                      && code != 0x8b && code != 0x9b
3269
                      && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3270
                          || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3271
                          || (code & 0x0f) == 0x0e))
3272
                    {
3273
                      /* Not safe if the high bit is on as relaxing may
3274
                         move the value out of high mem and thus not fit
3275
                         in a signed 8bit value.  This is currently over
3276
                         conservative.  */
3277
                      if ((value & 0x80) == 0)
3278
                        {
3279
                          /* Note that we've changed the relocation contents,
3280
                             etc.  */
3281
                          elf_section_data (sec)->relocs = internal_relocs;
3282
                          elf_section_data (sec)->this_hdr.contents = contents;
3283
                          symtab_hdr->contents = (unsigned char *) isymbuf;
3284
 
3285
                          /* Fix the opcode.  */
3286
                          bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
3287
                          bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3288
 
3289
                          /* Fix the relocation's type.  */
3290
                          irel->r_info =
3291
                            ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3292
                                          R_MN10300_8);
3293
 
3294
                          /* Delete two bytes of data.  */
3295
                          if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3296
                                                               irel->r_offset + 1, 2))
3297
                            goto error_return;
3298
 
3299
                          /* That will change things, so, we should relax
3300
                             again.  Note that this is not required, and it
3301
                             may be slow.  */
3302
                          *again = TRUE;
3303
                          break;
3304
                        }
3305
                    }
3306
                }
3307
            }
3308
        }
3309
 
3310
      /* Try to turn a 32bit immediate, displacement or absolute address
3311
         into a 16bit immediate, displacement or absolute address.  */
3312
      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32
3313
          || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32
3314
          || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3315
        {
3316
          bfd_vma value = symval;
3317
 
3318
          if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32)
3319
            {
3320
              asection * sgot;
3321
 
3322
              sgot = bfd_get_section_by_name (elf_hash_table (link_info)
3323
                                              ->dynobj, ".got");
3324
 
3325
              if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32)
3326
                {
3327
                  value = sgot->output_offset;
3328
 
3329
                  if (h)
3330
                    value += h->root.got.offset;
3331
                  else
3332
                    value += (elf_local_got_offsets
3333
                              (abfd)[ELF32_R_SYM (irel->r_info)]);
3334
                }
3335
              else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3336
                value -= sgot->output_section->vma;
3337
              else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
3338
                value = (sgot->output_section->vma
3339
                         - (sec->output_section->vma
3340
                            + sec->output_offset
3341
                            + irel->r_offset));
3342
              else
3343
                abort ();
3344
            }
3345
 
3346
          value += irel->r_addend;
3347
 
3348
          /* See if the value will fit in 24 bits.
3349
             We allow any 16bit match here.  We prune those we can't
3350
             handle below.  */
3351
          if ((long) value < 0x7fffff && (long) value > -0x800000)
3352
            {
3353
              unsigned char code;
3354
 
3355
              /* AM33 insns which have 32bit operands are 7 bytes long and
3356
                 will have 0xfe as the first byte.  */
3357
 
3358
              /* Get the first opcode.  */
3359
              code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3360
 
3361
              if (code == 0xfe)
3362
                {
3363
                  /* Get the second opcode.  */
3364
                  code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3365
 
3366
                  /* All the am33 32 -> 24 relaxing possibilities.  */
3367
                  /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3368
                     equivalent instructions exists.  */
3369
                  if (code != 0x6b && code != 0x7b
3370
                      && code != 0x8b && code != 0x9b
3371
                      && (ELF32_R_TYPE (irel->r_info)
3372
                          != (int) R_MN10300_GOTPC32)
3373
                      && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3374
                          || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3375
                          || (code & 0x0f) == 0x0e))
3376
                    {
3377
                      /* Not safe if the high bit is on as relaxing may
3378
                         move the value out of high mem and thus not fit
3379
                         in a signed 16bit value.  This is currently over
3380
                         conservative.  */
3381
                      if ((value & 0x8000) == 0)
3382
                        {
3383
                          /* Note that we've changed the relocation contents,
3384
                             etc.  */
3385
                          elf_section_data (sec)->relocs = internal_relocs;
3386
                          elf_section_data (sec)->this_hdr.contents = contents;
3387
                          symtab_hdr->contents = (unsigned char *) isymbuf;
3388
 
3389
                          /* Fix the opcode.  */
3390
                          bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
3391
                          bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3392
 
3393
                          /* Fix the relocation's type.  */
3394
                          irel->r_info =
3395
                            ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3396
                                          (ELF32_R_TYPE (irel->r_info)
3397
                                           == (int) R_MN10300_GOTOFF32)
3398
                                          ? R_MN10300_GOTOFF24
3399
                                          : (ELF32_R_TYPE (irel->r_info)
3400
                                             == (int) R_MN10300_GOT32)
3401
                                          ? R_MN10300_GOT24 :
3402
                                          R_MN10300_24);
3403
 
3404
                          /* Delete one byte of data.  */
3405
                          if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3406
                                                               irel->r_offset + 3, 1))
3407
                            goto error_return;
3408
 
3409
                          /* That will change things, so, we should relax
3410
                             again.  Note that this is not required, and it
3411
                             may be slow.  */
3412
                          *again = TRUE;
3413
                          break;
3414
                        }
3415
                    }
3416
                }
3417
            }
3418
 
3419
          /* See if the value will fit in 16 bits.
3420
             We allow any 16bit match here.  We prune those we can't
3421
             handle below.  */
3422
          if ((long) value < 0x7fff && (long) value > -0x8000)
3423
            {
3424
              unsigned char code;
3425
 
3426
              /* Most insns which have 32bit operands are 6 bytes long;
3427
                 exceptions are pcrel insns and bit insns.
3428
 
3429
                 We handle pcrel insns above.  We don't bother trying
3430
                 to handle the bit insns here.
3431
 
3432
                 The first byte of the remaining insns will be 0xfc.  */
3433
 
3434
              /* Get the first opcode.  */
3435
              code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3436
 
3437
              if (code != 0xfc)
3438
                continue;
3439
 
3440
              /* Get the second opcode.  */
3441
              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3442
 
3443
              if ((code & 0xf0) < 0x80)
3444
                switch (code & 0xf0)
3445
                  {
3446
                  /* mov (d32,am),dn   -> mov (d32,am),dn
3447
                     mov dm,(d32,am)   -> mov dn,(d32,am)
3448
                     mov (d32,am),an   -> mov (d32,am),an
3449
                     mov dm,(d32,am)   -> mov dn,(d32,am)
3450
                     movbu (d32,am),dn -> movbu (d32,am),dn
3451
                     movbu dm,(d32,am) -> movbu dn,(d32,am)
3452
                     movhu (d32,am),dn -> movhu (d32,am),dn
3453
                     movhu dm,(d32,am) -> movhu dn,(d32,am) */
3454
                  case 0x00:
3455
                  case 0x10:
3456
                  case 0x20:
3457
                  case 0x30:
3458
                  case 0x40:
3459
                  case 0x50:
3460
                  case 0x60:
3461
                  case 0x70:
3462
                    /* Not safe if the high bit is on as relaxing may
3463
                       move the value out of high mem and thus not fit
3464
                       in a signed 16bit value.  */
3465
                    if (code == 0xcc
3466
                        && (value & 0x8000))
3467
                      continue;
3468
 
3469
                    /* Note that we've changed the relocation contents, etc.  */
3470
                    elf_section_data (sec)->relocs = internal_relocs;
3471
                    elf_section_data (sec)->this_hdr.contents = contents;
3472
                    symtab_hdr->contents = (unsigned char *) isymbuf;
3473
 
3474
                    /* Fix the opcode.  */
3475
                    bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3476
                    bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3477
 
3478
                    /* Fix the relocation's type.  */
3479
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3480
                                                 (ELF32_R_TYPE (irel->r_info)
3481
                                                  == (int) R_MN10300_GOTOFF32)
3482
                                                 ? R_MN10300_GOTOFF16
3483
                                                 : (ELF32_R_TYPE (irel->r_info)
3484
                                                    == (int) R_MN10300_GOT32)
3485
                                                 ? R_MN10300_GOT16
3486
                                                 : (ELF32_R_TYPE (irel->r_info)
3487
                                                    == (int) R_MN10300_GOTPC32)
3488
                                                 ? R_MN10300_GOTPC16 :
3489
                                                 R_MN10300_16);
3490
 
3491
                    /* Delete two bytes of data.  */
3492
                    if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3493
                                                         irel->r_offset + 2, 2))
3494
                      goto error_return;
3495
 
3496
                    /* That will change things, so, we should relax again.
3497
                       Note that this is not required, and it may be slow.  */
3498
                    *again = TRUE;
3499
                    break;
3500
                  }
3501
              else if ((code & 0xf0) == 0x80
3502
                       || (code & 0xf0) == 0x90)
3503
                switch (code & 0xf3)
3504
                  {
3505
                  /* mov dn,(abs32)   -> mov dn,(abs16)
3506
                     movbu dn,(abs32) -> movbu dn,(abs16)
3507
                     movhu dn,(abs32) -> movhu dn,(abs16)  */
3508
                  case 0x81:
3509
                  case 0x82:
3510
                  case 0x83:
3511
                    /* Note that we've changed the relocation contents, etc.  */
3512
                    elf_section_data (sec)->relocs = internal_relocs;
3513
                    elf_section_data (sec)->this_hdr.contents = contents;
3514
                    symtab_hdr->contents = (unsigned char *) isymbuf;
3515
 
3516
                    if ((code & 0xf3) == 0x81)
3517
                      code = 0x01 + (code & 0x0c);
3518
                    else if ((code & 0xf3) == 0x82)
3519
                      code = 0x02 + (code & 0x0c);
3520
                    else if ((code & 0xf3) == 0x83)
3521
                      code = 0x03 + (code & 0x0c);
3522
                    else
3523
                      abort ();
3524
 
3525
                    /* Fix the opcode.  */
3526
                    bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3527
 
3528
                    /* Fix the relocation's type.  */
3529
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3530
                                                 (ELF32_R_TYPE (irel->r_info)
3531
                                                  == (int) R_MN10300_GOTOFF32)
3532
                                                 ? R_MN10300_GOTOFF16
3533
                                                 : (ELF32_R_TYPE (irel->r_info)
3534
                                                    == (int) R_MN10300_GOT32)
3535
                                                 ? R_MN10300_GOT16
3536
                                                 : (ELF32_R_TYPE (irel->r_info)
3537
                                                    == (int) R_MN10300_GOTPC32)
3538
                                                 ? R_MN10300_GOTPC16 :
3539
                                                 R_MN10300_16);
3540
 
3541
                    /* The opcode got shorter too, so we have to fix the
3542
                       addend and offset too!  */
3543
                    irel->r_offset -= 1;
3544
 
3545
                    /* Delete three bytes of data.  */
3546
                    if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3547
                                                         irel->r_offset + 1, 3))
3548
                      goto error_return;
3549
 
3550
                    /* That will change things, so, we should relax again.
3551
                       Note that this is not required, and it may be slow.  */
3552
                    *again = TRUE;
3553
                    break;
3554
 
3555
                  /* mov am,(abs32)    -> mov am,(abs16)
3556
                     mov am,(d32,sp)   -> mov am,(d16,sp)
3557
                     mov dm,(d32,sp)   -> mov dm,(d32,sp)
3558
                     movbu dm,(d32,sp) -> movbu dm,(d32,sp)
3559
                     movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
3560
                  case 0x80:
3561
                  case 0x90:
3562
                  case 0x91:
3563
                  case 0x92:
3564
                  case 0x93:
3565
                    /* sp-based offsets are zero-extended.  */
3566
                    if (code >= 0x90 && code <= 0x93
3567
                        && (long) value < 0)
3568
                      continue;
3569
 
3570
                    /* Note that we've changed the relocation contents, etc.  */
3571
                    elf_section_data (sec)->relocs = internal_relocs;
3572
                    elf_section_data (sec)->this_hdr.contents = contents;
3573
                    symtab_hdr->contents = (unsigned char *) isymbuf;
3574
 
3575
                    /* Fix the opcode.  */
3576
                    bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3577
                    bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3578
 
3579
                    /* Fix the relocation's type.  */
3580
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3581
                                                 (ELF32_R_TYPE (irel->r_info)
3582
                                                  == (int) R_MN10300_GOTOFF32)
3583
                                                 ? R_MN10300_GOTOFF16
3584
                                                 : (ELF32_R_TYPE (irel->r_info)
3585
                                                    == (int) R_MN10300_GOT32)
3586
                                                 ? R_MN10300_GOT16
3587
                                                 : (ELF32_R_TYPE (irel->r_info)
3588
                                                    == (int) R_MN10300_GOTPC32)
3589
                                                 ? R_MN10300_GOTPC16 :
3590
                                                 R_MN10300_16);
3591
 
3592
                    /* Delete two bytes of data.  */
3593
                    if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3594
                                                         irel->r_offset + 2, 2))
3595
                      goto error_return;
3596
 
3597
                    /* That will change things, so, we should relax again.
3598
                       Note that this is not required, and it may be slow.  */
3599
                    *again = TRUE;
3600
                    break;
3601
                  }
3602
              else if ((code & 0xf0) < 0xf0)
3603
                switch (code & 0xfc)
3604
                  {
3605
                  /* mov imm32,dn     -> mov imm16,dn
3606
                     mov imm32,an     -> mov imm16,an
3607
                     mov (abs32),dn   -> mov (abs16),dn
3608
                     movbu (abs32),dn -> movbu (abs16),dn
3609
                     movhu (abs32),dn -> movhu (abs16),dn  */
3610
                  case 0xcc:
3611
                  case 0xdc:
3612
                  case 0xa4:
3613
                  case 0xa8:
3614
                  case 0xac:
3615
                    /* Not safe if the high bit is on as relaxing may
3616
                       move the value out of high mem and thus not fit
3617
                       in a signed 16bit value.  */
3618
                    if (code == 0xcc
3619
                        && (value & 0x8000))
3620
                      continue;
3621
 
3622
                    /* mov imm16, an zero-extends the immediate.  */
3623
                    if (code == 0xdc
3624
                        && (long) value < 0)
3625
                      continue;
3626
 
3627
                    /* Note that we've changed the relocation contents, etc.  */
3628
                    elf_section_data (sec)->relocs = internal_relocs;
3629
                    elf_section_data (sec)->this_hdr.contents = contents;
3630
                    symtab_hdr->contents = (unsigned char *) isymbuf;
3631
 
3632
                    if ((code & 0xfc) == 0xcc)
3633
                      code = 0x2c + (code & 0x03);
3634
                    else if ((code & 0xfc) == 0xdc)
3635
                      code = 0x24 + (code & 0x03);
3636
                    else if ((code & 0xfc) == 0xa4)
3637
                      code = 0x30 + (code & 0x03);
3638
                    else if ((code & 0xfc) == 0xa8)
3639
                      code = 0x34 + (code & 0x03);
3640
                    else if ((code & 0xfc) == 0xac)
3641
                      code = 0x38 + (code & 0x03);
3642
                    else
3643
                      abort ();
3644
 
3645
                    /* Fix the opcode.  */
3646
                    bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3647
 
3648
                    /* Fix the relocation's type.  */
3649
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3650
                                                 (ELF32_R_TYPE (irel->r_info)
3651
                                                  == (int) R_MN10300_GOTOFF32)
3652
                                                 ? R_MN10300_GOTOFF16
3653
                                                 : (ELF32_R_TYPE (irel->r_info)
3654
                                                    == (int) R_MN10300_GOT32)
3655
                                                 ? R_MN10300_GOT16
3656
                                                 : (ELF32_R_TYPE (irel->r_info)
3657
                                                    == (int) R_MN10300_GOTPC32)
3658
                                                 ? R_MN10300_GOTPC16 :
3659
                                                 R_MN10300_16);
3660
 
3661
                    /* The opcode got shorter too, so we have to fix the
3662
                       addend and offset too!  */
3663
                    irel->r_offset -= 1;
3664
 
3665
                    /* Delete three bytes of data.  */
3666
                    if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3667
                                                         irel->r_offset + 1, 3))
3668
                      goto error_return;
3669
 
3670
                    /* That will change things, so, we should relax again.
3671
                       Note that this is not required, and it may be slow.  */
3672
                    *again = TRUE;
3673
                    break;
3674
 
3675
                  /* mov (abs32),an    -> mov (abs16),an
3676
                     mov (d32,sp),an   -> mov (d16,sp),an
3677
                     mov (d32,sp),dn   -> mov (d16,sp),dn
3678
                     movbu (d32,sp),dn -> movbu (d16,sp),dn
3679
                     movhu (d32,sp),dn -> movhu (d16,sp),dn
3680
                     add imm32,dn      -> add imm16,dn
3681
                     cmp imm32,dn      -> cmp imm16,dn
3682
                     add imm32,an      -> add imm16,an
3683
                     cmp imm32,an      -> cmp imm16,an
3684
                     and imm32,dn      -> and imm16,dn
3685
                     or imm32,dn       -> or imm16,dn
3686
                     xor imm32,dn      -> xor imm16,dn
3687
                     btst imm32,dn     -> btst imm16,dn */
3688
 
3689
                  case 0xa0:
3690
                  case 0xb0:
3691
                  case 0xb1:
3692
                  case 0xb2:
3693
                  case 0xb3:
3694
                  case 0xc0:
3695
                  case 0xc8:
3696
 
3697
                  case 0xd0:
3698
                  case 0xd8:
3699
                  case 0xe0:
3700
                  case 0xe1:
3701
                  case 0xe2:
3702
                  case 0xe3:
3703
                    /* cmp imm16, an zero-extends the immediate.  */
3704
                    if (code == 0xdc
3705
                        && (long) value < 0)
3706
                      continue;
3707
 
3708
                    /* So do sp-based offsets.  */
3709
                    if (code >= 0xb0 && code <= 0xb3
3710
                        && (long) value < 0)
3711
                      continue;
3712
 
3713
                    /* Note that we've changed the relocation contents, etc.  */
3714
                    elf_section_data (sec)->relocs = internal_relocs;
3715
                    elf_section_data (sec)->this_hdr.contents = contents;
3716
                    symtab_hdr->contents = (unsigned char *) isymbuf;
3717
 
3718
                    /* Fix the opcode.  */
3719
                    bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3720
                    bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3721
 
3722
                    /* Fix the relocation's type.  */
3723
                    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3724
                                                 (ELF32_R_TYPE (irel->r_info)
3725
                                                  == (int) R_MN10300_GOTOFF32)
3726
                                                 ? R_MN10300_GOTOFF16
3727
                                                 : (ELF32_R_TYPE (irel->r_info)
3728
                                                    == (int) R_MN10300_GOT32)
3729
                                                 ? R_MN10300_GOT16
3730
                                                 : (ELF32_R_TYPE (irel->r_info)
3731
                                                    == (int) R_MN10300_GOTPC32)
3732
                                                 ? R_MN10300_GOTPC16 :
3733
                                                 R_MN10300_16);
3734
 
3735
                    /* Delete two bytes of data.  */
3736
                    if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3737
                                                         irel->r_offset + 2, 2))
3738
                      goto error_return;
3739
 
3740
                    /* That will change things, so, we should relax again.
3741
                       Note that this is not required, and it may be slow.  */
3742
                    *again = TRUE;
3743
                    break;
3744
                  }
3745
              else if (code == 0xfe)
3746
                {
3747
                  /* add imm32,sp -> add imm16,sp  */
3748
 
3749
                  /* Note that we've changed the relocation contents, etc.  */
3750
                  elf_section_data (sec)->relocs = internal_relocs;
3751
                  elf_section_data (sec)->this_hdr.contents = contents;
3752
                  symtab_hdr->contents = (unsigned char *) isymbuf;
3753
 
3754
                  /* Fix the opcode.  */
3755
                  bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3756
                  bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
3757
 
3758
                  /* Fix the relocation's type.  */
3759
                  irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3760
                                               (ELF32_R_TYPE (irel->r_info)
3761
                                                == (int) R_MN10300_GOT32)
3762
                                               ? R_MN10300_GOT16
3763
                                               : (ELF32_R_TYPE (irel->r_info)
3764
                                                  == (int) R_MN10300_GOTOFF32)
3765
                                               ? R_MN10300_GOTOFF16
3766
                                               : (ELF32_R_TYPE (irel->r_info)
3767
                                                  == (int) R_MN10300_GOTPC32)
3768
                                               ? R_MN10300_GOTPC16 :
3769
                                               R_MN10300_16);
3770
 
3771
                  /* Delete two bytes of data.  */
3772
                  if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3773
                                                       irel->r_offset + 2, 2))
3774
                    goto error_return;
3775
 
3776
                  /* That will change things, so, we should relax again.
3777
                     Note that this is not required, and it may be slow.  */
3778
                  *again = TRUE;
3779
                  break;
3780
                }
3781
            }
3782
        }
3783
    }
3784
 
3785
  if (isymbuf != NULL
3786
      && symtab_hdr->contents != (unsigned char *) isymbuf)
3787
    {
3788
      if (! link_info->keep_memory)
3789
        free (isymbuf);
3790
      else
3791
        {
3792
          /* Cache the symbols for elf_link_input_bfd.  */
3793
          symtab_hdr->contents = (unsigned char *) isymbuf;
3794
        }
3795
    }
3796
 
3797
  if (contents != NULL
3798
      && elf_section_data (sec)->this_hdr.contents != contents)
3799
    {
3800
      if (! link_info->keep_memory)
3801
        free (contents);
3802
      else
3803
        {
3804
          /* Cache the section contents for elf_link_input_bfd.  */
3805
          elf_section_data (sec)->this_hdr.contents = contents;
3806
        }
3807
    }
3808
 
3809
  if (internal_relocs != NULL
3810
      && elf_section_data (sec)->relocs != internal_relocs)
3811
    free (internal_relocs);
3812
 
3813
  return TRUE;
3814
 
3815
 error_return:
3816
  if (isymbuf != NULL
3817
      && symtab_hdr->contents != (unsigned char *) isymbuf)
3818
    free (isymbuf);
3819
  if (contents != NULL
3820
      && elf_section_data (section)->this_hdr.contents != contents)
3821
    free (contents);
3822
  if (internal_relocs != NULL
3823
      && elf_section_data (section)->relocs != internal_relocs)
3824
    free (internal_relocs);
3825
 
3826
  return FALSE;
3827
}
3828
 
3829
/* This is a version of bfd_generic_get_relocated_section_contents
3830
   which uses mn10300_elf_relocate_section.  */
3831
 
3832
static bfd_byte *
3833
mn10300_elf_get_relocated_section_contents (bfd *output_bfd,
3834
                                            struct bfd_link_info *link_info,
3835
                                            struct bfd_link_order *link_order,
3836
                                            bfd_byte *data,
3837
                                            bfd_boolean relocatable,
3838
                                            asymbol **symbols)
3839
{
3840
  Elf_Internal_Shdr *symtab_hdr;
3841
  asection *input_section = link_order->u.indirect.section;
3842
  bfd *input_bfd = input_section->owner;
3843
  asection **sections = NULL;
3844
  Elf_Internal_Rela *internal_relocs = NULL;
3845
  Elf_Internal_Sym *isymbuf = NULL;
3846
 
3847
  /* We only need to handle the case of relaxing, or of having a
3848
     particular set of section contents, specially.  */
3849
  if (relocatable
3850
      || elf_section_data (input_section)->this_hdr.contents == NULL)
3851
    return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3852
                                                       link_order, data,
3853
                                                       relocatable,
3854
                                                       symbols);
3855
 
3856
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3857
 
3858
  memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3859
          (size_t) input_section->size);
3860
 
3861
  if ((input_section->flags & SEC_RELOC) != 0
3862
      && input_section->reloc_count > 0)
3863
    {
3864
      asection **secpp;
3865
      Elf_Internal_Sym *isym, *isymend;
3866
      bfd_size_type amt;
3867
 
3868
      internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
3869
                                                   NULL, NULL, FALSE);
3870
      if (internal_relocs == NULL)
3871
        goto error_return;
3872
 
3873
      if (symtab_hdr->sh_info != 0)
3874
        {
3875
          isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3876
          if (isymbuf == NULL)
3877
            isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3878
                                            symtab_hdr->sh_info, 0,
3879
                                            NULL, NULL, NULL);
3880
          if (isymbuf == NULL)
3881
            goto error_return;
3882
        }
3883
 
3884
      amt = symtab_hdr->sh_info;
3885
      amt *= sizeof (asection *);
3886
      sections = bfd_malloc (amt);
3887
      if (sections == NULL && amt != 0)
3888
        goto error_return;
3889
 
3890
      isymend = isymbuf + symtab_hdr->sh_info;
3891
      for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
3892
        {
3893
          asection *isec;
3894
 
3895
          if (isym->st_shndx == SHN_UNDEF)
3896
            isec = bfd_und_section_ptr;
3897
          else if (isym->st_shndx == SHN_ABS)
3898
            isec = bfd_abs_section_ptr;
3899
          else if (isym->st_shndx == SHN_COMMON)
3900
            isec = bfd_com_section_ptr;
3901
          else
3902
            isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3903
 
3904
          *secpp = isec;
3905
        }
3906
 
3907
      if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
3908
                                          input_section, data, internal_relocs,
3909
                                          isymbuf, sections))
3910
        goto error_return;
3911
 
3912
      if (sections != NULL)
3913
        free (sections);
3914
      if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3915
        free (isymbuf);
3916
      if (internal_relocs != elf_section_data (input_section)->relocs)
3917
        free (internal_relocs);
3918
    }
3919
 
3920
  return data;
3921
 
3922
 error_return:
3923
  if (sections != NULL)
3924
    free (sections);
3925
  if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3926
    free (isymbuf);
3927
  if (internal_relocs != NULL
3928
      && internal_relocs != elf_section_data (input_section)->relocs)
3929
    free (internal_relocs);
3930
  return NULL;
3931
}
3932
 
3933
/* Assorted hash table functions.  */
3934
 
3935
/* Initialize an entry in the link hash table.  */
3936
 
3937
/* Create an entry in an MN10300 ELF linker hash table.  */
3938
 
3939
static struct bfd_hash_entry *
3940
elf32_mn10300_link_hash_newfunc (struct bfd_hash_entry *entry,
3941
                                 struct bfd_hash_table *table,
3942
                                 const char *string)
3943
{
3944
  struct elf32_mn10300_link_hash_entry *ret =
3945
    (struct elf32_mn10300_link_hash_entry *) entry;
3946
 
3947
  /* Allocate the structure if it has not already been allocated by a
3948
     subclass.  */
3949
  if (ret == NULL)
3950
    ret = (struct elf32_mn10300_link_hash_entry *)
3951
           bfd_hash_allocate (table, sizeof (* ret));
3952
  if (ret == NULL)
3953
    return (struct bfd_hash_entry *) ret;
3954
 
3955
  /* Call the allocation method of the superclass.  */
3956
  ret = (struct elf32_mn10300_link_hash_entry *)
3957
         _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3958
                                     table, string);
3959
  if (ret != NULL)
3960
    {
3961
      ret->direct_calls = 0;
3962
      ret->stack_size = 0;
3963
      ret->movm_args = 0;
3964
      ret->movm_stack_size = 0;
3965
      ret->flags = 0;
3966
      ret->value = 0;
3967
    }
3968
 
3969
  return (struct bfd_hash_entry *) ret;
3970
}
3971
 
3972
/* Create an mn10300 ELF linker hash table.  */
3973
 
3974
static struct bfd_link_hash_table *
3975
elf32_mn10300_link_hash_table_create (bfd *abfd)
3976
{
3977
  struct elf32_mn10300_link_hash_table *ret;
3978
  bfd_size_type amt = sizeof (* ret);
3979
 
3980
  ret = bfd_malloc (amt);
3981
  if (ret == NULL)
3982
    return NULL;
3983
 
3984
  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3985
                                      elf32_mn10300_link_hash_newfunc,
3986
                                      sizeof (struct elf32_mn10300_link_hash_entry)))
3987
    {
3988
      free (ret);
3989
      return NULL;
3990
    }
3991
 
3992
  ret->flags = 0;
3993
  amt = sizeof (struct elf_link_hash_table);
3994
  ret->static_hash_table = bfd_malloc (amt);
3995
  if (ret->static_hash_table == NULL)
3996
    {
3997
      free (ret);
3998
      return NULL;
3999
    }
4000
 
4001
  if (!_bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
4002
                                      elf32_mn10300_link_hash_newfunc,
4003
                                      sizeof (struct elf32_mn10300_link_hash_entry)))
4004
    {
4005
      free (ret->static_hash_table);
4006
      free (ret);
4007
      return NULL;
4008
    }
4009
  return & ret->root.root;
4010
}
4011
 
4012
/* Free an mn10300 ELF linker hash table.  */
4013
 
4014
static void
4015
elf32_mn10300_link_hash_table_free (struct bfd_link_hash_table *hash)
4016
{
4017
  struct elf32_mn10300_link_hash_table *ret
4018
    = (struct elf32_mn10300_link_hash_table *) hash;
4019
 
4020
  _bfd_generic_link_hash_table_free
4021
    ((struct bfd_link_hash_table *) ret->static_hash_table);
4022
  _bfd_generic_link_hash_table_free
4023
    ((struct bfd_link_hash_table *) ret);
4024
}
4025
 
4026
static unsigned long
4027
elf_mn10300_mach (flagword flags)
4028
{
4029
  switch (flags & EF_MN10300_MACH)
4030
    {
4031
    case E_MN10300_MACH_MN10300:
4032
    default:
4033
      return bfd_mach_mn10300;
4034
 
4035
    case E_MN10300_MACH_AM33:
4036
      return bfd_mach_am33;
4037
 
4038
    case E_MN10300_MACH_AM33_2:
4039
      return bfd_mach_am33_2;
4040
    }
4041
}
4042
 
4043
/* The final processing done just before writing out a MN10300 ELF object
4044
   file.  This gets the MN10300 architecture right based on the machine
4045
   number.  */
4046
 
4047
static void
4048
_bfd_mn10300_elf_final_write_processing (bfd *abfd,
4049
                                         bfd_boolean linker ATTRIBUTE_UNUSED)
4050
{
4051
  unsigned long val;
4052
 
4053
  switch (bfd_get_mach (abfd))
4054
    {
4055
    default:
4056
    case bfd_mach_mn10300:
4057
      val = E_MN10300_MACH_MN10300;
4058
      break;
4059
 
4060
    case bfd_mach_am33:
4061
      val = E_MN10300_MACH_AM33;
4062
      break;
4063
 
4064
    case bfd_mach_am33_2:
4065
      val = E_MN10300_MACH_AM33_2;
4066
      break;
4067
    }
4068
 
4069
  elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
4070
  elf_elfheader (abfd)->e_flags |= val;
4071
}
4072
 
4073
static bfd_boolean
4074
_bfd_mn10300_elf_object_p (bfd *abfd)
4075
{
4076
  bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
4077
                             elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
4078
  return TRUE;
4079
}
4080
 
4081
/* Merge backend specific data from an object file to the output
4082
   object file when linking.  */
4083
 
4084
static bfd_boolean
4085
_bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4086
{
4087
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4088
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4089
    return TRUE;
4090
 
4091
  if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4092
      && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
4093
    {
4094
      if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4095
                               bfd_get_mach (ibfd)))
4096
        return FALSE;
4097
    }
4098
 
4099
  return TRUE;
4100
}
4101
 
4102
#define PLT0_ENTRY_SIZE     15
4103
#define PLT_ENTRY_SIZE      20
4104
#define PIC_PLT_ENTRY_SIZE  24
4105
 
4106
static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] =
4107
{
4108
  0xfc, 0xa0, 0, 0, 0, 0,   /* mov  (.got+8),a0 */
4109
  0xfe, 0xe, 0x10, 0, 0, 0, 0,      /* mov  (.got+4),r1 */
4110
  0xf0, 0xf4,                   /* jmp  (a0) */
4111
};
4112
 
4113
static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] =
4114
{
4115
  0xfc, 0xa0, 0, 0, 0, 0,   /* mov  (nameN@GOT + .got),a0 */
4116
  0xf0, 0xf4,                   /* jmp  (a0) */
4117
  0xfe, 8, 0, 0, 0, 0, 0,    /* mov  reloc-table-address,r0 */
4118
  0xdc, 0, 0, 0, 0,         /* jmp  .plt0 */
4119
};
4120
 
4121
static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] =
4122
{
4123
  0xfc, 0x22, 0, 0, 0, 0,   /* mov  (nameN@GOT,a2),a0 */
4124
  0xf0, 0xf4,                   /* jmp  (a0) */
4125
  0xfe, 8, 0, 0, 0, 0, 0,    /* mov  reloc-table-address,r0 */
4126
  0xf8, 0x22, 8,                /* mov  (8,a2),a0 */
4127
  0xfb, 0xa, 0x1a, 4,           /* mov  (4,a2),r1 */
4128
  0xf0, 0xf4,                   /* jmp  (a0) */
4129
};
4130
 
4131
/* Return size of the first PLT entry.  */
4132
#define elf_mn10300_sizeof_plt0(info) \
4133
  (info->shared ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
4134
 
4135
/* Return size of a PLT entry.  */
4136
#define elf_mn10300_sizeof_plt(info) \
4137
  (info->shared ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
4138
 
4139
/* Return offset of the PLT0 address in an absolute PLT entry.  */
4140
#define elf_mn10300_plt_plt0_offset(info) 16
4141
 
4142
/* Return offset of the linker in PLT0 entry.  */
4143
#define elf_mn10300_plt0_linker_offset(info) 2
4144
 
4145
/* Return offset of the GOT id in PLT0 entry.  */
4146
#define elf_mn10300_plt0_gotid_offset(info) 9
4147
 
4148
/* Return offset of the temporary in PLT entry.  */
4149
#define elf_mn10300_plt_temp_offset(info) 8
4150
 
4151
/* Return offset of the symbol in PLT entry.  */
4152
#define elf_mn10300_plt_symbol_offset(info) 2
4153
 
4154
/* Return offset of the relocation in PLT entry.  */
4155
#define elf_mn10300_plt_reloc_offset(info) 11
4156
 
4157
/* The name of the dynamic interpreter.  This is put in the .interp
4158
   section.  */
4159
 
4160
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
4161
 
4162
/* Create dynamic sections when linking against a dynamic object.  */
4163
 
4164
static bfd_boolean
4165
_bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4166
{
4167
  flagword   flags;
4168
  asection * s;
4169
  const struct elf_backend_data * bed = get_elf_backend_data (abfd);
4170
  int ptralign = 0;
4171
 
4172
  switch (bed->s->arch_size)
4173
    {
4174
    case 32:
4175
      ptralign = 2;
4176
      break;
4177
 
4178
    case 64:
4179
      ptralign = 3;
4180
      break;
4181
 
4182
    default:
4183
      bfd_set_error (bfd_error_bad_value);
4184
      return FALSE;
4185
    }
4186
 
4187
  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4188
     .rel[a].bss sections.  */
4189
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4190
           | SEC_LINKER_CREATED);
4191
 
4192
  s = bfd_make_section_with_flags (abfd,
4193
                                   (bed->default_use_rela_p
4194
                                    ? ".rela.plt" : ".rel.plt"),
4195
                                   flags | SEC_READONLY);
4196
  if (s == NULL
4197
      || ! bfd_set_section_alignment (abfd, s, ptralign))
4198
    return FALSE;
4199
 
4200
  if (! _bfd_mn10300_elf_create_got_section (abfd, info))
4201
    return FALSE;
4202
 
4203
  {
4204
    const char * secname;
4205
    char *       relname;
4206
    flagword     secflags;
4207
    asection *   sec;
4208
 
4209
    for (sec = abfd->sections; sec; sec = sec->next)
4210
      {
4211
        secflags = bfd_get_section_flags (abfd, sec);
4212
        if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
4213
            || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
4214
          continue;
4215
 
4216
        secname = bfd_get_section_name (abfd, sec);
4217
        relname = bfd_malloc (strlen (secname) + 6);
4218
        strcpy (relname, ".rela");
4219
        strcat (relname, secname);
4220
 
4221
        s = bfd_make_section_with_flags (abfd, relname,
4222
                                         flags | SEC_READONLY);
4223
        if (s == NULL
4224
            || ! bfd_set_section_alignment (abfd, s, ptralign))
4225
          return FALSE;
4226
      }
4227
  }
4228
 
4229
  if (bed->want_dynbss)
4230
    {
4231
      /* The .dynbss section is a place to put symbols which are defined
4232
         by dynamic objects, are referenced by regular objects, and are
4233
         not functions.  We must allocate space for them in the process
4234
         image and use a R_*_COPY reloc to tell the dynamic linker to
4235
         initialize them at run time.  The linker script puts the .dynbss
4236
         section into the .bss section of the final image.  */
4237
      s = bfd_make_section_with_flags (abfd, ".dynbss",
4238
                                       SEC_ALLOC | SEC_LINKER_CREATED);
4239
      if (s == NULL)
4240
        return FALSE;
4241
 
4242
      /* The .rel[a].bss section holds copy relocs.  This section is not
4243
         normally needed.  We need to create it here, though, so that the
4244
         linker will map it to an output section.  We can't just create it
4245
         only if we need it, because we will not know whether we need it
4246
         until we have seen all the input files, and the first time the
4247
         main linker code calls BFD after examining all the input files
4248
         (size_dynamic_sections) the input sections have already been
4249
         mapped to the output sections.  If the section turns out not to
4250
         be needed, we can discard it later.  We will never need this
4251
         section when generating a shared object, since they do not use
4252
         copy relocs.  */
4253
      if (! info->shared)
4254
        {
4255
          s = bfd_make_section_with_flags (abfd,
4256
                                           (bed->default_use_rela_p
4257
                                            ? ".rela.bss" : ".rel.bss"),
4258
                                           flags | SEC_READONLY);
4259
          if (s == NULL
4260
              || ! bfd_set_section_alignment (abfd, s, ptralign))
4261
            return FALSE;
4262
        }
4263
    }
4264
 
4265
  return TRUE;
4266
}
4267
 
4268
/* Adjust a symbol defined by a dynamic object and referenced by a
4269
   regular object.  The current definition is in some section of the
4270
   dynamic object, but we're not including those sections.  We have to
4271
   change the definition to something the rest of the link can
4272
   understand.  */
4273
 
4274
static bfd_boolean
4275
_bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
4276
                                        struct elf_link_hash_entry * h)
4277
{
4278
  bfd * dynobj;
4279
  asection * s;
4280
 
4281
  dynobj = elf_hash_table (info)->dynobj;
4282
 
4283
  /* Make sure we know what is going on here.  */
4284
  BFD_ASSERT (dynobj != NULL
4285
              && (h->needs_plt
4286
                  || h->u.weakdef != NULL
4287
                  || (h->def_dynamic
4288
                      && h->ref_regular
4289
                      && !h->def_regular)));
4290
 
4291
  /* If this is a function, put it in the procedure linkage table.  We
4292
     will fill in the contents of the procedure linkage table later,
4293
     when we know the address of the .got section.  */
4294
  if (h->type == STT_FUNC
4295
      || h->needs_plt)
4296
    {
4297
      if (! info->shared
4298
          && !h->def_dynamic
4299
          && !h->ref_dynamic)
4300
        {
4301
          /* This case can occur if we saw a PLT reloc in an input
4302
             file, but the symbol was never referred to by a dynamic
4303
             object.  In such a case, we don't actually need to build
4304
             a procedure linkage table, and we can just do a REL32
4305
             reloc instead.  */
4306
          BFD_ASSERT (h->needs_plt);
4307
          return TRUE;
4308
        }
4309
 
4310
      /* Make sure this symbol is output as a dynamic symbol.  */
4311
      if (h->dynindx == -1)
4312
        {
4313
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
4314
            return FALSE;
4315
        }
4316
 
4317
      s = bfd_get_section_by_name (dynobj, ".plt");
4318
      BFD_ASSERT (s != NULL);
4319
 
4320
      /* If this is the first .plt entry, make room for the special
4321
         first entry.  */
4322
      if (s->size == 0)
4323
        s->size += elf_mn10300_sizeof_plt0 (info);
4324
 
4325
      /* If this symbol is not defined in a regular file, and we are
4326
         not generating a shared library, then set the symbol to this
4327
         location in the .plt.  This is required to make function
4328
         pointers compare as equal between the normal executable and
4329
         the shared library.  */
4330
      if (! info->shared
4331
          && !h->def_regular)
4332
        {
4333
          h->root.u.def.section = s;
4334
          h->root.u.def.value = s->size;
4335
        }
4336
 
4337
      h->plt.offset = s->size;
4338
 
4339
      /* Make room for this entry.  */
4340
      s->size += elf_mn10300_sizeof_plt (info);
4341
 
4342
      /* We also need to make an entry in the .got.plt section, which
4343
         will be placed in the .got section by the linker script.  */
4344
      s = bfd_get_section_by_name (dynobj, ".got.plt");
4345
      BFD_ASSERT (s != NULL);
4346
      s->size += 4;
4347
 
4348
      /* We also need to make an entry in the .rela.plt section.  */
4349
      s = bfd_get_section_by_name (dynobj, ".rela.plt");
4350
      BFD_ASSERT (s != NULL);
4351
      s->size += sizeof (Elf32_External_Rela);
4352
 
4353
      return TRUE;
4354
    }
4355
 
4356
  /* If this is a weak symbol, and there is a real definition, the
4357
     processor independent code will have arranged for us to see the
4358
     real definition first, and we can just use the same value.  */
4359
  if (h->u.weakdef != NULL)
4360
    {
4361
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4362
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
4363
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
4364
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
4365
      return TRUE;
4366
    }
4367
 
4368
  /* This is a reference to a symbol defined by a dynamic object which
4369
     is not a function.  */
4370
 
4371
  /* If we are creating a shared library, we must presume that the
4372
     only references to the symbol are via the global offset table.
4373
     For such cases we need not do anything here; the relocations will
4374
     be handled correctly by relocate_section.  */
4375
  if (info->shared)
4376
    return TRUE;
4377
 
4378
  /* If there are no references to this symbol that do not use the
4379
     GOT, we don't need to generate a copy reloc.  */
4380
  if (!h->non_got_ref)
4381
    return TRUE;
4382
 
4383
  if (h->size == 0)
4384
    {
4385
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
4386
                             h->root.root.string);
4387
      return TRUE;
4388
    }
4389
 
4390
  /* We must allocate the symbol in our .dynbss section, which will
4391
     become part of the .bss section of the executable.  There will be
4392
     an entry for this symbol in the .dynsym section.  The dynamic
4393
     object will contain position independent code, so all references
4394
     from the dynamic object to this symbol will go through the global
4395
     offset table.  The dynamic linker will use the .dynsym entry to
4396
     determine the address it must put in the global offset table, so
4397
     both the dynamic object and the regular object will refer to the
4398
     same memory location for the variable.  */
4399
 
4400
  s = bfd_get_section_by_name (dynobj, ".dynbss");
4401
  BFD_ASSERT (s != NULL);
4402
 
4403
  /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to
4404
     copy the initial value out of the dynamic object and into the
4405
     runtime process image.  We need to remember the offset into the
4406
     .rela.bss section we are going to use.  */
4407
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4408
    {
4409
      asection * srel;
4410
 
4411
      srel = bfd_get_section_by_name (dynobj, ".rela.bss");
4412
      BFD_ASSERT (srel != NULL);
4413
      srel->size += sizeof (Elf32_External_Rela);
4414
      h->needs_copy = 1;
4415
    }
4416
 
4417
  return _bfd_elf_adjust_dynamic_copy (h, s);
4418
}
4419
 
4420
/* Set the sizes of the dynamic sections.  */
4421
 
4422
static bfd_boolean
4423
_bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
4424
                                        struct bfd_link_info * info)
4425
{
4426
  bfd * dynobj;
4427
  asection * s;
4428
  bfd_boolean plt;
4429
  bfd_boolean relocs;
4430
  bfd_boolean reltext;
4431
 
4432
  dynobj = elf_hash_table (info)->dynobj;
4433
  BFD_ASSERT (dynobj != NULL);
4434
 
4435
  if (elf_hash_table (info)->dynamic_sections_created)
4436
    {
4437
      /* Set the contents of the .interp section to the interpreter.  */
4438
      if (info->executable)
4439
        {
4440
          s = bfd_get_section_by_name (dynobj, ".interp");
4441
          BFD_ASSERT (s != NULL);
4442
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4443
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4444
        }
4445
    }
4446
  else
4447
    {
4448
      /* We may have created entries in the .rela.got section.
4449
         However, if we are not creating the dynamic sections, we will
4450
         not actually use these entries.  Reset the size of .rela.got,
4451
         which will cause it to get stripped from the output file
4452
         below.  */
4453
      s = bfd_get_section_by_name (dynobj, ".rela.got");
4454
      if (s != NULL)
4455
        s->size = 0;
4456
    }
4457
 
4458
  /* The check_relocs and adjust_dynamic_symbol entry points have
4459
     determined the sizes of the various dynamic sections.  Allocate
4460
     memory for them.  */
4461
  plt = FALSE;
4462
  relocs = FALSE;
4463
  reltext = FALSE;
4464
  for (s = dynobj->sections; s != NULL; s = s->next)
4465
    {
4466
      const char * name;
4467
 
4468
      if ((s->flags & SEC_LINKER_CREATED) == 0)
4469
        continue;
4470
 
4471
      /* It's OK to base decisions on the section name, because none
4472
         of the dynobj section names depend upon the input files.  */
4473
      name = bfd_get_section_name (dynobj, s);
4474
 
4475
      if (streq (name, ".plt"))
4476
        {
4477
          /* Remember whether there is a PLT.  */
4478
          plt = s->size != 0;
4479
        }
4480
      else if (CONST_STRNEQ (name, ".rela"))
4481
        {
4482
          if (s->size != 0)
4483
            {
4484
              asection * target;
4485
 
4486
              /* Remember whether there are any reloc sections other
4487
                 than .rela.plt.  */
4488
              if (! streq (name, ".rela.plt"))
4489
                {
4490
                  const char * outname;
4491
 
4492
                  relocs = TRUE;
4493
 
4494
                  /* If this relocation section applies to a read only
4495
                     section, then we probably need a DT_TEXTREL
4496
                     entry.  The entries in the .rela.plt section
4497
                     really apply to the .got section, which we
4498
                     created ourselves and so know is not readonly.  */
4499
                  outname = bfd_get_section_name (output_bfd,
4500
                                                  s->output_section);
4501
                  target = bfd_get_section_by_name (output_bfd, outname + 5);
4502
                  if (target != NULL
4503
                      && (target->flags & SEC_READONLY) != 0
4504
                      && (target->flags & SEC_ALLOC) != 0)
4505
                    reltext = TRUE;
4506
                }
4507
 
4508
              /* We use the reloc_count field as a counter if we need
4509
                 to copy relocs into the output file.  */
4510
              s->reloc_count = 0;
4511
            }
4512
        }
4513
      else if (! CONST_STRNEQ (name, ".got")
4514
               && ! streq (name, ".dynbss"))
4515
        /* It's not one of our sections, so don't allocate space.  */
4516
        continue;
4517
 
4518
      if (s->size == 0)
4519
        {
4520
          /* If we don't need this section, strip it from the
4521
             output file.  This is mostly to handle .rela.bss and
4522
             .rela.plt.  We must create both sections in
4523
             create_dynamic_sections, because they must be created
4524
             before the linker maps input sections to output
4525
             sections.  The linker does that before
4526
             adjust_dynamic_symbol is called, and it is that
4527
             function which decides whether anything needs to go
4528
             into these sections.  */
4529
          s->flags |= SEC_EXCLUDE;
4530
          continue;
4531
        }
4532
 
4533
        if ((s->flags & SEC_HAS_CONTENTS) == 0)
4534
          continue;
4535
 
4536
      /* Allocate memory for the section contents.  We use bfd_zalloc
4537
         here in case unused entries are not reclaimed before the
4538
         section's contents are written out.  This should not happen,
4539
         but this way if it does, we get a R_MN10300_NONE reloc
4540
         instead of garbage.  */
4541
      s->contents = bfd_zalloc (dynobj, s->size);
4542
      if (s->contents == NULL)
4543
        return FALSE;
4544
    }
4545
 
4546
  if (elf_hash_table (info)->dynamic_sections_created)
4547
    {
4548
      /* Add some entries to the .dynamic section.  We fill in the
4549
         values later, in _bfd_mn10300_elf_finish_dynamic_sections,
4550
         but we must add the entries now so that we get the correct
4551
         size for the .dynamic section.  The DT_DEBUG entry is filled
4552
         in by the dynamic linker and used by the debugger.  */
4553
      if (! info->shared)
4554
        {
4555
          if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
4556
            return FALSE;
4557
        }
4558
 
4559
      if (plt)
4560
        {
4561
          if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
4562
              || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4563
              || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
4564
              || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
4565
            return FALSE;
4566
        }
4567
 
4568
      if (relocs)
4569
        {
4570
          if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
4571
              || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
4572
              || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
4573
                                              sizeof (Elf32_External_Rela)))
4574
            return FALSE;
4575
        }
4576
 
4577
      if (reltext)
4578
        {
4579
          if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
4580
            return FALSE;
4581
        }
4582
    }
4583
 
4584
  return TRUE;
4585
}
4586
 
4587
/* Finish up dynamic symbol handling.  We set the contents of various
4588
   dynamic sections here.  */
4589
 
4590
static bfd_boolean
4591
_bfd_mn10300_elf_finish_dynamic_symbol (bfd * output_bfd,
4592
                                        struct bfd_link_info * info,
4593
                                        struct elf_link_hash_entry * h,
4594
                                        Elf_Internal_Sym * sym)
4595
{
4596
  bfd * dynobj;
4597
 
4598
  dynobj = elf_hash_table (info)->dynobj;
4599
 
4600
  if (h->plt.offset != (bfd_vma) -1)
4601
    {
4602
      asection *        splt;
4603
      asection *        sgot;
4604
      asection *        srel;
4605
      bfd_vma           plt_index;
4606
      bfd_vma           got_offset;
4607
      Elf_Internal_Rela rel;
4608
 
4609
      /* This symbol has an entry in the procedure linkage table.  Set
4610
         it up.  */
4611
 
4612
      BFD_ASSERT (h->dynindx != -1);
4613
 
4614
      splt = bfd_get_section_by_name (dynobj, ".plt");
4615
      sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4616
      srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4617
      BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
4618
 
4619
      /* Get the index in the procedure linkage table which
4620
         corresponds to this symbol.  This is the index of this symbol
4621
         in all the symbols for which we are making plt entries.  The
4622
         first entry in the procedure linkage table is reserved.  */
4623
      plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info))
4624
                   / elf_mn10300_sizeof_plt (info));
4625
 
4626
      /* Get the offset into the .got table of the entry that
4627
         corresponds to this function.  Each .got entry is 4 bytes.
4628
         The first three are reserved.  */
4629
      got_offset = (plt_index + 3) * 4;
4630
 
4631
      /* Fill in the entry in the procedure linkage table.  */
4632
      if (! info->shared)
4633
        {
4634
          memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
4635
                  elf_mn10300_sizeof_plt (info));
4636
          bfd_put_32 (output_bfd,
4637
                      (sgot->output_section->vma
4638
                       + sgot->output_offset
4639
                       + got_offset),
4640
                      (splt->contents + h->plt.offset
4641
                       + elf_mn10300_plt_symbol_offset (info)));
4642
 
4643
          bfd_put_32 (output_bfd,
4644
                      (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)),
4645
                      (splt->contents + h->plt.offset
4646
                       + elf_mn10300_plt_plt0_offset (info)));
4647
        }
4648
      else
4649
        {
4650
          memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry,
4651
                  elf_mn10300_sizeof_plt (info));
4652
 
4653
          bfd_put_32 (output_bfd, got_offset,
4654
                      (splt->contents + h->plt.offset
4655
                       + elf_mn10300_plt_symbol_offset (info)));
4656
        }
4657
 
4658
      bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4659
                  (splt->contents + h->plt.offset
4660
                   + elf_mn10300_plt_reloc_offset (info)));
4661
 
4662
      /* Fill in the entry in the global offset table.  */
4663
      bfd_put_32 (output_bfd,
4664
                  (splt->output_section->vma
4665
                   + splt->output_offset
4666
                   + h->plt.offset
4667
                   + elf_mn10300_plt_temp_offset (info)),
4668
                  sgot->contents + got_offset);
4669
 
4670
      /* Fill in the entry in the .rela.plt section.  */
4671
      rel.r_offset = (sgot->output_section->vma
4672
                      + sgot->output_offset
4673
                      + got_offset);
4674
      rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT);
4675
      rel.r_addend = 0;
4676
      bfd_elf32_swap_reloca_out (output_bfd, &rel,
4677
                                 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4678
                                               + plt_index));
4679
 
4680
      if (!h->def_regular)
4681
        /* Mark the symbol as undefined, rather than as defined in
4682
           the .plt section.  Leave the value alone.  */
4683
        sym->st_shndx = SHN_UNDEF;
4684
    }
4685
 
4686
  if (h->got.offset != (bfd_vma) -1)
4687
    {
4688
      asection *        sgot;
4689
      asection *        srel;
4690
      Elf_Internal_Rela rel;
4691
 
4692
      /* This symbol has an entry in the global offset table.  Set it up.  */
4693
      sgot = bfd_get_section_by_name (dynobj, ".got");
4694
      srel = bfd_get_section_by_name (dynobj, ".rela.got");
4695
      BFD_ASSERT (sgot != NULL && srel != NULL);
4696
 
4697
      rel.r_offset = (sgot->output_section->vma
4698
                      + sgot->output_offset
4699
                      + (h->got.offset & ~1));
4700
 
4701
      /* If this is a -Bsymbolic link, and the symbol is defined
4702
         locally, we just want to emit a RELATIVE reloc.  Likewise if
4703
         the symbol was forced to be local because of a version file.
4704
         The entry in the global offset table will already have been
4705
         initialized in the relocate_section function.  */
4706
      if (info->shared
4707
          && (info->symbolic || h->dynindx == -1)
4708
          && h->def_regular)
4709
        {
4710
          rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
4711
          rel.r_addend = (h->root.u.def.value
4712
                          + h->root.u.def.section->output_section->vma
4713
                          + h->root.u.def.section->output_offset);
4714
        }
4715
      else
4716
        {
4717
          bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
4718
          rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT);
4719
          rel.r_addend = 0;
4720
        }
4721
 
4722
      bfd_elf32_swap_reloca_out (output_bfd, &rel,
4723
                                 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4724
                                               + srel->reloc_count));
4725
      ++ srel->reloc_count;
4726
    }
4727
 
4728
  if (h->needs_copy)
4729
    {
4730
      asection *        s;
4731
      Elf_Internal_Rela rel;
4732
 
4733
      /* This symbol needs a copy reloc.  Set it up.  */
4734
      BFD_ASSERT (h->dynindx != -1
4735
                  && (h->root.type == bfd_link_hash_defined
4736
                      || h->root.type == bfd_link_hash_defweak));
4737
 
4738
      s = bfd_get_section_by_name (h->root.u.def.section->owner,
4739
                                   ".rela.bss");
4740
      BFD_ASSERT (s != NULL);
4741
 
4742
      rel.r_offset = (h->root.u.def.value
4743
                      + h->root.u.def.section->output_section->vma
4744
                      + h->root.u.def.section->output_offset);
4745
      rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY);
4746
      rel.r_addend = 0;
4747
      bfd_elf32_swap_reloca_out (output_bfd, & rel,
4748
                                 (bfd_byte *) ((Elf32_External_Rela *) s->contents
4749
                                               + s->reloc_count));
4750
      ++ s->reloc_count;
4751
    }
4752
 
4753
  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
4754
  if (streq (h->root.root.string, "_DYNAMIC")
4755
      || h == elf_hash_table (info)->hgot)
4756
    sym->st_shndx = SHN_ABS;
4757
 
4758
  return TRUE;
4759
}
4760
 
4761
/* Finish up the dynamic sections.  */
4762
 
4763
static bfd_boolean
4764
_bfd_mn10300_elf_finish_dynamic_sections (bfd * output_bfd,
4765
                                          struct bfd_link_info * info)
4766
{
4767
  bfd *      dynobj;
4768
  asection * sgot;
4769
  asection * sdyn;
4770
 
4771
  dynobj = elf_hash_table (info)->dynobj;
4772
 
4773
  sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4774
  BFD_ASSERT (sgot != NULL);
4775
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4776
 
4777
  if (elf_hash_table (info)->dynamic_sections_created)
4778
    {
4779
      asection *           splt;
4780
      Elf32_External_Dyn * dyncon;
4781
      Elf32_External_Dyn * dynconend;
4782
 
4783
      BFD_ASSERT (sdyn != NULL);
4784
 
4785
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
4786
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4787
 
4788
      for (; dyncon < dynconend; dyncon++)
4789
        {
4790
          Elf_Internal_Dyn dyn;
4791
          const char * name;
4792
          asection * s;
4793
 
4794
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4795
 
4796
          switch (dyn.d_tag)
4797
            {
4798
            default:
4799
              break;
4800
 
4801
            case DT_PLTGOT:
4802
              name = ".got";
4803
              goto get_vma;
4804
 
4805
            case DT_JMPREL:
4806
              name = ".rela.plt";
4807
            get_vma:
4808
              s = bfd_get_section_by_name (output_bfd, name);
4809
              BFD_ASSERT (s != NULL);
4810
              dyn.d_un.d_ptr = s->vma;
4811
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4812
              break;
4813
 
4814
            case DT_PLTRELSZ:
4815
              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4816
              BFD_ASSERT (s != NULL);
4817
              dyn.d_un.d_val = s->size;
4818
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4819
              break;
4820
 
4821
            case DT_RELASZ:
4822
              /* My reading of the SVR4 ABI indicates that the
4823
                 procedure linkage table relocs (DT_JMPREL) should be
4824
                 included in the overall relocs (DT_RELA).  This is
4825
                 what Solaris does.  However, UnixWare can not handle
4826
                 that case.  Therefore, we override the DT_RELASZ entry
4827
                 here to make it not include the JMPREL relocs.  Since
4828
                 the linker script arranges for .rela.plt to follow all
4829
                 other relocation sections, we don't have to worry
4830
                 about changing the DT_RELA entry.  */
4831
              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4832
              if (s != NULL)
4833
                dyn.d_un.d_val -= s->size;
4834
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4835
              break;
4836
            }
4837
        }
4838
 
4839
      /* Fill in the first entry in the procedure linkage table.  */
4840
      splt = bfd_get_section_by_name (dynobj, ".plt");
4841
      if (splt && splt->size > 0)
4842
        {
4843
          if (info->shared)
4844
            {
4845
              memcpy (splt->contents, elf_mn10300_pic_plt_entry,
4846
                      elf_mn10300_sizeof_plt (info));
4847
            }
4848
          else
4849
            {
4850
              memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE);
4851
              bfd_put_32 (output_bfd,
4852
                          sgot->output_section->vma + sgot->output_offset + 4,
4853
                          splt->contents + elf_mn10300_plt0_gotid_offset (info));
4854
              bfd_put_32 (output_bfd,
4855
                          sgot->output_section->vma + sgot->output_offset + 8,
4856
                          splt->contents + elf_mn10300_plt0_linker_offset (info));
4857
            }
4858
 
4859
          /* UnixWare sets the entsize of .plt to 4, although that doesn't
4860
             really seem like the right value.  */
4861
          elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
4862
        }
4863
    }
4864
 
4865
  /* Fill in the first three entries in the global offset table.  */
4866
  if (sgot->size > 0)
4867
    {
4868
      if (sdyn == NULL)
4869
        bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4870
      else
4871
        bfd_put_32 (output_bfd,
4872
                    sdyn->output_section->vma + sdyn->output_offset,
4873
                    sgot->contents);
4874
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4875
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4876
    }
4877
 
4878
  elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4879
 
4880
  return TRUE;
4881
}
4882
 
4883
/* Classify relocation types, such that combreloc can sort them
4884
   properly.  */
4885
 
4886
static enum elf_reloc_type_class
4887
_bfd_mn10300_elf_reloc_type_class (const Elf_Internal_Rela *rela)
4888
{
4889
  switch ((int) ELF32_R_TYPE (rela->r_info))
4890
    {
4891
    case R_MN10300_RELATIVE:    return reloc_class_relative;
4892
    case R_MN10300_JMP_SLOT:    return reloc_class_plt;
4893
    case R_MN10300_COPY:        return reloc_class_copy;
4894
    default:                    return reloc_class_normal;
4895
    }
4896
}
4897
 
4898
#ifndef ELF_ARCH
4899
#define TARGET_LITTLE_SYM       bfd_elf32_mn10300_vec
4900
#define TARGET_LITTLE_NAME      "elf32-mn10300"
4901
#define ELF_ARCH                bfd_arch_mn10300
4902
#define ELF_MACHINE_CODE        EM_MN10300
4903
#define ELF_MACHINE_ALT1        EM_CYGNUS_MN10300
4904
#define ELF_MAXPAGESIZE         0x1000
4905
#endif
4906
 
4907
#define elf_info_to_howto               mn10300_info_to_howto
4908
#define elf_info_to_howto_rel           0
4909
#define elf_backend_can_gc_sections     1
4910
#define elf_backend_rela_normal         1
4911
#define elf_backend_check_relocs        mn10300_elf_check_relocs
4912
#define elf_backend_gc_mark_hook        mn10300_elf_gc_mark_hook
4913
#define elf_backend_relocate_section    mn10300_elf_relocate_section
4914
#define bfd_elf32_bfd_relax_section     mn10300_elf_relax_section
4915
#define bfd_elf32_bfd_get_relocated_section_contents \
4916
                                mn10300_elf_get_relocated_section_contents
4917
#define bfd_elf32_bfd_link_hash_table_create \
4918
                                elf32_mn10300_link_hash_table_create
4919
#define bfd_elf32_bfd_link_hash_table_free \
4920
                                elf32_mn10300_link_hash_table_free
4921
 
4922
#ifndef elf_symbol_leading_char
4923
#define elf_symbol_leading_char '_'
4924
#endif
4925
 
4926
/* So we can set bits in e_flags.  */
4927
#define elf_backend_final_write_processing \
4928
                                        _bfd_mn10300_elf_final_write_processing
4929
#define elf_backend_object_p            _bfd_mn10300_elf_object_p
4930
 
4931
#define bfd_elf32_bfd_merge_private_bfd_data \
4932
                                        _bfd_mn10300_elf_merge_private_bfd_data
4933
 
4934
#define elf_backend_can_gc_sections     1
4935
#define elf_backend_create_dynamic_sections \
4936
  _bfd_mn10300_elf_create_dynamic_sections
4937
#define elf_backend_adjust_dynamic_symbol \
4938
  _bfd_mn10300_elf_adjust_dynamic_symbol
4939
#define elf_backend_size_dynamic_sections \
4940
  _bfd_mn10300_elf_size_dynamic_sections
4941
#define elf_backend_omit_section_dynsym \
4942
  ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4943
#define elf_backend_finish_dynamic_symbol \
4944
  _bfd_mn10300_elf_finish_dynamic_symbol
4945
#define elf_backend_finish_dynamic_sections \
4946
  _bfd_mn10300_elf_finish_dynamic_sections
4947
 
4948
#define elf_backend_reloc_type_class \
4949
  _bfd_mn10300_elf_reloc_type_class
4950
 
4951
#define elf_backend_want_got_plt        1
4952
#define elf_backend_plt_readonly        1
4953
#define elf_backend_want_plt_sym        0
4954
#define elf_backend_got_header_size     12
4955
 
4956
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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