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