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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [elf32-m68k.c] - Blame information for rev 156

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* Motorola 68k series support for 32-bit ELF
2
   Copyright 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3
   2004, 2005, 2006, 2007 Free Software Foundation, Inc.
4
 
5
   This file is part of BFD, the Binary File Descriptor library.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
 
22
#include "sysdep.h"
23
#include "bfd.h"
24
#include "bfdlink.h"
25
#include "libbfd.h"
26
#include "elf-bfd.h"
27
#include "elf/m68k.h"
28
#include "opcode/m68k.h"
29
 
30
static reloc_howto_type *reloc_type_lookup
31
  PARAMS ((bfd *, bfd_reloc_code_real_type));
32
static void rtype_to_howto
33
  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
34
static struct bfd_hash_entry *elf_m68k_link_hash_newfunc
35
  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
36
static struct bfd_link_hash_table *elf_m68k_link_hash_table_create
37
  PARAMS ((bfd *));
38
static bfd_boolean elf_m68k_check_relocs
39
  PARAMS ((bfd *, struct bfd_link_info *, asection *,
40
           const Elf_Internal_Rela *));
41
static bfd_boolean elf_m68k_adjust_dynamic_symbol
42
  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
43
static bfd_boolean elf_m68k_size_dynamic_sections
44
  PARAMS ((bfd *, struct bfd_link_info *));
45
static bfd_boolean elf_m68k_discard_copies
46
  PARAMS ((struct elf_link_hash_entry *, PTR));
47
static bfd_boolean elf_m68k_relocate_section
48
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
49
           Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
50
static bfd_boolean elf_m68k_finish_dynamic_symbol
51
  PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
52
           Elf_Internal_Sym *));
53
static bfd_boolean elf_m68k_finish_dynamic_sections
54
  PARAMS ((bfd *, struct bfd_link_info *));
55
 
56
static bfd_boolean elf32_m68k_set_private_flags
57
  PARAMS ((bfd *, flagword));
58
static bfd_boolean elf32_m68k_merge_private_bfd_data
59
  PARAMS ((bfd *, bfd *));
60
static bfd_boolean elf32_m68k_print_private_bfd_data
61
  PARAMS ((bfd *, PTR));
62
static enum elf_reloc_type_class elf32_m68k_reloc_type_class
63
  PARAMS ((const Elf_Internal_Rela *));
64
 
