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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [bfd/] [elf32-m68k.c] - Blame information for rev 330

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* 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, 2008, 2009, 2010 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
  /* TLS general dynamic variable reference.  */
119
  HOWTO (R_68K_TLS_GD32,        /* type */
120
         0,                      /* rightshift */
121
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
122
         32,                    /* bitsize */
123
         FALSE,                 /* pc_relative */
124
         0,                      /* bitpos */
125
         complain_overflow_bitfield, /* complain_on_overflow */
126
         bfd_elf_generic_reloc, /* special_function */
127
         "R_68K_TLS_GD32",      /* name */
128
         FALSE,                 /* partial_inplace */
129
         0,                      /* src_mask */
130
         0xffffffff,            /* dst_mask */
131
         FALSE),                /* pcrel_offset */
132
 
133
  HOWTO (R_68K_TLS_GD16,        /* type */
134
         0,                      /* rightshift */
135
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
136
         16,                    /* bitsize */
137
         FALSE,                 /* pc_relative */
138
         0,                      /* bitpos */
139
         complain_overflow_signed, /* complain_on_overflow */
140
         bfd_elf_generic_reloc, /* special_function */
141
         "R_68K_TLS_GD16",      /* name */
142
         FALSE,                 /* partial_inplace */
143
         0,                      /* src_mask */
144
         0x0000ffff,            /* dst_mask */
145
         FALSE),                /* pcrel_offset */
146
 
147
  HOWTO (R_68K_TLS_GD8,         /* type */
148
         0,                      /* rightshift */
149
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
150
         8,                     /* bitsize */
151
         FALSE,                 /* pc_relative */
152
         0,                      /* bitpos */
153
         complain_overflow_signed, /* complain_on_overflow */
154
         bfd_elf_generic_reloc, /* special_function */
155
         "R_68K_TLS_GD8",       /* name */
156
         FALSE,                 /* partial_inplace */
157
         0,                      /* src_mask */
158
         0x000000ff,            /* dst_mask */
159
         FALSE),                /* pcrel_offset */
160
 
161
  /* TLS local dynamic variable reference.  */
162
  HOWTO (R_68K_TLS_LDM32,       /* type */
163
         0,                      /* rightshift */
164
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
165
         32,                    /* bitsize */
166
         FALSE,                 /* pc_relative */
167
         0,                      /* bitpos */
168
         complain_overflow_bitfield, /* complain_on_overflow */
169
         bfd_elf_generic_reloc, /* special_function */
170
         "R_68K_TLS_LDM32",     /* name */
171
         FALSE,                 /* partial_inplace */
172
         0,                      /* src_mask */
173
         0xffffffff,            /* dst_mask */
174
         FALSE),                /* pcrel_offset */
175
 
176
  HOWTO (R_68K_TLS_LDM16,       /* type */
177
         0,                      /* rightshift */
178
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
179
         16,                    /* bitsize */
180
         FALSE,                 /* pc_relative */
181
         0,                      /* bitpos */
182
         complain_overflow_signed, /* complain_on_overflow */
183
         bfd_elf_generic_reloc, /* special_function */
184
         "R_68K_TLS_LDM16",     /* name */
185
         FALSE,                 /* partial_inplace */
186
         0,                      /* src_mask */
187
         0x0000ffff,            /* dst_mask */
188
         FALSE),                /* pcrel_offset */
189
 
190
  HOWTO (R_68K_TLS_LDM8,                /* type */
191
         0,                      /* rightshift */
192
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
193
         8,                     /* bitsize */
194
         FALSE,                 /* pc_relative */
195
         0,                      /* bitpos */
196
         complain_overflow_signed, /* complain_on_overflow */
197
         bfd_elf_generic_reloc, /* special_function */
198
         "R_68K_TLS_LDM8",      /* name */
199
         FALSE,                 /* partial_inplace */
200
         0,                      /* src_mask */
201
         0x000000ff,            /* dst_mask */
202
         FALSE),                /* pcrel_offset */
203
 
204
  HOWTO (R_68K_TLS_LDO32,       /* type */
205
         0,                      /* rightshift */
206
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
207
         32,                    /* bitsize */
208
         FALSE,                 /* pc_relative */
209
         0,                      /* bitpos */
210
         complain_overflow_bitfield, /* complain_on_overflow */
211
         bfd_elf_generic_reloc, /* special_function */
212
         "R_68K_TLS_LDO32",     /* name */
213
         FALSE,                 /* partial_inplace */
214
         0,                      /* src_mask */
215
         0xffffffff,            /* dst_mask */
216
         FALSE),                /* pcrel_offset */
217
 
218
  HOWTO (R_68K_TLS_LDO16,       /* type */
219
         0,                      /* rightshift */
220
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
221
         16,                    /* bitsize */
222
         FALSE,                 /* pc_relative */
223
         0,                      /* bitpos */
224
         complain_overflow_signed, /* complain_on_overflow */
225
         bfd_elf_generic_reloc, /* special_function */
226
         "R_68K_TLS_LDO16",     /* name */
227
         FALSE,                 /* partial_inplace */
228
         0,                      /* src_mask */
229
         0x0000ffff,            /* dst_mask */
230
         FALSE),                /* pcrel_offset */
231
 
232
  HOWTO (R_68K_TLS_LDO8,                /* type */
233
         0,                      /* rightshift */
234
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
235
         8,                     /* bitsize */
236
         FALSE,                 /* pc_relative */
237
         0,                      /* bitpos */
238
         complain_overflow_signed, /* complain_on_overflow */
239
         bfd_elf_generic_reloc, /* special_function */
240
         "R_68K_TLS_LDO8",      /* name */
241
         FALSE,                 /* partial_inplace */
242
         0,                      /* src_mask */
243
         0x000000ff,            /* dst_mask */
244
         FALSE),                /* pcrel_offset */
245
 
246
  /* TLS initial execution variable reference.  */
247
  HOWTO (R_68K_TLS_IE32,        /* type */
248
         0,                      /* rightshift */
249
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
250
         32,                    /* bitsize */
251
         FALSE,                 /* pc_relative */
252
         0,                      /* bitpos */
253
         complain_overflow_bitfield, /* complain_on_overflow */
254
         bfd_elf_generic_reloc, /* special_function */
255
         "R_68K_TLS_IE32",      /* name */
256
         FALSE,                 /* partial_inplace */
257
         0,                      /* src_mask */
258
         0xffffffff,            /* dst_mask */
259
         FALSE),                /* pcrel_offset */
260
 
261
  HOWTO (R_68K_TLS_IE16,        /* type */
262
         0,                      /* rightshift */
263
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
264
         16,                    /* bitsize */
265
         FALSE,                 /* pc_relative */
266
         0,                      /* bitpos */
267
         complain_overflow_signed, /* complain_on_overflow */
268
         bfd_elf_generic_reloc, /* special_function */
269
         "R_68K_TLS_IE16",      /* name */
270
         FALSE,                 /* partial_inplace */
271
         0,                      /* src_mask */
272
         0x0000ffff,            /* dst_mask */
273
         FALSE),                /* pcrel_offset */
274
 
275
  HOWTO (R_68K_TLS_IE8,         /* type */
276
         0,                      /* rightshift */
277
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
278
         8,                     /* bitsize */
279
         FALSE,                 /* pc_relative */
280
         0,                      /* bitpos */
281
         complain_overflow_signed, /* complain_on_overflow */
282
         bfd_elf_generic_reloc, /* special_function */
283
         "R_68K_TLS_IE8",       /* name */
284
         FALSE,                 /* partial_inplace */
285
         0,                      /* src_mask */
286
         0x000000ff,            /* dst_mask */
287
         FALSE),                /* pcrel_offset */
288
 
289
  /* TLS local execution variable reference.  */
290
  HOWTO (R_68K_TLS_LE32,        /* type */
291
         0,                      /* rightshift */
292
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
293
         32,                    /* bitsize */
294
         FALSE,                 /* pc_relative */
295
         0,                      /* bitpos */
296
         complain_overflow_bitfield, /* complain_on_overflow */
297
         bfd_elf_generic_reloc, /* special_function */
298
         "R_68K_TLS_LE32",      /* name */
299
         FALSE,                 /* partial_inplace */
300
         0,                      /* src_mask */
301
         0xffffffff,            /* dst_mask */
302
         FALSE),                /* pcrel_offset */
303
 
304
  HOWTO (R_68K_TLS_LE16,        /* type */
305
         0,                      /* rightshift */
306
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
307
         16,                    /* bitsize */
308
         FALSE,                 /* pc_relative */
309
         0,                      /* bitpos */
310
         complain_overflow_signed, /* complain_on_overflow */
311
         bfd_elf_generic_reloc, /* special_function */
312
         "R_68K_TLS_LE16",      /* name */
313
         FALSE,                 /* partial_inplace */
314
         0,                      /* src_mask */
315
         0x0000ffff,            /* dst_mask */
316
         FALSE),                /* pcrel_offset */
317
 
318
  HOWTO (R_68K_TLS_LE8,         /* type */
319
         0,                      /* rightshift */
320
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
321
         8,                     /* bitsize */
322
         FALSE,                 /* pc_relative */
323
         0,                      /* bitpos */
324
         complain_overflow_signed, /* complain_on_overflow */
325
         bfd_elf_generic_reloc, /* special_function */
326
         "R_68K_TLS_LE8",       /* name */
327
         FALSE,                 /* partial_inplace */
328
         0,                      /* src_mask */
329
         0x000000ff,            /* dst_mask */
330
         FALSE),                /* pcrel_offset */
331
 
332
  /* TLS GD/LD dynamic relocations.  */
333
  HOWTO (R_68K_TLS_DTPMOD32,    /* type */
334
         0,                      /* rightshift */
335
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
336
         32,                    /* bitsize */
337
         FALSE,                 /* pc_relative */
338
         0,                      /* bitpos */
339
         complain_overflow_dont, /* complain_on_overflow */
340
         bfd_elf_generic_reloc, /* special_function */
341
         "R_68K_TLS_DTPMOD32",  /* name */
342
         FALSE,                 /* partial_inplace */
343
         0,                      /* src_mask */
344
         0xffffffff,            /* dst_mask */
345
         FALSE),                /* pcrel_offset */
346
 
347
  HOWTO (R_68K_TLS_DTPREL32,    /* type */
348
         0,                      /* rightshift */
349
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
350
         32,                    /* bitsize */
351
         FALSE,                 /* pc_relative */
352
         0,                      /* bitpos */
353
         complain_overflow_dont, /* complain_on_overflow */
354
         bfd_elf_generic_reloc, /* special_function */
355
         "R_68K_TLS_DTPREL32",  /* name */
356
         FALSE,                 /* partial_inplace */
357
         0,                      /* src_mask */
358
         0xffffffff,            /* dst_mask */
359
         FALSE),                /* pcrel_offset */
360
 
361
  HOWTO (R_68K_TLS_TPREL32,     /* type */
362
         0,                      /* rightshift */
363
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
364
         32,                    /* bitsize */
365
         FALSE,                 /* pc_relative */
366
         0,                      /* bitpos */
367
         complain_overflow_dont, /* complain_on_overflow */
368
         bfd_elf_generic_reloc, /* special_function */
369
         "R_68K_TLS_TPREL32",   /* name */
370
         FALSE,                 /* partial_inplace */
371
         0,                      /* src_mask */
372
         0xffffffff,            /* dst_mask */
373
         FALSE),                /* pcrel_offset */
374
};
375
 
376
static void
377
rtype_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
378
{
379
  unsigned int indx = ELF32_R_TYPE (dst->r_info);
380
 
381
  if (indx >= (unsigned int) R_68K_max)
382
    {
383
      (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
384
                             abfd, (int) indx);
385
      indx = R_68K_NONE;
386
    }
387
  cache_ptr->howto = &howto_table[indx];
388
}
389
 
390
#define elf_info_to_howto rtype_to_howto
391
 
392
static const struct
393
{
394
  bfd_reloc_code_real_type bfd_val;
395
  int elf_val;
396
}
397
  reloc_map[] =
398
{
399
  { BFD_RELOC_NONE, R_68K_NONE },
400
  { BFD_RELOC_32, R_68K_32 },
401
  { BFD_RELOC_16, R_68K_16 },
402
  { BFD_RELOC_8, R_68K_8 },
403
  { BFD_RELOC_32_PCREL, R_68K_PC32 },
404
  { BFD_RELOC_16_PCREL, R_68K_PC16 },
405
  { BFD_RELOC_8_PCREL, R_68K_PC8 },
406
  { BFD_RELOC_32_GOT_PCREL, R_68K_GOT32 },
407
  { BFD_RELOC_16_GOT_PCREL, R_68K_GOT16 },
408
  { BFD_RELOC_8_GOT_PCREL, R_68K_GOT8 },
409
  { BFD_RELOC_32_GOTOFF, R_68K_GOT32O },
410
  { BFD_RELOC_16_GOTOFF, R_68K_GOT16O },
411
  { BFD_RELOC_8_GOTOFF, R_68K_GOT8O },
412
  { BFD_RELOC_32_PLT_PCREL, R_68K_PLT32 },
413
  { BFD_RELOC_16_PLT_PCREL, R_68K_PLT16 },
414
  { BFD_RELOC_8_PLT_PCREL, R_68K_PLT8 },
415
  { BFD_RELOC_32_PLTOFF, R_68K_PLT32O },
416
  { BFD_RELOC_16_PLTOFF, R_68K_PLT16O },
417
  { BFD_RELOC_8_PLTOFF, R_68K_PLT8O },
418
  { BFD_RELOC_NONE, R_68K_COPY },
419
  { BFD_RELOC_68K_GLOB_DAT, R_68K_GLOB_DAT },
420
  { BFD_RELOC_68K_JMP_SLOT, R_68K_JMP_SLOT },
421
  { BFD_RELOC_68K_RELATIVE, R_68K_RELATIVE },
422
  { BFD_RELOC_CTOR, R_68K_32 },
423
  { BFD_RELOC_VTABLE_INHERIT, R_68K_GNU_VTINHERIT },
424
  { BFD_RELOC_VTABLE_ENTRY, R_68K_GNU_VTENTRY },
425
  { BFD_RELOC_68K_TLS_GD32, R_68K_TLS_GD32 },
426
  { BFD_RELOC_68K_TLS_GD16, R_68K_TLS_GD16 },
427
  { BFD_RELOC_68K_TLS_GD8, R_68K_TLS_GD8 },
428
  { BFD_RELOC_68K_TLS_LDM32, R_68K_TLS_LDM32 },
429
  { BFD_RELOC_68K_TLS_LDM16, R_68K_TLS_LDM16 },
430
  { BFD_RELOC_68K_TLS_LDM8, R_68K_TLS_LDM8 },
431
  { BFD_RELOC_68K_TLS_LDO32, R_68K_TLS_LDO32 },
432
  { BFD_RELOC_68K_TLS_LDO16, R_68K_TLS_LDO16 },
433
  { BFD_RELOC_68K_TLS_LDO8, R_68K_TLS_LDO8 },
434
  { BFD_RELOC_68K_TLS_IE32, R_68K_TLS_IE32 },
435
  { BFD_RELOC_68K_TLS_IE16, R_68K_TLS_IE16 },
436
  { BFD_RELOC_68K_TLS_IE8, R_68K_TLS_IE8 },
437
  { BFD_RELOC_68K_TLS_LE32, R_68K_TLS_LE32 },
438
  { BFD_RELOC_68K_TLS_LE16, R_68K_TLS_LE16 },
439
  { BFD_RELOC_68K_TLS_LE8, R_68K_TLS_LE8 },
440
};
441
 
442
static reloc_howto_type *
443
reloc_type_lookup (abfd, code)
444
     bfd *abfd ATTRIBUTE_UNUSED;
445
     bfd_reloc_code_real_type code;
446
{
447
  unsigned int i;
448
  for (i = 0; i < sizeof (reloc_map) / sizeof (reloc_map[0]); i++)
449
    {
450
      if (reloc_map[i].bfd_val == code)
451
        return &howto_table[reloc_map[i].elf_val];
452
    }
453
  return 0;
454
}
455
 
456
static reloc_howto_type *
457
reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
458
{
459
  unsigned int i;
460
 
461
  for (i = 0; i < sizeof (howto_table) / sizeof (howto_table[0]); i++)
462
    if (howto_table[i].name != NULL
463
        && strcasecmp (howto_table[i].name, r_name) == 0)
464
      return &howto_table[i];
465
 
466
  return NULL;
467
}
468
 
469
#define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup
470
#define bfd_elf32_bfd_reloc_name_lookup reloc_name_lookup
471
#define ELF_ARCH bfd_arch_m68k
472
 
473
/* Functions for the m68k ELF linker.  */
474
 
475
/* The name of the dynamic interpreter.  This is put in the .interp
476
   section.  */
477
 
478
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
479
 
480
/* Describes one of the various PLT styles.  */
481
 
482
struct elf_m68k_plt_info
483
{
484
  /* The size of each PLT entry.  */
485
  bfd_vma size;
486
 
487
  /* The template for the first PLT entry.  */
488
  const bfd_byte *plt0_entry;
489
 
490
  /* Offsets of fields in PLT0_ENTRY that require R_68K_PC32 relocations.
491
     The comments by each member indicate the value that the relocation
492
     is against.  */
493
  struct {
494
    unsigned int got4; /* .got + 4 */
495
    unsigned int got8; /* .got + 8 */
496
  } plt0_relocs;
497
 
498
  /* The template for a symbol's PLT entry.  */
499
  const bfd_byte *symbol_entry;
500
 
501
  /* Offsets of fields in SYMBOL_ENTRY that require R_68K_PC32 relocations.
502
     The comments by each member indicate the value that the relocation
503
     is against.  */
504
  struct {
505
    unsigned int got; /* the symbol's .got.plt entry */
506
    unsigned int plt; /* .plt */
507
  } symbol_relocs;
508
 
509
  /* The offset of the resolver stub from the start of SYMBOL_ENTRY.
510
     The stub starts with "move.l #relocoffset,%d0".  */
511
  bfd_vma symbol_resolve_entry;
512
};
513
 
514
/* The size in bytes of an entry in the procedure linkage table.  */
515
 
516
#define PLT_ENTRY_SIZE 20
517
 
518
/* The first entry in a procedure linkage table looks like this.  See
519
   the SVR4 ABI m68k supplement to see how this works.  */
520
 
521
static const bfd_byte elf_m68k_plt0_entry[PLT_ENTRY_SIZE] =
522
{
523
  0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
524
  0, 0, 0, 2,                /* + (.got + 4) - . */
525
  0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,addr]) */
526
  0, 0, 0, 2,                /* + (.got + 8) - . */
527
  0, 0, 0, 0                  /* pad out to 20 bytes.  */
528
};
529
 
530
/* Subsequent entries in a procedure linkage table look like this.  */
531
 
532
static const bfd_byte elf_m68k_plt_entry[PLT_ENTRY_SIZE] =
533
{
534
  0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,symbol@GOTPC]) */
535
  0, 0, 0, 2,                /* + (.got.plt entry) - . */
536
  0x2f, 0x3c,             /* move.l #offset,-(%sp) */
537
  0, 0, 0, 0,                 /* + reloc index */
538
  0x60, 0xff,             /* bra.l .plt */
539
  0, 0, 0, 0                  /* + .plt - . */
540
};
541
 
542
static const struct elf_m68k_plt_info elf_m68k_plt_info = {
543
  PLT_ENTRY_SIZE,
544
  elf_m68k_plt0_entry, { 4, 12 },
545
  elf_m68k_plt_entry, { 4, 16 }, 8
546
};
547
 
548
#define ISAB_PLT_ENTRY_SIZE 24
549
 
550
static const bfd_byte elf_isab_plt0_entry[ISAB_PLT_ENTRY_SIZE] =
551
{
552
  0x20, 0x3c,             /* move.l #offset,%d0 */
553
  0, 0, 0, 0,             /* + (.got + 4) - . */
554
  0x2f, 0x3b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),-(%sp) */
555
  0x20, 0x3c,             /* move.l #offset,%d0 */
556
  0, 0, 0, 0,             /* + (.got + 8) - . */
557
  0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
558
  0x4e, 0xd0,             /* jmp (%a0) */
559
  0x4e, 0x71              /* nop */
560
};
561
 
562
/* Subsequent entries in a procedure linkage table look like this.  */
563
 
564
static const bfd_byte elf_isab_plt_entry[ISAB_PLT_ENTRY_SIZE] =
565
{
566
  0x20, 0x3c,             /* move.l #offset,%d0 */
567
  0, 0, 0, 0,             /* + (.got.plt entry) - . */
568
  0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
569
  0x4e, 0xd0,             /* jmp (%a0) */
570
  0x2f, 0x3c,             /* move.l #offset,-(%sp) */
571
  0, 0, 0, 0,             /* + reloc index */
572
  0x60, 0xff,             /* bra.l .plt */
573
  0, 0, 0, 0              /* + .plt - . */
574
};
575
 
576
static const struct elf_m68k_plt_info elf_isab_plt_info = {
577
  ISAB_PLT_ENTRY_SIZE,
578
  elf_isab_plt0_entry, { 2, 12 },
579
  elf_isab_plt_entry, { 2, 20 }, 12
580
};
581
 
582
#define ISAC_PLT_ENTRY_SIZE 24
583
 
584
static const bfd_byte elf_isac_plt0_entry[ISAC_PLT_ENTRY_SIZE] =
585
{
586
  0x20, 0x3c,             /* move.l #offset,%d0 */
587
  0, 0, 0, 0,                 /* replaced with .got + 4 - . */
588
  0x2e, 0xbb, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),(%sp) */
589
  0x20, 0x3c,             /* move.l #offset,%d0 */
590
  0, 0, 0, 0,                 /* replaced with .got + 8 - . */
591
  0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
592
  0x4e, 0xd0,             /* jmp (%a0) */
593
  0x4e, 0x71              /* nop */
594
};
595
 
596
/* Subsequent entries in a procedure linkage table look like this.  */
597
 
598
static const bfd_byte elf_isac_plt_entry[ISAC_PLT_ENTRY_SIZE] =
599
{
600
  0x20, 0x3c,             /* move.l #offset,%d0 */
601
  0, 0, 0, 0,                 /* replaced with (.got entry) - . */
602
  0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
603
  0x4e, 0xd0,             /* jmp (%a0) */
604
  0x2f, 0x3c,             /* move.l #offset,-(%sp) */
605
  0, 0, 0, 0,                 /* replaced with offset into relocation table */
606
  0x61, 0xff,             /* bsr.l .plt */
607
  0, 0, 0, 0                  /* replaced with .plt - . */
608
};
609
 
610
static const struct elf_m68k_plt_info elf_isac_plt_info = {
611
  ISAC_PLT_ENTRY_SIZE,
612
  elf_isac_plt0_entry, { 2, 12},
613
  elf_isac_plt_entry, { 2, 20 }, 12
614
};
615
 
