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