65
static reloc_howto_type howto_table[] = {
66
  HOWTO(R_68K_NONE,       0, 0, 0, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_NONE",      FALSE, 0, 0x00000000,FALSE),
67
  HOWTO(R_68K_32,         0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_32",        FALSE, 0, 0xffffffff,FALSE),
68
  HOWTO(R_68K_16,         0, 1,16, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_16",        FALSE, 0, 0x0000ffff,FALSE),
69
  HOWTO(R_68K_8,          0, 0, 8, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_8",         FALSE, 0, 0x000000ff,FALSE),
70
  HOWTO(R_68K_PC32,       0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PC32",      FALSE, 0, 0xffffffff,TRUE),
71
  HOWTO(R_68K_PC16,       0, 1,16, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PC16",      FALSE, 0, 0x0000ffff,TRUE),
72
  HOWTO(R_68K_PC8,        0, 0, 8, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PC8",       FALSE, 0, 0x000000ff,TRUE),
73
  HOWTO(R_68K_GOT32,      0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32",     FALSE, 0, 0xffffffff,TRUE),
74
  HOWTO(R_68K_GOT16,      0, 1,16, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_GOT16",     FALSE, 0, 0x0000ffff,TRUE),
75
  HOWTO(R_68K_GOT8,       0, 0, 8, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_GOT8",      FALSE, 0, 0x000000ff,TRUE),
76
  HOWTO(R_68K_GOT32O,     0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32O",    FALSE, 0, 0xffffffff,FALSE),
77
  HOWTO(R_68K_GOT16O,     0, 1,16, FALSE,0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_GOT16O",    FALSE, 0, 0x0000ffff,FALSE),
78
  HOWTO(R_68K_GOT8O,      0, 0, 8, FALSE,0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_GOT8O",     FALSE, 0, 0x000000ff,FALSE),
79
  HOWTO(R_68K_PLT32,      0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32",     FALSE, 0, 0xffffffff,TRUE),
80
  HOWTO(R_68K_PLT16,      0, 1,16, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PLT16",     FALSE, 0, 0x0000ffff,TRUE),
81
  HOWTO(R_68K_PLT8,       0, 0, 8, TRUE, 0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PLT8",      FALSE, 0, 0x000000ff,TRUE),
82
  HOWTO(R_68K_PLT32O,     0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32O",    FALSE, 0, 0xffffffff,FALSE),
83
  HOWTO(R_68K_PLT16O,     0, 1,16, FALSE,0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PLT16O",    FALSE, 0, 0x0000ffff,FALSE),
84
  HOWTO(R_68K_PLT8O,      0, 0, 8, FALSE,0, complain_overflow_signed,   bfd_elf_generic_reloc, "R_68K_PLT8O",     FALSE, 0, 0x000000ff,FALSE),
85
  HOWTO(R_68K_COPY,       0, 0, 0, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_COPY",      FALSE, 0, 0xffffffff,FALSE),
86
  HOWTO(R_68K_GLOB_DAT,   0, 2,32, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_GLOB_DAT",  FALSE, 0, 0xffffffff,FALSE),
87
  HOWTO(R_68K_JMP_SLOT,   0, 2,32, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_JMP_SLOT",  FALSE, 0, 0xffffffff,FALSE),
88
  HOWTO(R_68K_RELATIVE,   0, 2,32, FALSE,0, complain_overflow_dont,     bfd_elf_generic_reloc, "R_68K_RELATIVE",  FALSE, 0, 0xffffffff,FALSE),
89
  /* GNU extension to record C++ vtable hierarchy.  */
90
  HOWTO (R_68K_GNU_VTINHERIT,   /* type */
91
         0,                      /* rightshift */
92
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
93
         0,                      /* bitsize */
94
         FALSE,                 /* pc_relative */
95
         0,                      /* bitpos */
96
         complain_overflow_dont, /* complain_on_overflow */
97
         NULL,                  /* special_function */
98
         "R_68K_GNU_VTINHERIT", /* name */
99
         FALSE,                 /* partial_inplace */
100
         0,                      /* src_mask */
101
         0,                      /* dst_mask */
102
         FALSE),
103
  /* GNU extension to record C++ vtable member usage.  */
104
  HOWTO (R_68K_GNU_VTENTRY,     /* type */
105
         0,                      /* rightshift */
106
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
107
         0,                      /* bitsize */
108
         FALSE,                 /* pc_relative */
109
         0,                      /* bitpos */
110
         complain_overflow_dont, /* complain_on_overflow */
111
         _bfd_elf_rel_vtable_reloc_fn, /* special_function */
112
         "R_68K_GNU_VTENTRY",   /* name */
113
         FALSE,                 /* partial_inplace */
114
         0,                      /* src_mask */
115
         0,                      /* dst_mask */
116
         FALSE),
117
};
118
 
119
static void
120
rtype_to_howto (abfd, cache_ptr, dst)
121
     bfd *abfd ATTRIBUTE_UNUSED;
122
     arelent *cache_ptr;
123
     Elf_Internal_Rela *dst;
124
{
125
  BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_68K_max);
126
  cache_ptr->howto = &howto_table[ELF32_R_TYPE(dst->r_info)];
127
}
128
 
129
#define elf_info_to_howto rtype_to_howto
130
 
131
static const struct
132
{
133
  bfd_reloc_code_real_type bfd_val;
134
  int elf_val;
135
} reloc_map[] = {
136
  { BFD_RELOC_NONE, R_68K_NONE },
137
  { BFD_RELOC_32, R_68K_32 },
138
  { BFD_RELOC_16, R_68K_16 },
139
  { BFD_RELOC_8, R_68K_8 },
140
  { BFD_RELOC_32_PCREL, R_68K_PC32 },
141
  { BFD_RELOC_16_PCREL, R_68K_PC16 },
142
  { BFD_RELOC_8_PCREL, R_68K_PC8 },
143
  { BFD_RELOC_32_GOT_PCREL, R_68K_GOT32 },
144
  { BFD_RELOC_16_GOT_PCREL, R_68K_GOT16 },
145
  { BFD_RELOC_8_GOT_PCREL, R_68K_GOT8 },
146
  { BFD_RELOC_32_GOTOFF, R_68K_GOT32O },
147
  { BFD_RELOC_16_GOTOFF, R_68K_GOT16O },
148
  { BFD_RELOC_8_GOTOFF, R_68K_GOT8O },
149
  { BFD_RELOC_32_PLT_PCREL, R_68K_PLT32 },
150
  { BFD_RELOC_16_PLT_PCREL, R_68K_PLT16 },
151
  { BFD_RELOC_8_PLT_PCREL, R_68K_PLT8 },
152
  { BFD_RELOC_32_PLTOFF, R_68K_PLT32O },
153
  { BFD_RELOC_16_PLTOFF, R_68K_PLT16O },
154
  { BFD_RELOC_8_PLTOFF, R_68K_PLT8O },
155
  { BFD_RELOC_NONE, R_68K_COPY },
156
  { BFD_RELOC_68K_GLOB_DAT, R_68K_GLOB_DAT },
157
  { BFD_RELOC_68K_JMP_SLOT, R_68K_JMP_SLOT },
158
  { BFD_RELOC_68K_RELATIVE, R_68K_RELATIVE },
159
  { BFD_RELOC_CTOR, R_68K_32 },
160
  { BFD_RELOC_VTABLE_INHERIT, R_68K_GNU_VTINHERIT },
161
  { BFD_RELOC_VTABLE_ENTRY, R_68K_GNU_VTENTRY },
162
};
163
 
164
static reloc_howto_type *
165
reloc_type_lookup (abfd, code)
166
     bfd *abfd ATTRIBUTE_UNUSED;
167
     bfd_reloc_code_real_type code;
168
{
169
  unsigned int i;
170
  for (i = 0; i < sizeof (reloc_map) / sizeof (reloc_map[0]); i++)
171
    {
172
      if (reloc_map[i].bfd_val == code)
173
        return &howto_table[reloc_map[i].elf_val];
174
    }
175
  return 0;
176
}
177
 
178
static reloc_howto_type *
179
reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
180
{
181
  unsigned int i;
182
 
183
  for (i = 0; i < sizeof (howto_table) / sizeof (howto_table[0]); i++)
184
    if (howto_table[i].name != NULL
185
        && strcasecmp (howto_table[i].name, r_name) == 0)
186
      return &howto_table[i];
187
 
188
  return NULL;
189
}
190
 
191
#define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup
192
#define bfd_elf32_bfd_reloc_name_lookup reloc_name_lookup
193
#define ELF_ARCH bfd_arch_m68k
194
 
195
/* Functions for the m68k ELF linker.  */
196
 
197
/* The name of the dynamic interpreter.  This is put in the .interp
198
   section.  */
199
 
200
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
201
 
202
/* Describes one of the various PLT styles.  */
203
 
204
struct elf_m68k_plt_info
205
{
206
  /* The size of each PLT entry.  */
207
  bfd_vma size;
208
 
209
  /* The template for the first PLT entry.  */
210
  const bfd_byte *plt0_entry;
211
 
212
  /* Offsets of fields in PLT0_ENTRY that require R_68K_PC32 relocations.
213
     The comments by each member indicate the value that the relocation
214
     is against.  */
215
  struct {
216
    unsigned int got4; /* .got + 4 */
217
    unsigned int got8; /* .got + 8 */
218
  } plt0_relocs;
219
 
220
  /* The template for a symbol's PLT entry.  */
221
  const bfd_byte *symbol_entry;
222
 
223
  /* Offsets of fields in SYMBOL_ENTRY that require R_68K_PC32 relocations.
224
     The comments by each member indicate the value that the relocation
225
     is against.  */
226
  struct {
227
    unsigned int got; /* the symbol's .got.plt entry */
228
    unsigned int plt; /* .plt */
229
  } symbol_relocs;
230
 
231
  /* The offset of the resolver stub from the start of SYMBOL_ENTRY.
232
     The stub starts with "move.l #relocoffset,%d0".  */
233
  bfd_vma symbol_resolve_entry;
234
};
235
 
236
/* The size in bytes of an entry in the procedure linkage table.  */
237
 
238
#define PLT_ENTRY_SIZE 20
239
 
240
/* The first entry in a procedure linkage table looks like this.  See
241
   the SVR4 ABI m68k supplement to see how this works.  */
242
 
243
static const bfd_byte elf_m68k_plt0_entry[PLT_ENTRY_SIZE] =
244
{
245
  0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
246
  0, 0, 0, 2,                /* + (.got + 4) - . */
247
  0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,addr]) */
248
  0, 0, 0, 2,                /* + (.got + 8) - . */
249
  0, 0, 0, 0                  /* pad out to 20 bytes.  */
250
};
251
 
252
/* Subsequent entries in a procedure linkage table look like this.  */
253
 
254
static const bfd_byte elf_m68k_plt_entry[PLT_ENTRY_SIZE] =
255
{
256
  0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,symbol@GOTPC]) */
257
  0, 0, 0, 2,                /* + (.got.plt entry) - . */
258
  0x2f, 0x3c,             /* move.l #offset,-(%sp) */
259
  0, 0, 0, 0,                 /* + reloc index */
260
  0x60, 0xff,             /* bra.l .plt */
261
  0, 0, 0, 0                  /* + .plt - . */
262
};
263
 
264
static const struct elf_m68k_plt_info elf_m68k_plt_info = {
265
  PLT_ENTRY_SIZE,
266
  elf_m68k_plt0_entry, { 4, 12 },
267
  elf_m68k_plt_entry, { 4, 16 }, 8
268
};
269
 
270
#define ISAB_PLT_ENTRY_SIZE 24 
271
 
272
static const bfd_byte elf_isab_plt0_entry[ISAB_PLT_ENTRY_SIZE] =
273
{
274
  0x20, 0x3c,             /* move.l #offset,%d0 */
275
  0, 0, 0, 0,             /* + (.got + 4) - . */
276
  0x2f, 0x3b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),-(%sp) */
277
  0x20, 0x3c,             /* move.l #offset,%d0 */
278
  0, 0, 0, 0,             /* + (.got + 8) - . */
279
  0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
280
  0x4e, 0xd0,             /* jmp (%a0) */
281
  0x4e, 0x71              /* nop */
282
};
283
 
284
/* Subsequent entries in a procedure linkage table look like this.  */
285
 
286
static const bfd_byte elf_isab_plt_entry[ISAB_PLT_ENTRY_SIZE] =
287
{
288
  0x20, 0x3c,             /* move.l #offset,%d0 */
289
  0, 0, 0, 0,             /* + (.got.plt entry) - . */
290
  0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
291
  0x4e, 0xd0,             /* jmp (%a0) */
292
  0x2f, 0x3c,             /* move.l #offset,-(%sp) */
293
  0, 0, 0, 0,             /* + reloc index */
294
  0x60, 0xff,             /* bra.l .plt */
295
  0, 0, 0, 0              /* + .plt - . */
296
};
297
 
298
static const struct elf_m68k_plt_info elf_isab_plt_info = {
299
  ISAB_PLT_ENTRY_SIZE,
300
  elf_isab_plt0_entry, { 2, 12 },
301
  elf_isab_plt_entry, { 2, 20 }, 12
302
};
303
 
304
#define ISAC_PLT_ENTRY_SIZE 24 
305
 
306
static const bfd_byte elf_isac_plt0_entry[ISAC_PLT_ENTRY_SIZE] =
307
{
308
  0x20, 0x3c,             /* move.l #offset,%d0 */
309
  0, 0, 0, 0,                 /* replaced with .got + 4 - . */
310
  0x2e, 0xbb, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),(%sp) */
311
  0x20, 0x3c,             /* move.l #offset,%d0 */
312
  0, 0, 0, 0,                 /* replaced with .got + 8 - . */
313
  0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
314
  0x4e, 0xd0,             /* jmp (%a0) */
315
  0x4e, 0x71              /* nop */
316
};
317
 
318
/* Subsequent entries in a procedure linkage table look like this.  */
319
 
320
static const bfd_byte elf_isac_plt_entry[ISAC_PLT_ENTRY_SIZE] =
321
{
322
  0x20, 0x3c,             /* move.l #offset,%d0 */
323
  0, 0, 0, 0,                 /* replaced with (.got entry) - . */
324
  0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
325
  0x4e, 0xd0,             /* jmp (%a0) */
326
  0x2f, 0x3c,             /* move.l #offset,-(%sp) */
327
  0, 0, 0, 0,                 /* replaced with offset into relocation table */
328
  0x61, 0xff,             /* bsr.l .plt */
329
  0, 0, 0, 0                  /* replaced with .plt - . */
330
};
331
 
332
static const struct elf_m68k_plt_info elf_isac_plt_info = {
333
  ISAC_PLT_ENTRY_SIZE,
334
  elf_isac_plt0_entry, { 2, 12},
335
  elf_isac_plt_entry, { 2, 20 }, 12
336
};
337
 
338
#define CPU32_PLT_ENTRY_SIZE 24
339
/* Procedure linkage table entries for the cpu32 */
340
static const bfd_byte elf_cpu32_plt0_entry[CPU32_PLT_ENTRY_SIZE] =
341
{
342
  0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
343
  0, 0, 0, 2,             /* + (.got + 4) - . */
344
  0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
345
  0, 0, 0, 2,             /* + (.got + 8) - . */
346
  0x4e, 0xd1,             /* jmp %a1@ */
347
  0, 0, 0, 0,             /* pad out to 24 bytes.  */
348
  0, 0
349
};
350
 
351
static const bfd_byte elf_cpu32_plt_entry[CPU32_PLT_ENTRY_SIZE] =
352
{
353
  0x22, 0x7b, 0x01, 0x70,  /* moveal %pc@(0xc), %a1 */
354
  0, 0, 0, 2,              /* + (.got.plt entry) - . */
355
  0x4e, 0xd1,              /* jmp %a1@ */
356
  0x2f, 0x3c,              /* move.l #offset,-(%sp) */
357
  0, 0, 0, 0,              /* + reloc index */
358
  0x60, 0xff,              /* bra.l .plt */
359
  0, 0, 0, 0,              /* + .plt - . */
360
  0, 0
361
};
362
 
363
static const struct elf_m68k_plt_info elf_cpu32_plt_info = {
364
  CPU32_PLT_ENTRY_SIZE,
365
  elf_cpu32_plt0_entry, { 4, 12 },
366
  elf_cpu32_plt_entry, { 4, 18 }, 10
367
};
368
 
369
/* The m68k linker needs to keep track of the number of relocs that it
370
   decides to copy in check_relocs for each symbol.  This is so that it
371
   can discard PC relative relocs if it doesn't need them when linking
372
   with -Bsymbolic.  We store the information in a field extending the
373
   regular ELF linker hash table.  */
374
 
375
/* This structure keeps track of the number of PC relative relocs we have
376
   copied for a given symbol.  */
377
 
378
struct elf_m68k_pcrel_relocs_copied
379
{
380
  /* Next section.  */
381
  struct elf_m68k_pcrel_relocs_copied *next;
382
  /* A section in dynobj.  */
383
  asection *section;
384
  /* Number of relocs copied in this section.  */
385
  bfd_size_type count;
386
};
387
 
388
/* m68k ELF linker hash entry.  */
389
 
390
struct elf_m68k_link_hash_entry
391
{
392
  struct elf_link_hash_entry root;
393
 
394
  /* Number of PC relative relocs copied for this symbol.  */
395
  struct elf_m68k_pcrel_relocs_copied *pcrel_relocs_copied;
396
};
397
 
398
#define elf_m68k_hash_entry(ent) ((struct elf_m68k_link_hash_entry *) (ent))
399
 
400
/* m68k ELF linker hash table.  */
401
 
402
struct elf_m68k_link_hash_table
403
{
404
  struct elf_link_hash_table root;
405
 
406
  /* Small local sym to section mapping cache.  */
407
  struct sym_sec_cache sym_sec;
408
 
409
  /* The PLT format used by this link, or NULL if the format has not
410
     yet been chosen.  */
411
  const struct elf_m68k_plt_info *plt_info;
412
};
413
 
414
/* Get the m68k ELF linker hash table from a link_info structure.  */
415
 
416
#define elf_m68k_hash_table(p) \
417
  ((struct elf_m68k_link_hash_table *) (p)->hash)
418
 
419
/* Create an entry in an m68k ELF linker hash table.  */
420
 
421
static struct bfd_hash_entry *
422
elf_m68k_link_hash_newfunc (entry, table, string)
423
     struct bfd_hash_entry *entry;
424
     struct bfd_hash_table *table;
425
     const char *string;
426
{
427
  struct bfd_hash_entry *ret = entry;
428
 
429
  /* Allocate the structure if it has not already been allocated by a
430
     subclass.  */
431
  if (ret == NULL)
432
    ret = bfd_hash_allocate (table,
433
                             sizeof (struct elf_m68k_link_hash_entry));
434
  if (ret == NULL)
435
    return ret;
436
 
437
  /* Call the allocation method of the superclass.  */
438
  ret = _bfd_elf_link_hash_newfunc (ret, table, string);
439
  if (ret != NULL)
440
    elf_m68k_hash_entry (ret)->pcrel_relocs_copied = NULL;
441
 
442
  return ret;
443
}
444
 
445
/* Create an m68k ELF linker hash table.  */
446
 
447
static struct bfd_link_hash_table *
448
elf_m68k_link_hash_table_create (abfd)
449
     bfd *abfd;
450
{
451
  struct elf_m68k_link_hash_table *ret;
452
  bfd_size_type amt = sizeof (struct elf_m68k_link_hash_table);
453
 
454
  ret = (struct elf_m68k_link_hash_table *) bfd_malloc (amt);
455
  if (ret == (struct elf_m68k_link_hash_table *) NULL)
456
    return NULL;
457
 
458
  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
459
                                      elf_m68k_link_hash_newfunc,
460
                                      sizeof (struct elf_m68k_link_hash_entry)))
461
    {
462
      free (ret);
463
      return NULL;
464
    }
465
 
466
  ret->sym_sec.abfd = NULL;
467
  ret->plt_info = NULL;
468
 
469
  return &ret->root.root;
470
}
471
 
472
/* Set the right machine number.  */
473
 
474
static bfd_boolean
475
elf32_m68k_object_p (bfd *abfd)
476
{
477
  unsigned int mach = 0;
478
  unsigned features = 0;
479
  flagword eflags = elf_elfheader (abfd)->e_flags;
480
 
481
  if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
482
    features |= m68000;
483
  else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
484
    features |= cpu32;
485
  else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
486
    features |= fido_a;
487
  else
488
    {
489
      switch (eflags & EF_M68K_CF_ISA_MASK)
490
        {
491
        case EF_M68K_CF_ISA_A_NODIV:
492
          features |= mcfisa_a;
493
          break;
494
        case EF_M68K_CF_ISA_A:
495
          features |= mcfisa_a|mcfhwdiv;
496
          break;
497
        case EF_M68K_CF_ISA_A_PLUS:
498
          features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp;
499
          break;
500
        case EF_M68K_CF_ISA_B_NOUSP:
501
          features |= mcfisa_a|mcfisa_b|mcfhwdiv;
502
          break;
503
        case EF_M68K_CF_ISA_B:
504
          features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp;
505
          break;
506
        case EF_M68K_CF_ISA_C:
507
          features |= mcfisa_a|mcfisa_c|mcfhwdiv|mcfusp;
508
          break;
509
        case EF_M68K_CF_ISA_C_NODIV:
510
          features |= mcfisa_a|mcfisa_c|mcfusp;
511
          break;
512
        }
513
      switch (eflags & EF_M68K_CF_MAC_MASK)
514
        {
515
        case EF_M68K_CF_MAC:
516
          features |= mcfmac;
517
          break;
518
        case EF_M68K_CF_EMAC:
519
          features |= mcfemac;
520
          break;
521
        }
522
      if (eflags & EF_M68K_CF_FLOAT)
523
        features |= cfloat;
524
    }
525
 
526
  mach = bfd_m68k_features_to_mach (features);
527
  bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach);
528
 
529
  return TRUE;
530
}
531
 
532
/* Keep m68k-specific flags in the ELF header.  */
533
static bfd_boolean
534
elf32_m68k_set_private_flags (abfd, flags)
535
     bfd *abfd;
536
     flagword flags;
537
{
538
  elf_elfheader (abfd)->e_flags = flags;
539
  elf_flags_init (abfd) = TRUE;
540
  return TRUE;
541
}
542
 
543
/* Merge backend specific data from an object file to the output
544
   object file when linking.  */
545
static bfd_boolean
546
elf32_m68k_merge_private_bfd_data (ibfd, obfd)
547
     bfd *ibfd;
548
     bfd *obfd;
549
{
550
  flagword out_flags;
551
  flagword in_flags;
552
  flagword out_isa;
553
  flagword in_isa;
554
  const bfd_arch_info_type *arch_info;
555
 
556
  if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
557
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
558
    return FALSE;
559
 
560
  /* Get the merged machine.  This checks for incompatibility between
561
     Coldfire & non-Coldfire flags, incompability between different
562
     Coldfire ISAs, and incompability between different MAC types.  */
563
  arch_info = bfd_arch_get_compatible (ibfd, obfd, FALSE);
564
  if (!arch_info)
565
    return FALSE;
566
 
567
  bfd_set_arch_mach (obfd, bfd_arch_m68k, arch_info->mach);
568
 
569
  in_flags = elf_elfheader (ibfd)->e_flags;
570
  if (!elf_flags_init (obfd))
571
    {
572
      elf_flags_init (obfd) = TRUE;
573
      out_flags = in_flags;
574
    }
575
  else
576
    {
577
      out_flags = elf_elfheader (obfd)->e_flags;
578
      unsigned int variant_mask;
579
 
580
      if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
581
        variant_mask = 0;
582
      else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
583
        variant_mask = 0;
584
      else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
585
        variant_mask = 0;
586
      else
587
        variant_mask = EF_M68K_CF_ISA_MASK;
588
 
589
      in_isa = (in_flags & variant_mask);
590
      out_isa = (out_flags & variant_mask);
591
      if (in_isa > out_isa)
592
        out_flags ^= in_isa ^ out_isa;
593
      if (((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32
594
           && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
595
          || ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO
596
              && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32))
597
        out_flags = EF_M68K_FIDO;
598
      else
599
      out_flags |= in_flags ^ in_isa;
600
    }
601
  elf_elfheader (obfd)->e_flags = out_flags;
602
 
603
  return TRUE;
604
}
605
 
606
/* Display the flags field.  */
607
static bfd_boolean
608
elf32_m68k_print_private_bfd_data (abfd, ptr)
609
     bfd *abfd;
610
     PTR ptr;
611
{
612
  FILE *file = (FILE *) ptr;
613
  flagword eflags = elf_elfheader (abfd)->e_flags;
614
 
615
  BFD_ASSERT (abfd != NULL && ptr != NULL);
616
 
617
  /* Print normal ELF private data.  */
618
  _bfd_elf_print_private_bfd_data (abfd, ptr);
619
 
620
  /* Ignore init flag - it may not be set, despite the flags field containing valid data.  */
621
 
622
  /* xgettext:c-format */
623
  fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
624
 
625
  if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
626
    fprintf (file, " [m68000]");
627
  else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
628
    fprintf (file, " [cpu32]");
629
  else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
630
    fprintf (file, " [fido]");
631
  else
632
    {
633
      if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CFV4E)
634
        fprintf (file, " [cfv4e]");
635
 
636
      if (eflags & EF_M68K_CF_ISA_MASK)
637
        {
638
          char const *isa = _("unknown");
639
          char const *mac = _("unknown");
640
          char const *additional = "";
641
 
642
          switch (eflags & EF_M68K_CF_ISA_MASK)
643
            {
644
            case EF_M68K_CF_ISA_A_NODIV:
645
              isa = "A";
646
              additional = " [nodiv]";
647
              break;
648
            case EF_M68K_CF_ISA_A:
649
              isa = "A";
650
              break;
651
            case EF_M68K_CF_ISA_A_PLUS:
652
              isa = "A+";
653
              break;
654
            case EF_M68K_CF_ISA_B_NOUSP:
655
              isa = "B";
656
              additional = " [nousp]";
657
              break;
658
            case EF_M68K_CF_ISA_B:
659
              isa = "B";
660
              break;
661
            case EF_M68K_CF_ISA_C:
662
              isa = "C";
663
              break;
664
            case EF_M68K_CF_ISA_C_NODIV:
665
              isa = "C";
666
              additional = " [nodiv]";
667
              break;
668
            }
669
          fprintf (file, " [isa %s]%s", isa, additional);
670
          if (eflags & EF_M68K_CF_FLOAT)
671
            fprintf (file, " [float]");
672
          switch (eflags & EF_M68K_CF_MAC_MASK)
673
            {
674
            case 0:
675
              mac = NULL;
676
              break;
677
            case EF_M68K_CF_MAC:
678
              mac = "mac";
679
              break;
680
            case EF_M68K_CF_EMAC:
681
              mac = "emac";
682
              break;
683
            }
684
          if (mac)
685
            fprintf (file, " [%s]", mac);
686
        }
687
    }
688
 
689
  fputc ('\n', file);
690
 
691
  return TRUE;
692
}
693
/* Look through the relocs for a section during the first phase, and
694
   allocate space in the global offset table or procedure linkage
695
   table.  */
696
 
697
static bfd_boolean
698
elf_m68k_check_relocs (abfd, info, sec, relocs)
699
     bfd *abfd;
700
     struct bfd_link_info *info;
701
     asection *sec;
702
     const Elf_Internal_Rela *relocs;
703
{
704
  bfd *dynobj;
705
  Elf_Internal_Shdr *symtab_hdr;
706
  struct elf_link_hash_entry **sym_hashes;
707
  bfd_signed_vma *local_got_refcounts;
708
  const Elf_Internal_Rela *rel;
709
  const Elf_Internal_Rela *rel_end;
710
  asection *sgot;
711
  asection *srelgot;
712
  asection *sreloc;
713
 
714
  if (info->relocatable)
715
    return TRUE;
716
 
717
  dynobj = elf_hash_table (info)->dynobj;
718
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
719
  sym_hashes = elf_sym_hashes (abfd);
720
  local_got_refcounts = elf_local_got_refcounts (abfd);
721
 
722
  sgot = NULL;
723
  srelgot = NULL;
724
  sreloc = NULL;
725
 
726
  rel_end = relocs + sec->reloc_count;
727
  for (rel = relocs; rel < rel_end; rel++)
728
    {
729
      unsigned long r_symndx;
730
      struct elf_link_hash_entry *h;
731
 
732
      r_symndx = ELF32_R_SYM (rel->r_info);
733
 
734
      if (r_symndx < symtab_hdr->sh_info)
735
        h = NULL;
736
      else
737
        {
738
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
739
          while (h->root.type == bfd_link_hash_indirect
740
                 || h->root.type == bfd_link_hash_warning)
741
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
742
        }
743
 
744
      switch (ELF32_R_TYPE (rel->r_info))
745
        {
746
        case R_68K_GOT8:
747
        case R_68K_GOT16:
748
        case R_68K_GOT32:
749
          if (h != NULL
750
              && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
751
            break;
752
          /* Fall through.  */
753
        case R_68K_GOT8O:
754
        case R_68K_GOT16O:
755
        case R_68K_GOT32O:
756
          /* This symbol requires a global offset table entry.  */
757
 
758
          if (dynobj == NULL)
759
            {
760
              /* Create the .got section.  */
761
              elf_hash_table (info)->dynobj = dynobj = abfd;
762
              if (!_bfd_elf_create_got_section (dynobj, info))
763
                return FALSE;
764
            }
765
 
766
          if (sgot == NULL)
767
            {
768
              sgot = bfd_get_section_by_name (dynobj, ".got");
769
              BFD_ASSERT (sgot != NULL);
770
            }
771
 
772
          if (srelgot == NULL
773
              && (h != NULL || info->shared))
774
            {
775
              srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
776
              if (srelgot == NULL)
777
                {
778
                  srelgot = bfd_make_section_with_flags (dynobj,
779
                                                         ".rela.got",
780
                                                         (SEC_ALLOC
781
                                                          | SEC_LOAD
782
                                                          | SEC_HAS_CONTENTS
783
                                                          | SEC_IN_MEMORY
784
                                                          | SEC_LINKER_CREATED
785
                                                          | SEC_READONLY));
786
                  if (srelgot == NULL
787
                      || !bfd_set_section_alignment (dynobj, srelgot, 2))
788
                    return FALSE;
789
                }
790
            }
791
 
792
          if (h != NULL)
793
            {
794
              if (h->got.refcount == 0)
795
                {
796
                  /* Make sure this symbol is output as a dynamic symbol.  */
797
                  if (h->dynindx == -1
798
                      && !h->forced_local)
799
                    {
800
                      if (!bfd_elf_link_record_dynamic_symbol (info, h))
801
                        return FALSE;
802
                    }
803
 
804
                  /* Allocate space in the .got section.  */
805
                  sgot->size += 4;
806
                  /* Allocate relocation space.  */
807
                  srelgot->size += sizeof (Elf32_External_Rela);
808
                }
809
              h->got.refcount++;
810
            }
811
          else
812
            {
813
              /* This is a global offset table entry for a local symbol.  */
814
              if (local_got_refcounts == NULL)
815
                {
816
                  bfd_size_type size;
817
 
818
                  size = symtab_hdr->sh_info;
819
                  size *= sizeof (bfd_signed_vma);
820
                  local_got_refcounts = ((bfd_signed_vma *)
821
                                         bfd_zalloc (abfd, size));
822
                  if (local_got_refcounts == NULL)
823
                    return FALSE;
824
                  elf_local_got_refcounts (abfd) = local_got_refcounts;
825
                }
826
              if (local_got_refcounts[r_symndx] == 0)
827
                {
828
                  sgot->size += 4;
829
                  if (info->shared)
830
                    {
831
                      /* If we are generating a shared object, we need to
832
                         output a R_68K_RELATIVE reloc so that the dynamic
833
                         linker can adjust this GOT entry.  */
834
                      srelgot->size += sizeof (Elf32_External_Rela);
835
                    }
836
                }
837
              local_got_refcounts[r_symndx]++;
838
            }
839
          break;
840
 
841
        case R_68K_PLT8:
842
        case R_68K_PLT16:
843
        case R_68K_PLT32:
844
          /* This symbol requires a procedure linkage table entry.  We
845
             actually build the entry in adjust_dynamic_symbol,
846
             because this might be a case of linking PIC code which is
847
             never referenced by a dynamic object, in which case we
848
             don't need to generate a procedure linkage table entry
849
             after all.  */
850
 
851
          /* If this is a local symbol, we resolve it directly without
852
             creating a procedure linkage table entry.  */
853
          if (h == NULL)
854
            continue;
855
 
856
          h->needs_plt = 1;
857
          h->plt.refcount++;
858
          break;
859
 
860
        case R_68K_PLT8O:
861
        case R_68K_PLT16O:
862
        case R_68K_PLT32O:
863
          /* This symbol requires a procedure linkage table entry.  */
864
 
865
          if (h == NULL)
866
            {
867
              /* It does not make sense to have this relocation for a
868
                 local symbol.  FIXME: does it?  How to handle it if
869
                 it does make sense?  */
870
              bfd_set_error (bfd_error_bad_value);
871
              return FALSE;
872
            }
873
 
874
          /* Make sure this symbol is output as a dynamic symbol.  */
875
          if (h->dynindx == -1
876
              && !h->forced_local)
877
            {
878
              if (!bfd_elf_link_record_dynamic_symbol (info, h))
879
                return FALSE;
880
            }
881
 
882
          h->needs_plt = 1;
883
          h->plt.refcount++;
884
          break;
885
 
886
        case R_68K_PC8:
887
        case R_68K_PC16:
888
        case R_68K_PC32:
889
          /* If we are creating a shared library and this is not a local
890
             symbol, we need to copy the reloc into the shared library.
891
             However when linking with -Bsymbolic and this is a global
892
             symbol which is defined in an object we are including in the
893
             link (i.e., DEF_REGULAR is set), then we can resolve the
894
             reloc directly.  At this point we have not seen all the input
895
             files, so it is possible that DEF_REGULAR is not set now but
896
             will be set later (it is never cleared).  We account for that
897
             possibility below by storing information in the
898
             pcrel_relocs_copied field of the hash table entry.  */
899
          if (!(info->shared
900
                && (sec->flags & SEC_ALLOC) != 0
901
                && h != NULL
902
                && (!info->symbolic
903
                    || h->root.type == bfd_link_hash_defweak
904
                    || !h->def_regular)))
905
            {
906
              if (h != NULL)
907
                {
908
                  /* Make sure a plt entry is created for this symbol if
909
                     it turns out to be a function defined by a dynamic
910
                     object.  */
911
                  h->plt.refcount++;
912
                }
913
              break;
914
            }
915
          /* Fall through.  */
916
        case R_68K_8:
917
        case R_68K_16:
918
        case R_68K_32:
919
          if (h != NULL)
920
            {
921
              /* Make sure a plt entry is created for this symbol if it
922
                 turns out to be a function defined by a dynamic object.  */
923
              h->plt.refcount++;
924
            }
925
 
926
          /* If we are creating a shared library, we need to copy the
927
             reloc into the shared library.  */
928
          if (info->shared
929
              && (sec->flags & SEC_ALLOC) != 0)
930
            {
931
              /* When creating a shared object, we must copy these
932
                 reloc types into the output file.  We create a reloc
933
                 section in dynobj and make room for this reloc.  */
934
              if (sreloc == NULL)
935
                {
936
                  const char *name;
937
 
938
                  name = (bfd_elf_string_from_elf_section
939
                          (abfd,
940
                           elf_elfheader (abfd)->e_shstrndx,
941
                           elf_section_data (sec)->rel_hdr.sh_name));
942
                  if (name == NULL)
943
                    return FALSE;
944
 
945
                  BFD_ASSERT (CONST_STRNEQ (name, ".rela")
946
                              && strcmp (bfd_get_section_name (abfd, sec),
947
                                         name + 5) == 0);
948
 
949
                  sreloc = bfd_get_section_by_name (dynobj, name);
950
                  if (sreloc == NULL)
951
                    {
952
                      sreloc = bfd_make_section_with_flags (dynobj,
953
                                                            name,
954
                                                            (SEC_ALLOC
955
                                                             | SEC_LOAD
956
                                                             | SEC_HAS_CONTENTS
957
                                                             | SEC_IN_MEMORY
958
                                                             | SEC_LINKER_CREATED
959
                                                             | SEC_READONLY));
960
                      if (sreloc == NULL
961
                          || !bfd_set_section_alignment (dynobj, sreloc, 2))
962
                        return FALSE;
963
                    }
964
                  elf_section_data (sec)->sreloc = sreloc;
965
                }
966
 
967
              if (sec->flags & SEC_READONLY
968
                  /* Don't set DF_TEXTREL yet for PC relative
969
                     relocations, they might be discarded later.  */
970
                  && !(ELF32_R_TYPE (rel->r_info) == R_68K_PC8
971
                       || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
972
                       || ELF32_R_TYPE (rel->r_info) == R_68K_PC32))
973
                    info->flags |= DF_TEXTREL;
974
 
975
              sreloc->size += sizeof (Elf32_External_Rela);
976
 
977
              /* We count the number of PC relative relocations we have
978
                 entered for this symbol, so that we can discard them
979
                 again if, in the -Bsymbolic case, the symbol is later
980
                 defined by a regular object, or, in the normal shared
981
                 case, the symbol is forced to be local.  Note that this
982
                 function is only called if we are using an m68kelf linker
983
                 hash table, which means that h is really a pointer to an
984
                 elf_m68k_link_hash_entry.  */
985
              if (ELF32_R_TYPE (rel->r_info) == R_68K_PC8
986
                  || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
987
                  || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)
988
                {
989
                  struct elf_m68k_pcrel_relocs_copied *p;
990
                  struct elf_m68k_pcrel_relocs_copied **head;
991
 
992
                  if (h != NULL)
993
                    {
994
                      struct elf_m68k_link_hash_entry *eh
995
                        = elf_m68k_hash_entry (h);
996
                      head = &eh->pcrel_relocs_copied;
997
                    }
998
                  else
999
                    {
1000
                      asection *s;
1001
                      void *vpp;
1002
 
1003
                      s = (bfd_section_from_r_symndx
1004
                           (abfd, &elf_m68k_hash_table (info)->sym_sec,
1005
                            sec, r_symndx));
1006
                      if (s == NULL)
1007
                        return FALSE;
1008
 
1009
                      vpp = &elf_section_data (s)->local_dynrel;
1010
                      head = (struct elf_m68k_pcrel_relocs_copied **) vpp;
1011
                    }
1012
 
1013
                  for (p = *head; p != NULL; p = p->next)
1014
                    if (p->section == sreloc)
1015
                      break;
1016
 
1017
                  if (p == NULL)
1018
                    {
1019
                      p = ((struct elf_m68k_pcrel_relocs_copied *)
1020
                           bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
1021
                      if (p == NULL)
1022
                        return FALSE;
1023
                      p->next = *head;
1024
                      *head = p;
1025
                      p->section = sreloc;
1026
                      p->count = 0;
1027
                    }
1028
 
1029
                  ++p->count;
1030
                }
1031
            }
1032
 
1033
          break;
1034
 
1035
          /* This relocation describes the C++ object vtable hierarchy.
1036
             Reconstruct it for later use during GC.  */
1037
        case R_68K_GNU_VTINHERIT:
1038
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1039
            return FALSE;
1040
          break;
1041
 
1042
          /* This relocation describes which C++ vtable entries are actually
1043
             used.  Record for later use during GC.  */
1044
        case R_68K_GNU_VTENTRY:
1045
          BFD_ASSERT (h != NULL);
1046
          if (h != NULL
1047
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1048
            return FALSE;
1049
          break;
1050
 
1051
        default:
1052
          break;
1053
        }
1054
    }
1055
 
1056
  return TRUE;
1057
}
1058
 
1059
/* Return the section that should be marked against GC for a given
1060
   relocation.  */
1061
 
1062
static asection *
1063
elf_m68k_gc_mark_hook (asection *sec,
1064
                       struct bfd_link_info *info,
1065
                       Elf_Internal_Rela *rel,
1066
                       struct elf_link_hash_entry *h,
1067
                       Elf_Internal_Sym *sym)
1068
{
1069
  if (h != NULL)
1070
    switch (ELF32_R_TYPE (rel->r_info))
1071
      {
1072
      case R_68K_GNU_VTINHERIT:
1073
      case R_68K_GNU_VTENTRY:
1074
        return NULL;
1075
      }
1076
 
1077
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1078
}
1079
 
1080
/* Update the got entry reference counts for the section being removed.  */
1081
 
1082
static bfd_boolean
1083
elf_m68k_gc_sweep_hook (bfd *abfd,
1084
                        struct bfd_link_info *info,
1085
                        asection *sec,
1086
                        const Elf_Internal_Rela *relocs)
1087
{
1088
  Elf_Internal_Shdr *symtab_hdr;
1089
  struct elf_link_hash_entry **sym_hashes;
1090
  bfd_signed_vma *local_got_refcounts;
1091
  const Elf_Internal_Rela *rel, *relend;
1092
  bfd *dynobj;
1093
  asection *sgot;
1094
  asection *srelgot;
1095
 
1096
  if (info->relocatable)
1097
    return TRUE;
1098
 
1099
  dynobj = elf_hash_table (info)->dynobj;
1100
  if (dynobj == NULL)
1101
    return TRUE;
1102
 
1103
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1104
  sym_hashes = elf_sym_hashes (abfd);
1105
  local_got_refcounts = elf_local_got_refcounts (abfd);
1106
 
1107
  sgot = bfd_get_section_by_name (dynobj, ".got");
1108
  srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1109
 
1110
  relend = relocs + sec->reloc_count;
1111
  for (rel = relocs; rel < relend; rel++)
1112
    {
1113
      unsigned long r_symndx;
1114
      struct elf_link_hash_entry *h = NULL;
1115
 
1116
      r_symndx = ELF32_R_SYM (rel->r_info);
1117
      if (r_symndx >= symtab_hdr->sh_info)
1118
        {
1119
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1120
          while (h->root.type == bfd_link_hash_indirect
1121
                 || h->root.type == bfd_link_hash_warning)
1122
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
1123
        }
1124
 
1125
      switch (ELF32_R_TYPE (rel->r_info))
1126
        {
1127
        case R_68K_GOT8:
1128
        case R_68K_GOT16:
1129
        case R_68K_GOT32:
1130
        case R_68K_GOT8O:
1131
        case R_68K_GOT16O:
1132
        case R_68K_GOT32O:
1133
          if (h != NULL)
1134
            {
1135
              if (h->got.refcount > 0)
1136
                {
1137
                  --h->got.refcount;
1138
                  if (h->got.refcount == 0)
1139
                    {
1140
                      /* We don't need the .got entry any more.  */
1141
                      sgot->size -= 4;
1142
                      srelgot->size -= sizeof (Elf32_External_Rela);
1143
                    }
1144
                }
1145
            }
1146
          else if (local_got_refcounts != NULL)
1147
            {
1148
              if (local_got_refcounts[r_symndx] > 0)
1149
                {
1150
                  --local_got_refcounts[r_symndx];
1151
                  if (local_got_refcounts[r_symndx] == 0)
1152
                    {
1153
                      /* We don't need the .got entry any more.  */
1154
                      sgot->size -= 4;
1155
                      if (info->shared)
1156
                        srelgot->size -= sizeof (Elf32_External_Rela);
1157
                    }
1158
                }
1159
            }
1160
          break;
1161
 
1162
        case R_68K_PLT8:
1163
        case R_68K_PLT16:
1164
        case R_68K_PLT32:
1165
        case R_68K_PLT8O:
1166
        case R_68K_PLT16O:
1167
        case R_68K_PLT32O:
1168
        case R_68K_PC8:
1169
        case R_68K_PC16:
1170
        case R_68K_PC32:
1171
        case R_68K_8:
1172
        case R_68K_16:
1173
        case R_68K_32:
1174
          if (h != NULL)
1175
            {
1176
              if (h->plt.refcount > 0)
1177
                --h->plt.refcount;
1178
            }
1179
          break;
1180
 
1181
        default:
1182
          break;
1183
        }
1184
    }
1185
 
1186
  return TRUE;
1187
}
1188
 
1189
/* Return the type of PLT associated with OUTPUT_BFD.  */
1190
 
1191
static const struct elf_m68k_plt_info *
1192
elf_m68k_get_plt_info (bfd *output_bfd)
1193
{
1194
  unsigned int features;
1195
 
1196
  features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd));
1197
  if (features & cpu32)
1198
    return &elf_cpu32_plt_info;
1199
  if (features & mcfisa_b)
1200
    return &elf_isab_plt_info;
1201
  if (features & mcfisa_c)
1202
    return &elf_isac_plt_info;
1203
  return &elf_m68k_plt_info;
1204
}
1205
 
1206
/* This function is called after all the input files have been read,
1207
   and the input sections have been assigned to output sections.
1208
   It's a convenient place to determine the PLT style.  */
1209
 
1210
static bfd_boolean
1211
elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
1212
{
1213
  elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd);
1214
  return TRUE;
1215
}
1216
 
1217
/* Adjust a symbol defined by a dynamic object and referenced by a
1218
   regular object.  The current definition is in some section of the
1219
   dynamic object, but we're not including those sections.  We have to
1220
   change the definition to something the rest of the link can
1221
   understand.  */
1222
 
1223
static bfd_boolean
1224
elf_m68k_adjust_dynamic_symbol (info, h)
1225
     struct bfd_link_info *info;
1226
     struct elf_link_hash_entry *h;
1227
{
1228
  struct elf_m68k_link_hash_table *htab;
1229
  bfd *dynobj;
1230
  asection *s;
1231
 
1232
  htab = elf_m68k_hash_table (info);
1233
  dynobj = elf_hash_table (info)->dynobj;
1234
 
1235
  /* Make sure we know what is going on here.  */
1236
  BFD_ASSERT (dynobj != NULL
1237
              && (h->needs_plt
1238
                  || h->u.weakdef != NULL
1239
                  || (h->def_dynamic
1240
                      && h->ref_regular
1241
                      && !h->def_regular)));
1242
 
1243
  /* If this is a function, put it in the procedure linkage table.  We
1244
     will fill in the contents of the procedure linkage table later,
1245
     when we know the address of the .got section.  */
1246
  if (h->type == STT_FUNC
1247
      || h->needs_plt)
1248
    {
1249
      if ((h->plt.refcount <= 0
1250
           || SYMBOL_CALLS_LOCAL (info, h)
1251
           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1252
               && h->root.type == bfd_link_hash_undefweak))
1253
          /* We must always create the plt entry if it was referenced
1254
             by a PLTxxO relocation.  In this case we already recorded
1255
             it as a dynamic symbol.  */
1256
          && h->dynindx == -1)
1257
        {
1258
          /* This case can occur if we saw a PLTxx reloc in an input
1259
             file, but the symbol was never referred to by a dynamic
1260
             object, or if all references were garbage collected.  In
1261
             such a case, we don't actually need to build a procedure
1262
             linkage table, and we can just do a PCxx reloc instead.  */
1263
          h->plt.offset = (bfd_vma) -1;
1264
          h->needs_plt = 0;
1265
          return TRUE;
1266
        }
1267
 
1268
      /* Make sure this symbol is output as a dynamic symbol.  */
1269
      if (h->dynindx == -1
1270
          && !h->forced_local)
1271
        {
1272
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
1273
            return FALSE;
1274
        }
1275
 
1276
      s = bfd_get_section_by_name (dynobj, ".plt");
1277
      BFD_ASSERT (s != NULL);
1278
 
1279
      /* If this is the first .plt entry, make room for the special
1280
         first entry.  */
1281
      if (s->size == 0)
1282
        s->size = htab->plt_info->size;
1283
 
1284
      /* If this symbol is not defined in a regular file, and we are
1285
         not generating a shared library, then set the symbol to this
1286
         location in the .plt.  This is required to make function
1287
         pointers compare as equal between the normal executable and
1288
         the shared library.  */
1289
      if (!info->shared
1290
          && !h->def_regular)
1291
        {
1292
          h->root.u.def.section = s;
1293
          h->root.u.def.value = s->size;
1294
        }
1295
 
1296
      h->plt.offset = s->size;
1297
 
1298
      /* Make room for this entry.  */
1299
      s->size += htab->plt_info->size;
1300
 
1301
      /* We also need to make an entry in the .got.plt section, which
1302
         will be placed in the .got section by the linker script.  */
1303
      s = bfd_get_section_by_name (dynobj, ".got.plt");
1304
      BFD_ASSERT (s != NULL);
1305
      s->size += 4;
1306
 
1307
      /* We also need to make an entry in the .rela.plt section.  */
1308
      s = bfd_get_section_by_name (dynobj, ".rela.plt");
1309
      BFD_ASSERT (s != NULL);
1310
      s->size += sizeof (Elf32_External_Rela);
1311
 
1312
      return TRUE;
1313
    }
1314
 
1315
  /* Reinitialize the plt offset now that it is not used as a reference
1316
     count any more.  */
1317
  h->plt.offset = (bfd_vma) -1;
1318
 
1319
  /* If this is a weak symbol, and there is a real definition, the
1320
     processor independent code will have arranged for us to see the
1321
     real definition first, and we can just use the same value.  */
1322
  if (h->u.weakdef != NULL)
1323
    {
1324
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1325
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
1326
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
1327
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
1328
      return TRUE;
1329
    }
1330
 
1331
  /* This is a reference to a symbol defined by a dynamic object which
1332
     is not a function.  */
1333
 
1334
  /* If we are creating a shared library, we must presume that the
1335
     only references to the symbol are via the global offset table.
1336
     For such cases we need not do anything here; the relocations will
1337
     be handled correctly by relocate_section.  */
1338
  if (info->shared)
1339
    return TRUE;
1340
 
1341
  if (h->size == 0)
1342
    {
1343
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1344
                             h->root.root.string);
1345
      return TRUE;
1346
    }
1347
 
1348
  /* We must allocate the symbol in our .dynbss section, which will
1349
     become part of the .bss section of the executable.  There will be
1350
     an entry for this symbol in the .dynsym section.  The dynamic
1351
     object will contain position independent code, so all references
1352
     from the dynamic object to this symbol will go through the global
1353
     offset table.  The dynamic linker will use the .dynsym entry to
1354
     determine the address it must put in the global offset table, so
1355
     both the dynamic object and the regular object will refer to the
1356
     same memory location for the variable.  */
1357
 
1358
  s = bfd_get_section_by_name (dynobj, ".dynbss");
1359
  BFD_ASSERT (s != NULL);
1360
 
1361
  /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
1362
     copy the initial value out of the dynamic object and into the
1363
     runtime process image.  We need to remember the offset into the
1364
     .rela.bss section we are going to use.  */
1365
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1366
    {
1367
      asection *srel;
1368
 
1369
      srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1370
      BFD_ASSERT (srel != NULL);
1371
      srel->size += sizeof (Elf32_External_Rela);
1372
      h->needs_copy = 1;
1373
    }
1374
 
1375
  return _bfd_elf_adjust_dynamic_copy (h, s);
1376
}
1377
 
1378
/* Set the sizes of the dynamic sections.  */
1379
 
1380
static bfd_boolean
1381
elf_m68k_size_dynamic_sections (output_bfd, info)
1382
     bfd *output_bfd ATTRIBUTE_UNUSED;
1383
     struct bfd_link_info *info;
1384
{
1385
  bfd *dynobj;
1386
  asection *s;
1387
  bfd_boolean plt;
1388
  bfd_boolean relocs;
1389
 
1390
  dynobj = elf_hash_table (info)->dynobj;
1391
  BFD_ASSERT (dynobj != NULL);
1392
 
1393
  if (elf_hash_table (info)->dynamic_sections_created)
1394
    {
1395
      /* Set the contents of the .interp section to the interpreter.  */
1396
      if (info->executable)
1397
        {
1398
          s = bfd_get_section_by_name (dynobj, ".interp");
1399
          BFD_ASSERT (s != NULL);
1400
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1401
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1402
        }
1403
    }
1404
  else
1405
    {
1406
      /* We may have created entries in the .rela.got section.
1407
         However, if we are not creating the dynamic sections, we will
1408
         not actually use these entries.  Reset the size of .rela.got,
1409
         which will cause it to get stripped from the output file
1410
         below.  */
1411
      s = bfd_get_section_by_name (dynobj, ".rela.got");
1412
      if (s != NULL)
1413
        s->size = 0;
1414
    }
1415
 
1416
  /* If this is a -Bsymbolic shared link, then we need to discard all
1417
     PC relative relocs against symbols defined in a regular object.
1418
     For the normal shared case we discard the PC relative relocs
1419
     against symbols that have become local due to visibility changes.
1420
     We allocated space for them in the check_relocs routine, but we
1421
     will not fill them in in the relocate_section routine.  */
1422
  if (info->shared)
1423
    elf_link_hash_traverse (elf_hash_table (info),
1424
                            elf_m68k_discard_copies,
1425
                            (PTR) info);
1426
 
1427
  /* The check_relocs and adjust_dynamic_symbol entry points have
1428
     determined the sizes of the various dynamic sections.  Allocate
1429
     memory for them.  */
1430
  plt = FALSE;
1431
  relocs = FALSE;
1432
  for (s = dynobj->sections; s != NULL; s = s->next)
1433
    {
1434
      const char *name;
1435
 
1436
      if ((s->flags & SEC_LINKER_CREATED) == 0)
1437
        continue;
1438
 
1439
      /* It's OK to base decisions on the section name, because none
1440
         of the dynobj section names depend upon the input files.  */
1441
      name = bfd_get_section_name (dynobj, s);
1442
 
1443
      if (strcmp (name, ".plt") == 0)
1444
        {
1445
          /* Remember whether there is a PLT.  */
1446
          plt = s->size != 0;
1447
        }
1448
      else if (CONST_STRNEQ (name, ".rela"))
1449
        {
1450
          if (s->size != 0)
1451
            {
1452
              relocs = TRUE;
1453
 
1454
              /* We use the reloc_count field as a counter if we need
1455
                 to copy relocs into the output file.  */
1456
              s->reloc_count = 0;
1457
            }
1458
        }
1459
      else if (! CONST_STRNEQ (name, ".got")
1460
               && strcmp (name, ".dynbss") != 0)
1461
        {
1462
          /* It's not one of our sections, so don't allocate space.  */
1463
          continue;
1464
        }
1465
 
1466
      if (s->size == 0)
1467
        {
1468
          /* If we don't need this section, strip it from the
1469
             output file.  This is mostly to handle .rela.bss and
1470
             .rela.plt.  We must create both sections in
1471
             create_dynamic_sections, because they must be created
1472
             before the linker maps input sections to output
1473
             sections.  The linker does that before
1474
             adjust_dynamic_symbol is called, and it is that
1475
             function which decides whether anything needs to go
1476
             into these sections.  */
1477
          s->flags |= SEC_EXCLUDE;
1478
          continue;
1479
        }
1480
 
1481
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
1482
        continue;
1483
 
1484
      /* Allocate memory for the section contents.  */
1485
      /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1486
         Unused entries should be reclaimed before the section's contents
1487
         are written out, but at the moment this does not happen.  Thus in
1488
         order to prevent writing out garbage, we initialise the section's
1489
         contents to zero.  */
1490
      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1491
      if (s->contents == NULL)
1492
        return FALSE;
1493
    }
1494
 
1495
  if (elf_hash_table (info)->dynamic_sections_created)
1496
    {
1497
      /* Add some entries to the .dynamic section.  We fill in the
1498
         values later, in elf_m68k_finish_dynamic_sections, but we
1499
         must add the entries now so that we get the correct size for
1500
         the .dynamic section.  The DT_DEBUG entry is filled in by the
1501
         dynamic linker and used by the debugger.  */
1502
#define add_dynamic_entry(TAG, VAL) \
1503
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1504
 
1505
      if (!info->shared)
1506
        {
1507
          if (!add_dynamic_entry (DT_DEBUG, 0))
1508
            return FALSE;
1509
        }
1510
 
1511
      if (plt)
1512
        {
1513
          if (!add_dynamic_entry (DT_PLTGOT, 0)
1514
              || !add_dynamic_entry (DT_PLTRELSZ, 0)
1515
              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1516
              || !add_dynamic_entry (DT_JMPREL, 0))
1517
            return FALSE;
1518
        }
1519
 
1520
      if (relocs)
1521
        {
1522
          if (!add_dynamic_entry (DT_RELA, 0)
1523
              || !add_dynamic_entry (DT_RELASZ, 0)
1524
              || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1525
            return FALSE;
1526
        }
1527
 
1528
      if ((info->flags & DF_TEXTREL) != 0)
1529
        {
1530
          if (!add_dynamic_entry (DT_TEXTREL, 0))
1531
            return FALSE;
1532
        }
1533
    }
1534
#undef add_dynamic_entry
1535
 
1536
  return TRUE;
1537
}
1538
 
1539
/* This function is called via elf_link_hash_traverse if we are
1540
   creating a shared object.  In the -Bsymbolic case it discards the
1541
   space allocated to copy PC relative relocs against symbols which
1542
   are defined in regular objects.  For the normal shared case, it
1543
   discards space for pc-relative relocs that have become local due to
1544
   symbol visibility changes.  We allocated space for them in the
1545
   check_relocs routine, but we won't fill them in in the
1546
   relocate_section routine.
1547
 
1548
   We also check whether any of the remaining relocations apply
1549
   against a readonly section, and set the DF_TEXTREL flag in this
1550
   case.  */
1551
 
1552
static bfd_boolean
1553
elf_m68k_discard_copies (h, inf)
1554
     struct elf_link_hash_entry *h;
1555
     PTR inf;
1556
{
1557
  struct bfd_link_info *info = (struct bfd_link_info *) inf;
1558
  struct elf_m68k_pcrel_relocs_copied *s;
1559
 
1560
  if (h->root.type == bfd_link_hash_warning)
1561
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
1562
 
1563
  if (!h->def_regular
1564
      || (!info->symbolic
1565
          && !h->forced_local))
1566
    {
1567
      if ((info->flags & DF_TEXTREL) == 0)
1568
        {
1569
          /* Look for relocations against read-only sections.  */
1570
          for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
1571
               s != NULL;
1572
               s = s->next)
1573
            if ((s->section->flags & SEC_READONLY) != 0)
1574
              {
1575
                info->flags |= DF_TEXTREL;
1576
                break;
1577
              }
1578
        }
1579
 
1580
      return TRUE;
1581
    }
1582
 
1583
  for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
1584
       s != NULL;
1585
       s = s->next)
1586
    s->section->size -= s->count * sizeof (Elf32_External_Rela);
1587
 
1588
  return TRUE;
1589
}
1590
 
1591
/* Relocate an M68K ELF section.  */
1592
 
1593
static bfd_boolean
1594
elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section,
1595
                           contents, relocs, local_syms, local_sections)
1596
     bfd *output_bfd;
1597
     struct bfd_link_info *info;
1598
     bfd *input_bfd;
1599
     asection *input_section;
1600
     bfd_byte *contents;
1601
     Elf_Internal_Rela *relocs;
1602
     Elf_Internal_Sym *local_syms;
1603
     asection **local_sections;
1604
{
1605
  bfd *dynobj;
1606
  Elf_Internal_Shdr *symtab_hdr;
1607
  struct elf_link_hash_entry **sym_hashes;
1608
  bfd_vma *local_got_offsets;
1609
  asection *sgot;
1610
  asection *splt;
1611
  asection *sreloc;
1612
  Elf_Internal_Rela *rel;
1613
  Elf_Internal_Rela *relend;
1614
 
1615
  dynobj = elf_hash_table (info)->dynobj;
1616
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1617
  sym_hashes = elf_sym_hashes (input_bfd);
1618
  local_got_offsets = elf_local_got_offsets (input_bfd);
1619
 
1620
  sgot = NULL;
1621
  splt = NULL;
1622
  sreloc = NULL;
1623
 
1624
  rel = relocs;
1625
  relend = relocs + input_section->reloc_count;
1626
  for (; rel < relend; rel++)
1627
    {
1628
      int r_type;
1629
      reloc_howto_type *howto;
1630
      unsigned long r_symndx;
1631
      struct elf_link_hash_entry *h;
1632
      Elf_Internal_Sym *sym;
1633
      asection *sec;
1634
      bfd_vma relocation;
1635
      bfd_boolean unresolved_reloc;
1636
      bfd_reloc_status_type r;
1637
 
1638
      r_type = ELF32_R_TYPE (rel->r_info);
1639
      if (r_type < 0 || r_type >= (int) R_68K_max)
1640
        {
1641
          bfd_set_error (bfd_error_bad_value);
1642
          return FALSE;
1643
        }
1644
      howto = howto_table + r_type;
1645
 
1646
      r_symndx = ELF32_R_SYM (rel->r_info);
1647
 
1648
      h = NULL;
1649
      sym = NULL;
1650
      sec = NULL;
1651
      unresolved_reloc = FALSE;
1652
 
1653
      if (r_symndx < symtab_hdr->sh_info)
1654
        {
1655
          sym = local_syms + r_symndx;
1656
          sec = local_sections[r_symndx];
1657
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1658
        }
1659
      else
1660
        {
1661
          bfd_boolean warned;
1662
 
1663
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1664
                                   r_symndx, symtab_hdr, sym_hashes,
1665
                                   h, sec, relocation,
1666
                                   unresolved_reloc, warned);
1667
        }
1668
 
1669
      if (sec != NULL && elf_discarded_section (sec))
1670
        {
1671
          /* For relocs against symbols from removed linkonce sections,
1672
             or sections discarded by a linker script, we just want the
1673
             section contents zeroed.  Avoid any special processing.  */
1674
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1675
          rel->r_info = 0;
1676
          rel->r_addend = 0;
1677
          continue;
1678
        }
1679
 
1680
      if (info->relocatable)
1681
        continue;
1682
 
1683
      switch (r_type)
1684
        {
1685
        case R_68K_GOT8:
1686
        case R_68K_GOT16:
1687
        case R_68K_GOT32:
1688
          /* Relocation is to the address of the entry for this symbol
1689
             in the global offset table.  */
1690
          if (h != NULL
1691
              && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1692
            break;
1693
          /* Fall through.  */
1694
        case R_68K_GOT8O:
1695
        case R_68K_GOT16O:
1696
        case R_68K_GOT32O:
1697
          /* Relocation is the offset of the entry for this symbol in
1698
             the global offset table.  */
1699
 
1700
          {
1701
            bfd_vma off;
1702
 
1703
            if (sgot == NULL)
1704
              {
1705
                sgot = bfd_get_section_by_name (dynobj, ".got");
1706
                BFD_ASSERT (sgot != NULL);
1707
              }
1708
 
1709
            if (h != NULL)
1710
              {
1711
                bfd_boolean dyn;
1712
 
1713
                off = h->got.offset;
1714
                BFD_ASSERT (off != (bfd_vma) -1);
1715
 
1716
                dyn = elf_hash_table (info)->dynamic_sections_created;
1717
                if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1718
                    || (info->shared
1719
                        && (info->symbolic
1720
                            || h->dynindx == -1
1721
                            || h->forced_local)
1722
                        && h->def_regular))
1723
                  {
1724
                    /* This is actually a static link, or it is a
1725
                       -Bsymbolic link and the symbol is defined
1726
                       locally, or the symbol was forced to be local
1727
                       because of a version file..  We must initialize
1728
                       this entry in the global offset table.  Since
1729
                       the offset must always be a multiple of 4, we
1730
                       use the least significant bit to record whether
1731
                       we have initialized it already.
1732
 
1733
                       When doing a dynamic link, we create a .rela.got
1734
                       relocation entry to initialize the value.  This
1735
                       is done in the finish_dynamic_symbol routine.  */
1736
                    if ((off & 1) != 0)
1737
                      off &= ~1;
1738
                    else
1739
                      {
1740
                        bfd_put_32 (output_bfd, relocation,
1741
                                    sgot->contents + off);
1742
                        h->got.offset |= 1;
1743
                      }
1744
                  }
1745
                else
1746
                  unresolved_reloc = FALSE;
1747
              }
1748
            else
1749
              {
1750
                BFD_ASSERT (local_got_offsets != NULL
1751
                            && local_got_offsets[r_symndx] != (bfd_vma) -1);
1752
 
1753
                off = local_got_offsets[r_symndx];
1754
 
1755
                /* The offset must always be a multiple of 4.  We use
1756
                   the least significant bit to record whether we have
1757
                   already generated the necessary reloc.  */
1758
                if ((off & 1) != 0)
1759
                  off &= ~1;
1760
                else
1761
                  {
1762
                    bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1763
 
1764
                    if (info->shared)
1765
                      {
1766
                        asection *s;
1767
                        Elf_Internal_Rela outrel;
1768
                        bfd_byte *loc;
1769
 
1770
                        s = bfd_get_section_by_name (dynobj, ".rela.got");
1771
                        BFD_ASSERT (s != NULL);
1772
 
1773
                        outrel.r_offset = (sgot->output_section->vma
1774
                                           + sgot->output_offset
1775
                                           + off);
1776
                        outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1777
                        outrel.r_addend = relocation;
1778
                        loc = s->contents;
1779
                        loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1780
                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1781
                      }
1782
 
1783
                    local_got_offsets[r_symndx] |= 1;
1784
                  }
1785
              }
1786
 
1787
            relocation = sgot->output_offset + off;
1788
            if (r_type == R_68K_GOT8O
1789
                || r_type == R_68K_GOT16O
1790
                || r_type == R_68K_GOT32O)
1791
              {
1792
                /* This relocation does not use the addend.  */
1793
                rel->r_addend = 0;
1794
              }
1795
            else
1796
              relocation += sgot->output_section->vma;
1797
          }
1798
          break;
1799
 
1800
        case R_68K_PLT8:
1801
        case R_68K_PLT16:
1802
        case R_68K_PLT32:
1803
          /* Relocation is to the entry for this symbol in the
1804
             procedure linkage table.  */
1805
 
1806
          /* Resolve a PLTxx reloc against a local symbol directly,
1807
             without using the procedure linkage table.  */
1808
          if (h == NULL)
1809
            break;
1810
 
1811
          if (h->plt.offset == (bfd_vma) -1
1812
              || !elf_hash_table (info)->dynamic_sections_created)
1813
            {
1814
              /* We didn't make a PLT entry for this symbol.  This
1815
                 happens when statically linking PIC code, or when
1816
                 using -Bsymbolic.  */
1817
              break;
1818
            }
1819
 
1820
          if (splt == NULL)
1821
            {
1822
              splt = bfd_get_section_by_name (dynobj, ".plt");
1823
              BFD_ASSERT (splt != NULL);
1824
            }
1825
 
1826
          relocation = (splt->output_section->vma
1827
                        + splt->output_offset
1828
                        + h->plt.offset);
1829
          unresolved_reloc = FALSE;
1830
          break;
1831
 
1832
        case R_68K_PLT8O:
1833
        case R_68K_PLT16O:
1834
        case R_68K_PLT32O:
1835
          /* Relocation is the offset of the entry for this symbol in
1836
             the procedure linkage table.  */
1837
          BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
1838
 
1839
          if (splt == NULL)
1840
            {
1841
              splt = bfd_get_section_by_name (dynobj, ".plt");
1842
              BFD_ASSERT (splt != NULL);
1843
            }
1844
 
1845
          relocation = h->plt.offset;
1846
          unresolved_reloc = FALSE;
1847
 
1848
          /* This relocation does not use the addend.  */
1849
          rel->r_addend = 0;
1850
 
1851
          break;
1852
 
1853
        case R_68K_PC8:
1854
        case R_68K_PC16:
1855
        case R_68K_PC32:
1856
          if (h == NULL
1857
              || (info->shared
1858
                  && h->forced_local))
1859
            break;
1860
          /* Fall through.  */
1861
        case R_68K_8:
1862
        case R_68K_16:
1863
        case R_68K_32:
1864
          if (info->shared
1865
              && r_symndx != 0
1866
              && (input_section->flags & SEC_ALLOC) != 0
1867
              && (h == NULL
1868
                  || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1869
                  || h->root.type != bfd_link_hash_undefweak)
1870
              && ((r_type != R_68K_PC8
1871
                   && r_type != R_68K_PC16
1872
                   && r_type != R_68K_PC32)
1873
                  || (h != NULL
1874
                      && h->dynindx != -1
1875
                      && (!info->symbolic
1876
                          || !h->def_regular))))
1877
            {
1878
              Elf_Internal_Rela outrel;
1879
              bfd_byte *loc;
1880
              bfd_boolean skip, relocate;
1881
 
1882
              /* When generating a shared object, these relocations
1883
                 are copied into the output file to be resolved at run
1884
                 time.  */
1885
 
1886
              skip = FALSE;
1887
              relocate = FALSE;
1888
 
1889
              outrel.r_offset =
1890
                _bfd_elf_section_offset (output_bfd, info, input_section,
1891
                                         rel->r_offset);
1892
              if (outrel.r_offset == (bfd_vma) -1)
1893
                skip = TRUE;
1894
              else if (outrel.r_offset == (bfd_vma) -2)
1895
                skip = TRUE, relocate = TRUE;
1896
              outrel.r_offset += (input_section->output_section->vma
1897
                                  + input_section->output_offset);
1898
 
1899
              if (skip)
1900
                memset (&outrel, 0, sizeof outrel);
1901
              else if (h != NULL
1902
                       && h->dynindx != -1
1903
                       && (r_type == R_68K_PC8
1904
                           || r_type == R_68K_PC16
1905
                           || r_type == R_68K_PC32
1906
                           || !info->shared
1907
                           || !info->symbolic
1908
                           || !h->def_regular))
1909
                {
1910
                  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1911
                  outrel.r_addend = rel->r_addend;
1912
                }
1913
              else
1914
                {
1915
                  /* This symbol is local, or marked to become local.  */
1916
                  outrel.r_addend = relocation + rel->r_addend;
1917
 
1918
                  if (r_type == R_68K_32)
1919
                    {
1920
                      relocate = TRUE;
1921
                      outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1922
                    }
1923
                  else
1924
                    {
1925
                      long indx;
1926
 
1927
                      if (bfd_is_abs_section (sec))
1928
                        indx = 0;
1929
                      else if (sec == NULL || sec->owner == NULL)
1930
                        {
1931
                          bfd_set_error (bfd_error_bad_value);
1932
                          return FALSE;
1933
                        }
1934
                      else
1935
                        {
1936
                          asection *osec;
1937
 
1938
                          /* We are turning this relocation into one
1939
                             against a section symbol.  It would be
1940
                             proper to subtract the symbol's value,
1941
                             osec->vma, from the emitted reloc addend,
1942
                             but ld.so expects buggy relocs.  */
1943
                          osec = sec->output_section;
1944
                          indx = elf_section_data (osec)->dynindx;
1945
                          if (indx == 0)
1946
                            {
1947
                              struct elf_link_hash_table *htab;
1948
                              htab = elf_hash_table (info);
1949
                              osec = htab->text_index_section;
1950
                              indx = elf_section_data (osec)->dynindx;
1951
                            }
1952
                          BFD_ASSERT (indx != 0);
1953
                        }
1954
 
1955
                      outrel.r_info = ELF32_R_INFO (indx, r_type);
1956
                    }
1957
                }
1958
 
1959
              sreloc = elf_section_data (input_section)->sreloc;
1960
              if (sreloc == NULL)
1961
                abort ();
1962
 
1963
              loc = sreloc->contents;
1964
              loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1965
              bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1966
 
1967
              /* This reloc will be computed at runtime, so there's no
1968
                 need to do anything now, except for R_68K_32
1969
                 relocations that have been turned into
1970
                 R_68K_RELATIVE.  */
1971
              if (!relocate)
1972
                continue;
1973
            }
1974
 
1975
          break;
1976
 
1977
        case R_68K_GNU_VTINHERIT:
1978
        case R_68K_GNU_VTENTRY:
1979
          /* These are no-ops in the end.  */
1980
          continue;
1981
 
1982
        default:
1983
          break;
1984
        }
1985
 
1986
      /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1987
         because such sections are not SEC_ALLOC and thus ld.so will
1988
         not process them.  */
1989
      if (unresolved_reloc
1990
          && !((input_section->flags & SEC_DEBUGGING) != 0
1991
               && h->def_dynamic))
1992
        {
1993
          (*_bfd_error_handler)
1994
            (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1995
             input_bfd,
1996
             input_section,
1997
             (long) rel->r_offset,
1998
             howto->name,
1999
             h->root.root.string);
2000
          return FALSE;
2001
        }
2002
 
2003
      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2004
                                    contents, rel->r_offset,
2005
                                    relocation, rel->r_addend);
2006
 
2007
      if (r != bfd_reloc_ok)
2008
        {
2009
          const char *name;
2010
 
2011
          if (h != NULL)
2012
            name = h->root.root.string;
2013
          else
2014
            {
2015
              name = bfd_elf_string_from_elf_section (input_bfd,
2016
                                                      symtab_hdr->sh_link,
2017
                                                      sym->st_name);
2018
              if (name == NULL)
2019
                return FALSE;
2020
              if (*name == '\0')
2021
                name = bfd_section_name (input_bfd, sec);
2022
            }
2023
 
2024
          if (r == bfd_reloc_overflow)
2025
            {
2026
              if (!(info->callbacks->reloc_overflow
2027
                    (info, (h ? &h->root : NULL), name, howto->name,
2028
                     (bfd_vma) 0, input_bfd, input_section,
2029
                     rel->r_offset)))
2030
                return FALSE;
2031
            }
2032
          else
2033
            {
2034
              (*_bfd_error_handler)
2035
                (_("%B(%A+0x%lx): reloc against `%s': error %d"),
2036
                 input_bfd, input_section,
2037
                 (long) rel->r_offset, name, (int) r);
2038
              return FALSE;
2039
            }
2040
        }
2041
    }
2042
 
2043
  return TRUE;
2044
}
2045
 
2046
/* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
2047
   into section SEC.  */
2048
 
2049
static void
2050
elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value)
2051
{
2052
  /* Make VALUE PC-relative.  */
2053
  value -= sec->output_section->vma + offset;
2054
 
2055
  /* Apply any in-place addend.  */
2056
  value += bfd_get_32 (sec->owner, sec->contents + offset);
2057
 
2058
  bfd_put_32 (sec->owner, value, sec->contents + offset);
2059
}
2060
 
2061
/* Finish up dynamic symbol handling.  We set the contents of various
2062
   dynamic sections here.  */
2063
 
2064
static bfd_boolean
2065
elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym)
2066
     bfd *output_bfd;
2067
     struct bfd_link_info *info;
2068
     struct elf_link_hash_entry *h;
2069
     Elf_Internal_Sym *sym;
2070
{
2071
  bfd *dynobj;
2072
 
2073
  dynobj = elf_hash_table (info)->dynobj;
2074
 
2075
  if (h->plt.offset != (bfd_vma) -1)
2076
    {
2077
      const struct elf_m68k_plt_info *plt_info;
2078
      asection *splt;
2079
      asection *sgot;
2080
      asection *srela;
2081
      bfd_vma plt_index;
2082
      bfd_vma got_offset;
2083
      Elf_Internal_Rela rela;
2084
      bfd_byte *loc;
2085
 
2086
      /* This symbol has an entry in the procedure linkage table.  Set
2087
         it up.  */
2088
 
2089
      BFD_ASSERT (h->dynindx != -1);
2090
 
2091
      plt_info = elf_m68k_hash_table (info)->plt_info;
2092
      splt = bfd_get_section_by_name (dynobj, ".plt");
2093
      sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2094
      srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2095
      BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
2096
 
2097
      /* Get the index in the procedure linkage table which
2098
         corresponds to this symbol.  This is the index of this symbol
2099
         in all the symbols for which we are making plt entries.  The
2100
         first entry in the procedure linkage table is reserved.  */
2101
      plt_index = (h->plt.offset / plt_info->size) - 1;
2102
 
2103
      /* Get the offset into the .got table of the entry that
2104
         corresponds to this function.  Each .got entry is 4 bytes.
2105
         The first three are reserved.  */
2106
      got_offset = (plt_index + 3) * 4;
2107
 
2108
      memcpy (splt->contents + h->plt.offset,
2109
              plt_info->symbol_entry,
2110
              plt_info->size);
2111
 
2112
      elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got,
2113
                             (sgot->output_section->vma
2114
                              + sgot->output_offset
2115
                              + got_offset));
2116
 
2117
      bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
2118
                  splt->contents
2119
                  + h->plt.offset
2120
                  + plt_info->symbol_resolve_entry + 2);
2121
 
2122
      elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt,
2123
                             splt->output_section->vma);
2124
 
2125
      /* Fill in the entry in the global offset table.  */
2126
      bfd_put_32 (output_bfd,
2127
                  (splt->output_section->vma
2128
                   + splt->output_offset
2129
                   + h->plt.offset
2130
                   + plt_info->symbol_resolve_entry),
2131
                  sgot->contents + got_offset);
2132
 
2133
      /* Fill in the entry in the .rela.plt section.  */
2134
      rela.r_offset = (sgot->output_section->vma
2135
                       + sgot->output_offset
2136
                       + got_offset);
2137
      rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
2138
      rela.r_addend = 0;
2139
      loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
2140
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2141
 
2142
      if (!h->def_regular)
2143
        {
2144
          /* Mark the symbol as undefined, rather than as defined in
2145
             the .plt section.  Leave the value alone.  */
2146
          sym->st_shndx = SHN_UNDEF;
2147
        }
2148
    }
2149
 
2150
  if (h->got.offset != (bfd_vma) -1)
2151
    {
2152
      asection *sgot;
2153
      asection *srela;
2154
      Elf_Internal_Rela rela;
2155
      bfd_byte *loc;
2156
 
2157
      /* This symbol has an entry in the global offset table.  Set it
2158
         up.  */
2159
 
2160
      sgot = bfd_get_section_by_name (dynobj, ".got");
2161
      srela = bfd_get_section_by_name (dynobj, ".rela.got");
2162
      BFD_ASSERT (sgot != NULL && srela != NULL);
2163
 
2164
      rela.r_offset = (sgot->output_section->vma
2165
                       + sgot->output_offset
2166
                       + (h->got.offset &~ (bfd_vma) 1));
2167
 
2168
      /* If this is a -Bsymbolic link, and the symbol is defined
2169
         locally, we just want to emit a RELATIVE reloc.  Likewise if
2170
         the symbol was forced to be local because of a version file.
2171
         The entry in the global offset table will already have been
2172
         initialized in the relocate_section function.  */
2173
      if (info->shared
2174
          && (info->symbolic
2175
              || h->dynindx == -1
2176
              || h->forced_local)
2177
          && h->def_regular)
2178
        {
2179
          rela.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
2180
          rela.r_addend = bfd_get_signed_32 (output_bfd,
2181
                                             (sgot->contents
2182
                                              + (h->got.offset &~ (bfd_vma) 1)));
2183
        }
2184
      else
2185
        {
2186
          bfd_put_32 (output_bfd, (bfd_vma) 0,
2187
                      sgot->contents + (h->got.offset &~ (bfd_vma) 1));
2188
          rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
2189
          rela.r_addend = 0;
2190
        }
2191
 
2192
      loc = srela->contents;
2193
      loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
2194
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2195
    }
2196
 
2197
  if (h->needs_copy)
2198
    {
2199
      asection *s;
2200
      Elf_Internal_Rela rela;
2201
      bfd_byte *loc;
2202
 
2203
      /* This symbol needs a copy reloc.  Set it up.  */
2204
 
2205
      BFD_ASSERT (h->dynindx != -1
2206
                  && (h->root.type == bfd_link_hash_defined
2207
                      || h->root.type == bfd_link_hash_defweak));
2208
 
2209
      s = bfd_get_section_by_name (h->root.u.def.section->owner,
2210
                                   ".rela.bss");
2211
      BFD_ASSERT (s != NULL);
2212
 
2213
      rela.r_offset = (h->root.u.def.value
2214
                       + h->root.u.def.section->output_section->vma
2215
                       + h->root.u.def.section->output_offset);
2216
      rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
2217
      rela.r_addend = 0;
2218
      loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
2219
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2220
    }
2221
 
2222
  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2223
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2224
      || h == elf_hash_table (info)->hgot)