616
#define CPU32_PLT_ENTRY_SIZE 24
617
/* Procedure linkage table entries for the cpu32 */
618
static const bfd_byte elf_cpu32_plt0_entry[CPU32_PLT_ENTRY_SIZE] =
619
{
620
  0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
621
  0, 0, 0, 2,             /* + (.got + 4) - . */
622
  0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
623
  0, 0, 0, 2,             /* + (.got + 8) - . */
624
  0x4e, 0xd1,             /* jmp %a1@ */
625
  0, 0, 0, 0,             /* pad out to 24 bytes.  */
626
  0, 0
627
};
628
 
629
static const bfd_byte elf_cpu32_plt_entry[CPU32_PLT_ENTRY_SIZE] =
630
{
631
  0x22, 0x7b, 0x01, 0x70,  /* moveal %pc@(0xc), %a1 */
632
  0, 0, 0, 2,              /* + (.got.plt entry) - . */
633
  0x4e, 0xd1,              /* jmp %a1@ */
634
  0x2f, 0x3c,              /* move.l #offset,-(%sp) */
635
  0, 0, 0, 0,              /* + reloc index */
636
  0x60, 0xff,              /* bra.l .plt */
637
  0, 0, 0, 0,              /* + .plt - . */
638
  0, 0
639
};
640
 
641
static const struct elf_m68k_plt_info elf_cpu32_plt_info = {
642
  CPU32_PLT_ENTRY_SIZE,
643
  elf_cpu32_plt0_entry, { 4, 12 },
644
  elf_cpu32_plt_entry, { 4, 18 }, 10
645
};
646
 
647
/* The m68k linker needs to keep track of the number of relocs that it
648
   decides to copy in check_relocs for each symbol.  This is so that it
649
   can discard PC relative relocs if it doesn't need them when linking
650
   with -Bsymbolic.  We store the information in a field extending the
651
   regular ELF linker hash table.  */
652
 
653
/* This structure keeps track of the number of PC relative relocs we have
654
   copied for a given symbol.  */
655
 
656
struct elf_m68k_pcrel_relocs_copied
657
{
658
  /* Next section.  */
659
  struct elf_m68k_pcrel_relocs_copied *next;
660
  /* A section in dynobj.  */
661
  asection *section;
662
  /* Number of relocs copied in this section.  */
663
  bfd_size_type count;
664
};
665
 
666
/* Forward declaration.  */
667
struct elf_m68k_got_entry;
668
 
669
/* m68k ELF linker hash entry.  */
670
 
671
struct elf_m68k_link_hash_entry
672
{
673
  struct elf_link_hash_entry root;
674
 
675
  /* Number of PC relative relocs copied for this symbol.  */
676
  struct elf_m68k_pcrel_relocs_copied *pcrel_relocs_copied;
677
 
678
  /* Key to got_entries.  */
679
  unsigned long got_entry_key;
680
 
681
  /* List of GOT entries for this symbol.  This list is build during
682
     offset finalization and is used within elf_m68k_finish_dynamic_symbol
683
     to traverse all GOT entries for a particular symbol.
684
 
685
     ??? We could've used root.got.glist field instead, but having
686
     a separate field is cleaner.  */
687
  struct elf_m68k_got_entry *glist;
688
};
689
 
690
#define elf_m68k_hash_entry(ent) ((struct elf_m68k_link_hash_entry *) (ent))
691
 
692
/* Key part of GOT entry in hashtable.  */
693
struct elf_m68k_got_entry_key
694
{
695
  /* BFD in which this symbol was defined.  NULL for global symbols.  */
696
  const bfd *bfd;
697
 
698
  /* Symbol index.  Either local symbol index or h->got_entry_key.  */
699
  unsigned long symndx;
700
 
701
  /* Type is one of R_68K_GOT{8, 16, 32}O, R_68K_TLS_GD{8, 16, 32},
702
     R_68K_TLS_LDM{8, 16, 32} or R_68K_TLS_IE{8, 16, 32}.
703
 
704
     From perspective of hashtable key, only elf_m68k_got_reloc_type (type)
705
     matters.  That is, we distinguish between, say, R_68K_GOT16O
706
     and R_68K_GOT32O when allocating offsets, but they are considered to be
707
     the same when searching got->entries.  */
708
  enum elf_m68k_reloc_type type;
709
};
710
 
711
/* Size of the GOT offset suitable for relocation.  */
712
enum elf_m68k_got_offset_size { R_8, R_16, R_32, R_LAST };
713
 
714
/* Entry of the GOT.  */
715
struct elf_m68k_got_entry
716
{
717
  /* GOT entries are put into a got->entries hashtable.  This is the key.  */
718
  struct elf_m68k_got_entry_key key_;
719
 
720
  /* GOT entry data.  We need s1 before offset finalization and s2 after.  */
721
  union
722
  {
723
    struct
724
    {
725
      /* Number of times this entry is referenced.  It is used to
726
         filter out unnecessary GOT slots in elf_m68k_gc_sweep_hook.  */
727
      bfd_vma refcount;
728
    } s1;
729
 
730
    struct
731
    {
732
      /* Offset from the start of .got section.  To calculate offset relative
733
         to GOT pointer one should substract got->offset from this value.  */
734
      bfd_vma offset;
735
 
736
      /* Pointer to the next GOT entry for this global symbol.
737
         Symbols have at most one entry in one GOT, but might
738
         have entries in more than one GOT.
739
         Root of this list is h->glist.
740
         NULL for local symbols.  */
741
      struct elf_m68k_got_entry *next;
742
    } s2;
743
  } u;
744
};
745
 
746
/* Return representative type for relocation R_TYPE.
747
   This is used to avoid enumerating many relocations in comparisons,
748
   switches etc.  */
749
 
750
static enum elf_m68k_reloc_type
751
elf_m68k_reloc_got_type (enum elf_m68k_reloc_type r_type)
752
{
753
  switch (r_type)
754
    {
755
      /* In most cases R_68K_GOTx relocations require the very same
756
         handling as R_68K_GOT32O relocation.  In cases when we need
757
         to distinguish between the two, we use explicitly compare against
758
         r_type.  */
759
    case R_68K_GOT32:
760
    case R_68K_GOT16:
761
    case R_68K_GOT8:
762
    case R_68K_GOT32O:
763
    case R_68K_GOT16O:
764
    case R_68K_GOT8O:
765
      return R_68K_GOT32O;
766
 
767
    case R_68K_TLS_GD32:
768
    case R_68K_TLS_GD16:
769
    case R_68K_TLS_GD8:
770
      return R_68K_TLS_GD32;
771
 
772
    case R_68K_TLS_LDM32:
773
    case R_68K_TLS_LDM16:
774
    case R_68K_TLS_LDM8:
775
      return R_68K_TLS_LDM32;
776
 
777
    case R_68K_TLS_IE32:
778
    case R_68K_TLS_IE16:
779
    case R_68K_TLS_IE8:
780
      return R_68K_TLS_IE32;
781
 
782
    default:
783
      BFD_ASSERT (FALSE);
784
      return 0;
785
    }
786
}
787
 
788
/* Return size of the GOT entry offset for relocation R_TYPE.  */
789
 
790
static enum elf_m68k_got_offset_size
791
elf_m68k_reloc_got_offset_size (enum elf_m68k_reloc_type r_type)
792
{
793
  switch (r_type)
794
    {
795
    case R_68K_GOT32: case R_68K_GOT16: case R_68K_GOT8:
796
    case R_68K_GOT32O: case R_68K_TLS_GD32: case R_68K_TLS_LDM32:
797
    case R_68K_TLS_IE32:
798
      return R_32;
799
 
800
    case R_68K_GOT16O: case R_68K_TLS_GD16: case R_68K_TLS_LDM16:
801
    case R_68K_TLS_IE16:
802
      return R_16;
803
 
804
    case R_68K_GOT8O: case R_68K_TLS_GD8: case R_68K_TLS_LDM8:
805
    case R_68K_TLS_IE8:
806
      return R_8;
807
 
808
    default:
809
      BFD_ASSERT (FALSE);
810
      return 0;
811
    }
812
}
813
 
814
/* Return number of GOT entries we need to allocate in GOT for
815
   relocation R_TYPE.  */
816
 
817
static bfd_vma
818
elf_m68k_reloc_got_n_slots (enum elf_m68k_reloc_type r_type)
819
{
820
  switch (elf_m68k_reloc_got_type (r_type))
821
    {
822
    case R_68K_GOT32O:
823
    case R_68K_TLS_IE32:
824
      return 1;
825
 
826
    case R_68K_TLS_GD32:
827
    case R_68K_TLS_LDM32:
828
      return 2;
829
 
830
    default:
831
      BFD_ASSERT (FALSE);
832
      return 0;
833
    }
834
}
835
 
836
/* Return TRUE if relocation R_TYPE is a TLS one.  */
837
 
838
static bfd_boolean
839
elf_m68k_reloc_tls_p (enum elf_m68k_reloc_type r_type)
840
{
841
  switch (r_type)
842
    {
843
    case R_68K_TLS_GD32: case R_68K_TLS_GD16: case R_68K_TLS_GD8:
844
    case R_68K_TLS_LDM32: case R_68K_TLS_LDM16: case R_68K_TLS_LDM8:
845
    case R_68K_TLS_LDO32: case R_68K_TLS_LDO16: case R_68K_TLS_LDO8:
846
    case R_68K_TLS_IE32: case R_68K_TLS_IE16: case R_68K_TLS_IE8:
847
    case R_68K_TLS_LE32: case R_68K_TLS_LE16: case R_68K_TLS_LE8:
848
    case R_68K_TLS_DTPMOD32: case R_68K_TLS_DTPREL32: case R_68K_TLS_TPREL32:
849
      return TRUE;
850
 
851
    default:
852
      return FALSE;
853
    }
854
}
855
 
856
/* Data structure representing a single GOT.  */
857
struct elf_m68k_got
858
{
859
  /* Hashtable of 'struct elf_m68k_got_entry's.
860
     Starting size of this table is the maximum number of
861
     R_68K_GOT8O entries.  */
862
  htab_t entries;
863
 
864
  /* Number of R_x slots in this GOT.  Some (e.g., TLS) entries require
865
     several GOT slots.
866
 
867
     n_slots[R_8] is the count of R_8 slots in this GOT.
868
     n_slots[R_16] is the cumulative count of R_8 and R_16 slots
869
     in this GOT.
870
     n_slots[R_32] is the cumulative count of R_8, R_16 and R_32 slots
871
     in this GOT.  This is the total number of slots.  */
872
  bfd_vma n_slots[R_LAST];
873
 
874
  /* Number of local (entry->key_.h == NULL) slots in this GOT.
875
     This is only used to properly calculate size of .rela.got section;
876
     see elf_m68k_partition_multi_got.  */
877
  bfd_vma local_n_slots;
878
 
879
  /* Offset of this GOT relative to beginning of .got section.  */
880
  bfd_vma offset;
881
};
882
 
883
/* BFD and its GOT.  This is an entry in multi_got->bfd2got hashtable.  */
884
struct elf_m68k_bfd2got_entry
885
{
886
  /* BFD.  */
887
  const bfd *bfd;
888
 
889
  /* Assigned GOT.  Before partitioning multi-GOT each BFD has its own
890
     GOT structure.  After partitioning several BFD's might [and often do]
891
     share a single GOT.  */
892
  struct elf_m68k_got *got;
893
};
894
 
895
/* The main data structure holding all the pieces.  */
896
struct elf_m68k_multi_got
897
{
898
  /* Hashtable mapping each BFD to its GOT.  If a BFD doesn't have an entry
899
     here, then it doesn't need a GOT (this includes the case of a BFD
900
     having an empty GOT).
901
 
902
     ??? This hashtable can be replaced by an array indexed by bfd->id.  */
903
  htab_t bfd2got;
904
 
905
  /* Next symndx to assign a global symbol.
906
     h->got_entry_key is initialized from this counter.  */
907
  unsigned long global_symndx;
908
};
909
 
910
/* m68k ELF linker hash table.  */
911
 
912
struct elf_m68k_link_hash_table
913
{
914
  struct elf_link_hash_table root;
915
 
916
  /* Small local sym cache.  */
917
  struct sym_cache sym_cache;
918
 
919
  /* The PLT format used by this link, or NULL if the format has not
920
     yet been chosen.  */
921
  const struct elf_m68k_plt_info *plt_info;
922
 
923
  /* True, if GP is loaded within each function which uses it.
924
     Set to TRUE when GOT negative offsets or multi-GOT is enabled.  */
925
  bfd_boolean local_gp_p;
926
 
927
  /* Switch controlling use of negative offsets to double the size of GOTs.  */
928
  bfd_boolean use_neg_got_offsets_p;
929
 
930
  /* Switch controlling generation of multiple GOTs.  */
931
  bfd_boolean allow_multigot_p;
932
 
933
  /* Multi-GOT data structure.  */
934
  struct elf_m68k_multi_got multi_got_;
935
};
936
 
937
/* Get the m68k ELF linker hash table from a link_info structure.  */
938
 
939
#define elf_m68k_hash_table(p) \
940
  (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
941
  == M68K_ELF_DATA ? ((struct elf_m68k_link_hash_table *) ((p)->hash)) : NULL)
942
 
943
/* Shortcut to multi-GOT data.  */
944
#define elf_m68k_multi_got(INFO) (&elf_m68k_hash_table (INFO)->multi_got_)
945
 
946
/* Create an entry in an m68k ELF linker hash table.  */
947
 
948
static struct bfd_hash_entry *
949
elf_m68k_link_hash_newfunc (struct bfd_hash_entry *entry,
950
                            struct bfd_hash_table *table,
951
                            const char *string)
952
{
953
  struct bfd_hash_entry *ret = entry;
954
 
955
  /* Allocate the structure if it has not already been allocated by a
956
     subclass.  */
957
  if (ret == NULL)
958
    ret = bfd_hash_allocate (table,
959
                             sizeof (struct elf_m68k_link_hash_entry));
960
  if (ret == NULL)
961
    return ret;
962
 
963
  /* Call the allocation method of the superclass.  */
964
  ret = _bfd_elf_link_hash_newfunc (ret, table, string);
965
  if (ret != NULL)
966
    {
967
      elf_m68k_hash_entry (ret)->pcrel_relocs_copied = NULL;
968
      elf_m68k_hash_entry (ret)->got_entry_key = 0;
969
      elf_m68k_hash_entry (ret)->glist = NULL;
970
    }
971
 
972
  return ret;
973
}
974
 
975
/* Create an m68k ELF linker hash table.  */
976
 
977
static struct bfd_link_hash_table *
978
elf_m68k_link_hash_table_create (bfd *abfd)
979
{
980
  struct elf_m68k_link_hash_table *ret;
981
  bfd_size_type amt = sizeof (struct elf_m68k_link_hash_table);
982
 
983
  ret = (struct elf_m68k_link_hash_table *) bfd_malloc (amt);
984
  if (ret == (struct elf_m68k_link_hash_table *) NULL)
985
    return NULL;
986
 
987
  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
988
                                      elf_m68k_link_hash_newfunc,
989
                                      sizeof (struct elf_m68k_link_hash_entry),
990
                                      M68K_ELF_DATA))
991
    {
992
      free (ret);
993
      return NULL;
994
    }
995
 
996
  ret->sym_cache.abfd = NULL;
997
  ret->plt_info = NULL;
998
  ret->local_gp_p = FALSE;
999
  ret->use_neg_got_offsets_p = FALSE;
1000
  ret->allow_multigot_p = FALSE;
1001
  ret->multi_got_.bfd2got = NULL;
1002
  ret->multi_got_.global_symndx = 1;
1003
 
1004
  return &ret->root.root;
1005
}
1006
 
1007
/* Destruct local data.  */
1008
 
1009
static void
1010
elf_m68k_link_hash_table_free (struct bfd_link_hash_table *_htab)
1011
{
1012
  struct elf_m68k_link_hash_table *htab;
1013
 
1014
  htab = (struct elf_m68k_link_hash_table *) _htab;
1015
 
1016
  if (htab->multi_got_.bfd2got != NULL)
1017
    {
1018
      htab_delete (htab->multi_got_.bfd2got);
1019
      htab->multi_got_.bfd2got = NULL;
1020
    }
1021
}
1022
 
1023
/* Set the right machine number.  */
1024
 
1025
static bfd_boolean
1026
elf32_m68k_object_p (bfd *abfd)
1027
{
1028
  unsigned int mach = 0;
1029
  unsigned features = 0;
1030
  flagword eflags = elf_elfheader (abfd)->e_flags;
1031
 
1032
  if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
1033
    features |= m68000;
1034
  else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1035
    features |= cpu32;
1036
  else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1037
    features |= fido_a;
1038
  else
1039
    {
1040
      switch (eflags & EF_M68K_CF_ISA_MASK)
1041
        {
1042
        case EF_M68K_CF_ISA_A_NODIV:
1043
          features |= mcfisa_a;
1044
          break;
1045
        case EF_M68K_CF_ISA_A:
1046
          features |= mcfisa_a|mcfhwdiv;
1047
          break;
1048
        case EF_M68K_CF_ISA_A_PLUS:
1049
          features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp;
1050
          break;
1051
        case EF_M68K_CF_ISA_B_NOUSP:
1052
          features |= mcfisa_a|mcfisa_b|mcfhwdiv;
1053
          break;
1054
        case EF_M68K_CF_ISA_B:
1055
          features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp;
1056
          break;
1057
        case EF_M68K_CF_ISA_C:
1058
          features |= mcfisa_a|mcfisa_c|mcfhwdiv|mcfusp;
1059
          break;
1060
        case EF_M68K_CF_ISA_C_NODIV:
1061
          features |= mcfisa_a|mcfisa_c|mcfusp;
1062
          break;
1063
        }
1064
      switch (eflags & EF_M68K_CF_MAC_MASK)
1065
        {
1066
        case EF_M68K_CF_MAC:
1067
          features |= mcfmac;
1068
          break;
1069
        case EF_M68K_CF_EMAC:
1070
          features |= mcfemac;
1071
          break;
1072
        }
1073
      if (eflags & EF_M68K_CF_FLOAT)
1074
        features |= cfloat;
1075
    }
1076
 
1077
  mach = bfd_m68k_features_to_mach (features);
1078
  bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach);
1079
 
1080
  return TRUE;
1081
}
1082
 
1083
/* Somewhat reverse of elf32_m68k_object_p, this sets the e_flag
1084
   field based on the machine number.  */
1085
 
1086
static void
1087
elf_m68k_final_write_processing (bfd *abfd,
1088
                                 bfd_boolean linker ATTRIBUTE_UNUSED)
1089
{
1090
  int mach = bfd_get_mach (abfd);
1091
  unsigned long e_flags = elf_elfheader (abfd)->e_flags;
1092
 
1093
  if (!e_flags)
1094
    {
1095
      unsigned int arch_mask;
1096
 
1097
      arch_mask = bfd_m68k_mach_to_features (mach);
1098
 
1099
      if (arch_mask & m68000)
1100
        e_flags = EF_M68K_M68000;
1101
      else if (arch_mask & cpu32)
1102
        e_flags = EF_M68K_CPU32;
1103
      else if (arch_mask & fido_a)
1104
        e_flags = EF_M68K_FIDO;
1105
      else
1106
        {
1107
          switch (arch_mask
1108
                  & (mcfisa_a | mcfisa_aa | mcfisa_b | mcfisa_c | mcfhwdiv | mcfusp))
1109
            {
1110
            case mcfisa_a:
1111
              e_flags |= EF_M68K_CF_ISA_A_NODIV;
1112
              break;
1113
            case mcfisa_a | mcfhwdiv:
1114
              e_flags |= EF_M68K_CF_ISA_A;
1115
              break;
1116
            case mcfisa_a | mcfisa_aa | mcfhwdiv | mcfusp:
1117
              e_flags |= EF_M68K_CF_ISA_A_PLUS;
1118
              break;
1119
            case mcfisa_a | mcfisa_b | mcfhwdiv:
1120
              e_flags |= EF_M68K_CF_ISA_B_NOUSP;
1121
              break;
1122
            case mcfisa_a | mcfisa_b | mcfhwdiv | mcfusp:
1123
              e_flags |= EF_M68K_CF_ISA_B;
1124
              break;
1125
            case mcfisa_a | mcfisa_c | mcfhwdiv | mcfusp:
1126
              e_flags |= EF_M68K_CF_ISA_C;
1127
              break;
1128
            case mcfisa_a | mcfisa_c | mcfusp:
1129
              e_flags |= EF_M68K_CF_ISA_C_NODIV;
1130
              break;
1131
            }
1132
          if (arch_mask & mcfmac)
1133
            e_flags |= EF_M68K_CF_MAC;
1134
          else if (arch_mask & mcfemac)
1135
            e_flags |= EF_M68K_CF_EMAC;
1136
          if (arch_mask & cfloat)
1137
            e_flags |= EF_M68K_CF_FLOAT | EF_M68K_CFV4E;
1138
        }
1139
      elf_elfheader (abfd)->e_flags = e_flags;
1140
    }
1141
}
1142
 
1143
/* Keep m68k-specific flags in the ELF header.  */
1144
 
1145
static bfd_boolean
1146
elf32_m68k_set_private_flags (abfd, flags)
1147
     bfd *abfd;
1148
     flagword flags;
1149
{
1150
  elf_elfheader (abfd)->e_flags = flags;
1151
  elf_flags_init (abfd) = TRUE;
1152
  return TRUE;
1153
}
1154
 
1155
/* Merge backend specific data from an object file to the output
1156
   object file when linking.  */
1157
static bfd_boolean
1158
elf32_m68k_merge_private_bfd_data (ibfd, obfd)
1159
     bfd *ibfd;
1160
     bfd *obfd;
