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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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