2225
    sym->st_shndx = SHN_ABS;
2226
 
2227
  return TRUE;
2228
}
2229
 
2230
/* Finish up the dynamic sections.  */
2231
 
2232
static bfd_boolean
2233
elf_m68k_finish_dynamic_sections (output_bfd, info)
2234
     bfd *output_bfd;
2235
     struct bfd_link_info *info;
2236
{
2237
  bfd *dynobj;
2238
  asection *sgot;
2239
  asection *sdyn;
2240
 
2241
  dynobj = elf_hash_table (info)->dynobj;
2242
 
2243
  sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2244
  BFD_ASSERT (sgot != NULL);
2245
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2246
 
2247
  if (elf_hash_table (info)->dynamic_sections_created)
2248
    {
2249
      asection *splt;
2250
      Elf32_External_Dyn *dyncon, *dynconend;
2251
 
2252
      splt = bfd_get_section_by_name (dynobj, ".plt");
2253
      BFD_ASSERT (splt != NULL && sdyn != NULL);
2254
 
2255
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
2256
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2257
      for (; dyncon < dynconend; dyncon++)
2258
        {
2259
          Elf_Internal_Dyn dyn;
2260
          const char *name;
2261
          asection *s;
2262
 
2263
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2264
 
2265
          switch (dyn.d_tag)
2266
            {
2267
            default:
2268
              break;
2269
 
2270
            case DT_PLTGOT:
2271
              name = ".got";
2272
              goto get_vma;
2273
            case DT_JMPREL:
2274
              name = ".rela.plt";
2275
            get_vma:
2276
              s = bfd_get_section_by_name (output_bfd, name);
2277
              BFD_ASSERT (s != NULL);
2278
              dyn.d_un.d_ptr = s->vma;
2279
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2280
              break;
2281
 
2282
            case DT_PLTRELSZ:
2283
              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2284
              BFD_ASSERT (s != NULL);
2285
              dyn.d_un.d_val = s->size;
2286
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2287
              break;
2288
 
2289
            case DT_RELASZ:
2290
              /* The procedure linkage table relocs (DT_JMPREL) should
2291
                 not be included in the overall relocs (DT_RELA).
2292
                 Therefore, we override the DT_RELASZ entry here to
2293
                 make it not include the JMPREL relocs.  Since the
2294
                 linker script arranges for .rela.plt to follow all
2295
                 other relocation sections, we don't have to worry
2296
                 about changing the DT_RELA entry.  */
2297
              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2298
              if (s != NULL)
2299
                dyn.d_un.d_val -= s->size;
2300
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2301
              break;
2302
            }
2303
        }
2304
 
2305
      /* Fill in the first entry in the procedure linkage table.  */
2306
      if (splt->size > 0)
2307
        {
2308
          const struct elf_m68k_plt_info *plt_info;
2309
 
2310
          plt_info = elf_m68k_hash_table (info)->plt_info;
2311
          memcpy (splt->contents, plt_info->plt0_entry, plt_info->size);
2312
 
2313
          elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4,
2314
                                 (sgot->output_section->vma
2315
                                  + sgot->output_offset
2316
                                  + 4));
2317
 
2318
          elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8,
2319
                                 (sgot->output_section->vma
2320
                                  + sgot->output_offset
2321
                                  + 8));
2322
 
2323
          elf_section_data (splt->output_section)->this_hdr.sh_entsize
2324
            = plt_info->size;
2325
        }