1161
{
1162
  flagword out_flags;
1163
  flagword in_flags;
1164
  flagword out_isa;
1165
  flagword in_isa;
1166
  const bfd_arch_info_type *arch_info;
1167
 
1168
  if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1169
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1170
    return FALSE;
1171
 
1172
  /* Get the merged machine.  This checks for incompatibility between
1173
     Coldfire & non-Coldfire flags, incompability between different
1174
     Coldfire ISAs, and incompability between different MAC types.  */
1175
  arch_info = bfd_arch_get_compatible (ibfd, obfd, FALSE);
1176
  if (!arch_info)
1177
    return FALSE;
1178
 
1179
  bfd_set_arch_mach (obfd, bfd_arch_m68k, arch_info->mach);
1180
 
1181
  in_flags = elf_elfheader (ibfd)->e_flags;
1182
  if (!elf_flags_init (obfd))
1183
    {
1184
      elf_flags_init (obfd) = TRUE;
1185
      out_flags = in_flags;
1186
    }
1187
  else
1188
    {
1189
      out_flags = elf_elfheader (obfd)->e_flags;
1190
      unsigned int variant_mask;
1191
 
1192
      if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
1193
        variant_mask = 0;
1194
      else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1195
        variant_mask = 0;
1196
      else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1197
        variant_mask = 0;
1198
      else
1199
        variant_mask = EF_M68K_CF_ISA_MASK;
1200
 
1201
      in_isa = (in_flags & variant_mask);
1202
      out_isa = (out_flags & variant_mask);
1203
      if (in_isa > out_isa)
1204
        out_flags ^= in_isa ^ out_isa;
1205
      if (((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32
1206
           && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1207
          || ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO
1208
              && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32))
1209
        out_flags = EF_M68K_FIDO;
1210
      else
1211
      out_flags |= in_flags ^ in_isa;
1212
    }
1213
  elf_elfheader (obfd)->e_flags = out_flags;
1214
 
1215
  return TRUE;
1216
}
1217
 
1218
/* Display the flags field.  */
1219
 
1220
static bfd_boolean
1221
elf32_m68k_print_private_bfd_data (bfd *abfd, void * ptr)
1222
{
1223
  FILE *file = (FILE *) ptr;
1224
  flagword eflags = elf_elfheader (abfd)->e_flags;
1225
 
1226
  BFD_ASSERT (abfd != NULL && ptr != NULL);
1227
 
1228
  /* Print normal ELF private data.  */
1229
  _bfd_elf_print_private_bfd_data (abfd, ptr);
1230
 
1231
  /* Ignore init flag - it may not be set, despite the flags field containing valid data.  */
1232
 
1233
  /* xgettext:c-format */
1234
  fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1235
 
1236
  if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
1237
    fprintf (file, " [m68000]");
1238
  else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1239
    fprintf (file, " [cpu32]");
1240
  else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1241
    fprintf (file, " [fido]");
1242
  else
1243
    {
1244
      if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CFV4E)
1245
        fprintf (file, " [cfv4e]");
1246
 
1247
      if (eflags & EF_M68K_CF_ISA_MASK)
1248
        {
1249
          char const *isa = _("unknown");
1250
          char const *mac = _("unknown");
1251
          char const *additional = "";
1252
 
1253
          switch (eflags & EF_M68K_CF_ISA_MASK)
1254
            {
1255
            case EF_M68K_CF_ISA_A_NODIV:
1256
              isa = "A";
1257
              additional = " [nodiv]";
1258
              break;
1259
            case EF_M68K_CF_ISA_A:
1260
              isa = "A";
1261
              break;
1262
            case EF_M68K_CF_ISA_A_PLUS:
1263
              isa = "A+";
1264
              break;
1265
            case EF_M68K_CF_ISA_B_NOUSP:
1266
              isa = "B";
1267
              additional = " [nousp]";
1268
              break;
1269
            case EF_M68K_CF_ISA_B:
1270
              isa = "B";
1271
              break;
1272
            case EF_M68K_CF_ISA_C:
1273
              isa = "C";
1274
              break;
1275
            case EF_M68K_CF_ISA_C_NODIV:
1276
              isa = "C";
1277
              additional = " [nodiv]";
1278
              break;
1279
            }
1280
          fprintf (file, " [isa %s]%s", isa, additional);
1281
 
1282
          if (eflags & EF_M68K_CF_FLOAT)
1283
            fprintf (file, " [float]");
1284
 
1285
          switch (eflags & EF_M68K_CF_MAC_MASK)
1286
            {
1287
            case 0:
1288
              mac = NULL;
1289
              break;
1290
            case EF_M68K_CF_MAC:
1291
              mac = "mac";
1292
              break;
1293
            case EF_M68K_CF_EMAC:
1294
              mac = "emac";
1295
              break;
1296
            }
1297
          if (mac)
1298
            fprintf (file, " [%s]", mac);
1299
        }
1300
    }
1301
 
1302
  fputc ('\n', file);
1303
 
1304
  return TRUE;
1305
}
1306
 
1307
/* Multi-GOT support implementation design:
1308
 
1309
   Multi-GOT starts in check_relocs hook.  There we scan all
1310
   relocations of a BFD and build a local GOT (struct elf_m68k_got)
1311
   for it.  If a single BFD appears to require too many GOT slots with
1312
   R_68K_GOT8O or R_68K_GOT16O relocations, we fail with notification
1313
   to user.
1314
   After check_relocs has been invoked for each input BFD, we have
1315
   constructed a GOT for each input BFD.
1316
 
1317
   To minimize total number of GOTs required for a particular output BFD
1318
   (as some environments support only 1 GOT per output object) we try
1319
   to merge some of the GOTs to share an offset space.  Ideally [and in most
1320
   cases] we end up with a single GOT.  In cases when there are too many
1321
   restricted relocations (e.g., R_68K_GOT16O relocations) we end up with
1322
   several GOTs, assuming the environment can handle them.
1323
 
1324
   Partitioning is done in elf_m68k_partition_multi_got.  We start with
1325
   an empty GOT and traverse bfd2got hashtable putting got_entries from
1326
   local GOTs to the new 'big' one.  We do that by constructing an
1327
   intermediate GOT holding all the entries the local GOT has and the big
1328
   GOT lacks.  Then we check if there is room in the big GOT to accomodate
1329
   all the entries from diff.  On success we add those entries to the big
1330
   GOT; on failure we start the new 'big' GOT and retry the adding of
1331
   entries from the local GOT.  Note that this retry will always succeed as
1332
   each local GOT doesn't overflow the limits.  After partitioning we
1333
   end up with each bfd assigned one of the big GOTs.  GOT entries in the
1334
   big GOTs are initialized with GOT offsets.  Note that big GOTs are
1335
   positioned consequently in program space and represent a single huge GOT
1336
   to the outside world.
1337
 
1338
   After that we get to elf_m68k_relocate_section.  There we
1339
   adjust relocations of GOT pointer (_GLOBAL_OFFSET_TABLE_) and symbol
1340
   relocations to refer to appropriate [assigned to current input_bfd]
1341
   big GOT.
1342
 
1343
   Notes:
1344
 
1345
   GOT entry type: We have several types of GOT entries.
1346
   * R_8 type is used in entries for symbols that have at least one
1347
   R_68K_GOT8O or R_68K_TLS_*8 relocation.  We can have at most 0x40
1348
   such entries in one GOT.
1349
   * R_16 type is used in entries for symbols that have at least one
1350
   R_68K_GOT16O or R_68K_TLS_*16 relocation and no R_8 relocations.
1351
   We can have at most 0x4000 such entries in one GOT.
1352
   * R_32 type is used in all other cases.  We can have as many
1353
   such entries in one GOT as we'd like.
1354
   When counting relocations we have to include the count of the smaller
1355
   ranged relocations in the counts of the larger ranged ones in order
1356
   to correctly detect overflow.
1357
 
1358
   Sorting the GOT: In each GOT starting offsets are assigned to
1359
   R_8 entries, which are followed by R_16 entries, and
1360
   R_32 entries go at the end.  See finalize_got_offsets for details.
1361
 
1362
   Negative GOT offsets: To double usable offset range of GOTs we use
1363
   negative offsets.  As we assign entries with GOT offsets relative to
1364
   start of .got section, the offset values are positive.  They become
1365
   negative only in relocate_section where got->offset value is
1366
   subtracted from them.
1367
 
1368
   3 special GOT entries: There are 3 special GOT entries used internally
1369
   by loader.  These entries happen to be placed to .got.plt section,
1370
   so we don't do anything about them in multi-GOT support.
1371
 
1372
   Memory management: All data except for hashtables
1373
   multi_got->bfd2got and got->entries are allocated on
1374
   elf_hash_table (info)->dynobj bfd (for this reason we pass 'info'
1375
   to most functions), so we don't need to care to free them.  At the
1376
   moment of allocation hashtables are being linked into main data
1377
   structure (multi_got), all pieces of which are reachable from
1378
   elf_m68k_multi_got (info).  We deallocate them in
1379
   elf_m68k_link_hash_table_free.  */
1380
 
1381
/* Initialize GOT.  */
1382
 
1383
static void
1384
elf_m68k_init_got (struct elf_m68k_got *got)
1385
{
1386
  got->entries = NULL;
1387
  got->n_slots[R_8] = 0;
1388
  got->n_slots[R_16] = 0;
1389
  got->n_slots[R_32] = 0;
1390
  got->local_n_slots = 0;
1391
  got->offset = (bfd_vma) -1;
1392
}
1393
 
1394
/* Destruct GOT.  */
1395
 
1396
static void
1397
elf_m68k_clear_got (struct elf_m68k_got *got)
1398
{
1399
  if (got->entries != NULL)
1400
    {
1401
      htab_delete (got->entries);
1402
      got->entries = NULL;
1403
    }
1404
}
1405
 
1406
/* Create and empty GOT structure.  INFO is the context where memory
1407
   should be allocated.  */
1408
 
1409
static struct elf_m68k_got *
1410
elf_m68k_create_empty_got (struct bfd_link_info *info)
1411
{
1412
  struct elf_m68k_got *got;
1413
 
1414
  got = bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*got));
1415
  if (got == NULL)
1416
    return NULL;
1417
 
1418
  elf_m68k_init_got (got);
1419
 
1420
  return got;
1421
}
1422
 
1423
/* Initialize KEY.  */
1424
 
1425
static void
1426
elf_m68k_init_got_entry_key (struct elf_m68k_got_entry_key *key,
1427
                             struct elf_link_hash_entry *h,
1428
                             const bfd *abfd, unsigned long symndx,
1429
                             enum elf_m68k_reloc_type reloc_type)
1430
{
1431
  if (elf_m68k_reloc_got_type (reloc_type) == R_68K_TLS_LDM32)
1432
    /* All TLS_LDM relocations share a single GOT entry.  */
1433
    {
1434
      key->bfd = NULL;
1435
      key->symndx = 0;
1436
    }
1437
  else if (h != NULL)
1438
    /* Global symbols are identified with their got_entry_key.  */
1439
    {
1440
      key->bfd = NULL;
1441
      key->symndx = elf_m68k_hash_entry (h)->got_entry_key;
1442
      BFD_ASSERT (key->symndx != 0);
1443
    }
1444
  else
1445
    /* Local symbols are identified by BFD they appear in and symndx.  */
1446
    {
1447
      key->bfd = abfd;
1448
      key->symndx = symndx;
1449
    }
1450
 
1451
  key->type = reloc_type;
1452
}
1453
 
1454
/* Calculate hash of got_entry.
1455
   ??? Is it good?  */
1456
 
1457
static hashval_t
1458
elf_m68k_got_entry_hash (const void *_entry)
1459
{
1460
  const struct elf_m68k_got_entry_key *key;
1461
 
1462
  key = &((const struct elf_m68k_got_entry *) _entry)->key_;
1463
 
1464
  return (key->symndx
1465
          + (key->bfd != NULL ? (int) key->bfd->id : -1)
1466
          + elf_m68k_reloc_got_type (key->type));
1467
}
1468
 
1469
/* Check if two got entries are equal.  */
1470
 
1471
static int
1472
elf_m68k_got_entry_eq (const void *_entry1, const void *_entry2)
1473
{
1474
  const struct elf_m68k_got_entry_key *key1;
1475
  const struct elf_m68k_got_entry_key *key2;
1476
 
1477
  key1 = &((const struct elf_m68k_got_entry *) _entry1)->key_;
1478
  key2 = &((const struct elf_m68k_got_entry *) _entry2)->key_;
1479
 
1480
  return (key1->bfd == key2->bfd
1481
          && key1->symndx == key2->symndx
1482
          && (elf_m68k_reloc_got_type (key1->type)
1483
              == elf_m68k_reloc_got_type (key2->type)));
1484
}
1485
 
1486
/* When using negative offsets, we allocate one extra R_8, one extra R_16
1487
   and one extra R_32 slots to simplify handling of 2-slot entries during
1488
   offset allocation -- hence -1 for R_8 slots and -2 for R_16 slots.  */
1489
 
1490
/* Maximal number of R_8 slots in a single GOT.  */
1491
#define ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT(INFO)           \
1492
  (elf_m68k_hash_table (INFO)->use_neg_got_offsets_p            \
1493
   ? (0x40 - 1)                                                 \
1494
   : 0x20)
1495
 
1496
/* Maximal number of R_8 and R_16 slots in a single GOT.  */
1497
#define ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT(INFO)                \
1498
  (elf_m68k_hash_table (INFO)->use_neg_got_offsets_p            \
1499
   ? (0x4000 - 2)                                               \
1500
   : 0x2000)
1501
 
1502
/* SEARCH - simply search the hashtable, don't insert new entries or fail when
1503
   the entry cannot be found.
1504
   FIND_OR_CREATE - search for an existing entry, but create new if there's
1505
   no such.
1506
   MUST_FIND - search for an existing entry and assert that it exist.
1507
   MUST_CREATE - assert that there's no such entry and create new one.  */
1508
enum elf_m68k_get_entry_howto
1509
  {
1510
    SEARCH,
1511
    FIND_OR_CREATE,
1512
    MUST_FIND,
1513
    MUST_CREATE
1514
  };
1515
 
1516
/* Get or create (depending on HOWTO) entry with KEY in GOT.
1517
   INFO is context in which memory should be allocated (can be NULL if
1518
   HOWTO is SEARCH or MUST_FIND).  */
1519
 
1520
static struct elf_m68k_got_entry *
1521
elf_m68k_get_got_entry (struct elf_m68k_got *got,
1522
                        const struct elf_m68k_got_entry_key *key,
1523
                        enum elf_m68k_get_entry_howto howto,
1524
                        struct bfd_link_info *info)
1525
{
1526
  struct elf_m68k_got_entry entry_;
1527
  struct elf_m68k_got_entry *entry;
1528
  void **ptr;
1529
 
1530
  BFD_ASSERT ((info == NULL) == (howto == SEARCH || howto == MUST_FIND));
1531
 
1532
  if (got->entries == NULL)
1533
    /* This is the first entry in ABFD.  Initialize hashtable.  */
1534
    {
1535
      if (howto == SEARCH)
1536
        return NULL;
1537
 
1538
      got->entries = htab_try_create (ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT
1539
                                      (info),
1540
                                      elf_m68k_got_entry_hash,
1541
                                      elf_m68k_got_entry_eq, NULL);
1542
      if (got->entries == NULL)
1543
        {
1544
          bfd_set_error (bfd_error_no_memory);
1545
          return NULL;
1546
        }
1547
    }
1548
 
1549
  entry_.key_ = *key;
1550
  ptr = htab_find_slot (got->entries, &entry_, (howto != SEARCH
1551
                                                ? INSERT : NO_INSERT));
1552
  if (ptr == NULL)
1553
    {
1554
      if (howto == SEARCH)
1555
        /* Entry not found.  */
1556
        return NULL;
1557
 
1558
      /* We're out of memory.  */
1559
      bfd_set_error (bfd_error_no_memory);
1560
      return NULL;
1561
    }
1562
 
1563
  if (*ptr == NULL)
1564
    /* We didn't find the entry and we're asked to create a new one.  */
1565
    {
1566
      BFD_ASSERT (howto != MUST_FIND && howto != SEARCH);
1567
 
1568
      entry = bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*entry));
1569
      if (entry == NULL)
1570
        return NULL;
1571
 
1572
      /* Initialize new entry.  */
1573
      entry->key_ = *key;
1574
 
1575
      entry->u.s1.refcount = 0;
1576
 
1577
      /* Mark the entry as not initialized.  */
1578
      entry->key_.type = R_68K_max;
1579
 
1580
      *ptr = entry;
1581
    }
1582
  else
1583
    /* We found the entry.  */
1584
    {
1585
      BFD_ASSERT (howto != MUST_CREATE);
1586
 
1587
      entry = *ptr;
1588
    }
1589
 
1590
  return entry;
1591
}
1592
 
1593
/* Update GOT counters when merging entry of WAS type with entry of NEW type.
1594
   Return the value to which ENTRY's type should be set.  */
1595
 
1596
static enum elf_m68k_reloc_type
1597
elf_m68k_update_got_entry_type (struct elf_m68k_got *got,
1598
                                enum elf_m68k_reloc_type was,
1599
                                enum elf_m68k_reloc_type new_reloc)
1600
{
1601
  enum elf_m68k_got_offset_size was_size;
1602
  enum elf_m68k_got_offset_size new_size;
1603
  bfd_vma n_slots;
1604
 
1605
  if (was == R_68K_max)
1606
    /* The type of the entry is not initialized yet.  */
1607
    {
1608
      /* Update all got->n_slots counters, including n_slots[R_32].  */
1609
      was_size = R_LAST;
1610
 
1611
      was = new_reloc;
1612
    }
1613
  else
1614
    {
1615
      /* !!! We, probably, should emit an error rather then fail on assert
1616
         in such a case.  */
1617
      BFD_ASSERT (elf_m68k_reloc_got_type (was)
1618
                  == elf_m68k_reloc_got_type (new_reloc));
1619
 
1620
      was_size = elf_m68k_reloc_got_offset_size (was);
1621
    }
1622
 
1623
  new_size = elf_m68k_reloc_got_offset_size (new_reloc);
1624
  n_slots = elf_m68k_reloc_got_n_slots (new_reloc);
1625
 
1626
  while (was_size > new_size)
1627
    {
1628
      --was_size;
1629
      got->n_slots[was_size] += n_slots;
1630
    }
1631
 
1632
  if (new_reloc > was)
1633
    /* Relocations are ordered from bigger got offset size to lesser,
1634
       so choose the relocation type with lesser offset size.  */
1635
    was = new_reloc;
1636
 
1637
  return was;
1638
}
1639
 
1640
/* Update GOT counters when removing an entry of type TYPE.  */
1641
 
1642
static void
1643
elf_m68k_remove_got_entry_type (struct elf_m68k_got *got,
1644
                                enum elf_m68k_reloc_type type)
1645
{
1646
  enum elf_m68k_got_offset_size os;
1647
  bfd_vma n_slots;
1648
 
1649
  n_slots = elf_m68k_reloc_got_n_slots (type);
1650
 
1651
  /* Decrese counter of slots with offset size corresponding to TYPE
1652
     and all greater offset sizes.  */
1653
  for (os = elf_m68k_reloc_got_offset_size (type); os <= R_32; ++os)
1654
    {
1655
      BFD_ASSERT (got->n_slots[os] >= n_slots);
1656
 
1657
      got->n_slots[os] -= n_slots;
1658
    }
1659
}
1660
 
1661
/* Add new or update existing entry to GOT.
1662
   H, ABFD, TYPE and SYMNDX is data for the entry.
1663
   INFO is a context where memory should be allocated.  */
1664
 
1665
static struct elf_m68k_got_entry *
1666
elf_m68k_add_entry_to_got (struct elf_m68k_got *got,
1667
                           struct elf_link_hash_entry *h,
1668
                           const bfd *abfd,
1669
                           enum elf_m68k_reloc_type reloc_type,
1670
                           unsigned long symndx,
1671
                           struct bfd_link_info *info)
1672
{
1673
  struct elf_m68k_got_entry_key key_;
1674
  struct elf_m68k_got_entry *entry;
1675
 
1676
  if (h != NULL && elf_m68k_hash_entry (h)->got_entry_key == 0)
1677
    elf_m68k_hash_entry (h)->got_entry_key
1678
      = elf_m68k_multi_got (info)->global_symndx++;
1679
 
1680
  elf_m68k_init_got_entry_key (&key_, h, abfd, symndx, reloc_type);
1681
 
1682
  entry = elf_m68k_get_got_entry (got, &key_, FIND_OR_CREATE, info);
1683
  if (entry == NULL)
1684
    return NULL;
1685
 
1686
  /* Determine entry's type and update got->n_slots counters.  */
1687
  entry->key_.type = elf_m68k_update_got_entry_type (got,
1688
                                                     entry->key_.type,
1689
                                                     reloc_type);
1690
 
1691
  /* Update refcount.  */
1692
  ++entry->u.s1.refcount;
1693
 
1694
  if (entry->u.s1.refcount == 1)
1695
    /* We see this entry for the first time.  */
1696
    {
1697
      if (entry->key_.bfd != NULL)
1698
        got->local_n_slots += elf_m68k_reloc_got_n_slots (entry->key_.type);
1699
    }
1700
 
1701
  BFD_ASSERT (got->n_slots[R_32] >= got->local_n_slots);
1702
 
1703
  if ((got->n_slots[R_8]
1704
       > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1705
      || (got->n_slots[R_16]
1706
          > ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info)))
1707
    /* This BFD has too many relocation.  */
1708
    {
1709
      if (got->n_slots[R_8] > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1710
        (*_bfd_error_handler) (_("%B: GOT overflow: "
1711
                                 "Number of relocations with 8-bit "
1712
                                 "offset > %d"),
1713
                               abfd,
1714
                               ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info));
1715
      else
1716
        (*_bfd_error_handler) (_("%B: GOT overflow: "
1717
                                 "Number of relocations with 8- or 16-bit "
1718
                                 "offset > %d"),
1719
                               abfd,
1720
                               ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info));
1721
 
1722
      return NULL;
1723
    }
1724
 
1725
  return entry;
1726
}
1727
 
1728
/* Compute the hash value of the bfd in a bfd2got hash entry.  */
1729
 
1730
static hashval_t
1731
elf_m68k_bfd2got_entry_hash (const void *entry)
1732
{
1733
  const struct elf_m68k_bfd2got_entry *e;
1734
 
1735
  e = (const struct elf_m68k_bfd2got_entry *) entry;
1736
 
1737
  return e->bfd->id;
1738
}
1739
 
1740
/* Check whether two hash entries have the same bfd.  */
1741
 
1742
static int
1743
elf_m68k_bfd2got_entry_eq (const void *entry1, const void *entry2)
1744
{
1745
  const struct elf_m68k_bfd2got_entry *e1;
1746
  const struct elf_m68k_bfd2got_entry *e2;
1747
 
1748
  e1 = (const struct elf_m68k_bfd2got_entry *) entry1;
1749
  e2 = (const struct elf_m68k_bfd2got_entry *) entry2;
1750
 
1751
  return e1->bfd == e2->bfd;
1752
}
1753
 
1754
/* Destruct a bfd2got entry.  */
1755
 
1756
static void
1757
elf_m68k_bfd2got_entry_del (void *_entry)
1758
{
1759
  struct elf_m68k_bfd2got_entry *entry;
1760
 
1761
  entry = (struct elf_m68k_bfd2got_entry *) _entry;
1762
 
1763
  BFD_ASSERT (entry->got != NULL);
1764
  elf_m68k_clear_got (entry->got);
1765
}
1766
 
1767
/* Find existing or create new (depending on HOWTO) bfd2got entry in
1768
   MULTI_GOT.  ABFD is the bfd we need a GOT for.  INFO is a context where
1769
   memory should be allocated.  */
1770
 
1771
static struct elf_m68k_bfd2got_entry *
1772
elf_m68k_get_bfd2got_entry (struct elf_m68k_multi_got *multi_got,
1773
                            const bfd *abfd,
1774
                            enum elf_m68k_get_entry_howto howto,
1775
                            struct bfd_link_info *info)
1776
{
1777
  struct elf_m68k_bfd2got_entry entry_;
1778
  void **ptr;
1779
  struct elf_m68k_bfd2got_entry *entry;
1780
 
1781
  BFD_ASSERT ((info == NULL) == (howto == SEARCH || howto == MUST_FIND));
1782
 
1783
  if (multi_got->bfd2got == NULL)
1784
    /* This is the first GOT.  Initialize bfd2got.  */
1785
    {
1786
      if (howto == SEARCH)
1787
        return NULL;
1788
 
1789
      multi_got->bfd2got = htab_try_create (1, elf_m68k_bfd2got_entry_hash,
1790
                                            elf_m68k_bfd2got_entry_eq,
1791
                                            elf_m68k_bfd2got_entry_del);
1792
      if (multi_got->bfd2got == NULL)
1793
        {
1794
          bfd_set_error (bfd_error_no_memory);
1795
          return NULL;
1796
        }
1797
    }
1798
 
1799
  entry_.bfd = abfd;
1800
  ptr = htab_find_slot (multi_got->bfd2got, &entry_, (howto != SEARCH
1801
                                                      ? INSERT : NO_INSERT));
1802
  if (ptr == NULL)
1803
    {
1804
      if (howto == SEARCH)
1805
        /* Entry not found.  */
1806
        return NULL;
1807
 
1808
      /* We're out of memory.  */
1809
      bfd_set_error (bfd_error_no_memory);
1810
      return NULL;
1811
    }
1812
 
1813
  if (*ptr == NULL)
1814
    /* Entry was not found.  Create new one.  */
1815
    {
1816
      BFD_ASSERT (howto != MUST_FIND && howto != SEARCH);
1817
 
1818
      entry = ((struct elf_m68k_bfd2got_entry *)
1819
               bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*entry)));
1820
      if (entry == NULL)
1821
        return NULL;
1822
 
1823
      entry->bfd = abfd;
1824
 
1825
      entry->got = elf_m68k_create_empty_got (info);
1826
      if (entry->got == NULL)
1827
        return NULL;
1828
 
1829
      *ptr = entry;
1830
    }
1831
  else
1832
    {
1833
      BFD_ASSERT (howto != MUST_CREATE);
1834
 
1835
      /* Return existing entry.  */
1836
      entry = *ptr;
1837
    }
1838
 
1839
  return entry;
1840
}
1841
 
1842
struct elf_m68k_can_merge_gots_arg
1843
{
1844
  /* A current_got that we constructing a DIFF against.  */
1845
  struct elf_m68k_got *big;
1846
 
1847
  /* GOT holding entries not present or that should be changed in
1848
     BIG.  */
1849
  struct elf_m68k_got *diff;
1850
 
1851
  /* Context where to allocate memory.  */
1852
  struct bfd_link_info *info;
1853
 
1854
  /* Error flag.  */
1855
  bfd_boolean error_p;
1856
};
1857
 
1858
/* Process a single entry from the small GOT to see if it should be added
1859
   or updated in the big GOT.  */
1860
 
1861
static int
1862
elf_m68k_can_merge_gots_1 (void **_entry_ptr, void *_arg)
1863
{
1864
  const struct elf_m68k_got_entry *entry1;
1865
  struct elf_m68k_can_merge_gots_arg *arg;
1866
  const struct elf_m68k_got_entry *entry2;
1867
  enum elf_m68k_reloc_type type;
1868
 
1869
  entry1 = (const struct elf_m68k_got_entry *) *_entry_ptr;
1870
  arg = (struct elf_m68k_can_merge_gots_arg *) _arg;
1871
 
1872
  entry2 = elf_m68k_get_got_entry (arg->big, &entry1->key_, SEARCH, NULL);
1873
 
1874
  if (entry2 != NULL)
1875
    /* We found an existing entry.  Check if we should update it.  */
1876
    {
1877
      type = elf_m68k_update_got_entry_type (arg->diff,
1878
                                             entry2->key_.type,
1879
                                             entry1->key_.type);
1880
 
1881
      if (type == entry2->key_.type)
1882
        /* ENTRY1 doesn't update data in ENTRY2.  Skip it.
1883
           To skip creation of difference entry we use the type,
1884
           which we won't see in GOT entries for sure.  */
1885
        type = R_68K_max;
1886
    }
1887
  else
1888
    /* We didn't find the entry.  Add entry1 to DIFF.  */
1889
    {
1890
      BFD_ASSERT (entry1->key_.type != R_68K_max);
1891
 
1892
      type = elf_m68k_update_got_entry_type (arg->diff,
1893
                                             R_68K_max, entry1->key_.type);
1894
 
1895
      if (entry1->key_.bfd != NULL)
1896
        arg->diff->local_n_slots += elf_m68k_reloc_got_n_slots (type);
1897
    }
1898
 
1899
  if (type != R_68K_max)
1900
    /* Create an entry in DIFF.  */
1901
    {
1902
      struct elf_m68k_got_entry *entry;
1903
 
1904
      entry = elf_m68k_get_got_entry (arg->diff, &entry1->key_, MUST_CREATE,
1905
                                      arg->info);
1906
      if (entry == NULL)
1907
        {
1908
          arg->error_p = TRUE;
1909
          return 0;
1910
        }
1911
 
1912
      entry->key_.type = type;
1913
    }
1914
 
1915
  return 1;
1916
}
1917
 
1918
/* Return TRUE if SMALL GOT can be added to BIG GOT without overflowing it.
1919
   Construct DIFF GOT holding the entries which should be added or updated
1920
   in BIG GOT to accumulate information from SMALL.
1921
   INFO is the context where memory should be allocated.  */
1922
 
1923
static bfd_boolean
1924
elf_m68k_can_merge_gots (struct elf_m68k_got *big,
1925
                         const struct elf_m68k_got *small,
1926
                         struct bfd_link_info *info,
1927
                         struct elf_m68k_got *diff)
1928
{
1929
  struct elf_m68k_can_merge_gots_arg arg_;
1930
 
1931
  BFD_ASSERT (small->offset == (bfd_vma) -1);
1932
 
1933
  arg_.big = big;
1934
  arg_.diff = diff;
1935
  arg_.info = info;
1936
  arg_.error_p = FALSE;
1937
  htab_traverse_noresize (small->entries, elf_m68k_can_merge_gots_1, &arg_);
1938
  if (arg_.error_p)
1939
    {
1940
      diff->offset = 0;
1941
      return FALSE;
1942
    }
1943
 
1944
  /* Check for overflow.  */
1945
  if ((big->n_slots[R_8] + arg_.diff->n_slots[R_8]
1946
       > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1947
      || (big->n_slots[R_16] + arg_.diff->n_slots[R_16]
1948
          > ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info)))
1949
    return FALSE;
1950
 
1951
  return TRUE;
1952
}
1953
 
1954
struct elf_m68k_merge_gots_arg
1955
{
1956
  /* The BIG got.  */
1957
  struct elf_m68k_got *big;
1958
 
1959
  /* Context where memory should be allocated.  */
1960
  struct bfd_link_info *info;
1961
 
1962
  /* Error flag.  */
1963
  bfd_boolean error_p;
1964
};
1965
 
1966
/* Process a single entry from DIFF got.  Add or update corresponding
1967
   entry in the BIG got.  */
1968
 
1969
static int
1970
elf_m68k_merge_gots_1 (void **entry_ptr, void *_arg)
1971
{
1972
  const struct elf_m68k_got_entry *from;
1973
  struct elf_m68k_merge_gots_arg *arg;
1974
  struct elf_m68k_got_entry *to;
1975
 
1976
  from = (const struct elf_m68k_got_entry *) *entry_ptr;
1977
  arg = (struct elf_m68k_merge_gots_arg *) _arg;
1978
 
1979
  to = elf_m68k_get_got_entry (arg->big, &from->key_, FIND_OR_CREATE,
1980
                               arg->info);
1981
  if (to == NULL)
1982
    {
1983
      arg->error_p = TRUE;
1984
      return 0;
1985
    }
1986
 
1987
  BFD_ASSERT (to->u.s1.refcount == 0);
1988
  /* All we need to merge is TYPE.  */
1989
  to->key_.type = from->key_.type;
1990
 
1991
  return 1;
1992
}
1993
 
1994
/* Merge data from DIFF to BIG.  INFO is context where memory should be
1995
   allocated.  */
1996
 
1997
static bfd_boolean
1998
elf_m68k_merge_gots (struct elf_m68k_got *big,
1999
                     struct elf_m68k_got *diff,
2000
                     struct bfd_link_info *info)
2001
{
2002
  if (diff->entries != NULL)
2003
    /* DIFF is not empty.  Merge it into BIG GOT.  */
2004
    {
2005
      struct elf_m68k_merge_gots_arg arg_;
2006
 
2007
      /* Merge entries.  */
2008
      arg_.big = big;
2009
      arg_.info = info;
2010
      arg_.error_p = FALSE;
2011
      htab_traverse_noresize (diff->entries, elf_m68k_merge_gots_1, &arg_);
2012
      if (arg_.error_p)
2013
        return FALSE;
2014
 
2015
      /* Merge counters.  */
2016
      big->n_slots[R_8] += diff->n_slots[R_8];
2017
      big->n_slots[R_16] += diff->n_slots[R_16];
2018
      big->n_slots[R_32] += diff->n_slots[R_32];
2019
      big->local_n_slots += diff->local_n_slots;
2020
    }
2021
  else
2022
    /* DIFF is empty.  */
2023
    {
2024
      BFD_ASSERT (diff->n_slots[R_8] == 0);
2025
      BFD_ASSERT (diff->n_slots[R_16] == 0);
2026
      BFD_ASSERT (diff->n_slots[R_32] == 0);
2027
      BFD_ASSERT (diff->local_n_slots == 0);
2028
    }
2029
 
2030
  BFD_ASSERT (!elf_m68k_hash_table (info)->allow_multigot_p
2031
              || ((big->n_slots[R_8]
2032
                   <= ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
2033
                  && (big->n_slots[R_16]
2034
                      <= ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info))));
2035
 
2036
  return TRUE;
2037
}
2038
 
2039
struct elf_m68k_finalize_got_offsets_arg
2040
{
2041
  /* Ranges of the offsets for GOT entries.
2042
     R_x entries receive offsets between offset1[R_x] and offset2[R_x].
2043
     R_x is R_8, R_16 and R_32.  */
2044
  bfd_vma *offset1;
2045
  bfd_vma *offset2;
2046
 
2047
  /* Mapping from global symndx to global symbols.
2048
     This is used to build lists of got entries for global symbols.  */
2049
  struct elf_m68k_link_hash_entry **symndx2h;
2050
 
2051
  bfd_vma n_ldm_entries;
2052
};
2053
 
2054
/* Assign ENTRY an offset.  Build list of GOT entries for global symbols
2055
   along the way.  */
2056
 
2057
static int
2058
elf_m68k_finalize_got_offsets_1 (void **entry_ptr, void *_arg)
2059
{
2060
  struct elf_m68k_got_entry *entry;
2061
  struct elf_m68k_finalize_got_offsets_arg *arg;
2062
 
2063
  enum elf_m68k_got_offset_size got_offset_size;
2064
  bfd_vma entry_size;
2065
 
2066
  entry = (struct elf_m68k_got_entry *) *entry_ptr;
2067
  arg = (struct elf_m68k_finalize_got_offsets_arg *) _arg;
2068
 
2069
  /* This should be a fresh entry created in elf_m68k_can_merge_gots.  */
2070
  BFD_ASSERT (entry->u.s1.refcount == 0);
2071
 
2072
  /* Get GOT offset size for the entry .  */
2073
  got_offset_size = elf_m68k_reloc_got_offset_size (entry->key_.type);
2074
 
2075
  /* Calculate entry size in bytes.  */
2076
  entry_size = 4 * elf_m68k_reloc_got_n_slots (entry->key_.type);
2077
 
2078
  /* Check if we should switch to negative range of the offsets. */
2079
  if (arg->offset1[got_offset_size] + entry_size
2080
      > arg->offset2[got_offset_size])
2081
    {
2082
      /* Verify that this is the only switch to negative range for
2083
         got_offset_size.  If this assertion fails, then we've miscalculated
2084
         range for got_offset_size entries in
2085
         elf_m68k_finalize_got_offsets.  */
2086
      BFD_ASSERT (arg->offset2[got_offset_size]
2087
                  != arg->offset2[-(int) got_offset_size - 1]);
2088
 
2089
      /* Switch.  */
2090
      arg->offset1[got_offset_size] = arg->offset1[-(int) got_offset_size - 1];
2091
      arg->offset2[got_offset_size] = arg->offset2[-(int) got_offset_size - 1];
2092
 
2093
      /* Verify that now we have enough room for the entry.  */
2094
      BFD_ASSERT (arg->offset1[got_offset_size] + entry_size
2095
                  <= arg->offset2[got_offset_size]);
2096
    }
2097
 
2098
  /* Assign offset to entry.  */
2099
  entry->u.s2.offset = arg->offset1[got_offset_size];
2100
  arg->offset1[got_offset_size] += entry_size;
2101
 
2102
  if (entry->key_.bfd == NULL)
2103
    /* Hook up this entry into the list of got_entries of H.  */
2104
    {
2105
      struct elf_m68k_link_hash_entry *h;
2106
 
2107
      h = arg->symndx2h[entry->key_.symndx];
2108
      if (h != NULL)
2109
        {
2110
          entry->u.s2.next = h->glist;
2111
          h->glist = entry;
2112
        }
2113
      else
2114
        /* This should be the entry for TLS_LDM relocation then.  */
2115
        {
2116
          BFD_ASSERT ((elf_m68k_reloc_got_type (entry->key_.type)
2117
                       == R_68K_TLS_LDM32)
2118
                      && entry->key_.symndx == 0);
2119
 
2120
          ++arg->n_ldm_entries;
2121
        }
2122
    }
2123
  else
2124
    /* This entry is for local symbol.  */
2125
    entry->u.s2.next = NULL;
2126
 
2127
  return 1;
2128
}
2129
 
2130
/* Assign offsets within GOT.  USE_NEG_GOT_OFFSETS_P indicates if we
2131
   should use negative offsets.
2132
   Build list of GOT entries for global symbols along the way.
2133
   SYMNDX2H is mapping from global symbol indices to actual
2134
   global symbols.
2135
   Return offset at which next GOT should start.  */
2136
 
2137
static void
2138
elf_m68k_finalize_got_offsets (struct elf_m68k_got *got,
2139
                               bfd_boolean use_neg_got_offsets_p,
2140
                               struct elf_m68k_link_hash_entry **symndx2h,
2141
                               bfd_vma *final_offset, bfd_vma *n_ldm_entries)
2142
{
2143
  struct elf_m68k_finalize_got_offsets_arg arg_;
2144
  bfd_vma offset1_[2 * R_LAST];
2145
  bfd_vma offset2_[2 * R_LAST];
2146
  int i;
2147
  bfd_vma start_offset;
2148
 
2149
  BFD_ASSERT (got->offset != (bfd_vma) -1);
2150
 
2151
  /* We set entry offsets relative to the .got section (and not the
2152
     start of a particular GOT), so that we can use them in
2153
     finish_dynamic_symbol without needing to know the GOT which they come
2154
     from.  */
2155
 
2156
  /* Put offset1 in the middle of offset1_, same for offset2.  */
2157
  arg_.offset1 = offset1_ + R_LAST;
2158
  arg_.offset2 = offset2_ + R_LAST;
2159
 
2160
  start_offset = got->offset;
2161
 
2162
  if (use_neg_got_offsets_p)
2163
    /* Setup both negative and positive ranges for R_8, R_16 and R_32.  */
2164
    i = -(int) R_32 - 1;
2165
  else
2166
    /* Setup positives ranges for R_8, R_16 and R_32.  */
2167
    i = (int) R_8;
2168
 
2169
  for (; i <= (int) R_32; ++i)
2170
    {
2171
      int j;
2172
      size_t n;
2173
 
2174
      /* Set beginning of the range of offsets I.  */
2175
      arg_.offset1[i] = start_offset;
2176
 
2177
      /* Calculate number of slots that require I offsets.  */
2178
      j = (i >= 0) ? i : -i - 1;
2179
      n = (j >= 1) ? got->n_slots[j - 1] : 0;
2180
      n = got->n_slots[j] - n;
2181
 
2182
      if (use_neg_got_offsets_p && n != 0)
2183
        {
2184
          if (i < 0)
2185
            /* We first fill the positive side of the range, so we might
2186
               end up with one empty slot at that side when we can't fit
2187
               whole 2-slot entry.  Account for that at negative side of
2188
               the interval with one additional entry.  */
2189
            n = n / 2 + 1;
2190
          else
2191
            /* When the number of slots is odd, make positive side of the
2192
               range one entry bigger.  */
2193
            n = (n + 1) / 2;
2194
        }
2195
 
2196
      /* N is the number of slots that require I offsets.
2197
         Calculate length of the range for I offsets.  */
2198
      n = 4 * n;
2199
 
2200
      /* Set end of the range.  */
2201
      arg_.offset2[i] = start_offset + n;
2202
 
2203
      start_offset = arg_.offset2[i];
2204
    }
2205
 
2206
  if (!use_neg_got_offsets_p)
2207
    /* Make sure that if we try to switch to negative offsets in
2208
       elf_m68k_finalize_got_offsets_1, the assert therein will catch
2209
       the bug.  */
2210
    for (i = R_8; i <= R_32; ++i)
2211
      arg_.offset2[-i - 1] = arg_.offset2[i];
2212
 
2213
  /* Setup got->offset.  offset1[R_8] is either in the middle or at the
2214
     beginning of GOT depending on use_neg_got_offsets_p.  */
2215
  got->offset = arg_.offset1[R_8];
2216
 
2217
  arg_.symndx2h = symndx2h;
2218
  arg_.n_ldm_entries = 0;
2219
 
2220
  /* Assign offsets.  */
2221
  htab_traverse (got->entries, elf_m68k_finalize_got_offsets_1, &arg_);
2222
 
2223
  /* Check offset ranges we have actually assigned.  */
2224
  for (i = (int) R_8; i <= (int) R_32; ++i)
2225
    BFD_ASSERT (arg_.offset2[i] - arg_.offset1[i] <= 4);
2226
 
2227
  *final_offset = start_offset;
2228
  *n_ldm_entries = arg_.n_ldm_entries;
2229
}
2230
 
2231
struct elf_m68k_partition_multi_got_arg
2232
{
2233
  /* The GOT we are adding entries to.  Aka big got.  */
2234
  struct elf_m68k_got *current_got;
2235
 
2236
  /* Offset to assign the next CURRENT_GOT.  */
2237
  bfd_vma offset;
2238
 
2239
  /* Context where memory should be allocated.  */
2240
  struct bfd_link_info *info;
2241
 
2242
  /* Total number of slots in the .got section.
2243
     This is used to calculate size of the .got and .rela.got sections.  */
2244
  bfd_vma n_slots;
2245
 
2246
  /* Difference in numbers of allocated slots in the .got section
2247
     and necessary relocations in the .rela.got section.
2248
     This is used to calculate size of the .rela.got section.  */
2249
  bfd_vma slots_relas_diff;
2250
 
2251
  /* Error flag.  */
2252
  bfd_boolean error_p;
2253
 
2254
  /* Mapping from global symndx to global symbols.
2255
     This is used to build lists of got entries for global symbols.  */
2256
  struct elf_m68k_link_hash_entry **symndx2h;
2257
};
2258
 
2259
static void
2260
elf_m68k_partition_multi_got_2 (struct elf_m68k_partition_multi_got_arg *arg)
2261
{
2262
  bfd_vma n_ldm_entries;
2263
 
2264
  elf_m68k_finalize_got_offsets (arg->current_got,
2265
                                 (elf_m68k_hash_table (arg->info)
2266
                                  ->use_neg_got_offsets_p),
2267
                                 arg->symndx2h,
2268
                                 &arg->offset, &n_ldm_entries);
2269
 
2270
  arg->n_slots += arg->current_got->n_slots[R_32];
2271
 
2272
  if (!arg->info->shared)
2273
    /* If we are generating a shared object, we need to
2274
       output a R_68K_RELATIVE reloc so that the dynamic
2275
       linker can adjust this GOT entry.  Overwise we
2276
       don't need space in .rela.got for local symbols.  */
2277
    arg->slots_relas_diff += arg->current_got->local_n_slots;
2278
 
2279
  /* @LDM relocations require a 2-slot GOT entry, but only
2280
     one relocation.  Account for that.  */
2281
  arg->slots_relas_diff += n_ldm_entries;
2282
 
2283
  BFD_ASSERT (arg->slots_relas_diff <= arg->n_slots);
2284
}
2285
 
2286
 
2287
/* Process a single BFD2GOT entry and either merge GOT to CURRENT_GOT
2288
   or start a new CURRENT_GOT.  */
2289
 