2326
    }
2327
 
2328
  /* Fill in the first three entries in the global offset table.  */
2329
  if (sgot->size > 0)
2330
    {
2331
      if (sdyn == NULL)
2332
        bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2333
      else
2334
        bfd_put_32 (output_bfd,
2335
                    sdyn->output_section->vma + sdyn->output_offset,
2336
                    sgot->contents);
2337
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2338
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2339
    }
2340
 
2341
  elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2342
 
2343
  return TRUE;
2344
}
2345
 
2346
/* Given a .data section and a .emreloc in-memory section, store
2347
   relocation information into the .emreloc section which can be
2348
   used at runtime to relocate the section.  This is called by the
2349
   linker when the --embedded-relocs switch is used.  This is called
2350
   after the add_symbols entry point has been called for all the
2351
   objects, and before the final_link entry point is called.  */
2352
 
2353
bfd_boolean
2354
bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
2355
     bfd *abfd;
2356
     struct bfd_link_info *info;
2357
     asection *datasec;
2358
     asection *relsec;
2359
     char **errmsg;
2360
{
2361
  Elf_Internal_Shdr *symtab_hdr;
2362
  Elf_Internal_Sym *isymbuf = NULL;
2363
  Elf_Internal_Rela *internal_relocs = NULL;
2364
  Elf_Internal_Rela *irel, *irelend;
2365
  bfd_byte *p;
2366
  bfd_size_type amt;
2367
 
2368
  BFD_ASSERT (! info->relocatable);
2369
 
2370
  *errmsg = NULL;
2371
 
2372
  if (datasec->reloc_count == 0)
2373
    return TRUE;
2374
 
2375
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2376
 
2377
  /* Get a copy of the native relocations.  */
2378
  internal_relocs = (_bfd_elf_link_read_relocs
2379
                     (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2380
                      info->keep_memory));
2381
  if (internal_relocs == NULL)
2382
    goto error_return;
2383
 
2384
  amt = (bfd_size_type) datasec->reloc_count * 12;
2385
  relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2386
  if (relsec->contents == NULL)
2387
    goto error_return;
2388
 
2389
  p = relsec->contents;
2390
 
2391
  irelend = internal_relocs + datasec->reloc_count;
2392
  for (irel = internal_relocs; irel < irelend; irel++, p += 12)
2393
    {
2394
      asection *targetsec;
2395
 
2396
      /* We are going to write a four byte longword into the runtime
2397
       reloc section.  The longword will be the address in the data
2398
       section which must be relocated.  It is followed by the name
2399
       of the target section NUL-padded or truncated to 8
2400
       characters.  */
2401
 
2402
      /* We can only relocate absolute longword relocs at run time.  */
2403
      if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
2404
        {
2405
          *errmsg = _("unsupported reloc type");
2406
          bfd_set_error (bfd_error_bad_value);
2407
          goto error_return;
2408
        }
2409
 
2410
      /* Get the target section referred to by the reloc.  */
2411
      if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2412
        {
2413
          /* A local symbol.  */
2414
          Elf_Internal_Sym *isym;
2415
 
2416
          /* Read this BFD's local symbols if we haven't done so already.  */
2417
          if (isymbuf == NULL)
2418
            {
2419
              isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2420
              if (isymbuf == NULL)
2421
                isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2422
                                                symtab_hdr->sh_info, 0,
2423
                                                NULL, NULL, NULL);
2424
              if (isymbuf == NULL)
2425
                goto error_return;
2426
            }
2427
 
2428
          isym = isymbuf + ELF32_R_SYM (irel->r_info);
2429
          targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2430
        }
2431
      else
2432
        {
2433
          unsigned long indx;
2434
          struct elf_link_hash_entry *h;
2435
 
2436
          /* An external symbol.  */
2437
          indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2438
          h = elf_sym_hashes (abfd)[indx];
2439
          BFD_ASSERT (h != NULL);
2440
          if (h->root.type == bfd_link_hash_defined
2441
              || h->root.type == bfd_link_hash_defweak)
2442
            targetsec = h->root.u.def.section;
2443
          else
2444
            targetsec = NULL;
2445
        }
2446
 
2447
      bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
2448
      memset (p + 4, 0, 8);
2449
      if (targetsec != NULL)
2450
        strncpy ((char *) p + 4, targetsec->output_section->name, 8);
2451
    }
2452
 
2453
  if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2454
    free (isymbuf);
2455
  if (internal_relocs != NULL
2456
      && elf_section_data (datasec)->relocs != internal_relocs)
2457
    free (internal_relocs);
2458
  return TRUE;
2459
 
2460
error_return:
2461
  if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2462
    free (isymbuf);
2463
  if (internal_relocs != NULL
2464
      && elf_section_data (datasec)->relocs != internal_relocs)
2465
    free (internal_relocs);
2466
  return FALSE;
2467
}
2468
 
2469
static enum elf_reloc_type_class
2470
elf32_m68k_reloc_type_class (rela)
2471
     const Elf_Internal_Rela *rela;
2472
{
2473
  switch ((int) ELF32_R_TYPE (rela->r_info))
2474
    {
2475
    case R_68K_RELATIVE:
2476
      return reloc_class_relative;
2477
    case R_68K_JMP_SLOT:
2478
      return reloc_class_plt;
2479
    case R_68K_COPY:
2480
      return reloc_class_copy;
2481
    default:
2482
      return reloc_class_normal;
2483
    }
2484
}
2485
 
2486
/* Return address for Ith PLT stub in section PLT, for relocation REL
2487
   or (bfd_vma) -1 if it should not be included.  */
2488
 
2489
static bfd_vma
2490
elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
2491
                      const arelent *rel ATTRIBUTE_UNUSED)