2290
static int
2291
elf_m68k_partition_multi_got_1 (void **_entry, void *_arg)
2292
{
2293
  struct elf_m68k_bfd2got_entry *entry;
2294
  struct elf_m68k_partition_multi_got_arg *arg;
2295
  struct elf_m68k_got *got;
2296
  struct elf_m68k_got diff_;
2297
  struct elf_m68k_got *diff;
2298
 
2299
  entry = (struct elf_m68k_bfd2got_entry *) *_entry;
2300
  arg = (struct elf_m68k_partition_multi_got_arg *) _arg;
2301
 
2302
  got = entry->got;
2303
  BFD_ASSERT (got != NULL);
2304
  BFD_ASSERT (got->offset == (bfd_vma) -1);
2305
 
2306
  diff = NULL;
2307
 
2308
  if (arg->current_got != NULL)
2309
    /* Construct diff.  */
2310
    {
2311
      diff = &diff_;
2312
      elf_m68k_init_got (diff);
2313
 
2314
      if (!elf_m68k_can_merge_gots (arg->current_got, got, arg->info, diff))
2315
        {
2316
          if (diff->offset == 0)
2317
            /* Offset set to 0 in the diff_ indicates an error.  */
2318
            {
2319
              arg->error_p = TRUE;
2320
              goto final_return;
2321
            }
2322
 
2323
          if (elf_m68k_hash_table (arg->info)->allow_multigot_p)
2324
            {
2325
              elf_m68k_clear_got (diff);
2326
              /* Schedule to finish up current_got and start new one.  */
2327
              diff = NULL;
2328
            }
2329
          /* else
2330
             Merge GOTs no matter what.  If big GOT overflows,
2331
             we'll fail in relocate_section due to truncated relocations.
2332
 
2333
             ??? May be fail earlier?  E.g., in can_merge_gots.  */
2334
        }
2335
    }
2336
  else
2337
    /* Diff of got against empty current_got is got itself.  */
2338
    {
2339
      /* Create empty current_got to put subsequent GOTs to.  */
2340
      arg->current_got = elf_m68k_create_empty_got (arg->info);
2341
      if (arg->current_got == NULL)
2342
        {
2343
          arg->error_p = TRUE;
2344
          goto final_return;
2345
        }
2346
 
2347
      arg->current_got->offset = arg->offset;
2348
 
2349
      diff = got;
2350
    }
2351
 
2352
  if (diff != NULL)
2353
    {
2354
      if (!elf_m68k_merge_gots (arg->current_got, diff, arg->info))
2355
        {
2356
          arg->error_p = TRUE;
2357
          goto final_return;
2358
        }
2359
 
2360
      /* Now we can free GOT.  */
2361
      elf_m68k_clear_got (got);
2362
 
2363
      entry->got = arg->current_got;
2364
    }
2365
  else
2366
    {
2367
      /* Finish up current_got.  */
2368
      elf_m68k_partition_multi_got_2 (arg);
2369
 
2370
      /* Schedule to start a new current_got.  */
2371
      arg->current_got = NULL;
2372
 
2373
      /* Retry.  */
2374
      if (!elf_m68k_partition_multi_got_1 (_entry, _arg))
2375
        {
2376
          BFD_ASSERT (arg->error_p);
2377
          goto final_return;
2378
        }
2379
    }
2380
 
2381
 final_return:
2382
  if (diff != NULL)
2383
    elf_m68k_clear_got (diff);
2384
 
2385
  return arg->error_p == FALSE ? 1 : 0;
2386
}
2387
 
2388
/* Helper function to build symndx2h mapping.  */
2389
 
2390
static bfd_boolean
2391
elf_m68k_init_symndx2h_1 (struct elf_link_hash_entry *_h,
2392
                          void *_arg)
2393
{
2394
  struct elf_m68k_link_hash_entry *h;
2395
 
2396
  h = elf_m68k_hash_entry (_h);
2397
 
2398
  if (h->got_entry_key != 0)
2399
    /* H has at least one entry in the GOT.  */
2400
    {
2401
      struct elf_m68k_partition_multi_got_arg *arg;
2402
 
2403
      arg = (struct elf_m68k_partition_multi_got_arg *) _arg;
2404
 
2405
      BFD_ASSERT (arg->symndx2h[h->got_entry_key] == NULL);
2406
      arg->symndx2h[h->got_entry_key] = h;
2407
    }
2408
 
2409
  return TRUE;
2410
}
2411
 
2412
/* Merge GOTs of some BFDs, assign offsets to GOT entries and build
2413
   lists of GOT entries for global symbols.
2414
   Calculate sizes of .got and .rela.got sections.  */
2415
 
2416
static bfd_boolean
2417
elf_m68k_partition_multi_got (struct bfd_link_info *info)
2418
{
2419
  struct elf_m68k_multi_got *multi_got;
2420
  struct elf_m68k_partition_multi_got_arg arg_;
2421
 
2422
  multi_got = elf_m68k_multi_got (info);
2423
 
2424
  arg_.current_got = NULL;
2425
  arg_.offset = 0;
2426
  arg_.info = info;
2427
  arg_.n_slots = 0;
2428
  arg_.slots_relas_diff = 0;
2429
  arg_.error_p = FALSE;
2430
 
2431
  if (multi_got->bfd2got != NULL)
2432
    {
2433
      /* Initialize symndx2h mapping.  */
2434
      {
2435
        arg_.symndx2h = bfd_zmalloc (multi_got->global_symndx
2436
                                     * sizeof (*arg_.symndx2h));
2437
        if (arg_.symndx2h == NULL)
2438
          return FALSE;
2439
 
2440
        elf_link_hash_traverse (elf_hash_table (info),
2441
                                elf_m68k_init_symndx2h_1, &arg_);
2442
      }
2443
 
2444
      /* Partition.  */
2445
      htab_traverse (multi_got->bfd2got, elf_m68k_partition_multi_got_1,
2446
                     &arg_);
2447
      if (arg_.error_p)
2448
        {
2449
          free (arg_.symndx2h);
2450
          arg_.symndx2h = NULL;
2451
 
2452
          return FALSE;
2453
        }
2454
 
2455
      /* Finish up last current_got.  */
2456
      elf_m68k_partition_multi_got_2 (&arg_);
2457
 
2458
      free (arg_.symndx2h);
2459
    }
2460
 
2461
  if (elf_hash_table (info)->dynobj != NULL)
2462
    /* Set sizes of .got and .rela.got sections.  */
2463
    {
2464
      asection *s;
2465
 
2466
      s = bfd_get_section_by_name (elf_hash_table (info)->dynobj, ".got");
2467
      if (s != NULL)
2468
        s->size = arg_.offset;
2469
      else
2470
        BFD_ASSERT (arg_.offset == 0);
2471
 
2472
      BFD_ASSERT (arg_.slots_relas_diff <= arg_.n_slots);
2473
      arg_.n_slots -= arg_.slots_relas_diff;
2474
 
2475
      s = bfd_get_section_by_name (elf_hash_table (info)->dynobj, ".rela.got");
2476
      if (s != NULL)
2477
        s->size = arg_.n_slots * sizeof (Elf32_External_Rela);
2478
      else
2479
        BFD_ASSERT (arg_.n_slots == 0);
2480
    }
2481
  else
2482
    BFD_ASSERT (multi_got->bfd2got == NULL);
2483
 
2484
  return TRUE;
2485
}
2486
 
2487
/* Specialized version of elf_m68k_get_got_entry that returns pointer
2488
   to hashtable slot, thus allowing removal of entry via
2489
   elf_m68k_remove_got_entry.  */
2490
 
2491
static struct elf_m68k_got_entry **
2492
elf_m68k_find_got_entry_ptr (struct elf_m68k_got *got,
2493
                             struct elf_m68k_got_entry_key *key)
2494
{
2495
  void **ptr;
2496
  struct elf_m68k_got_entry entry_;
2497
  struct elf_m68k_got_entry **entry_ptr;
2498
 
2499
  entry_.key_ = *key;
2500
  ptr = htab_find_slot (got->entries, &entry_, NO_INSERT);
2501
  BFD_ASSERT (ptr != NULL);
2502
 
2503
  entry_ptr = (struct elf_m68k_got_entry **) ptr;
2504
 
2505
  return entry_ptr;
2506
}
2507
 
2508
/* Remove entry pointed to by ENTRY_PTR from GOT.  */
2509
 
2510
static void
2511
elf_m68k_remove_got_entry (struct elf_m68k_got *got,
2512
                           struct elf_m68k_got_entry **entry_ptr)
2513
{
2514
  struct elf_m68k_got_entry *entry;
2515
 
2516
  entry = *entry_ptr;
2517
 
2518
  /* Check that offsets have not been finalized yet.  */
2519
  BFD_ASSERT (got->offset == (bfd_vma) -1);
2520
  /* Check that this entry is indeed unused.  */
2521
  BFD_ASSERT (entry->u.s1.refcount == 0);
2522
 
2523
  elf_m68k_remove_got_entry_type (got, entry->key_.type);
2524
 
2525
  if (entry->key_.bfd != NULL)
2526
    got->local_n_slots -= elf_m68k_reloc_got_n_slots (entry->key_.type);
2527
 
2528
  BFD_ASSERT (got->n_slots[R_32] >= got->local_n_slots);
2529
 
2530
  htab_clear_slot (got->entries, (void **) entry_ptr);
2531
}
2532
 
2533
/* Copy any information related to dynamic linking from a pre-existing
2534
   symbol to a newly created symbol.  Also called to copy flags and
2535
   other back-end info to a weakdef, in which case the symbol is not
2536
   newly created and plt/got refcounts and dynamic indices should not
2537
   be copied.  */
2538
 
2539
static void
2540
elf_m68k_copy_indirect_symbol (struct bfd_link_info *info,
2541
                               struct elf_link_hash_entry *_dir,
2542
                               struct elf_link_hash_entry *_ind)
2543
{
2544
  struct elf_m68k_link_hash_entry *dir;
2545
  struct elf_m68k_link_hash_entry *ind;
2546
 
2547
  _bfd_elf_link_hash_copy_indirect (info, _dir, _ind);
2548
 
2549
  if (_ind->root.type != bfd_link_hash_indirect)
2550
    return;
2551
 
2552
  dir = elf_m68k_hash_entry (_dir);
2553
  ind = elf_m68k_hash_entry (_ind);
2554
 
2555
  /* Any absolute non-dynamic relocations against an indirect or weak
2556
     definition will be against the target symbol.  */
2557
  _dir->non_got_ref |= _ind->non_got_ref;
2558
 
2559
  /* We might have a direct symbol already having entries in the GOTs.
2560
     Update its key only in case indirect symbol has GOT entries and
2561
     assert that both indirect and direct symbols don't have GOT entries
2562
     at the same time.  */
2563
  if (ind->got_entry_key != 0)
2564
    {
2565
      BFD_ASSERT (dir->got_entry_key == 0);
2566
      /* Assert that GOTs aren't partioned yet.  */
2567
      BFD_ASSERT (ind->glist == NULL);
2568
 
2569
      dir->got_entry_key = ind->got_entry_key;
2570
      ind->got_entry_key = 0;
2571
    }
2572
}
2573
 
2574
/* Look through the relocs for a section during the first phase, and
2575
   allocate space in the global offset table or procedure linkage
2576
   table.  */
2577
 
2578
static bfd_boolean
2579
elf_m68k_check_relocs (abfd, info, sec, relocs)
2580
     bfd *abfd;
2581
     struct bfd_link_info *info;
2582
     asection *sec;
2583
     const Elf_Internal_Rela *relocs;
2584
{
2585
  bfd *dynobj;
2586
  Elf_Internal_Shdr *symtab_hdr;
2587
  struct elf_link_hash_entry **sym_hashes;
2588
  const Elf_Internal_Rela *rel;
2589
  const Elf_Internal_Rela *rel_end;
2590
  asection *sgot;
2591
  asection *srelgot;
2592
  asection *sreloc;
2593
  struct elf_m68k_got *got;
2594
 
2595
  if (info->relocatable)
2596
    return TRUE;
2597
 
2598
  dynobj = elf_hash_table (info)->dynobj;
2599
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2600
  sym_hashes = elf_sym_hashes (abfd);
2601
 
2602
  sgot = NULL;
2603
  srelgot = NULL;
2604
  sreloc = NULL;
2605
 
2606
  got = NULL;
2607
 
2608
  rel_end = relocs + sec->reloc_count;
2609
  for (rel = relocs; rel < rel_end; rel++)
2610
    {
2611
      unsigned long r_symndx;
2612
      struct elf_link_hash_entry *h;
2613
 
2614
      r_symndx = ELF32_R_SYM (rel->r_info);
2615
 
2616
      if (r_symndx < symtab_hdr->sh_info)
2617
        h = NULL;
2618
      else
2619
        {
2620
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2621
          while (h->root.type == bfd_link_hash_indirect
2622
                 || h->root.type == bfd_link_hash_warning)
2623
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
2624
        }
2625
 
2626
      switch (ELF32_R_TYPE (rel->r_info))
2627
        {
2628
        case R_68K_GOT8:
2629
        case R_68K_GOT16:
2630
        case R_68K_GOT32:
2631
          if (h != NULL
2632
              && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2633
            break;
2634
          /* Fall through.  */
2635
 
2636
          /* Relative GOT relocations.  */
2637
        case R_68K_GOT8O:
2638
        case R_68K_GOT16O:
2639
        case R_68K_GOT32O:
2640
          /* Fall through.  */
2641
 
2642
          /* TLS relocations.  */
2643
        case R_68K_TLS_GD8:
2644
        case R_68K_TLS_GD16:
2645
        case R_68K_TLS_GD32:
2646
        case R_68K_TLS_LDM8:
2647
        case R_68K_TLS_LDM16:
2648
        case R_68K_TLS_LDM32:
2649
        case R_68K_TLS_IE8:
2650
        case R_68K_TLS_IE16:
2651
        case R_68K_TLS_IE32:
2652
 
2653
        case R_68K_TLS_TPREL32:
2654
        case R_68K_TLS_DTPREL32:
2655
 
2656
          if (ELF32_R_TYPE (rel->r_info) == R_68K_TLS_TPREL32
2657
              && info->shared)
2658
            /* Do the special chorus for libraries with static TLS.  */
2659
            info->flags |= DF_STATIC_TLS;
2660
 
2661
          /* This symbol requires a global offset table entry.  */
2662
 
2663
          if (dynobj == NULL)
2664
            {
2665
              /* Create the .got section.  */
2666
              elf_hash_table (info)->dynobj = dynobj = abfd;
2667
              if (!_bfd_elf_create_got_section (dynobj, info))
2668
                return FALSE;
2669
            }
2670
 
2671
          if (sgot == NULL)
2672
            {
2673
              sgot = bfd_get_section_by_name (dynobj, ".got");
2674
              BFD_ASSERT (sgot != NULL);
2675
            }
2676
 
2677
          if (srelgot == NULL
2678
              && (h != NULL || info->shared))
2679
            {
2680
              srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2681
              if (srelgot == NULL)
2682
                {
2683
                  srelgot = bfd_make_section_with_flags (dynobj,
2684
                                                         ".rela.got",
2685
                                                         (SEC_ALLOC
2686
                                                          | SEC_LOAD
2687
                                                          | SEC_HAS_CONTENTS
2688
                                                          | SEC_IN_MEMORY
2689
                                                          | SEC_LINKER_CREATED
2690
                                                          | SEC_READONLY));
2691
                  if (srelgot == NULL
2692
                      || !bfd_set_section_alignment (dynobj, srelgot, 2))
2693
                    return FALSE;
2694
                }
2695
            }
2696
 
2697
          if (got == NULL)
2698
            {
2699
              struct elf_m68k_bfd2got_entry *bfd2got_entry;
2700
 
2701
              bfd2got_entry
2702
                = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
2703
                                              abfd, FIND_OR_CREATE, info);
2704
              if (bfd2got_entry == NULL)
2705
                return FALSE;
2706
 
2707
              got = bfd2got_entry->got;
2708
              BFD_ASSERT (got != NULL);
2709
            }
2710
 
2711
          {
2712
            struct elf_m68k_got_entry *got_entry;
2713
 
2714
            /* Add entry to got.  */
2715
            got_entry = elf_m68k_add_entry_to_got (got, h, abfd,
2716
                                                   ELF32_R_TYPE (rel->r_info),
2717
                                                   r_symndx, info);
2718
            if (got_entry == NULL)
2719
              return FALSE;
2720
 
2721
            if (got_entry->u.s1.refcount == 1)
2722
              {
2723
                /* Make sure this symbol is output as a dynamic symbol.  */
2724
                if (h != NULL
2725
                    && h->dynindx == -1
2726
                    && !h->forced_local)
2727
                  {
2728
                    if (!bfd_elf_link_record_dynamic_symbol (info, h))
2729
                      return FALSE;
2730
                  }
2731
              }
2732
          }
2733
 
2734
          break;
2735
 
2736
        case R_68K_PLT8:
2737
        case R_68K_PLT16:
2738
        case R_68K_PLT32:
2739
          /* This symbol requires a procedure linkage table entry.  We
2740
             actually build the entry in adjust_dynamic_symbol,
2741
             because this might be a case of linking PIC code which is
2742
             never referenced by a dynamic object, in which case we
2743
             don't need to generate a procedure linkage table entry
2744
             after all.  */
2745
 
2746
          /* If this is a local symbol, we resolve it directly without
2747
             creating a procedure linkage table entry.  */
2748
          if (h == NULL)
2749
            continue;
2750
 
2751
          h->needs_plt = 1;
2752
          h->plt.refcount++;
2753
          break;
2754
 
2755
        case R_68K_PLT8O:
2756
        case R_68K_PLT16O:
2757
        case R_68K_PLT32O:
2758
          /* This symbol requires a procedure linkage table entry.  */
2759
 
2760
          if (h == NULL)
2761
            {
2762
              /* It does not make sense to have this relocation for a
2763
                 local symbol.  FIXME: does it?  How to handle it if
2764
                 it does make sense?  */
2765
              bfd_set_error (bfd_error_bad_value);
2766
              return FALSE;
2767
            }
2768
 
2769
          /* Make sure this symbol is output as a dynamic symbol.  */
2770
          if (h->dynindx == -1
2771
              && !h->forced_local)
2772
            {
2773
              if (!bfd_elf_link_record_dynamic_symbol (info, h))
2774
                return FALSE;
2775
            }
2776
 
2777
          h->needs_plt = 1;
2778
          h->plt.refcount++;
2779
          break;
2780
 
2781
        case R_68K_PC8:
2782
        case R_68K_PC16:
2783
        case R_68K_PC32:
2784
          /* If we are creating a shared library and this is not a local
2785
             symbol, we need to copy the reloc into the shared library.
2786
             However when linking with -Bsymbolic and this is a global
2787
             symbol which is defined in an object we are including in the
2788
             link (i.e., DEF_REGULAR is set), then we can resolve the
2789
             reloc directly.  At this point we have not seen all the input
2790
             files, so it is possible that DEF_REGULAR is not set now but
2791
             will be set later (it is never cleared).  We account for that
2792
             possibility below by storing information in the
2793
             pcrel_relocs_copied field of the hash table entry.  */
2794
          if (!(info->shared
2795
                && (sec->flags & SEC_ALLOC) != 0
2796
                && h != NULL
2797
                && (!info->symbolic
2798
                    || h->root.type == bfd_link_hash_defweak
2799
                    || !h->def_regular)))
2800
            {
2801
              if (h != NULL)
2802
                {
2803
                  /* Make sure a plt entry is created for this symbol if
2804
                     it turns out to be a function defined by a dynamic
2805
                     object.  */
2806
                  h->plt.refcount++;
2807
                }
2808
              break;
2809
            }
2810
          /* Fall through.  */
2811
        case R_68K_8:
2812
        case R_68K_16:
2813
        case R_68K_32:
2814
          if (h != NULL)
2815
            {
2816
              /* Make sure a plt entry is created for this symbol if it
2817
                 turns out to be a function defined by a dynamic object.  */
2818
              h->plt.refcount++;
2819
 
2820
              if (!info->shared)
2821
                /* This symbol needs a non-GOT reference.  */
2822
                h->non_got_ref = 1;
2823
            }
2824
 
2825
          /* If we are creating a shared library, we need to copy the
2826
             reloc into the shared library.  */
2827
          if (info->shared
2828
              && (sec->flags & SEC_ALLOC) != 0)
2829
            {
2830
              /* When creating a shared object, we must copy these
2831
                 reloc types into the output file.  We create a reloc
2832
                 section in dynobj and make room for this reloc.  */
2833
              if (sreloc == NULL)
2834
                {
2835
                  sreloc = _bfd_elf_make_dynamic_reloc_section
2836
                    (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
2837
 
2838
                  if (sreloc == NULL)
2839
                    return FALSE;
2840
                }
2841
 
2842
              if (sec->flags & SEC_READONLY
2843
                  /* Don't set DF_TEXTREL yet for PC relative
2844
                     relocations, they might be discarded later.  */
2845
                  && !(ELF32_R_TYPE (rel->r_info) == R_68K_PC8
2846
                       || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
2847
                       || ELF32_R_TYPE (rel->r_info) == R_68K_PC32))
2848
                    info->flags |= DF_TEXTREL;
2849
 
2850
              sreloc->size += sizeof (Elf32_External_Rela);
2851
 
2852
              /* We count the number of PC relative relocations we have
2853
                 entered for this symbol, so that we can discard them
2854
                 again if, in the -Bsymbolic case, the symbol is later
2855
                 defined by a regular object, or, in the normal shared
2856
                 case, the symbol is forced to be local.  Note that this
2857
                 function is only called if we are using an m68kelf linker
2858
                 hash table, which means that h is really a pointer to an
2859
                 elf_m68k_link_hash_entry.  */
2860
              if (ELF32_R_TYPE (rel->r_info) == R_68K_PC8
2861
                  || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
2862
                  || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)
2863
                {
2864
                  struct elf_m68k_pcrel_relocs_copied *p;
2865
                  struct elf_m68k_pcrel_relocs_copied **head;
2866
 
2867
                  if (h != NULL)
2868
                    {
2869
                      struct elf_m68k_link_hash_entry *eh
2870
                        = elf_m68k_hash_entry (h);
2871
                      head = &eh->pcrel_relocs_copied;
2872
                    }
2873
                  else
2874
                    {
2875
                      asection *s;
2876
                      void *vpp;
2877
                      Elf_Internal_Sym *isym;
2878
 
2879
                      isym = bfd_sym_from_r_symndx (&elf_m68k_hash_table (info)->sym_cache,
2880
                                                    abfd, r_symndx);
2881
                      if (isym == NULL)
2882
                        return FALSE;
2883
 
2884
                      s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2885
                      if (s == NULL)
2886
                        s = sec;
2887
 
2888
                      vpp = &elf_section_data (s)->local_dynrel;
2889
                      head = (struct elf_m68k_pcrel_relocs_copied **) vpp;
2890
                    }
2891
 
2892
                  for (p = *head; p != NULL; p = p->next)
2893
                    if (p->section == sreloc)
2894
                      break;
2895
 
2896
                  if (p == NULL)
2897
                    {
2898
                      p = ((struct elf_m68k_pcrel_relocs_copied *)
2899
                           bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
2900
                      if (p == NULL)
2901
                        return FALSE;
2902
                      p->next = *head;
2903
                      *head = p;
2904
                      p->section = sreloc;
2905
                      p->count = 0;
2906
                    }
2907
 
2908
                  ++p->count;
2909
                }
2910
            }
2911
 
2912
          break;
2913
 
2914
          /* This relocation describes the C++ object vtable hierarchy.
2915
             Reconstruct it for later use during GC.  */
2916
        case R_68K_GNU_VTINHERIT:
2917
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2918
            return FALSE;
2919
          break;
2920
 
2921
          /* This relocation describes which C++ vtable entries are actually
2922
             used.  Record for later use during GC.  */
2923
        case R_68K_GNU_VTENTRY:
2924
          BFD_ASSERT (h != NULL);
2925
          if (h != NULL
2926
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2927
            return FALSE;
2928
          break;
2929
 
2930
        default:
2931
          break;
2932
        }
2933
    }
2934
 
2935
  return TRUE;
2936
}
2937
 
2938
/* Return the section that should be marked against GC for a given
2939
   relocation.  */
2940
 
2941
static asection *
2942
elf_m68k_gc_mark_hook (asection *sec,
2943
                       struct bfd_link_info *info,
2944
                       Elf_Internal_Rela *rel,
2945
                       struct elf_link_hash_entry *h,
2946
                       Elf_Internal_Sym *sym)
2947
{
2948
  if (h != NULL)
2949
    switch (ELF32_R_TYPE (rel->r_info))
2950
      {
2951
      case R_68K_GNU_VTINHERIT:
2952
      case R_68K_GNU_VTENTRY:
2953
        return NULL;
2954
      }
2955
 
2956
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2957
}
2958
 
2959
/* Update the got entry reference counts for the section being removed.  */
2960
 
2961
static bfd_boolean
2962
elf_m68k_gc_sweep_hook (bfd *abfd,
2963
                        struct bfd_link_info *info,
2964
                        asection *sec,
2965
                        const Elf_Internal_Rela *relocs)
2966
{
2967
  Elf_Internal_Shdr *symtab_hdr;
2968
  struct elf_link_hash_entry **sym_hashes;
2969
  const Elf_Internal_Rela *rel, *relend;
2970
  bfd *dynobj;
2971
  struct elf_m68k_got *got;
2972
 
2973
  if (info->relocatable)
2974
    return TRUE;
2975
 
2976
  dynobj = elf_hash_table (info)->dynobj;
2977
  if (dynobj == NULL)
2978
    return TRUE;
2979
 
2980
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2981
  sym_hashes = elf_sym_hashes (abfd);
2982
  got = NULL;
2983
 
2984
  relend = relocs + sec->reloc_count;
2985
  for (rel = relocs; rel < relend; rel++)
2986
    {
2987
      unsigned long r_symndx;
2988
      struct elf_link_hash_entry *h = NULL;
2989
 
2990
      r_symndx = ELF32_R_SYM (rel->r_info);
2991
      if (r_symndx >= symtab_hdr->sh_info)
2992
        {
2993
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2994
          while (h->root.type == bfd_link_hash_indirect
2995
                 || h->root.type == bfd_link_hash_warning)
2996
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
2997
        }
2998
 
2999
      switch (ELF32_R_TYPE (rel->r_info))
3000
        {
3001
        case R_68K_GOT8:
3002
        case R_68K_GOT16:
3003
        case R_68K_GOT32:
3004
          if (h != NULL
3005
              && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3006
            break;
3007
 
3008
          /* FALLTHRU */
3009
        case R_68K_GOT8O:
3010
        case R_68K_GOT16O:
3011
        case R_68K_GOT32O:
3012
          /* Fall through.  */
3013
 
3014
          /* TLS relocations.  */
3015
        case R_68K_TLS_GD8:
3016
        case R_68K_TLS_GD16:
3017
        case R_68K_TLS_GD32:
3018
        case R_68K_TLS_LDM8:
3019
        case R_68K_TLS_LDM16:
3020
        case R_68K_TLS_LDM32:
3021
        case R_68K_TLS_IE8:
3022
        case R_68K_TLS_IE16:
3023
        case R_68K_TLS_IE32:
3024
 
3025
        case R_68K_TLS_TPREL32:
3026
        case R_68K_TLS_DTPREL32:
3027
 
3028
          if (got == NULL)
3029
            {
3030
              got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3031
                                                abfd, MUST_FIND, NULL)->got;
3032
              BFD_ASSERT (got != NULL);
3033
            }
3034
 
3035
          {
3036
            struct elf_m68k_got_entry_key key_;
3037
            struct elf_m68k_got_entry **got_entry_ptr;
3038
            struct elf_m68k_got_entry *got_entry;
3039
 
3040
            elf_m68k_init_got_entry_key (&key_, h, abfd, r_symndx,
3041
                                         ELF32_R_TYPE (rel->r_info));
3042
            got_entry_ptr = elf_m68k_find_got_entry_ptr (got, &key_);
3043
 
3044
            got_entry = *got_entry_ptr;
3045
 
3046
            if (got_entry->u.s1.refcount > 0)
3047
              {
3048
                --got_entry->u.s1.refcount;
3049
 
3050
                if (got_entry->u.s1.refcount == 0)
3051
                  /* We don't need the .got entry any more.  */
3052
                  elf_m68k_remove_got_entry (got, got_entry_ptr);
3053
              }
3054
          }
3055
          break;
3056
 
3057
        case R_68K_PLT8:
3058
        case R_68K_PLT16:
3059
        case R_68K_PLT32:
3060
        case R_68K_PLT8O:
3061
        case R_68K_PLT16O:
3062
        case R_68K_PLT32O:
3063
        case R_68K_PC8:
3064
        case R_68K_PC16:
3065
        case R_68K_PC32:
3066
        case R_68K_8:
3067
        case R_68K_16:
3068
        case R_68K_32:
3069
          if (h != NULL)
3070
            {
3071
              if (h->plt.refcount > 0)
3072
                --h->plt.refcount;
3073
            }
3074
          break;
3075
 
3076
        default:
3077
          break;
3078
        }
3079
    }
3080
 
3081
  return TRUE;
3082
}
3083
 
3084
/* Return the type of PLT associated with OUTPUT_BFD.  */
3085
 
3086
static const struct elf_m68k_plt_info *
3087
elf_m68k_get_plt_info (bfd *output_bfd)
3088
{
3089
  unsigned int features;
3090
 
3091
  features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd));
3092
  if (features & cpu32)
3093
    return &elf_cpu32_plt_info;
3094
  if (features & mcfisa_b)
3095
    return &elf_isab_plt_info;
3096
  if (features & mcfisa_c)
3097
    return &elf_isac_plt_info;
3098
  return &elf_m68k_plt_info;
3099
}
3100
 
3101
/* This function is called after all the input files have been read,
3102
   and the input sections have been assigned to output sections.
3103
   It's a convenient place to determine the PLT style.  */
3104
 
3105
static bfd_boolean
3106
elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
3107
{
3108
  /* Bind input BFDs to GOTs and calculate sizes of .got and .rela.got
3109
     sections.  */
3110
  if (!elf_m68k_partition_multi_got (info))
3111
    return FALSE;
3112
 
3113
  elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd);
3114
  return TRUE;
3115
}
3116
 
3117
/* Adjust a symbol defined by a dynamic object and referenced by a
3118
   regular object.  The current definition is in some section of the
3119
   dynamic object, but we're not including those sections.  We have to
3120
   change the definition to something the rest of the link can
3121
   understand.  */
3122
 
3123
static bfd_boolean
3124
elf_m68k_adjust_dynamic_symbol (info, h)
3125
     struct bfd_link_info *info;
3126
     struct elf_link_hash_entry *h;
3127
{
3128
  struct elf_m68k_link_hash_table *htab;
3129
  bfd *dynobj;
3130
  asection *s;
3131
 
3132
  htab = elf_m68k_hash_table (info);
3133
  dynobj = elf_hash_table (info)->dynobj;
3134
 
3135
  /* Make sure we know what is going on here.  */
3136
  BFD_ASSERT (dynobj != NULL
3137
              && (h->needs_plt
3138
                  || h->u.weakdef != NULL
3139
                  || (h->def_dynamic
3140
                      && h->ref_regular
3141
                      && !h->def_regular)));
3142
 
3143
  /* If this is a function, put it in the procedure linkage table.  We
3144
     will fill in the contents of the procedure linkage table later,
3145
     when we know the address of the .got section.  */
3146
  if (h->type == STT_FUNC
3147
      || h->needs_plt)
3148
    {
3149
      if ((h->plt.refcount <= 0
3150
           || SYMBOL_CALLS_LOCAL (info, h)
3151
           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3152
               && h->root.type == bfd_link_hash_undefweak))
3153
          /* We must always create the plt entry if it was referenced
3154
             by a PLTxxO relocation.  In this case we already recorded
3155
             it as a dynamic symbol.  */
3156
          && h->dynindx == -1)
3157
        {
3158
          /* This case can occur if we saw a PLTxx reloc in an input
3159
             file, but the symbol was never referred to by a dynamic
3160
             object, or if all references were garbage collected.  In
3161
             such a case, we don't actually need to build a procedure
3162
             linkage table, and we can just do a PCxx reloc instead.  */
3163
          h->plt.offset = (bfd_vma) -1;
3164
          h->needs_plt = 0;
3165
          return TRUE;
3166
        }
3167
 
3168
      /* Make sure this symbol is output as a dynamic symbol.  */
3169
      if (h->dynindx == -1
3170
          && !h->forced_local)
3171
        {
3172
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
3173
            return FALSE;
3174
        }
3175
 
3176
      s = bfd_get_section_by_name (dynobj, ".plt");
3177
      BFD_ASSERT (s != NULL);
3178
 
3179
      /* If this is the first .plt entry, make room for the special
3180
         first entry.  */
3181
      if (s->size == 0)
3182
        s->size = htab->plt_info->size;
3183
 
3184
      /* If this symbol is not defined in a regular file, and we are
3185
         not generating a shared library, then set the symbol to this
3186
         location in the .plt.  This is required to make function
3187
         pointers compare as equal between the normal executable and
3188
         the shared library.  */
3189
      if (!info->shared
3190
          && !h->def_regular)
3191
        {
3192
          h->root.u.def.section = s;
3193
          h->root.u.def.value = s->size;
3194
        }
3195
 
3196
      h->plt.offset = s->size;
3197
 
3198
      /* Make room for this entry.  */
3199
      s->size += htab->plt_info->size;
3200
 
3201
      /* We also need to make an entry in the .got.plt section, which
3202
         will be placed in the .got section by the linker script.  */
3203
      s = bfd_get_section_by_name (dynobj, ".got.plt");
3204
      BFD_ASSERT (s != NULL);
3205
      s->size += 4;
3206
 
3207
      /* We also need to make an entry in the .rela.plt section.  */
3208
      s = bfd_get_section_by_name (dynobj, ".rela.plt");
3209
      BFD_ASSERT (s != NULL);
3210
      s->size += sizeof (Elf32_External_Rela);
3211
 
3212
      return TRUE;
3213
    }
3214
 
3215
  /* Reinitialize the plt offset now that it is not used as a reference
3216
     count any more.  */
3217
  h->plt.offset = (bfd_vma) -1;
3218
 
3219
  /* If this is a weak symbol, and there is a real definition, the
3220
     processor independent code will have arranged for us to see the
3221
     real definition first, and we can just use the same value.  */
3222
  if (h->u.weakdef != NULL)
3223
    {
3224
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3225
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
3226
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
3227
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
3228
      return TRUE;
3229
    }
3230
 
3231
  /* This is a reference to a symbol defined by a dynamic object which
3232
     is not a function.  */
3233
 
3234
  /* If we are creating a shared library, we must presume that the
3235
     only references to the symbol are via the global offset table.
3236
     For such cases we need not do anything here; the relocations will
3237
     be handled correctly by relocate_section.  */
3238
  if (info->shared)
3239
    return TRUE;
3240
 
3241
  /* If there are no references to this symbol that do not use the
3242
     GOT, we don't need to generate a copy reloc.  */
3243
  if (!h->non_got_ref)
3244
    return TRUE;
3245
 
3246
  if (h->size == 0)
3247
    {
3248
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
3249
                             h->root.root.string);
3250
      return TRUE;
3251
    }
3252
 
3253
  /* We must allocate the symbol in our .dynbss section, which will
3254
     become part of the .bss section of the executable.  There will be
3255
     an entry for this symbol in the .dynsym section.  The dynamic
3256
     object will contain position independent code, so all references
3257
     from the dynamic object to this symbol will go through the global
3258
     offset table.  The dynamic linker will use the .dynsym entry to
3259
     determine the address it must put in the global offset table, so
3260
     both the dynamic object and the regular object will refer to the
3261
     same memory location for the variable.  */
3262
 
3263
  s = bfd_get_section_by_name (dynobj, ".dynbss");
3264
  BFD_ASSERT (s != NULL);
3265
 
3266
  /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
3267
     copy the initial value out of the dynamic object and into the
3268
     runtime process image.  We need to remember the offset into the
3269
     .rela.bss section we are going to use.  */
3270
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3271
    {
3272
      asection *srel;
3273
 
3274
      srel = bfd_get_section_by_name (dynobj, ".rela.bss");
3275
      BFD_ASSERT (srel != NULL);
3276
      srel->size += sizeof (Elf32_External_Rela);
3277
      h->needs_copy = 1;
3278
    }
3279
 
3280
  return _bfd_elf_adjust_dynamic_copy (h, s);
3281
}
3282
 
3283
/* Set the sizes of the dynamic sections.  */
3284
 
3285
static bfd_boolean
3286
elf_m68k_size_dynamic_sections (output_bfd, info)
3287
     bfd *output_bfd ATTRIBUTE_UNUSED;
3288
     struct bfd_link_info *info;
3289
{
3290
  bfd *dynobj;
3291
  asection *s;
3292
  bfd_boolean plt;
3293
  bfd_boolean relocs;
3294
 
3295
  dynobj = elf_hash_table (info)->dynobj;
3296
  BFD_ASSERT (dynobj != NULL);
3297
 
3298
  if (elf_hash_table (info)->dynamic_sections_created)
3299
    {
3300
      /* Set the contents of the .interp section to the interpreter.  */
3301
      if (info->executable)
3302
        {
3303
          s = bfd_get_section_by_name (dynobj, ".interp");
3304
          BFD_ASSERT (s != NULL);
3305
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3306
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3307
        }
3308
    }
3309
  else
3310
    {
3311
      /* We may have created entries in the .rela.got section.
3312
         However, if we are not creating the dynamic sections, we will
3313
         not actually use these entries.  Reset the size of .rela.got,
3314
         which will cause it to get stripped from the output file
3315
         below.  */
3316
      s = bfd_get_section_by_name (dynobj, ".rela.got");
3317
      if (s != NULL)
3318
        s->size = 0;
3319
    }
3320
 
3321
  /* If this is a -Bsymbolic shared link, then we need to discard all
3322
     PC relative relocs against symbols defined in a regular object.
3323
     For the normal shared case we discard the PC relative relocs
3324
     against symbols that have become local due to visibility changes.
3325
     We allocated space for them in the check_relocs routine, but we
3326
     will not fill them in in the relocate_section routine.  */
3327
  if (info->shared)
3328
    elf_link_hash_traverse (elf_hash_table (info),
3329
                            elf_m68k_discard_copies,
3330
                            (PTR) info);
3331
 
3332
  /* The check_relocs and adjust_dynamic_symbol entry points have
3333
     determined the sizes of the various dynamic sections.  Allocate
3334
     memory for them.  */
3335
  plt = FALSE;
3336
  relocs = FALSE;
3337
  for (s = dynobj->sections; s != NULL; s = s->next)
3338
    {
3339
      const char *name;
3340
 
3341
      if ((s->flags & SEC_LINKER_CREATED) == 0)
3342
        continue;
3343
 
3344
      /* It's OK to base decisions on the section name, because none
3345
         of the dynobj section names depend upon the input files.  */
3346
      name = bfd_get_section_name (dynobj, s);
3347
 
3348
      if (strcmp (name, ".plt") == 0)
3349
        {
3350
          /* Remember whether there is a PLT.  */
3351
          plt = s->size != 0;
3352
        }
3353
      else if (CONST_STRNEQ (name, ".rela"))
3354
        {
3355
          if (s->size != 0)
3356
            {
3357
              relocs = TRUE;
3358
 
3359
              /* We use the reloc_count field as a counter if we need
3360
                 to copy relocs into the output file.  */
3361
              s->reloc_count = 0;
3362
            }
3363
        }
3364
      else if (! CONST_STRNEQ (name, ".got")
3365
               && strcmp (name, ".dynbss") != 0)
3366
        {
3367
          /* It's not one of our sections, so don't allocate space.  */
3368
          continue;
3369
        }
3370
 
3371
      if (s->size == 0)
3372
        {
3373
          /* If we don't need this section, strip it from the
3374
             output file.  This is mostly to handle .rela.bss and
3375
             .rela.plt.  We must create both sections in
3376
             create_dynamic_sections, because they must be created
3377
             before the linker maps input sections to output
3378
             sections.  The linker does that before
3379
             adjust_dynamic_symbol is called, and it is that
3380
             function which decides whether anything needs to go
3381
             into these sections.  */
3382
          s->flags |= SEC_EXCLUDE;
3383
          continue;
3384
        }
3385
 
3386
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
3387
        continue;
3388
 
3389
      /* Allocate memory for the section contents.  */
3390
      /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
3391
         Unused entries should be reclaimed before the section's contents
3392
         are written out, but at the moment this does not happen.  Thus in
3393
         order to prevent writing out garbage, we initialise the section's
3394
         contents to zero.  */
3395
      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3396
      if (s->contents == NULL)
3397
        return FALSE;
3398
    }
3399
 
3400
  if (elf_hash_table (info)->dynamic_sections_created)
3401
    {
3402
      /* Add some entries to the .dynamic section.  We fill in the
3403
         values later, in elf_m68k_finish_dynamic_sections, but we
3404
         must add the entries now so that we get the correct size for
3405
         the .dynamic section.  The DT_DEBUG entry is filled in by the
3406
         dynamic linker and used by the debugger.  */
3407
#define add_dynamic_entry(TAG, VAL) \
3408
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3409
 
3410
      if (!info->shared)
3411
        {
3412
          if (!add_dynamic_entry (DT_DEBUG, 0))
3413
            return FALSE;
3414
        }
3415
 
3416
      if (plt)
3417
        {
3418
          if (!add_dynamic_entry (DT_PLTGOT, 0)
3419
              || !add_dynamic_entry (DT_PLTRELSZ, 0)
3420
              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3421
              || !add_dynamic_entry (DT_JMPREL, 0))
3422
            return FALSE;
3423
        }
3424
 
3425
      if (relocs)
3426
        {
3427
          if (!add_dynamic_entry (DT_RELA, 0)
3428
              || !add_dynamic_entry (DT_RELASZ, 0)
3429
              || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3430
            return FALSE;
3431
        }
3432
 
3433
      if ((info->flags & DF_TEXTREL) != 0)
3434
        {
3435
          if (!add_dynamic_entry (DT_TEXTREL, 0))
3436
            return FALSE;
3437
        }
3438
    }
3439
#undef add_dynamic_entry
3440
 
3441
  return TRUE;
3442
}
3443
 
3444
/* This function is called via elf_link_hash_traverse if we are
3445
   creating a shared object.  In the -Bsymbolic case it discards the
3446
   space allocated to copy PC relative relocs against symbols which
3447
   are defined in regular objects.  For the normal shared case, it
3448
   discards space for pc-relative relocs that have become local due to
3449
   symbol visibility changes.  We allocated space for them in the
3450
   check_relocs routine, but we won't fill them in in the
3451
   relocate_section routine.
3452
 
3453
   We also check whether any of the remaining relocations apply
3454
   against a readonly section, and set the DF_TEXTREL flag in this
3455
   case.  */
3456
 
3457
static bfd_boolean
3458
elf_m68k_discard_copies (h, inf)
3459
     struct elf_link_hash_entry *h;
3460
     PTR inf;
3461
{
3462
  struct bfd_link_info *info = (struct bfd_link_info *) inf;
3463
  struct elf_m68k_pcrel_relocs_copied *s;
3464
 
3465
  if (h->root.type == bfd_link_hash_warning)
3466
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
3467
 
3468
  if (!SYMBOL_CALLS_LOCAL (info, h))
3469
    {
3470
      if ((info->flags & DF_TEXTREL) == 0)
3471
        {
3472
          /* Look for relocations against read-only sections.  */
3473
          for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3474
               s != NULL;
3475
               s = s->next)
3476
            if ((s->section->flags & SEC_READONLY) != 0)
3477
              {
3478
                info->flags |= DF_TEXTREL;
3479
                break;
3480
              }
3481
        }
3482
 
3483
      return TRUE;
3484
    }
3485
 
3486
  for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3487
       s != NULL;
3488
       s = s->next)
3489
    s->section->size -= s->count * sizeof (Elf32_External_Rela);
3490
 
3491
  return TRUE;
3492
}
3493
 
3494
 
3495
/* Install relocation RELA.  */
3496
 
3497
static void
3498
elf_m68k_install_rela (bfd *output_bfd,
3499
                       asection *srela,
3500
                       Elf_Internal_Rela *rela)
3501
{
3502
  bfd_byte *loc;
3503
 
3504
  loc = srela->contents;
3505
  loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3506
  bfd_elf32_swap_reloca_out (output_bfd, rela, loc);
3507
}
3508
 
3509
/* Find the base offsets for thread-local storage in this object,
3510
   for GD/LD and IE/LE respectively.  */
3511
 
3512
#define DTP_OFFSET 0x8000
3513
#define TP_OFFSET  0x7000
3514
 
3515
static bfd_vma
3516
dtpoff_base (struct bfd_link_info *info)
3517
{
3518
  /* If tls_sec is NULL, we should have signalled an error already.  */
3519
  if (elf_hash_table (info)->tls_sec == NULL)
3520
    return 0;
3521
  return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
3522
}
3523
 
3524
static bfd_vma
3525
tpoff_base (struct bfd_link_info *info)
3526
{
3527
  /* If tls_sec is NULL, we should have signalled an error already.  */
3528
  if (elf_hash_table (info)->tls_sec == NULL)
3529
    return 0;
3530
  return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
3531
}
3532
 
3533
/* Output necessary relocation to handle a symbol during static link.
3534
   This function is called from elf_m68k_relocate_section.  */
3535
 
3536
static void
3537
elf_m68k_init_got_entry_static (struct bfd_link_info *info,
3538
                                bfd *output_bfd,
3539
                                enum elf_m68k_reloc_type r_type,
3540
                                asection *sgot,
3541
                                bfd_vma got_entry_offset,
3542
                                bfd_vma relocation)
3543
{
3544
  switch (elf_m68k_reloc_got_type (r_type))
3545
    {
3546
    case R_68K_GOT32O:
3547
      bfd_put_32 (output_bfd, relocation, sgot->contents + got_entry_offset);
3548
      break;
3549
 
3550
    case R_68K_TLS_GD32:
3551
      /* We know the offset within the module,
3552
         put it into the second GOT slot.  */
3553
      bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3554
                  sgot->contents + got_entry_offset + 4);
3555
      /* FALLTHRU */
3556
 
3557
    case R_68K_TLS_LDM32:
3558
      /* Mark it as belonging to module 1, the executable.  */
3559
      bfd_put_32 (output_bfd, 1, sgot->contents + got_entry_offset);
3560
      break;
3561
 
3562
    case R_68K_TLS_IE32:
3563
      bfd_put_32 (output_bfd, relocation - tpoff_base (info),
3564
                  sgot->contents + got_entry_offset);
3565
      break;
3566
 
3567
    default:
3568
      BFD_ASSERT (FALSE);
3569
    }
3570
}
3571
 