2492
{
2493
  return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
2494
}
2495
 
2496
#define TARGET_BIG_SYM                  bfd_elf32_m68k_vec
2497
#define TARGET_BIG_NAME                 "elf32-m68k"
2498
#define ELF_MACHINE_CODE                EM_68K
2499
#define ELF_MAXPAGESIZE                 0x2000
2500
#define elf_backend_create_dynamic_sections \
2501
                                        _bfd_elf_create_dynamic_sections
2502
#define bfd_elf32_bfd_link_hash_table_create \
2503
                                        elf_m68k_link_hash_table_create
2504
#define bfd_elf32_bfd_final_link        bfd_elf_gc_common_final_link
2505
 
2506
#define elf_backend_check_relocs        elf_m68k_check_relocs
2507
#define elf_backend_always_size_sections \
2508
                                        elf_m68k_always_size_sections
2509
#define elf_backend_adjust_dynamic_symbol \
2510
                                        elf_m68k_adjust_dynamic_symbol
2511
#define elf_backend_size_dynamic_sections \
2512
                                        elf_m68k_size_dynamic_sections
2513
#define elf_backend_init_index_section  _bfd_elf_init_1_index_section
2514
#define elf_backend_relocate_section    elf_m68k_relocate_section
2515
#define elf_backend_finish_dynamic_symbol \
2516
                                        elf_m68k_finish_dynamic_symbol