3572
/* Output necessary relocation to handle a local symbol
3573
   during dynamic link.
3574
   This function is called either from elf_m68k_relocate_section
3575
   or from elf_m68k_finish_dynamic_symbol.  */
3576
 
3577
static void
3578
elf_m68k_init_got_entry_local_shared (struct bfd_link_info *info,
3579
                                      bfd *output_bfd,
3580
                                      enum elf_m68k_reloc_type r_type,
3581
                                      asection *sgot,
3582
                                      bfd_vma got_entry_offset,
3583
                                      bfd_vma relocation,
3584
                                      asection *srela)
3585
{
3586
  Elf_Internal_Rela outrel;
3587
 
3588
  switch (elf_m68k_reloc_got_type (r_type))
3589
    {
3590
    case R_68K_GOT32O:
3591
      /* Emit RELATIVE relocation to initialize GOT slot
3592
         at run-time.  */
3593
      outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
3594
      outrel.r_addend = relocation;
3595
      break;
3596
 
3597
    case R_68K_TLS_GD32:
3598
      /* We know the offset within the module,
3599
         put it into the second GOT slot.  */
3600
      bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3601
                  sgot->contents + got_entry_offset + 4);
3602
      /* FALLTHRU */
3603
 
3604
    case R_68K_TLS_LDM32:
3605
      /* We don't know the module number,
3606
         create a relocation for it.  */
3607
      outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_DTPMOD32);
3608
      outrel.r_addend = 0;
3609
      break;
3610
 
3611
    case R_68K_TLS_IE32:
3612
      /* Emit TPREL relocation to initialize GOT slot
3613
         at run-time.  */
3614
      outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_TPREL32);
3615
      outrel.r_addend = relocation - elf_hash_table (info)->tls_sec->vma;
3616
      break;
3617
 
3618
    default:
3619
      BFD_ASSERT (FALSE);
3620
    }
3621
 
3622
  /* Offset of the GOT entry.  */
3623
  outrel.r_offset = (sgot->output_section->vma
3624
                     + sgot->output_offset
3625
                     + got_entry_offset);
3626
 
3627
  /* Install one of the above relocations.  */
3628
  elf_m68k_install_rela (output_bfd, srela, &outrel);
3629
 
3630
  bfd_put_32 (output_bfd, outrel.r_addend, sgot->contents + got_entry_offset);
3631
}
3632
 
3633
/* Relocate an M68K ELF section.  */
3634
 
3635
static bfd_boolean
3636
elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section,
3637
                           contents, relocs, local_syms, local_sections)
3638
     bfd *output_bfd;
3639
     struct bfd_link_info *info;
3640
     bfd *input_bfd;
3641
     asection *input_section;
3642
     bfd_byte *contents;
3643
     Elf_Internal_Rela *relocs;
3644
     Elf_Internal_Sym *local_syms;
3645
     asection **local_sections;
3646
{
3647
  bfd *dynobj;
3648
  Elf_Internal_Shdr *symtab_hdr;
3649
  struct elf_link_hash_entry **sym_hashes;
3650
  asection *sgot;
3651
  asection *splt;
3652
  asection *sreloc;
3653
  asection *srela;
3654
  struct elf_m68k_got *got;
3655
  Elf_Internal_Rela *rel;
3656
  Elf_Internal_Rela *relend;
3657
 
3658
  dynobj = elf_hash_table (info)->dynobj;
3659
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3660
  sym_hashes = elf_sym_hashes (input_bfd);
3661
 
3662
  sgot = NULL;
3663
  splt = NULL;
3664
  sreloc = NULL;
3665
  srela = NULL;
3666
 
3667
  got = NULL;
3668
 
3669
  rel = relocs;
3670
  relend = relocs + input_section->reloc_count;
3671
  for (; rel < relend; rel++)
3672
    {
3673
      int r_type;
3674
      reloc_howto_type *howto;
3675
      unsigned long r_symndx;
3676
      struct elf_link_hash_entry *h;
3677
      Elf_Internal_Sym *sym;
3678
      asection *sec;
3679
      bfd_vma relocation;
3680
      bfd_boolean unresolved_reloc;
3681
      bfd_reloc_status_type r;
3682
 
3683
      r_type = ELF32_R_TYPE (rel->r_info);
3684
      if (r_type < 0 || r_type >= (int) R_68K_max)
3685
        {
3686
          bfd_set_error (bfd_error_bad_value);
3687
          return FALSE;
3688
        }
3689
      howto = howto_table + r_type;
3690
 
3691
      r_symndx = ELF32_R_SYM (rel->r_info);
3692
 
3693
      h = NULL;
3694
      sym = NULL;
3695
      sec = NULL;
3696
      unresolved_reloc = FALSE;
3697
 
3698
      if (r_symndx < symtab_hdr->sh_info)
3699
        {
3700
          sym = local_syms + r_symndx;
3701
          sec = local_sections[r_symndx];
3702
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3703
        }
3704
      else
3705
        {
3706
          bfd_boolean warned;
3707
 
3708
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3709
                                   r_symndx, symtab_hdr, sym_hashes,
3710
                                   h, sec, relocation,
3711
                                   unresolved_reloc, warned);
3712
        }
3713
 
3714
      if (sec != NULL && elf_discarded_section (sec))
3715
        {
3716
          /* For relocs against symbols from removed linkonce sections,
3717
             or sections discarded by a linker script, we just want the
3718
             section contents zeroed.  Avoid any special processing.  */
3719
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
3720
          rel->r_info = 0;
3721
          rel->r_addend = 0;
3722
          continue;
3723
        }
3724
 
3725
      if (info->relocatable)
3726
        continue;
3727
 
3728
      switch (r_type)
3729
        {
3730
        case R_68K_GOT8:
3731
        case R_68K_GOT16:
3732
        case R_68K_GOT32:
3733
          /* Relocation is to the address of the entry for this symbol
3734
             in the global offset table.  */
3735
          if (h != NULL
3736
              && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3737
            {
3738
              if (elf_m68k_hash_table (info)->local_gp_p)
3739
                {
3740
                  bfd_vma sgot_output_offset;
3741
                  bfd_vma got_offset;
3742
 
3743
                  if (sgot == NULL)
3744
                    {
3745
                      sgot = bfd_get_section_by_name (dynobj, ".got");
3746
 
3747
                      if (sgot != NULL)
3748
                        sgot_output_offset = sgot->output_offset;
3749
                      else
3750
                        /* In this case we have a reference to
3751
                           _GLOBAL_OFFSET_TABLE_, but the GOT itself is
3752
                           empty.
3753
                           ??? Issue a warning?  */
3754
                        sgot_output_offset = 0;
3755
                    }
3756
                  else
3757
                    sgot_output_offset = sgot->output_offset;
3758
 
3759
                  if (got == NULL)
3760
                    {
3761
                      struct elf_m68k_bfd2got_entry *bfd2got_entry;
3762
 
3763
                      bfd2got_entry
3764
                        = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3765
                                                      input_bfd, SEARCH, NULL);
3766
 
3767
                      if (bfd2got_entry != NULL)
3768
                        {
3769
                          got = bfd2got_entry->got;
3770
                          BFD_ASSERT (got != NULL);
3771
 
3772
                          got_offset = got->offset;
3773
                        }
3774
                      else
3775
                        /* In this case we have a reference to
3776
                           _GLOBAL_OFFSET_TABLE_, but no other references
3777
                           accessing any GOT entries.
3778
                           ??? Issue a warning?  */
3779
                        got_offset = 0;
3780
                    }
3781
                  else
3782
                    got_offset = got->offset;
3783
 
3784
                  /* Adjust GOT pointer to point to the GOT
3785
                     assigned to input_bfd.  */
3786
                  rel->r_addend += sgot_output_offset + got_offset;
3787
                }
3788
              else
3789
                BFD_ASSERT (got == NULL || got->offset == 0);
3790
 
3791
              break;
3792
            }
3793
          /* Fall through.  */
3794
        case R_68K_GOT8O:
3795
        case R_68K_GOT16O:
3796
        case R_68K_GOT32O:
3797
 
3798
        case R_68K_TLS_LDM32:
3799
        case R_68K_TLS_LDM16:
3800
        case R_68K_TLS_LDM8:
3801
 
3802
        case R_68K_TLS_GD8:
3803
        case R_68K_TLS_GD16:
3804
        case R_68K_TLS_GD32:
3805
 
3806
        case R_68K_TLS_IE8:
3807
        case R_68K_TLS_IE16:
3808
        case R_68K_TLS_IE32:
3809
 
3810
          /* Relocation is the offset of the entry for this symbol in
3811
             the global offset table.  */
3812
 
3813
          {
3814
            struct elf_m68k_got_entry_key key_;
3815
            bfd_vma *off_ptr;
3816
            bfd_vma off;
3817
 
3818
            if (sgot == NULL)
3819
              {
3820
                sgot = bfd_get_section_by_name (dynobj, ".got");
3821
                BFD_ASSERT (sgot != NULL);
3822
              }
3823
 
3824
            if (got == NULL)
3825
              {
3826
                got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3827
                                                  input_bfd, MUST_FIND,
3828
                                                  NULL)->got;
3829
                BFD_ASSERT (got != NULL);
3830
              }
3831
 
3832
            /* Get GOT offset for this symbol.  */
3833
            elf_m68k_init_got_entry_key (&key_, h, input_bfd, r_symndx,
3834
                                         r_type);
3835
            off_ptr = &elf_m68k_get_got_entry (got, &key_, MUST_FIND,
3836
                                               NULL)->u.s2.offset;
3837
            off = *off_ptr;
3838
 
3839
            /* The offset must always be a multiple of 4.  We use
3840
               the least significant bit to record whether we have
3841
               already generated the necessary reloc.  */
3842
            if ((off & 1) != 0)
3843
              off &= ~1;
3844
            else
3845
              {
3846
                if (h != NULL
3847
                    /* @TLSLDM relocations are bounded to the module, in
3848
                       which the symbol is defined -- not to the symbol
3849
                       itself.  */
3850
                    && elf_m68k_reloc_got_type (r_type) != R_68K_TLS_LDM32)
3851
                  {
3852
                    bfd_boolean dyn;
3853
 
3854
                    dyn = elf_hash_table (info)->dynamic_sections_created;
3855
                    if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3856
                        || (info->shared
3857
                            && SYMBOL_REFERENCES_LOCAL (info, h))
3858
                        || (ELF_ST_VISIBILITY (h->other)
3859
                            && h->root.type == bfd_link_hash_undefweak))
3860
                      {
3861
                        /* This is actually a static link, or it is a
3862
                           -Bsymbolic link and the symbol is defined
3863
                           locally, or the symbol was forced to be local
3864
                           because of a version file.  We must initialize
3865
                           this entry in the global offset table.  Since
3866
                           the offset must always be a multiple of 4, we
3867
                           use the least significant bit to record whether
3868
                           we have initialized it already.
3869
 
3870
                           When doing a dynamic link, we create a .rela.got
3871
                           relocation entry to initialize the value.  This
3872
                           is done in the finish_dynamic_symbol routine.  */
3873
 
3874
                        elf_m68k_init_got_entry_static (info,
3875
                                                        output_bfd,
3876
                                                        r_type,
3877
                                                        sgot,
3878
                                                        off,
3879
                                                        relocation);
3880
 
3881
                        *off_ptr |= 1;
3882
                      }
3883
                    else
3884
                      unresolved_reloc = FALSE;
3885
                  }
3886
                else if (info->shared) /* && h == NULL */
3887
                  /* Process local symbol during dynamic link.  */
3888
                  {
3889
                    if (srela == NULL)
3890
                      {
3891
                        srela = bfd_get_section_by_name (dynobj, ".rela.got");
3892
                        BFD_ASSERT (srela != NULL);
3893
                      }
3894
 
3895
                    elf_m68k_init_got_entry_local_shared (info,
3896
                                                          output_bfd,
3897
                                                          r_type,
3898
                                                          sgot,
3899
                                                          off,
3900
                                                          relocation,
3901
                                                          srela);
3902
 
3903
                    *off_ptr |= 1;
3904
                  }
3905
                else /* h == NULL && !info->shared */
3906
                  {
3907
                    elf_m68k_init_got_entry_static (info,
3908
                                                    output_bfd,
3909
                                                    r_type,
3910
                                                    sgot,
3911
                                                    off,
3912
                                                    relocation);
3913
 
3914
                    *off_ptr |= 1;
3915
                  }
3916
              }
3917
 
3918
            /* We don't use elf_m68k_reloc_got_type in the condition below
3919
               because this is the only place where difference between
3920
               R_68K_GOTx and R_68K_GOTxO relocations matters.  */
3921
            if (r_type == R_68K_GOT32O
3922
                || r_type == R_68K_GOT16O
3923
                || r_type == R_68K_GOT8O
3924
                || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_GD32
3925
                || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_LDM32
3926
                || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_IE32)
3927
              {
3928
                /* GOT pointer is adjusted to point to the start/middle
3929
                   of local GOT.  Adjust the offset accordingly.  */
3930
                BFD_ASSERT (elf_m68k_hash_table (info)->use_neg_got_offsets_p
3931
                            || off >= got->offset);
3932
 
3933
                if (elf_m68k_hash_table (info)->local_gp_p)
3934
                  relocation = off - got->offset;
3935
                else
3936
                  {
3937
                    BFD_ASSERT (got->offset == 0);
3938
                    relocation = sgot->output_offset + off;
3939
                  }
3940
 
3941
                /* This relocation does not use the addend.  */
3942
                rel->r_addend = 0;
3943
              }
3944
            else
3945
              relocation = (sgot->output_section->vma + sgot->output_offset
3946
                            + off);
3947
          }
3948
          break;
3949
 
3950
        case R_68K_TLS_LDO32:
3951
        case R_68K_TLS_LDO16:
3952
        case R_68K_TLS_LDO8:
3953
          relocation -= dtpoff_base (info);
3954
          break;
3955
 
3956
        case R_68K_TLS_LE32:
3957
        case R_68K_TLS_LE16:
3958
        case R_68K_TLS_LE8:
3959
          if (info->shared)
3960
            {
3961
              (*_bfd_error_handler)
3962
                (_("%B(%A+0x%lx): R_68K_TLS_LE32 relocation not permitted "
3963
                   "in shared object"),
3964
                 input_bfd, input_section, (long) rel->r_offset, howto->name);
3965
 
3966
              return FALSE;
3967
            }
3968
          else
3969
            relocation -= tpoff_base (info);
3970
 
3971
          break;
3972
 
3973
        case R_68K_PLT8:
3974
        case R_68K_PLT16:
3975
        case R_68K_PLT32:
3976
          /* Relocation is to the entry for this symbol in the
3977
             procedure linkage table.  */
3978
 
3979
          /* Resolve a PLTxx reloc against a local symbol directly,
3980
             without using the procedure linkage table.  */
3981
          if (h == NULL)
3982
            break;
3983
 
3984
          if (h->plt.offset == (bfd_vma) -1
3985
              || !elf_hash_table (info)->dynamic_sections_created)
3986
            {
3987
              /* We didn't make a PLT entry for this symbol.  This
3988
                 happens when statically linking PIC code, or when
3989
                 using -Bsymbolic.  */
3990
              break;
3991
            }
3992
 
3993
          if (splt == NULL)
3994
            {
3995
              splt = bfd_get_section_by_name (dynobj, ".plt");
3996
              BFD_ASSERT (splt != NULL);
3997
            }
3998
 
3999
          relocation = (splt->output_section->vma
4000
                        + splt->output_offset
4001
                        + h->plt.offset);
4002
          unresolved_reloc = FALSE;
4003
          break;
4004
 
4005
        case R_68K_PLT8O:
4006
        case R_68K_PLT16O:
4007
        case R_68K_PLT32O:
4008
          /* Relocation is the offset of the entry for this symbol in
4009
             the procedure linkage table.  */
4010
          BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
4011
 
4012
          if (splt == NULL)
4013
            {
4014
              splt = bfd_get_section_by_name (dynobj, ".plt");
4015
              BFD_ASSERT (splt != NULL);
4016
            }
4017
 
4018
          relocation = h->plt.offset;
4019
          unresolved_reloc = FALSE;
4020
 
4021
          /* This relocation does not use the addend.  */
4022
          rel->r_addend = 0;
4023
 
4024
          break;
4025
 
4026
        case R_68K_8:
4027
        case R_68K_16:
4028
        case R_68K_32:
4029
        case R_68K_PC8:
4030
        case R_68K_PC16:
4031
        case R_68K_PC32:
4032
          if (info->shared
4033
              && r_symndx != 0
4034
              && (input_section->flags & SEC_ALLOC) != 0
4035
              && (h == NULL
4036
                  || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4037
                  || h->root.type != bfd_link_hash_undefweak)
4038
              && ((r_type != R_68K_PC8
4039
                   && r_type != R_68K_PC16
4040
                   && r_type != R_68K_PC32)
4041
                  || !SYMBOL_CALLS_LOCAL (info, h)))
4042
            {
4043
              Elf_Internal_Rela outrel;
4044
              bfd_byte *loc;
4045
              bfd_boolean skip, relocate;
4046
 
4047
              /* When generating a shared object, these relocations
4048
                 are copied into the output file to be resolved at run
4049
                 time.  */
4050
 
4051
              skip = FALSE;
4052
              relocate = FALSE;
4053
 
4054
              outrel.r_offset =
4055
                _bfd_elf_section_offset (output_bfd, info, input_section,
4056
                                         rel->r_offset);
4057
              if (outrel.r_offset == (bfd_vma) -1)
4058
                skip = TRUE;
4059
              else if (outrel.r_offset == (bfd_vma) -2)
4060
                skip = TRUE, relocate = TRUE;
4061
              outrel.r_offset += (input_section->output_section->vma
4062
                                  + input_section->output_offset);
4063
 
4064
              if (skip)
4065
                memset (&outrel, 0, sizeof outrel);
4066
              else if (h != NULL
4067
                       && h->dynindx != -1
4068
                       && (r_type == R_68K_PC8
4069
                           || r_type == R_68K_PC16
4070
                           || r_type == R_68K_PC32
4071
                           || !info->shared
4072
                           || !info->symbolic
4073
                           || !h->def_regular))
4074
                {
4075
                  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4076
                  outrel.r_addend = rel->r_addend;
4077
                }
4078
              else
4079
                {
4080
                  /* This symbol is local, or marked to become local.  */
4081
                  outrel.r_addend = relocation + rel->r_addend;
4082
 
4083
                  if (r_type == R_68K_32)
4084
                    {
4085
                      relocate = TRUE;
4086
                      outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
4087
                    }
4088
                  else
4089
                    {
4090
                      long indx;
4091
 
4092
                      if (bfd_is_abs_section (sec))
4093
                        indx = 0;
4094
                      else if (sec == NULL || sec->owner == NULL)
4095
                        {
4096
                          bfd_set_error (bfd_error_bad_value);
4097
                          return FALSE;
4098
                        }
4099
                      else
4100
                        {
4101
                          asection *osec;
4102
 
4103
                          /* We are turning this relocation into one
4104
                             against a section symbol.  It would be
4105
                             proper to subtract the symbol's value,
4106
                             osec->vma, from the emitted reloc addend,
4107
                             but ld.so expects buggy relocs.  */
4108
                          osec = sec->output_section;
4109
                          indx = elf_section_data (osec)->dynindx;
4110
                          if (indx == 0)
4111
                            {
4112
                              struct elf_link_hash_table *htab;
4113
                              htab = elf_hash_table (info);
4114
                              osec = htab->text_index_section;
4115
                              indx = elf_section_data (osec)->dynindx;
4116
                            }
4117
                          BFD_ASSERT (indx != 0);
4118
                        }
4119
 
4120
                      outrel.r_info = ELF32_R_INFO (indx, r_type);
4121
                    }
4122
                }
4123
 
4124
              sreloc = elf_section_data (input_section)->sreloc;
4125
              if (sreloc == NULL)
4126
                abort ();
4127
 
4128
              loc = sreloc->contents;
4129
              loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4130
              bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4131
 
4132
              /* This reloc will be computed at runtime, so there's no
4133
                 need to do anything now, except for R_68K_32
4134
                 relocations that have been turned into
4135
                 R_68K_RELATIVE.  */
4136
              if (!relocate)
4137
                continue;
4138
            }
4139
 
4140
          break;
4141
 
4142
        case R_68K_GNU_VTINHERIT:
4143
        case R_68K_GNU_VTENTRY:
4144
          /* These are no-ops in the end.  */
4145
          continue;
4146
 
4147
        default:
4148
          break;
4149
        }
4150
 
4151
      /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4152
         because such sections are not SEC_ALLOC and thus ld.so will
4153
         not process them.  */
4154
      if (unresolved_reloc
4155
          && !((input_section->flags & SEC_DEBUGGING) != 0
4156
               && h->def_dynamic))
4157
        {
4158
          (*_bfd_error_handler)
4159
            (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4160
             input_bfd,
4161
             input_section,
4162
             (long) rel->r_offset,
4163
             howto->name,
4164
             h->root.root.string);
4165
          return FALSE;
4166
        }
4167
 
4168
      if (r_symndx != 0
4169
          && r_type != R_68K_NONE
4170
          && (h == NULL
4171
              || h->root.type == bfd_link_hash_defined
4172
              || h->root.type == bfd_link_hash_defweak))
4173
        {
4174
          char sym_type;
4175
 
4176
          sym_type = (sym != NULL) ? ELF32_ST_TYPE (sym->st_info) : h->type;
4177
 
4178
          if (elf_m68k_reloc_tls_p (r_type) != (sym_type == STT_TLS))
4179
            {
4180
              const char *name;
4181
 
4182
              if (h != NULL)
4183
                name = h->root.root.string;
4184
              else
4185
                {
4186
                  name = (bfd_elf_string_from_elf_section
4187
                          (input_bfd, symtab_hdr->sh_link, sym->st_name));
4188
                  if (name == NULL || *name == '\0')
4189
                    name = bfd_section_name (input_bfd, sec);
4190
                }
4191
 
4192
              (*_bfd_error_handler)
4193
                ((sym_type == STT_TLS
4194
                  ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
4195
                  : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
4196
                 input_bfd,
4197
                 input_section,
4198
                 (long) rel->r_offset,
4199
                 howto->name,
4200
                 name);
4201
            }
4202
        }
4203
 
4204
      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4205
                                    contents, rel->r_offset,
4206
                                    relocation, rel->r_addend);
4207
 
4208
      if (r != bfd_reloc_ok)
4209
        {
4210
          const char *name;
4211
 
4212
          if (h != NULL)
4213
            name = h->root.root.string;
4214
          else
4215
            {
4216
              name = bfd_elf_string_from_elf_section (input_bfd,
4217
                                                      symtab_hdr->sh_link,
4218
                                                      sym->st_name);
4219
              if (name == NULL)
4220
                return FALSE;
4221
              if (*name == '\0')
4222
                name = bfd_section_name (input_bfd, sec);
4223
            }
4224
 
4225
          if (r == bfd_reloc_overflow)
4226
            {
4227
              if (!(info->callbacks->reloc_overflow
4228
                    (info, (h ? &h->root : NULL), name, howto->name,
4229
                     (bfd_vma) 0, input_bfd, input_section,
4230
                     rel->r_offset)))
4231
                return FALSE;
4232
            }
4233
          else
4234
            {
4235
              (*_bfd_error_handler)
4236
                (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4237
                 input_bfd, input_section,
4238
                 (long) rel->r_offset, name, (int) r);
4239
              return FALSE;
4240
            }
4241
        }
4242
    }
4243
 
4244
  return TRUE;
4245
}
4246
 
4247
/* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
4248
   into section SEC.  */
4249
 
4250
static void
4251
elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value)
4252
{
4253
  /* Make VALUE PC-relative.  */
4254
  value -= sec->output_section->vma + offset;
4255
 
4256
  /* Apply any in-place addend.  */
4257
  value += bfd_get_32 (sec->owner, sec->contents + offset);
4258
 
4259
  bfd_put_32 (sec->owner, value, sec->contents + offset);
4260
}
4261
 
4262
/* Finish up dynamic symbol handling.  We set the contents of various
4263
   dynamic sections here.  */
4264
 
4265
static bfd_boolean
4266
elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym)
4267
     bfd *output_bfd;
4268
     struct bfd_link_info *info;
4269
     struct elf_link_hash_entry *h;
4270
     Elf_Internal_Sym *sym;
4271
{
4272
  bfd *dynobj;
4273
 
4274
  dynobj = elf_hash_table (info)->dynobj;
4275
 
4276
  if (h->plt.offset != (bfd_vma) -1)
4277
    {
4278
      const struct elf_m68k_plt_info *plt_info;
4279
      asection *splt;
4280
      asection *sgot;
4281
      asection *srela;
4282
      bfd_vma plt_index;
4283
      bfd_vma got_offset;
4284
      Elf_Internal_Rela rela;
4285
      bfd_byte *loc;
4286
 
4287
      /* This symbol has an entry in the procedure linkage table.  Set
4288
         it up.  */
4289
 
4290
      BFD_ASSERT (h->dynindx != -1);
4291
 
4292
      plt_info = elf_m68k_hash_table (info)->plt_info;
4293
      splt = bfd_get_section_by_name (dynobj, ".plt");
4294
      sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4295
      srela = bfd_get_section_by_name (dynobj, ".rela.plt");
4296
      BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
4297
 
4298
      /* Get the index in the procedure linkage table which
4299
         corresponds to this symbol.  This is the index of this symbol
4300
         in all the symbols for which we are making plt entries.  The
4301
         first entry in the procedure linkage table is reserved.  */
4302
      plt_index = (h->plt.offset / plt_info->size) - 1;
4303
 
4304
      /* Get the offset into the .got table of the entry that
4305
         corresponds to this function.  Each .got entry is 4 bytes.
4306
         The first three are reserved.  */
4307
      got_offset = (plt_index + 3) * 4;
4308
 
4309
      memcpy (splt->contents + h->plt.offset,
4310
              plt_info->symbol_entry,
4311
              plt_info->size);
4312
 
4313
      elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got,
4314
                             (sgot->output_section->vma
4315
                              + sgot->output_offset
4316
                              + got_offset));
4317
 
4318
      bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4319
                  splt->contents
4320
                  + h->plt.offset
4321
                  + plt_info->symbol_resolve_entry + 2);
4322
 
4323
      elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt,
4324
                             splt->output_section->vma);
4325
 
4326
      /* Fill in the entry in the global offset table.  */
4327
      bfd_put_32 (output_bfd,
4328
                  (splt->output_section->vma
4329
                   + splt->output_offset
4330
                   + h->plt.offset
4331
                   + plt_info->symbol_resolve_entry),
4332
                  sgot->contents + got_offset);
4333
 
4334
      /* Fill in the entry in the .rela.plt section.  */
4335
      rela.r_offset = (sgot->output_section->vma
4336
                       + sgot->output_offset
4337
                       + got_offset);
4338
      rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
4339
      rela.r_addend = 0;
4340
      loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
4341
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4342
 
4343
      if (!h->def_regular)
4344
        {
4345
          /* Mark the symbol as undefined, rather than as defined in
4346
             the .plt section.  Leave the value alone.  */
4347
          sym->st_shndx = SHN_UNDEF;
4348
        }
4349
    }
4350
 
4351
  if (elf_m68k_hash_entry (h)->glist != NULL)
4352
    {
4353
      asection *sgot;
4354
      asection *srela;
4355
      struct elf_m68k_got_entry *got_entry;
4356
 
4357
      /* This symbol has an entry in the global offset table.  Set it
4358
         up.  */
4359
 
4360
      sgot = bfd_get_section_by_name (dynobj, ".got");
4361
      srela = bfd_get_section_by_name (dynobj, ".rela.got");
4362
      BFD_ASSERT (sgot != NULL && srela != NULL);
4363
 
4364
      got_entry = elf_m68k_hash_entry (h)->glist;
4365
 
4366
      while (got_entry != NULL)
4367
        {
4368
          enum elf_m68k_reloc_type r_type;
4369
          bfd_vma got_entry_offset;
4370
 
4371
          r_type = got_entry->key_.type;
4372
          got_entry_offset = got_entry->u.s2.offset &~ (bfd_vma) 1;
4373
 
4374
          /* If this is a -Bsymbolic link, and the symbol is defined
4375
             locally, we just want to emit a RELATIVE reloc.  Likewise if
4376
             the symbol was forced to be local because of a version file.
4377
             The entry in the global offset table already have been
4378
             initialized in the relocate_section function.  */
4379
          if (info->shared
4380
              && SYMBOL_REFERENCES_LOCAL (info, h))
4381
            {
4382
              bfd_vma relocation;
4383
 
4384
              relocation = bfd_get_signed_32 (output_bfd,
4385
                                              (sgot->contents
4386
                                               + got_entry_offset));
4387
 
4388
              /* Undo TP bias.  */
4389
              switch (elf_m68k_reloc_got_type (r_type))
4390
                {
4391
                case R_68K_GOT32O:
4392
                case R_68K_TLS_LDM32:
4393
                  break;
4394
 
4395
                case R_68K_TLS_GD32:
4396
                  relocation += dtpoff_base (info);
4397
                  break;
4398
 
4399
                case R_68K_TLS_IE32:
4400
                  relocation += tpoff_base (info);
4401
                  break;
4402
 
4403
                default:
4404
                  BFD_ASSERT (FALSE);
4405
                }
4406
 
4407
              elf_m68k_init_got_entry_local_shared (info,
4408
                                                    output_bfd,
4409
                                                    r_type,
4410
                                                    sgot,
4411
                                                    got_entry_offset,
4412
                                                    relocation,
4413
                                                    srela);
4414
            }
4415
          else
4416
            {
4417
              Elf_Internal_Rela rela;
4418
 
4419
              /* Put zeros to GOT slots that will be initialized
4420
                 at run-time.  */
4421
              {
4422
                bfd_vma n_slots;
4423
 
4424
                n_slots = elf_m68k_reloc_got_n_slots (got_entry->key_.type);
4425
                while (n_slots--)
4426
                  bfd_put_32 (output_bfd, (bfd_vma) 0,
4427
                              (sgot->contents + got_entry_offset
4428
                               + 4 * n_slots));
4429
              }
4430
 
4431
              rela.r_addend = 0;
4432
              rela.r_offset = (sgot->output_section->vma
4433
                               + sgot->output_offset
4434
                               + got_entry_offset);
4435
 
4436
              switch (elf_m68k_reloc_got_type (r_type))
4437
                {
4438
                case R_68K_GOT32O:
4439
                  rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
4440
                  elf_m68k_install_rela (output_bfd, srela, &rela);
4441
                  break;
4442
 
4443
                case R_68K_TLS_GD32:
4444
                  rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_DTPMOD32);
4445
                  elf_m68k_install_rela (output_bfd, srela, &rela);
4446
 
4447
                  rela.r_offset += 4;
4448
                  rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_DTPREL32);
4449
                  elf_m68k_install_rela (output_bfd, srela, &rela);
4450
                  break;
4451
 
4452
                case R_68K_TLS_IE32:
4453
                  rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_TPREL32);
4454
                  elf_m68k_install_rela (output_bfd, srela, &rela);
4455
                  break;
4456
 
4457
                default:
4458
                  BFD_ASSERT (FALSE);
4459
                  break;
4460
                }
4461
            }
4462
 
4463
          got_entry = got_entry->u.s2.next;
4464
        }
4465
    }
4466
 
4467
  if (h->needs_copy)
4468
    {
4469
      asection *s;
4470
      Elf_Internal_Rela rela;
4471
      bfd_byte *loc;
4472
 
4473
      /* This symbol needs a copy reloc.  Set it up.  */
4474
 
4475
      BFD_ASSERT (h->dynindx != -1
4476
                  && (h->root.type == bfd_link_hash_defined
4477
                      || h->root.type == bfd_link_hash_defweak));
4478
 
4479
      s = bfd_get_section_by_name (h->root.u.def.section->owner,
4480
                                   ".rela.bss");
4481
      BFD_ASSERT (s != NULL);
4482
 
4483
      rela.r_offset = (h->root.u.def.value
4484
                       + h->root.u.def.section->output_section->vma
4485
                       + h->root.u.def.section->output_offset);
4486
      rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
4487
      rela.r_addend = 0;
4488
      loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
4489
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4490
    }
4491
 
4492
  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
4493
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4494
      || h == elf_hash_table (info)->hgot)
4495
    sym->st_shndx = SHN_ABS;
4496
 
4497
  return TRUE;
4498
}
4499
 
4500
/* Finish up the dynamic sections.  */
4501
 
4502
static bfd_boolean
4503
elf_m68k_finish_dynamic_sections (output_bfd, info)
4504
     bfd *output_bfd;
4505
     struct bfd_link_info *info;
4506
{
4507
  bfd *dynobj;
4508
  asection *sgot;
4509
  asection *sdyn;
4510
 
4511
  dynobj = elf_hash_table (info)->dynobj;
4512
 
4513
  sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4514
  BFD_ASSERT (sgot != NULL);
4515
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4516
 
4517
  if (elf_hash_table (info)->dynamic_sections_created)
4518
    {
4519
      asection *splt;
4520
      Elf32_External_Dyn *dyncon, *dynconend;
4521
 
4522
      splt = bfd_get_section_by_name (dynobj, ".plt");
4523
      BFD_ASSERT (splt != NULL && sdyn != NULL);
4524
 
4525
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
4526
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4527
      for (; dyncon < dynconend; dyncon++)
4528
        {
4529
          Elf_Internal_Dyn dyn;
4530
          const char *name;
4531
          asection *s;
4532
 
4533
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4534
 
4535
          switch (dyn.d_tag)
4536
            {
4537
            default:
4538
              break;
4539
 
4540
            case DT_PLTGOT:
4541
              name = ".got";
4542
              goto get_vma;
4543
            case DT_JMPREL:
4544
              name = ".rela.plt";
4545
            get_vma:
4546
              s = bfd_get_section_by_name (output_bfd, name);
4547
              BFD_ASSERT (s != NULL);
4548
              dyn.d_un.d_ptr = s->vma;
4549
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4550
              break;
4551
 
4552
            case DT_PLTRELSZ:
4553
              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4554
              BFD_ASSERT (s != NULL);
4555
              dyn.d_un.d_val = s->size;
4556
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4557
              break;
4558
 
4559
            case DT_RELASZ:
4560
              /* The procedure linkage table relocs (DT_JMPREL) should
4561
                 not be included in the overall relocs (DT_RELA).
4562
                 Therefore, we override the DT_RELASZ entry here to
4563
                 make it not include the JMPREL relocs.  Since the
4564
                 linker script arranges for .rela.plt to follow all
4565
                 other relocation sections, we don't have to worry
4566
                 about changing the DT_RELA entry.  */
4567
              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4568
              if (s != NULL)
4569
                dyn.d_un.d_val -= s->size;
4570
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4571
              break;
4572
            }
4573
        }
4574
 
4575
      /* Fill in the first entry in the procedure linkage table.  */
4576
      if (splt->size > 0)
4577
        {
4578
          const struct elf_m68k_plt_info *plt_info;
4579
 
4580
          plt_info = elf_m68k_hash_table (info)->plt_info;
4581
          memcpy (splt->contents, plt_info->plt0_entry, plt_info->size);
4582
 
4583
          elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4,
4584
                                 (sgot->output_section->vma
4585
                                  + sgot->output_offset
4586
                                  + 4));
4587
 
4588
          elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8,
4589
                                 (sgot->output_section->vma
4590
                                  + sgot->output_offset
4591
                                  + 8));
4592
 
4593
          elf_section_data (splt->output_section)->this_hdr.sh_entsize
4594
            = plt_info->size;
4595
        }
4596
    }
4597
 
4598
  /* Fill in the first three entries in the global offset table.  */
4599
  if (sgot->size > 0)
4600
    {
4601
      if (sdyn == NULL)
4602
        bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4603
      else
4604
        bfd_put_32 (output_bfd,
4605
                    sdyn->output_section->vma + sdyn->output_offset,
4606
                    sgot->contents);
4607
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4608
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4609
    }
4610
 
4611
  elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4612
 
4613
  return TRUE;
4614
}
4615
 
4616
/* Given a .data section and a .emreloc in-memory section, store
4617
   relocation information into the .emreloc section which can be
4618
   used at runtime to relocate the section.  This is called by the
4619
   linker when the --embedded-relocs switch is used.  This is called
4620
   after the add_symbols entry point has been called for all the
4621
   objects, and before the final_link entry point is called.  */
4622
 
4623
bfd_boolean
4624
bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
4625
     bfd *abfd;
4626
     struct bfd_link_info *info;
4627
     asection *datasec;
4628
     asection *relsec;
4629
     char **errmsg;
4630
{
4631
  Elf_Internal_Shdr *symtab_hdr;
4632
  Elf_Internal_Sym *isymbuf = NULL;
4633
  Elf_Internal_Rela *internal_relocs = NULL;
4634
  Elf_Internal_Rela *irel, *irelend;
4635
  bfd_byte *p;
4636
  bfd_size_type amt;
4637
 
4638
  BFD_ASSERT (! info->relocatable);
4639
 
4640
  *errmsg = NULL;
4641
 
4642
  if (datasec->reloc_count == 0)
4643
    return TRUE;
4644
 
4645
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4646
 
4647
  /* Get a copy of the native relocations.  */
4648
  internal_relocs = (_bfd_elf_link_read_relocs
4649
                     (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
4650
                      info->keep_memory));
4651
  if (internal_relocs == NULL)
4652
    goto error_return;
4653
 
4654
  amt = (bfd_size_type) datasec->reloc_count * 12;
4655
  relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
4656
  if (relsec->contents == NULL)
4657
    goto error_return;
4658
 
4659
  p = relsec->contents;
4660
 
4661
  irelend = internal_relocs + datasec->reloc_count;
4662
  for (irel = internal_relocs; irel < irelend; irel++, p += 12)
4663
    {
4664
      asection *targetsec;
4665
 
4666
      /* We are going to write a four byte longword into the runtime
4667
       reloc section.  The longword will be the address in the data
4668
       section which must be relocated.  It is followed by the name
4669
       of the target section NUL-padded or truncated to 8
4670
       characters.  */
4671
 
4672
      /* We can only relocate absolute longword relocs at run time.  */
4673
      if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
4674
        {
4675
          *errmsg = _("unsupported reloc type");
4676
          bfd_set_error (bfd_error_bad_value);
4677
          goto error_return;
4678
        }
4679
 
4680
      /* Get the target section referred to by the reloc.  */
4681
      if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
4682
        {
4683
          /* A local symbol.  */
4684
          Elf_Internal_Sym *isym;
4685
 
4686
          /* Read this BFD's local symbols if we haven't done so already.  */
4687
          if (isymbuf == NULL)
4688
            {
4689
              isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4690
              if (isymbuf == NULL)
4691
                isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
4692
                                                symtab_hdr->sh_info, 0,
4693
                                                NULL, NULL, NULL);
4694
              if (isymbuf == NULL)
4695
                goto error_return;
4696
            }
4697
 
4698
          isym = isymbuf + ELF32_R_SYM (irel->r_info);
4699
          targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
4700
        }
4701
      else
4702
        {
4703
          unsigned long indx;
4704
          struct elf_link_hash_entry *h;
4705
 
4706
          /* An external symbol.  */
4707
          indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
4708
          h = elf_sym_hashes (abfd)[indx];
4709
          BFD_ASSERT (h != NULL);
4710
          if (h->root.type == bfd_link_hash_defined
4711
              || h->root.type == bfd_link_hash_defweak)
4712
            targetsec = h->root.u.def.section;
4713
          else
4714
            targetsec = NULL;
4715
        }
4716
 
4717
      bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
4718
      memset (p + 4, 0, 8);
4719
      if (targetsec != NULL)
4720
        strncpy ((char *) p + 4, targetsec->output_section->name, 8);
4721
    }
4722
 
4723
  if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4724
    free (isymbuf);
4725
  if (internal_relocs != NULL
4726
      && elf_section_data (datasec)->relocs != internal_relocs)
4727
    free (internal_relocs);
4728
  return TRUE;
4729
 
4730
error_return:
4731
  if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4732
    free (isymbuf);
4733
  if (internal_relocs != NULL
4734
      && elf_section_data (datasec)->relocs != internal_relocs)
4735
    free (internal_relocs);
4736
  return FALSE;
4737
}
4738
 
4739
/* Set target options.  */
4740
 
4741
void
4742
bfd_elf_m68k_set_target_options (struct bfd_link_info *info, int got_handling)
4743
{
4744
  struct elf_m68k_link_hash_table *htab;
4745
 
4746
  htab = elf_m68k_hash_table (info);
4747
 
4748
  switch (got_handling)
4749
    {
4750
    case 0:
4751
      /* --got=single.  */
4752
      htab->local_gp_p = FALSE;
4753
      htab->use_neg_got_offsets_p = FALSE;
4754
      htab->allow_multigot_p = FALSE;
4755
      break;
4756
 
4757
    case 1:
4758
      /* --got=negative.  */
4759
      htab->local_gp_p = TRUE;
4760
      htab->use_neg_got_offsets_p = TRUE;
4761
      htab->allow_multigot_p = FALSE;
4762
      break;
4763
 
4764
    case 2:
4765
      /* --got=multigot.  */
4766
      htab->local_gp_p = TRUE;
4767
      htab->use_neg_got_offsets_p = TRUE;
4768
      htab->allow_multigot_p = TRUE;
4769
      break;
4770
 
4771
    default:
4772
      BFD_ASSERT (FALSE);
4773
    }
4774
}
4775
 
4776
static enum elf_reloc_type_class
4777
elf32_m68k_reloc_type_class (rela)
4778
     const Elf_Internal_Rela *rela;
4779
{
4780
  switch ((int) ELF32_R_TYPE (rela->r_info))
4781
    {
4782
    case R_68K_RELATIVE:
4783
      return reloc_class_relative;
4784
    case R_68K_JMP_SLOT:
4785
      return reloc_class_plt;
4786
    case R_68K_COPY:
4787
      return reloc_class_copy;
4788
    default:
4789
      return reloc_class_normal;
4790
    }
4791
}
4792
 
4793
/* Return address for Ith PLT stub in section PLT, for relocation REL
4794
   or (bfd_vma) -1 if it should not be included.  */
4795
 
4796
static bfd_vma
4797
elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
4798
                      const arelent *rel ATTRIBUTE_UNUSED)
4799
{
4800
  return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
4801
}
4802
 
4803
#define TARGET_BIG_SYM                  bfd_elf32_m68k_vec
4804
#define TARGET_BIG_NAME                 "elf32-m68k"
4805
#define ELF_MACHINE_CODE                EM_68K
4806
#define ELF_MAXPAGESIZE                 0x2000
4807
#define elf_backend_create_dynamic_sections \
4808
                                        _bfd_elf_create_dynamic_sections
4809
#define bfd_elf32_bfd_link_hash_table_create \
4810
                                        elf_m68k_link_hash_table_create
4811
/* ??? Should it be this macro or bfd_elfNN_bfd_link_hash_table_create?  */
4812
#define bfd_elf32_bfd_link_hash_table_free \
4813
                                        elf_m68k_link_hash_table_free
4814
#define bfd_elf32_bfd_final_link        bfd_elf_final_link
4815
 
4816
#define elf_backend_check_relocs        elf_m68k_check_relocs
4817
#define elf_backend_always_size_sections \
4818
                                        elf_m68k_always_size_sections
4819
#define elf_backend_adjust_dynamic_symbol \
4820
                                        elf_m68k_adjust_dynamic_symbol
4821
#define elf_backend_size_dynamic_sections \
4822
                                        elf_m68k_size_dynamic_sections
4823
#define elf_backend_final_write_processing      elf_m68k_final_write_processing
4824
#define elf_backend_init_index_section  _bfd_elf_init_1_index_section
4825
#define elf_backend_relocate_section    elf_m68k_relocate_section
4826
#define elf_backend_finish_dynamic_symbol \
4827
                                        elf_m68k_finish_dynamic_symbol
4828
#define elf_backend_finish_dynamic_sections \
4829
                                        elf_m68k_finish_dynamic_sections
4830
#define elf_backend_gc_mark_hook        elf_m68k_gc_mark_hook
4831
#define elf_backend_gc_sweep_hook       elf_m68k_gc_sweep_hook
4832
#define elf_backend_copy_indirect_symbol elf_m68k_copy_indirect_symbol
4833
#define bfd_elf32_bfd_merge_private_bfd_data \
4834
                                        elf32_m68k_merge_private_bfd_data
4835
#define bfd_elf32_bfd_set_private_flags \
4836
                                        elf32_m68k_set_private_flags
4837
#define bfd_elf32_bfd_print_private_bfd_data \
4838
                                        elf32_m68k_print_private_bfd_data
4839
#define elf_backend_reloc_type_class    elf32_m68k_reloc_type_class
4840
#define elf_backend_plt_sym_val         elf_m68k_plt_sym_val
4841
#define elf_backend_object_p            elf32_m68k_object_p
4842
 
4843
#define elf_backend_can_gc_sections 1
4844
#define elf_backend_can_refcount 1
4845
#define elf_backend_want_got_plt 1
4846
#define elf_backend_plt_readonly 1
4847
#define elf_backend_want_plt_sym 0
4848
#define elf_backend_got_header_size     12
4849
#define elf_backend_rela_normal         1
4850
 
4851
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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