2517
#define elf_backend_finish_dynamic_sections \
2518
                                        elf_m68k_finish_dynamic_sections
2519
#define elf_backend_gc_mark_hook        elf_m68k_gc_mark_hook
2520
#define elf_backend_gc_sweep_hook       elf_m68k_gc_sweep_hook
2521
#define bfd_elf32_bfd_merge_private_bfd_data \
2522
                                        elf32_m68k_merge_private_bfd_data
2523
#define bfd_elf32_bfd_set_private_flags \
2524
                                        elf32_m68k_set_private_flags
2525
#define bfd_elf32_bfd_print_private_bfd_data \
2526
                                        elf32_m68k_print_private_bfd_data
2527
#define elf_backend_reloc_type_class    elf32_m68k_reloc_type_class
2528
#define elf_backend_plt_sym_val         elf_m68k_plt_sym_val
2529
#define elf_backend_object_p            elf32_m68k_object_p
2530
 
2531
#define elf_backend_can_gc_sections 1
2532
#define elf_backend_can_refcount 1
2533
#define elf_backend_want_got_plt 1
2534
#define elf_backend_plt_readonly 1
2535
#define elf_backend_want_plt_sym 0
2536
#define elf_backend_got_header_size     12
2537
#define elf_backend_rela_normal         1
2538
 
2539
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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