projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* elfcode.h (elf_checksum_contents): Free contents.
[deliverable/binutils-gdb.git] / bfd / elf32-m68k.c
1 /* Motorola 68k series support for 32-bit ELF
2 Copyright 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #include "elf-bfd.h"
28 #include "elf/m68k.h"
29 #include "opcode/m68k.h"
30
31 static bfd_boolean
32 elf_m68k_discard_copies (struct elf_link_hash_entry *, void *);
33
34 static reloc_howto_type howto_table[] =
35 {
36 HOWTO(R_68K_NONE, 0, 0, 0, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_NONE", FALSE, 0, 0x00000000,FALSE),
37 HOWTO(R_68K_32, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_32", FALSE, 0, 0xffffffff,FALSE),
38 HOWTO(R_68K_16, 0, 1,16, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_16", FALSE, 0, 0x0000ffff,FALSE),
39 HOWTO(R_68K_8, 0, 0, 8, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_8", FALSE, 0, 0x000000ff,FALSE),
40 HOWTO(R_68K_PC32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PC32", FALSE, 0, 0xffffffff,TRUE),
41 HOWTO(R_68K_PC16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PC16", FALSE, 0, 0x0000ffff,TRUE),
42 HOWTO(R_68K_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PC8", FALSE, 0, 0x000000ff,TRUE),
43 HOWTO(R_68K_GOT32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32", FALSE, 0, 0xffffffff,TRUE),
44 HOWTO(R_68K_GOT16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT16", FALSE, 0, 0x0000ffff,TRUE),
45 HOWTO(R_68K_GOT8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT8", FALSE, 0, 0x000000ff,TRUE),
46 HOWTO(R_68K_GOT32O, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32O", FALSE, 0, 0xffffffff,FALSE),
47 HOWTO(R_68K_GOT16O, 0, 1,16, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT16O", FALSE, 0, 0x0000ffff,FALSE),
48 HOWTO(R_68K_GOT8O, 0, 0, 8, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT8O", FALSE, 0, 0x000000ff,FALSE),
49 HOWTO(R_68K_PLT32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32", FALSE, 0, 0xffffffff,TRUE),
50 HOWTO(R_68K_PLT16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT16", FALSE, 0, 0x0000ffff,TRUE),
51 HOWTO(R_68K_PLT8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT8", FALSE, 0, 0x000000ff,TRUE),
52 HOWTO(R_68K_PLT32O, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32O", FALSE, 0, 0xffffffff,FALSE),
53 HOWTO(R_68K_PLT16O, 0, 1,16, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT16O", FALSE, 0, 0x0000ffff,FALSE),
54 HOWTO(R_68K_PLT8O, 0, 0, 8, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT8O", FALSE, 0, 0x000000ff,FALSE),
55 HOWTO(R_68K_COPY, 0, 0, 0, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_COPY", FALSE, 0, 0xffffffff,FALSE),
56 HOWTO(R_68K_GLOB_DAT, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_GLOB_DAT", FALSE, 0, 0xffffffff,FALSE),
57 HOWTO(R_68K_JMP_SLOT, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_JMP_SLOT", FALSE, 0, 0xffffffff,FALSE),
58 HOWTO(R_68K_RELATIVE, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_RELATIVE", FALSE, 0, 0xffffffff,FALSE),
59 /* GNU extension to record C++ vtable hierarchy. */
60 HOWTO (R_68K_GNU_VTINHERIT, /* type */
61 0, /* rightshift */
62 2, /* size (0 = byte, 1 = short, 2 = long) */
63 0, /* bitsize */
64 FALSE, /* pc_relative */
65 0, /* bitpos */
66 complain_overflow_dont, /* complain_on_overflow */
67 NULL, /* special_function */
68 "R_68K_GNU_VTINHERIT", /* name */
69 FALSE, /* partial_inplace */
70 0, /* src_mask */
71 0, /* dst_mask */
72 FALSE),
73 /* GNU extension to record C++ vtable member usage. */
74 HOWTO (R_68K_GNU_VTENTRY, /* type */
75 0, /* rightshift */
76 2, /* size (0 = byte, 1 = short, 2 = long) */
77 0, /* bitsize */
78 FALSE, /* pc_relative */
79 0, /* bitpos */
80 complain_overflow_dont, /* complain_on_overflow */
81 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
82 "R_68K_GNU_VTENTRY", /* name */
83 FALSE, /* partial_inplace */
84 0, /* src_mask */
85 0, /* dst_mask */
86 FALSE),
87
88 /* TLS general dynamic variable reference. */
89 HOWTO (R_68K_TLS_GD32, /* type */
90 0, /* rightshift */
91 2, /* size (0 = byte, 1 = short, 2 = long) */
92 32, /* bitsize */
93 FALSE, /* pc_relative */
94 0, /* bitpos */
95 complain_overflow_bitfield, /* complain_on_overflow */
96 bfd_elf_generic_reloc, /* special_function */
97 "R_68K_TLS_GD32", /* name */
98 FALSE, /* partial_inplace */
99 0, /* src_mask */
100 0xffffffff, /* dst_mask */
101 FALSE), /* pcrel_offset */
102
103 HOWTO (R_68K_TLS_GD16, /* type */
104 0, /* rightshift */
105 1, /* size (0 = byte, 1 = short, 2 = long) */
106 16, /* bitsize */
107 FALSE, /* pc_relative */
108 0, /* bitpos */
109 complain_overflow_signed, /* complain_on_overflow */
110 bfd_elf_generic_reloc, /* special_function */
111 "R_68K_TLS_GD16", /* name */
112 FALSE, /* partial_inplace */
113 0, /* src_mask */
114 0x0000ffff, /* dst_mask */
115 FALSE), /* pcrel_offset */
116
117 HOWTO (R_68K_TLS_GD8, /* type */
118 0, /* rightshift */
119 0, /* size (0 = byte, 1 = short, 2 = long) */
120 8, /* bitsize */
121 FALSE, /* pc_relative */
122 0, /* bitpos */
123 complain_overflow_signed, /* complain_on_overflow */
124 bfd_elf_generic_reloc, /* special_function */
125 "R_68K_TLS_GD8", /* name */
126 FALSE, /* partial_inplace */
127 0, /* src_mask */
128 0x000000ff, /* dst_mask */
129 FALSE), /* pcrel_offset */
130
131 /* TLS local dynamic variable reference. */
132 HOWTO (R_68K_TLS_LDM32, /* type */
133 0, /* rightshift */
134 2, /* size (0 = byte, 1 = short, 2 = long) */
135 32, /* bitsize */
136 FALSE, /* pc_relative */
137 0, /* bitpos */
138 complain_overflow_bitfield, /* complain_on_overflow */
139 bfd_elf_generic_reloc, /* special_function */
140 "R_68K_TLS_LDM32", /* name */
141 FALSE, /* partial_inplace */
142 0, /* src_mask */
143 0xffffffff, /* dst_mask */
144 FALSE), /* pcrel_offset */
145
146 HOWTO (R_68K_TLS_LDM16, /* type */
147 0, /* rightshift */
148 1, /* size (0 = byte, 1 = short, 2 = long) */
149 16, /* bitsize */
150 FALSE, /* pc_relative */
151 0, /* bitpos */
152 complain_overflow_signed, /* complain_on_overflow */
153 bfd_elf_generic_reloc, /* special_function */
154 "R_68K_TLS_LDM16", /* name */
155 FALSE, /* partial_inplace */
156 0, /* src_mask */
157 0x0000ffff, /* dst_mask */
158 FALSE), /* pcrel_offset */
159
160 HOWTO (R_68K_TLS_LDM8, /* type */
161 0, /* rightshift */
162 0, /* size (0 = byte, 1 = short, 2 = long) */
163 8, /* bitsize */
164 FALSE, /* pc_relative */
165 0, /* bitpos */
166 complain_overflow_signed, /* complain_on_overflow */
167 bfd_elf_generic_reloc, /* special_function */
168 "R_68K_TLS_LDM8", /* name */
169 FALSE, /* partial_inplace */
170 0, /* src_mask */
171 0x000000ff, /* dst_mask */
172 FALSE), /* pcrel_offset */
173
174 HOWTO (R_68K_TLS_LDO32, /* type */
175 0, /* rightshift */
176 2, /* size (0 = byte, 1 = short, 2 = long) */
177 32, /* bitsize */
178 FALSE, /* pc_relative */
179 0, /* bitpos */
180 complain_overflow_bitfield, /* complain_on_overflow */
181 bfd_elf_generic_reloc, /* special_function */
182 "R_68K_TLS_LDO32", /* name */
183 FALSE, /* partial_inplace */
184 0, /* src_mask */
185 0xffffffff, /* dst_mask */
186 FALSE), /* pcrel_offset */
187
188 HOWTO (R_68K_TLS_LDO16, /* type */
189 0, /* rightshift */
190 1, /* size (0 = byte, 1 = short, 2 = long) */
191 16, /* bitsize */
192 FALSE, /* pc_relative */
193 0, /* bitpos */
194 complain_overflow_signed, /* complain_on_overflow */
195 bfd_elf_generic_reloc, /* special_function */
196 "R_68K_TLS_LDO16", /* name */
197 FALSE, /* partial_inplace */
198 0, /* src_mask */
199 0x0000ffff, /* dst_mask */
200 FALSE), /* pcrel_offset */
201
202 HOWTO (R_68K_TLS_LDO8, /* type */
203 0, /* rightshift */
204 0, /* size (0 = byte, 1 = short, 2 = long) */
205 8, /* bitsize */
206 FALSE, /* pc_relative */
207 0, /* bitpos */
208 complain_overflow_signed, /* complain_on_overflow */
209 bfd_elf_generic_reloc, /* special_function */
210 "R_68K_TLS_LDO8", /* name */
211 FALSE, /* partial_inplace */
212 0, /* src_mask */
213 0x000000ff, /* dst_mask */
214 FALSE), /* pcrel_offset */
215
216 /* TLS initial execution variable reference. */
217 HOWTO (R_68K_TLS_IE32, /* type */
218 0, /* rightshift */
219 2, /* size (0 = byte, 1 = short, 2 = long) */
220 32, /* bitsize */
221 FALSE, /* pc_relative */
222 0, /* bitpos */
223 complain_overflow_bitfield, /* complain_on_overflow */
224 bfd_elf_generic_reloc, /* special_function */
225 "R_68K_TLS_IE32", /* name */
226 FALSE, /* partial_inplace */
227 0, /* src_mask */
228 0xffffffff, /* dst_mask */
229 FALSE), /* pcrel_offset */
230
231 HOWTO (R_68K_TLS_IE16, /* type */
232 0, /* rightshift */
233 1, /* size (0 = byte, 1 = short, 2 = long) */
234 16, /* bitsize */
235 FALSE, /* pc_relative */
236 0, /* bitpos */
237 complain_overflow_signed, /* complain_on_overflow */
238 bfd_elf_generic_reloc, /* special_function */
239 "R_68K_TLS_IE16", /* name */
240 FALSE, /* partial_inplace */
241 0, /* src_mask */
242 0x0000ffff, /* dst_mask */
243 FALSE), /* pcrel_offset */
244
245 HOWTO (R_68K_TLS_IE8, /* type */
246 0, /* rightshift */
247 0, /* size (0 = byte, 1 = short, 2 = long) */
248 8, /* bitsize */
249 FALSE, /* pc_relative */
250 0, /* bitpos */
251 complain_overflow_signed, /* complain_on_overflow */
252 bfd_elf_generic_reloc, /* special_function */
253 "R_68K_TLS_IE8", /* name */
254 FALSE, /* partial_inplace */
255 0, /* src_mask */
256 0x000000ff, /* dst_mask */
257 FALSE), /* pcrel_offset */
258
259 /* TLS local execution variable reference. */
260 HOWTO (R_68K_TLS_LE32, /* type */
261 0, /* rightshift */
262 2, /* size (0 = byte, 1 = short, 2 = long) */
263 32, /* bitsize */
264 FALSE, /* pc_relative */
265 0, /* bitpos */
266 complain_overflow_bitfield, /* complain_on_overflow */
267 bfd_elf_generic_reloc, /* special_function */
268 "R_68K_TLS_LE32", /* name */
269 FALSE, /* partial_inplace */
270 0, /* src_mask */
271 0xffffffff, /* dst_mask */
272 FALSE), /* pcrel_offset */
273
274 HOWTO (R_68K_TLS_LE16, /* type */
275 0, /* rightshift */
276 1, /* size (0 = byte, 1 = short, 2 = long) */
277 16, /* bitsize */
278 FALSE, /* pc_relative */
279 0, /* bitpos */
280 complain_overflow_signed, /* complain_on_overflow */
281 bfd_elf_generic_reloc, /* special_function */
282 "R_68K_TLS_LE16", /* name */
283 FALSE, /* partial_inplace */
284 0, /* src_mask */
285 0x0000ffff, /* dst_mask */
286 FALSE), /* pcrel_offset */
287
288 HOWTO (R_68K_TLS_LE8, /* type */
289 0, /* rightshift */
290 0, /* size (0 = byte, 1 = short, 2 = long) */
291 8, /* bitsize */
292 FALSE, /* pc_relative */
293 0, /* bitpos */
294 complain_overflow_signed, /* complain_on_overflow */
295 bfd_elf_generic_reloc, /* special_function */
296 "R_68K_TLS_LE8", /* name */
297 FALSE, /* partial_inplace */
298 0, /* src_mask */
299 0x000000ff, /* dst_mask */
300 FALSE), /* pcrel_offset */
301
302 /* TLS GD/LD dynamic relocations. */
303 HOWTO (R_68K_TLS_DTPMOD32, /* type */
304 0, /* rightshift */
305 2, /* size (0 = byte, 1 = short, 2 = long) */
306 32, /* bitsize */
307 FALSE, /* pc_relative */
308 0, /* bitpos */
309 complain_overflow_dont, /* complain_on_overflow */
310 bfd_elf_generic_reloc, /* special_function */
311 "R_68K_TLS_DTPMOD32", /* name */
312 FALSE, /* partial_inplace */
313 0, /* src_mask */
314 0xffffffff, /* dst_mask */
315 FALSE), /* pcrel_offset */
316
317 HOWTO (R_68K_TLS_DTPREL32, /* type */
318 0, /* rightshift */
319 2, /* size (0 = byte, 1 = short, 2 = long) */
320 32, /* bitsize */
321 FALSE, /* pc_relative */
322 0, /* bitpos */
323 complain_overflow_dont, /* complain_on_overflow */
324 bfd_elf_generic_reloc, /* special_function */
325 "R_68K_TLS_DTPREL32", /* name */
326 FALSE, /* partial_inplace */
327 0, /* src_mask */
328 0xffffffff, /* dst_mask */
329 FALSE), /* pcrel_offset */
330
331 HOWTO (R_68K_TLS_TPREL32, /* type */
332 0, /* rightshift */
333 2, /* size (0 = byte, 1 = short, 2 = long) */
334 32, /* bitsize */
335 FALSE, /* pc_relative */
336 0, /* bitpos */
337 complain_overflow_dont, /* complain_on_overflow */
338 bfd_elf_generic_reloc, /* special_function */
339 "R_68K_TLS_TPREL32", /* name */
340 FALSE, /* partial_inplace */
341 0, /* src_mask */
342 0xffffffff, /* dst_mask */
343 FALSE), /* pcrel_offset */
344 };
345
346 static void
347 rtype_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
348 {
349 unsigned int indx = ELF32_R_TYPE (dst->r_info);
350
351 if (indx >= (unsigned int) R_68K_max)
352 {
353 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
354 abfd, (int) indx);
355 indx = R_68K_NONE;
356 }
357 cache_ptr->howto = &howto_table[indx];
358 }
359
360 #define elf_info_to_howto rtype_to_howto
361
362 static const struct
363 {
364 bfd_reloc_code_real_type bfd_val;
365 int elf_val;
366 }
367 reloc_map[] =
368 {
369 { BFD_RELOC_NONE, R_68K_NONE },
370 { BFD_RELOC_32, R_68K_32 },
371 { BFD_RELOC_16, R_68K_16 },
372 { BFD_RELOC_8, R_68K_8 },
373 { BFD_RELOC_32_PCREL, R_68K_PC32 },
374 { BFD_RELOC_16_PCREL, R_68K_PC16 },
375 { BFD_RELOC_8_PCREL, R_68K_PC8 },
376 { BFD_RELOC_32_GOT_PCREL, R_68K_GOT32 },
377 { BFD_RELOC_16_GOT_PCREL, R_68K_GOT16 },
378 { BFD_RELOC_8_GOT_PCREL, R_68K_GOT8 },
379 { BFD_RELOC_32_GOTOFF, R_68K_GOT32O },
380 { BFD_RELOC_16_GOTOFF, R_68K_GOT16O },
381 { BFD_RELOC_8_GOTOFF, R_68K_GOT8O },
382 { BFD_RELOC_32_PLT_PCREL, R_68K_PLT32 },
383 { BFD_RELOC_16_PLT_PCREL, R_68K_PLT16 },
384 { BFD_RELOC_8_PLT_PCREL, R_68K_PLT8 },
385 { BFD_RELOC_32_PLTOFF, R_68K_PLT32O },
386 { BFD_RELOC_16_PLTOFF, R_68K_PLT16O },
387 { BFD_RELOC_8_PLTOFF, R_68K_PLT8O },
388 { BFD_RELOC_NONE, R_68K_COPY },
389 { BFD_RELOC_68K_GLOB_DAT, R_68K_GLOB_DAT },
390 { BFD_RELOC_68K_JMP_SLOT, R_68K_JMP_SLOT },
391 { BFD_RELOC_68K_RELATIVE, R_68K_RELATIVE },
392 { BFD_RELOC_CTOR, R_68K_32 },
393 { BFD_RELOC_VTABLE_INHERIT, R_68K_GNU_VTINHERIT },
394 { BFD_RELOC_VTABLE_ENTRY, R_68K_GNU_VTENTRY },
395 { BFD_RELOC_68K_TLS_GD32, R_68K_TLS_GD32 },
396 { BFD_RELOC_68K_TLS_GD16, R_68K_TLS_GD16 },
397 { BFD_RELOC_68K_TLS_GD8, R_68K_TLS_GD8 },
398 { BFD_RELOC_68K_TLS_LDM32, R_68K_TLS_LDM32 },
399 { BFD_RELOC_68K_TLS_LDM16, R_68K_TLS_LDM16 },
400 { BFD_RELOC_68K_TLS_LDM8, R_68K_TLS_LDM8 },
401 { BFD_RELOC_68K_TLS_LDO32, R_68K_TLS_LDO32 },
402 { BFD_RELOC_68K_TLS_LDO16, R_68K_TLS_LDO16 },
403 { BFD_RELOC_68K_TLS_LDO8, R_68K_TLS_LDO8 },
404 { BFD_RELOC_68K_TLS_IE32, R_68K_TLS_IE32 },
405 { BFD_RELOC_68K_TLS_IE16, R_68K_TLS_IE16 },
406 { BFD_RELOC_68K_TLS_IE8, R_68K_TLS_IE8 },
407 { BFD_RELOC_68K_TLS_LE32, R_68K_TLS_LE32 },
408 { BFD_RELOC_68K_TLS_LE16, R_68K_TLS_LE16 },
409 { BFD_RELOC_68K_TLS_LE8, R_68K_TLS_LE8 },
410 };
411
412 static reloc_howto_type *
413 reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
414 bfd_reloc_code_real_type code)
415 {
416 unsigned int i;
417 for (i = 0; i < sizeof (reloc_map) / sizeof (reloc_map[0]); i++)
418 {
419 if (reloc_map[i].bfd_val == code)
420 return &howto_table[reloc_map[i].elf_val];
421 }
422 return 0;
423 }
424
425 static reloc_howto_type *
426 reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
427 {
428 unsigned int i;
429
430 for (i = 0; i < sizeof (howto_table) / sizeof (howto_table[0]); i++)
431 if (howto_table[i].name != NULL
432 && strcasecmp (howto_table[i].name, r_name) == 0)
433 return &howto_table[i];
434
435 return NULL;
436 }
437
438 #define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup
439 #define bfd_elf32_bfd_reloc_name_lookup reloc_name_lookup
440 #define ELF_ARCH bfd_arch_m68k
441 #define ELF_TARGET_ID M68K_ELF_DATA
442 \f
443 /* Functions for the m68k ELF linker. */
444
445 /* The name of the dynamic interpreter. This is put in the .interp
446 section. */
447
448 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
449
450 /* Describes one of the various PLT styles. */
451
452 struct elf_m68k_plt_info
453 {
454 /* The size of each PLT entry. */
455 bfd_vma size;
456
457 /* The template for the first PLT entry. */
458 const bfd_byte *plt0_entry;
459
460 /* Offsets of fields in PLT0_ENTRY that require R_68K_PC32 relocations.
461 The comments by each member indicate the value that the relocation
462 is against. */
463 struct {
464 unsigned int got4; /* .got + 4 */
465 unsigned int got8; /* .got + 8 */
466 } plt0_relocs;
467
468 /* The template for a symbol's PLT entry. */
469 const bfd_byte *symbol_entry;
470
471 /* Offsets of fields in SYMBOL_ENTRY that require R_68K_PC32 relocations.
472 The comments by each member indicate the value that the relocation
473 is against. */
474 struct {
475 unsigned int got; /* the symbol's .got.plt entry */
476 unsigned int plt; /* .plt */
477 } symbol_relocs;
478
479 /* The offset of the resolver stub from the start of SYMBOL_ENTRY.
480 The stub starts with "move.l #relocoffset,%d0". */
481 bfd_vma symbol_resolve_entry;
482 };
483
484 /* The size in bytes of an entry in the procedure linkage table. */
485
486 #define PLT_ENTRY_SIZE 20
487
488 /* The first entry in a procedure linkage table looks like this. See
489 the SVR4 ABI m68k supplement to see how this works. */
490
491 static const bfd_byte elf_m68k_plt0_entry[PLT_ENTRY_SIZE] =
492 {
493 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
494 0, 0, 0, 2, /* + (.got + 4) - . */
495 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,addr]) */
496 0, 0, 0, 2, /* + (.got + 8) - . */
497 0, 0, 0, 0 /* pad out to 20 bytes. */
498 };
499
500 /* Subsequent entries in a procedure linkage table look like this. */
501
502 static const bfd_byte elf_m68k_plt_entry[PLT_ENTRY_SIZE] =
503 {
504 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,symbol@GOTPC]) */
505 0, 0, 0, 2, /* + (.got.plt entry) - . */
506 0x2f, 0x3c, /* move.l #offset,-(%sp) */
507 0, 0, 0, 0, /* + reloc index */
508 0x60, 0xff, /* bra.l .plt */
509 0, 0, 0, 0 /* + .plt - . */
510 };
511
512 static const struct elf_m68k_plt_info elf_m68k_plt_info = {
513 PLT_ENTRY_SIZE,
514 elf_m68k_plt0_entry, { 4, 12 },
515 elf_m68k_plt_entry, { 4, 16 }, 8
516 };
517
518 #define ISAB_PLT_ENTRY_SIZE 24
519
520 static const bfd_byte elf_isab_plt0_entry[ISAB_PLT_ENTRY_SIZE] =
521 {
522 0x20, 0x3c, /* move.l #offset,%d0 */
523 0, 0, 0, 0, /* + (.got + 4) - . */
524 0x2f, 0x3b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),-(%sp) */
525 0x20, 0x3c, /* move.l #offset,%d0 */
526 0, 0, 0, 0, /* + (.got + 8) - . */
527 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
528 0x4e, 0xd0, /* jmp (%a0) */
529 0x4e, 0x71 /* nop */
530 };
531
532 /* Subsequent entries in a procedure linkage table look like this. */
533
534 static const bfd_byte elf_isab_plt_entry[ISAB_PLT_ENTRY_SIZE] =
535 {
536 0x20, 0x3c, /* move.l #offset,%d0 */
537 0, 0, 0, 0, /* + (.got.plt entry) - . */
538 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
539 0x4e, 0xd0, /* jmp (%a0) */
540 0x2f, 0x3c, /* move.l #offset,-(%sp) */
541 0, 0, 0, 0, /* + reloc index */
542 0x60, 0xff, /* bra.l .plt */
543 0, 0, 0, 0 /* + .plt - . */
544 };
545
546 static const struct elf_m68k_plt_info elf_isab_plt_info = {
547 ISAB_PLT_ENTRY_SIZE,
548 elf_isab_plt0_entry, { 2, 12 },
549 elf_isab_plt_entry, { 2, 20 }, 12
550 };
551
552 #define ISAC_PLT_ENTRY_SIZE 24
553
554 static const bfd_byte elf_isac_plt0_entry[ISAC_PLT_ENTRY_SIZE] =
555 {
556 0x20, 0x3c, /* move.l #offset,%d0 */
557 0, 0, 0, 0, /* replaced with .got + 4 - . */
558 0x2e, 0xbb, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),(%sp) */
559 0x20, 0x3c, /* move.l #offset,%d0 */
560 0, 0, 0, 0, /* replaced with .got + 8 - . */
561 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
562 0x4e, 0xd0, /* jmp (%a0) */
563 0x4e, 0x71 /* nop */
564 };
565
566 /* Subsequent entries in a procedure linkage table look like this. */
567
568 static const bfd_byte elf_isac_plt_entry[ISAC_PLT_ENTRY_SIZE] =
569 {
570 0x20, 0x3c, /* move.l #offset,%d0 */
571 0, 0, 0, 0, /* replaced with (.got entry) - . */
572 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
573 0x4e, 0xd0, /* jmp (%a0) */
574 0x2f, 0x3c, /* move.l #offset,-(%sp) */
575 0, 0, 0, 0, /* replaced with offset into relocation table */
576 0x61, 0xff, /* bsr.l .plt */
577 0, 0, 0, 0 /* replaced with .plt - . */
578 };
579
580 static const struct elf_m68k_plt_info elf_isac_plt_info = {
581 ISAC_PLT_ENTRY_SIZE,
582 elf_isac_plt0_entry, { 2, 12},
583 elf_isac_plt_entry, { 2, 20 }, 12
584 };
585
586 #define CPU32_PLT_ENTRY_SIZE 24
587 /* Procedure linkage table entries for the cpu32 */
588 static const bfd_byte elf_cpu32_plt0_entry[CPU32_PLT_ENTRY_SIZE] =
589 {
590 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
591 0, 0, 0, 2, /* + (.got + 4) - . */
592 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
593 0, 0, 0, 2, /* + (.got + 8) - . */
594 0x4e, 0xd1, /* jmp %a1@ */
595 0, 0, 0, 0, /* pad out to 24 bytes. */
596 0, 0
597 };
598
599 static const bfd_byte elf_cpu32_plt_entry[CPU32_PLT_ENTRY_SIZE] =
600 {
601 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
602 0, 0, 0, 2, /* + (.got.plt entry) - . */
603 0x4e, 0xd1, /* jmp %a1@ */
604 0x2f, 0x3c, /* move.l #offset,-(%sp) */
605 0, 0, 0, 0, /* + reloc index */
606 0x60, 0xff, /* bra.l .plt */
607 0, 0, 0, 0, /* + .plt - . */
608 0, 0
609 };
610
611 static const struct elf_m68k_plt_info elf_cpu32_plt_info = {
612 CPU32_PLT_ENTRY_SIZE,
613 elf_cpu32_plt0_entry, { 4, 12 },
614 elf_cpu32_plt_entry, { 4, 18 }, 10
615 };
616
617 /* The m68k linker needs to keep track of the number of relocs that it
618 decides to copy in check_relocs for each symbol. This is so that it
619 can discard PC relative relocs if it doesn't need them when linking
620 with -Bsymbolic. We store the information in a field extending the
621 regular ELF linker hash table. */
622
623 /* This structure keeps track of the number of PC relative relocs we have
624 copied for a given symbol. */
625
626 struct elf_m68k_pcrel_relocs_copied
627 {
628 /* Next section. */
629 struct elf_m68k_pcrel_relocs_copied *next;
630 /* A section in dynobj. */
631 asection *section;
632 /* Number of relocs copied in this section. */
633 bfd_size_type count;
634 };
635
636 /* Forward declaration. */
637 struct elf_m68k_got_entry;
638
639 /* m68k ELF linker hash entry. */
640
641 struct elf_m68k_link_hash_entry
642 {
643 struct elf_link_hash_entry root;
644
645 /* Number of PC relative relocs copied for this symbol. */
646 struct elf_m68k_pcrel_relocs_copied *pcrel_relocs_copied;
647
648 /* Key to got_entries. */
649 unsigned long got_entry_key;
650
651 /* List of GOT entries for this symbol. This list is build during
652 offset finalization and is used within elf_m68k_finish_dynamic_symbol
653 to traverse all GOT entries for a particular symbol.
654
655 ??? We could've used root.got.glist field instead, but having
656 a separate field is cleaner. */
657 struct elf_m68k_got_entry *glist;
658 };
659
660 #define elf_m68k_hash_entry(ent) ((struct elf_m68k_link_hash_entry *) (ent))
661
662 /* Key part of GOT entry in hashtable. */
663 struct elf_m68k_got_entry_key
664 {
665 /* BFD in which this symbol was defined. NULL for global symbols. */
666 const bfd *bfd;
667
668 /* Symbol index. Either local symbol index or h->got_entry_key. */
669 unsigned long symndx;
670
671 /* Type is one of R_68K_GOT{8, 16, 32}O, R_68K_TLS_GD{8, 16, 32},
672 R_68K_TLS_LDM{8, 16, 32} or R_68K_TLS_IE{8, 16, 32}.
673
674 From perspective of hashtable key, only elf_m68k_got_reloc_type (type)
675 matters. That is, we distinguish between, say, R_68K_GOT16O
676 and R_68K_GOT32O when allocating offsets, but they are considered to be
677 the same when searching got->entries. */
678 enum elf_m68k_reloc_type type;
679 };
680
681 /* Size of the GOT offset suitable for relocation. */
682 enum elf_m68k_got_offset_size { R_8, R_16, R_32, R_LAST };
683
684 /* Entry of the GOT. */
685 struct elf_m68k_got_entry
686 {
687 /* GOT entries are put into a got->entries hashtable. This is the key. */
688 struct elf_m68k_got_entry_key key_;
689
690 /* GOT entry data. We need s1 before offset finalization and s2 after. */
691 union
692 {
693 struct
694 {
695 /* Number of times this entry is referenced. It is used to
696 filter out unnecessary GOT slots in elf_m68k_gc_sweep_hook. */
697 bfd_vma refcount;
698 } s1;
699
700 struct
701 {
702 /* Offset from the start of .got section. To calculate offset relative
703 to GOT pointer one should substract got->offset from this value. */
704 bfd_vma offset;
705
706 /* Pointer to the next GOT entry for this global symbol.
707 Symbols have at most one entry in one GOT, but might
708 have entries in more than one GOT.
709 Root of this list is h->glist.
710 NULL for local symbols. */
711 struct elf_m68k_got_entry *next;
712 } s2;
713 } u;
714 };
715
716 /* Return representative type for relocation R_TYPE.
717 This is used to avoid enumerating many relocations in comparisons,
718 switches etc. */
719
720 static enum elf_m68k_reloc_type
721 elf_m68k_reloc_got_type (enum elf_m68k_reloc_type r_type)
722 {
723 switch (r_type)
724 {
725 /* In most cases R_68K_GOTx relocations require the very same
726 handling as R_68K_GOT32O relocation. In cases when we need
727 to distinguish between the two, we use explicitly compare against
728 r_type. */
729 case R_68K_GOT32:
730 case R_68K_GOT16:
731 case R_68K_GOT8:
732 case R_68K_GOT32O:
733 case R_68K_GOT16O:
734 case R_68K_GOT8O:
735 return R_68K_GOT32O;
736
737 case R_68K_TLS_GD32:
738 case R_68K_TLS_GD16:
739 case R_68K_TLS_GD8:
740 return R_68K_TLS_GD32;
741
742 case R_68K_TLS_LDM32:
743 case R_68K_TLS_LDM16:
744 case R_68K_TLS_LDM8:
745 return R_68K_TLS_LDM32;
746
747 case R_68K_TLS_IE32:
748 case R_68K_TLS_IE16:
749 case R_68K_TLS_IE8:
750 return R_68K_TLS_IE32;
751
752 default:
753 BFD_ASSERT (FALSE);
754 return 0;
755 }
756 }
757
758 /* Return size of the GOT entry offset for relocation R_TYPE. */
759
760 static enum elf_m68k_got_offset_size
761 elf_m68k_reloc_got_offset_size (enum elf_m68k_reloc_type r_type)
762 {
763 switch (r_type)
764 {
765 case R_68K_GOT32: case R_68K_GOT16: case R_68K_GOT8:
766 case R_68K_GOT32O: case R_68K_TLS_GD32: case R_68K_TLS_LDM32:
767 case R_68K_TLS_IE32:
768 return R_32;
769
770 case R_68K_GOT16O: case R_68K_TLS_GD16: case R_68K_TLS_LDM16:
771 case R_68K_TLS_IE16:
772 return R_16;
773
774 case R_68K_GOT8O: case R_68K_TLS_GD8: case R_68K_TLS_LDM8:
775 case R_68K_TLS_IE8:
776 return R_8;
777
778 default:
779 BFD_ASSERT (FALSE);
780 return 0;
781 }
782 }
783
784 /* Return number of GOT entries we need to allocate in GOT for
785 relocation R_TYPE. */
786
787 static bfd_vma
788 elf_m68k_reloc_got_n_slots (enum elf_m68k_reloc_type r_type)
789 {
790 switch (elf_m68k_reloc_got_type (r_type))
791 {
792 case R_68K_GOT32O:
793 case R_68K_TLS_IE32:
794 return 1;
795
796 case R_68K_TLS_GD32:
797 case R_68K_TLS_LDM32:
798 return 2;
799
800 default:
801 BFD_ASSERT (FALSE);
802 return 0;
803 }
804 }
805
806 /* Return TRUE if relocation R_TYPE is a TLS one. */
807
808 static bfd_boolean
809 elf_m68k_reloc_tls_p (enum elf_m68k_reloc_type r_type)
810 {
811 switch (r_type)
812 {
813 case R_68K_TLS_GD32: case R_68K_TLS_GD16: case R_68K_TLS_GD8:
814 case R_68K_TLS_LDM32: case R_68K_TLS_LDM16: case R_68K_TLS_LDM8:
815 case R_68K_TLS_LDO32: case R_68K_TLS_LDO16: case R_68K_TLS_LDO8:
816 case R_68K_TLS_IE32: case R_68K_TLS_IE16: case R_68K_TLS_IE8:
817 case R_68K_TLS_LE32: case R_68K_TLS_LE16: case R_68K_TLS_LE8:
818 case R_68K_TLS_DTPMOD32: case R_68K_TLS_DTPREL32: case R_68K_TLS_TPREL32:
819 return TRUE;
820
821 default:
822 return FALSE;
823 }
824 }
825
826 /* Data structure representing a single GOT. */
827 struct elf_m68k_got
828 {
829 /* Hashtable of 'struct elf_m68k_got_entry's.
830 Starting size of this table is the maximum number of
831 R_68K_GOT8O entries. */
832 htab_t entries;
833
834 /* Number of R_x slots in this GOT. Some (e.g., TLS) entries require
835 several GOT slots.
836
837 n_slots[R_8] is the count of R_8 slots in this GOT.
838 n_slots[R_16] is the cumulative count of R_8 and R_16 slots
839 in this GOT.
840 n_slots[R_32] is the cumulative count of R_8, R_16 and R_32 slots
841 in this GOT. This is the total number of slots. */
842 bfd_vma n_slots[R_LAST];
843
844 /* Number of local (entry->key_.h == NULL) slots in this GOT.
845 This is only used to properly calculate size of .rela.got section;
846 see elf_m68k_partition_multi_got. */
847 bfd_vma local_n_slots;
848
849 /* Offset of this GOT relative to beginning of .got section. */
850 bfd_vma offset;
851 };
852
853 /* BFD and its GOT. This is an entry in multi_got->bfd2got hashtable. */
854 struct elf_m68k_bfd2got_entry
855 {
856 /* BFD. */
857 const bfd *bfd;
858
859 /* Assigned GOT. Before partitioning multi-GOT each BFD has its own
860 GOT structure. After partitioning several BFD's might [and often do]
861 share a single GOT. */
862 struct elf_m68k_got *got;
863 };
864
865 /* The main data structure holding all the pieces. */
866 struct elf_m68k_multi_got
867 {
868 /* Hashtable mapping each BFD to its GOT. If a BFD doesn't have an entry
869 here, then it doesn't need a GOT (this includes the case of a BFD
870 having an empty GOT).
871
872 ??? This hashtable can be replaced by an array indexed by bfd->id. */
873 htab_t bfd2got;
874
875 /* Next symndx to assign a global symbol.
876 h->got_entry_key is initialized from this counter. */
877 unsigned long global_symndx;
878 };
879
880 /* m68k ELF linker hash table. */
881
882 struct elf_m68k_link_hash_table
883 {
884 struct elf_link_hash_table root;
885
886 /* Small local sym cache. */
887 struct sym_cache sym_cache;
888
889 /* The PLT format used by this link, or NULL if the format has not
890 yet been chosen. */
891 const struct elf_m68k_plt_info *plt_info;
892
893 /* True, if GP is loaded within each function which uses it.
894 Set to TRUE when GOT negative offsets or multi-GOT is enabled. */
895 bfd_boolean local_gp_p;
896
897 /* Switch controlling use of negative offsets to double the size of GOTs. */
898 bfd_boolean use_neg_got_offsets_p;
899
900 /* Switch controlling generation of multiple GOTs. */
901 bfd_boolean allow_multigot_p;
902
903 /* Multi-GOT data structure. */
904 struct elf_m68k_multi_got multi_got_;
905 };
906
907 /* Get the m68k ELF linker hash table from a link_info structure. */
908
909 #define elf_m68k_hash_table(p) \
910 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
911 == M68K_ELF_DATA ? ((struct elf_m68k_link_hash_table *) ((p)->hash)) : NULL)
912
913 /* Shortcut to multi-GOT data. */
914 #define elf_m68k_multi_got(INFO) (&elf_m68k_hash_table (INFO)->multi_got_)
915
916 /* Create an entry in an m68k ELF linker hash table. */
917
918 static struct bfd_hash_entry *
919 elf_m68k_link_hash_newfunc (struct bfd_hash_entry *entry,
920 struct bfd_hash_table *table,
921 const char *string)
922 {
923 struct bfd_hash_entry *ret = entry;
924
925 /* Allocate the structure if it has not already been allocated by a
926 subclass. */
927 if (ret == NULL)
928 ret = bfd_hash_allocate (table,
929 sizeof (struct elf_m68k_link_hash_entry));
930 if (ret == NULL)
931 return ret;
932
933 /* Call the allocation method of the superclass. */
934 ret = _bfd_elf_link_hash_newfunc (ret, table, string);
935 if (ret != NULL)
936 {
937 elf_m68k_hash_entry (ret)->pcrel_relocs_copied = NULL;
938 elf_m68k_hash_entry (ret)->got_entry_key = 0;
939 elf_m68k_hash_entry (ret)->glist = NULL;
940 }
941
942 return ret;
943 }
944
945 /* Create an m68k ELF linker hash table. */
946
947 static struct bfd_link_hash_table *
948 elf_m68k_link_hash_table_create (bfd *abfd)
949 {
950 struct elf_m68k_link_hash_table *ret;
951 bfd_size_type amt = sizeof (struct elf_m68k_link_hash_table);
952
953 ret = (struct elf_m68k_link_hash_table *) bfd_zmalloc (amt);
954 if (ret == (struct elf_m68k_link_hash_table *) NULL)
955 return NULL;
956
957 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
958 elf_m68k_link_hash_newfunc,
959 sizeof (struct elf_m68k_link_hash_entry),
960 M68K_ELF_DATA))
961 {
962 free (ret);
963 return NULL;
964 }
965
966 ret->multi_got_.global_symndx = 1;
967
968 return &ret->root.root;
969 }
970
971 /* Destruct local data. */
972
973 static void
974 elf_m68k_link_hash_table_free (struct bfd_link_hash_table *_htab)
975 {
976 struct elf_m68k_link_hash_table *htab;
977
978 htab = (struct elf_m68k_link_hash_table *) _htab;
979
980 if (htab->multi_got_.bfd2got != NULL)
981 {
982 htab_delete (htab->multi_got_.bfd2got);
983 htab->multi_got_.bfd2got = NULL;
984 }
985 _bfd_elf_link_hash_table_free (_htab);
986 }
987
988 /* Set the right machine number. */
989
990 static bfd_boolean
991 elf32_m68k_object_p (bfd *abfd)
992 {
993 unsigned int mach = 0;
994 unsigned features = 0;
995 flagword eflags = elf_elfheader (abfd)->e_flags;
996
997 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
998 features |= m68000;
999 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1000 features |= cpu32;
1001 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1002 features |= fido_a;
1003 else
1004 {
1005 switch (eflags & EF_M68K_CF_ISA_MASK)
1006 {
1007 case EF_M68K_CF_ISA_A_NODIV:
1008 features |= mcfisa_a;
1009 break;
1010 case EF_M68K_CF_ISA_A:
1011 features |= mcfisa_a|mcfhwdiv;
1012 break;
1013 case EF_M68K_CF_ISA_A_PLUS:
1014 features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp;
1015 break;
1016 case EF_M68K_CF_ISA_B_NOUSP:
1017 features |= mcfisa_a|mcfisa_b|mcfhwdiv;
1018 break;
1019 case EF_M68K_CF_ISA_B:
1020 features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp;
1021 break;
1022 case EF_M68K_CF_ISA_C:
1023 features |= mcfisa_a|mcfisa_c|mcfhwdiv|mcfusp;
1024 break;
1025 case EF_M68K_CF_ISA_C_NODIV:
1026 features |= mcfisa_a|mcfisa_c|mcfusp;
1027 break;
1028 }
1029 switch (eflags & EF_M68K_CF_MAC_MASK)
1030 {
1031 case EF_M68K_CF_MAC:
1032 features |= mcfmac;
1033 break;
1034 case EF_M68K_CF_EMAC:
1035 features |= mcfemac;
1036 break;
1037 }
1038 if (eflags & EF_M68K_CF_FLOAT)
1039 features |= cfloat;
1040 }
1041
1042 mach = bfd_m68k_features_to_mach (features);
1043 bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach);
1044
1045 return TRUE;
1046 }
1047
1048 /* Somewhat reverse of elf32_m68k_object_p, this sets the e_flag
1049 field based on the machine number. */
1050
1051 static void
1052 elf_m68k_final_write_processing (bfd *abfd,
1053 bfd_boolean linker ATTRIBUTE_UNUSED)
1054 {
1055 int mach = bfd_get_mach (abfd);
1056 unsigned long e_flags = elf_elfheader (abfd)->e_flags;
1057
1058 if (!e_flags)
1059 {
1060 unsigned int arch_mask;
1061
1062 arch_mask = bfd_m68k_mach_to_features (mach);
1063
1064 if (arch_mask & m68000)
1065 e_flags = EF_M68K_M68000;
1066 else if (arch_mask & cpu32)
1067 e_flags = EF_M68K_CPU32;
1068 else if (arch_mask & fido_a)
1069 e_flags = EF_M68K_FIDO;
1070 else
1071 {
1072 switch (arch_mask
1073 & (mcfisa_a | mcfisa_aa | mcfisa_b | mcfisa_c | mcfhwdiv | mcfusp))
1074 {
1075 case mcfisa_a:
1076 e_flags |= EF_M68K_CF_ISA_A_NODIV;
1077 break;
1078 case mcfisa_a | mcfhwdiv:
1079 e_flags |= EF_M68K_CF_ISA_A;
1080 break;
1081 case mcfisa_a | mcfisa_aa | mcfhwdiv | mcfusp:
1082 e_flags |= EF_M68K_CF_ISA_A_PLUS;
1083 break;
1084 case mcfisa_a | mcfisa_b | mcfhwdiv:
1085 e_flags |= EF_M68K_CF_ISA_B_NOUSP;
1086 break;
1087 case mcfisa_a | mcfisa_b | mcfhwdiv | mcfusp:
1088 e_flags |= EF_M68K_CF_ISA_B;
1089 break;
1090 case mcfisa_a | mcfisa_c | mcfhwdiv | mcfusp:
1091 e_flags |= EF_M68K_CF_ISA_C;
1092 break;
1093 case mcfisa_a | mcfisa_c | mcfusp:
1094 e_flags |= EF_M68K_CF_ISA_C_NODIV;
1095 break;
1096 }
1097 if (arch_mask & mcfmac)
1098 e_flags |= EF_M68K_CF_MAC;
1099 else if (arch_mask & mcfemac)
1100 e_flags |= EF_M68K_CF_EMAC;
1101 if (arch_mask & cfloat)
1102 e_flags |= EF_M68K_CF_FLOAT | EF_M68K_CFV4E;
1103 }
1104 elf_elfheader (abfd)->e_flags = e_flags;
1105 }
1106 }
1107
1108 /* Keep m68k-specific flags in the ELF header. */
1109
1110 static bfd_boolean
1111 elf32_m68k_set_private_flags (bfd *abfd, flagword flags)
1112 {
1113 elf_elfheader (abfd)->e_flags = flags;
1114 elf_flags_init (abfd) = TRUE;
1115 return TRUE;
1116 }
1117
1118 /* Merge backend specific data from an object file to the output
1119 object file when linking. */
1120 static bfd_boolean
1121 elf32_m68k_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
1122 {
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 (!arg->info->shared)
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 (info->relocatable)
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
2589 switch (ELF32_R_TYPE (rel->r_info))
2590 {
2591 case R_68K_GOT8:
2592 case R_68K_GOT16:
2593 case R_68K_GOT32:
2594 if (h != NULL
2595 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2596 break;
2597 /* Fall through. */
2598
2599 /* Relative GOT relocations. */
2600 case R_68K_GOT8O:
2601 case R_68K_GOT16O:
2602 case R_68K_GOT32O:
2603 /* Fall through. */
2604
2605 /* TLS relocations. */
2606 case R_68K_TLS_GD8:
2607 case R_68K_TLS_GD16:
2608 case R_68K_TLS_GD32:
2609 case R_68K_TLS_LDM8:
2610 case R_68K_TLS_LDM16:
2611 case R_68K_TLS_LDM32:
2612 case R_68K_TLS_IE8:
2613 case R_68K_TLS_IE16:
2614 case R_68K_TLS_IE32:
2615
2616 case R_68K_TLS_TPREL32:
2617 case R_68K_TLS_DTPREL32:
2618
2619 if (ELF32_R_TYPE (rel->r_info) == R_68K_TLS_TPREL32
2620 && info->shared)
2621 /* Do the special chorus for libraries with static TLS. */
2622 info->flags |= DF_STATIC_TLS;
2623
2624 /* This symbol requires a global offset table entry. */
2625
2626 if (dynobj == NULL)
2627 {
2628 /* Create the .got section. */
2629 elf_hash_table (info)->dynobj = dynobj = abfd;
2630 if (!_bfd_elf_create_got_section (dynobj, info))
2631 return FALSE;
2632 }
2633
2634 if (sgot == NULL)
2635 {
2636 sgot = bfd_get_linker_section (dynobj, ".got");
2637 BFD_ASSERT (sgot != NULL);
2638 }
2639
2640 if (srelgot == NULL
2641 && (h != NULL || info->shared))
2642 {
2643 srelgot = bfd_get_linker_section (dynobj, ".rela.got");
2644 if (srelgot == NULL)
2645 {
2646 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2647 | SEC_IN_MEMORY | SEC_LINKER_CREATED
2648 | SEC_READONLY);
2649 srelgot = bfd_make_section_anyway_with_flags (dynobj,
2650 ".rela.got",
2651 flags);
2652 if (srelgot == NULL
2653 || !bfd_set_section_alignment (dynobj, srelgot, 2))
2654 return FALSE;
2655 }
2656 }
2657
2658 if (got == NULL)
2659 {
2660 struct elf_m68k_bfd2got_entry *bfd2got_entry;
2661
2662 bfd2got_entry
2663 = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
2664 abfd, FIND_OR_CREATE, info);
2665 if (bfd2got_entry == NULL)
2666 return FALSE;
2667
2668 got = bfd2got_entry->got;
2669 BFD_ASSERT (got != NULL);
2670 }
2671
2672 {
2673 struct elf_m68k_got_entry *got_entry;
2674
2675 /* Add entry to got. */
2676 got_entry = elf_m68k_add_entry_to_got (got, h, abfd,
2677 ELF32_R_TYPE (rel->r_info),
2678 r_symndx, info);
2679 if (got_entry == NULL)
2680 return FALSE;
2681
2682 if (got_entry->u.s1.refcount == 1)
2683 {
2684 /* Make sure this symbol is output as a dynamic symbol. */
2685 if (h != NULL
2686 && h->dynindx == -1
2687 && !h->forced_local)
2688 {
2689 if (!bfd_elf_link_record_dynamic_symbol (info, h))
2690 return FALSE;
2691 }
2692 }
2693 }
2694
2695 break;
2696
2697 case R_68K_PLT8:
2698 case R_68K_PLT16:
2699 case R_68K_PLT32:
2700 /* This symbol requires a procedure linkage table entry. We
2701 actually build the entry in adjust_dynamic_symbol,
2702 because this might be a case of linking PIC code which is
2703 never referenced by a dynamic object, in which case we
2704 don't need to generate a procedure linkage table entry
2705 after all. */
2706
2707 /* If this is a local symbol, we resolve it directly without
2708 creating a procedure linkage table entry. */
2709 if (h == NULL)
2710 continue;
2711
2712 h->needs_plt = 1;
2713 h->plt.refcount++;
2714 break;
2715
2716 case R_68K_PLT8O:
2717 case R_68K_PLT16O:
2718 case R_68K_PLT32O:
2719 /* This symbol requires a procedure linkage table entry. */
2720
2721 if (h == NULL)
2722 {
2723 /* It does not make sense to have this relocation for a
2724 local symbol. FIXME: does it? How to handle it if
2725 it does make sense? */
2726 bfd_set_error (bfd_error_bad_value);
2727 return FALSE;
2728 }
2729
2730 /* Make sure this symbol is output as a dynamic symbol. */
2731 if (h->dynindx == -1
2732 && !h->forced_local)
2733 {
2734 if (!bfd_elf_link_record_dynamic_symbol (info, h))
2735 return FALSE;
2736 }
2737
2738 h->needs_plt = 1;
2739 h->plt.refcount++;
2740 break;
2741
2742 case R_68K_PC8:
2743 case R_68K_PC16:
2744 case R_68K_PC32:
2745 /* If we are creating a shared library and this is not a local
2746 symbol, we need to copy the reloc into the shared library.
2747 However when linking with -Bsymbolic and this is a global
2748 symbol which is defined in an object we are including in the
2749 link (i.e., DEF_REGULAR is set), then we can resolve the
2750 reloc directly. At this point we have not seen all the input
2751 files, so it is possible that DEF_REGULAR is not set now but
2752 will be set later (it is never cleared). We account for that
2753 possibility below by storing information in the
2754 pcrel_relocs_copied field of the hash table entry. */
2755 if (!(info->shared
2756 && (sec->flags & SEC_ALLOC) != 0
2757 && h != NULL
2758 && (!info->symbolic
2759 || h->root.type == bfd_link_hash_defweak
2760 || !h->def_regular)))
2761 {
2762 if (h != NULL)
2763 {
2764 /* Make sure a plt entry is created for this symbol if
2765 it turns out to be a function defined by a dynamic
2766 object. */
2767 h->plt.refcount++;
2768 }
2769 break;
2770 }
2771 /* Fall through. */
2772 case R_68K_8:
2773 case R_68K_16:
2774 case R_68K_32:
2775 /* We don't need to handle relocs into sections not going into
2776 the "real" output. */
2777 if ((sec->flags & SEC_ALLOC) == 0)
2778 break;
2779
2780 if (h != NULL)
2781 {
2782 /* Make sure a plt entry is created for this symbol if it
2783 turns out to be a function defined by a dynamic object. */
2784 h->plt.refcount++;
2785
2786 if (info->executable)
2787 /* This symbol needs a non-GOT reference. */
2788 h->non_got_ref = 1;
2789 }
2790
2791 /* If we are creating a shared library, we need to copy the
2792 reloc into the shared library. */
2793 if (info->shared)
2794 {
2795 /* When creating a shared object, we must copy these
2796 reloc types into the output file. We create a reloc
2797 section in dynobj and make room for this reloc. */
2798 if (sreloc == NULL)
2799 {
2800 sreloc = _bfd_elf_make_dynamic_reloc_section
2801 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
2802
2803 if (sreloc == NULL)
2804 return FALSE;
2805 }
2806
2807 if (sec->flags & SEC_READONLY
2808 /* Don't set DF_TEXTREL yet for PC relative
2809 relocations, they might be discarded later. */
2810 && !(ELF32_R_TYPE (rel->r_info) == R_68K_PC8
2811 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
2812 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32))
2813 info->flags |= DF_TEXTREL;
2814
2815 sreloc->size += sizeof (Elf32_External_Rela);
2816
2817 /* We count the number of PC relative relocations we have
2818 entered for this symbol, so that we can discard them
2819 again if, in the -Bsymbolic case, the symbol is later
2820 defined by a regular object, or, in the normal shared
2821 case, the symbol is forced to be local. Note that this
2822 function is only called if we are using an m68kelf linker
2823 hash table, which means that h is really a pointer to an
2824 elf_m68k_link_hash_entry. */
2825 if (ELF32_R_TYPE (rel->r_info) == R_68K_PC8
2826 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
2827 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)
2828 {
2829 struct elf_m68k_pcrel_relocs_copied *p;
2830 struct elf_m68k_pcrel_relocs_copied **head;
2831
2832 if (h != NULL)
2833 {
2834 struct elf_m68k_link_hash_entry *eh
2835 = elf_m68k_hash_entry (h);
2836 head = &eh->pcrel_relocs_copied;
2837 }
2838 else
2839 {
2840 asection *s;
2841 void *vpp;
2842 Elf_Internal_Sym *isym;
2843
2844 isym = bfd_sym_from_r_symndx (&elf_m68k_hash_table (info)->sym_cache,
2845 abfd, r_symndx);
2846 if (isym == NULL)
2847 return FALSE;
2848
2849 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2850 if (s == NULL)
2851 s = sec;
2852
2853 vpp = &elf_section_data (s)->local_dynrel;
2854 head = (struct elf_m68k_pcrel_relocs_copied **) vpp;
2855 }
2856
2857 for (p = *head; p != NULL; p = p->next)
2858 if (p->section == sreloc)
2859 break;
2860
2861 if (p == NULL)
2862 {
2863 p = ((struct elf_m68k_pcrel_relocs_copied *)
2864 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
2865 if (p == NULL)
2866 return FALSE;
2867 p->next = *head;
2868 *head = p;
2869 p->section = sreloc;
2870 p->count = 0;
2871 }
2872
2873 ++p->count;
2874 }
2875 }
2876
2877 break;
2878
2879 /* This relocation describes the C++ object vtable hierarchy.
2880 Reconstruct it for later use during GC. */
2881 case R_68K_GNU_VTINHERIT:
2882 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2883 return FALSE;
2884 break;
2885
2886 /* This relocation describes which C++ vtable entries are actually
2887 used. Record for later use during GC. */
2888 case R_68K_GNU_VTENTRY:
2889 BFD_ASSERT (h != NULL);
2890 if (h != NULL
2891 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2892 return FALSE;
2893 break;
2894
2895 default:
2896 break;
2897 }
2898 }
2899
2900 return TRUE;
2901 }
2902
2903 /* Return the section that should be marked against GC for a given
2904 relocation. */
2905
2906 static asection *
2907 elf_m68k_gc_mark_hook (asection *sec,
2908 struct bfd_link_info *info,
2909 Elf_Internal_Rela *rel,
2910 struct elf_link_hash_entry *h,
2911 Elf_Internal_Sym *sym)
2912 {
2913 if (h != NULL)
2914 switch (ELF32_R_TYPE (rel->r_info))
2915 {
2916 case R_68K_GNU_VTINHERIT:
2917 case R_68K_GNU_VTENTRY:
2918 return NULL;
2919 }
2920
2921 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2922 }
2923
2924 /* Update the got entry reference counts for the section being removed. */
2925
2926 static bfd_boolean
2927 elf_m68k_gc_sweep_hook (bfd *abfd,
2928 struct bfd_link_info *info,
2929 asection *sec,
2930 const Elf_Internal_Rela *relocs)
2931 {
2932 Elf_Internal_Shdr *symtab_hdr;
2933 struct elf_link_hash_entry **sym_hashes;
2934 const Elf_Internal_Rela *rel, *relend;
2935 bfd *dynobj;
2936 struct elf_m68k_got *got;
2937
2938 if (info->relocatable)
2939 return TRUE;
2940
2941 dynobj = elf_hash_table (info)->dynobj;
2942 if (dynobj == NULL)
2943 return TRUE;
2944
2945 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2946 sym_hashes = elf_sym_hashes (abfd);
2947 got = NULL;
2948
2949 relend = relocs + sec->reloc_count;
2950 for (rel = relocs; rel < relend; rel++)
2951 {
2952 unsigned long r_symndx;
2953 struct elf_link_hash_entry *h = NULL;
2954
2955 r_symndx = ELF32_R_SYM (rel->r_info);
2956 if (r_symndx >= symtab_hdr->sh_info)
2957 {
2958 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2959 while (h->root.type == bfd_link_hash_indirect
2960 || h->root.type == bfd_link_hash_warning)
2961 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2962 }
2963
2964 switch (ELF32_R_TYPE (rel->r_info))
2965 {
2966 case R_68K_GOT8:
2967 case R_68K_GOT16:
2968 case R_68K_GOT32:
2969 if (h != NULL
2970 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2971 break;
2972
2973 /* FALLTHRU */
2974 case R_68K_GOT8O:
2975 case R_68K_GOT16O:
2976 case R_68K_GOT32O:
2977 /* Fall through. */
2978
2979 /* TLS relocations. */
2980 case R_68K_TLS_GD8:
2981 case R_68K_TLS_GD16:
2982 case R_68K_TLS_GD32:
2983 case R_68K_TLS_LDM8:
2984 case R_68K_TLS_LDM16:
2985 case R_68K_TLS_LDM32:
2986 case R_68K_TLS_IE8:
2987 case R_68K_TLS_IE16:
2988 case R_68K_TLS_IE32:
2989
2990 case R_68K_TLS_TPREL32:
2991 case R_68K_TLS_DTPREL32:
2992
2993 if (got == NULL)
2994 {
2995 got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
2996 abfd, MUST_FIND, NULL)->got;
2997 BFD_ASSERT (got != NULL);
2998 }
2999
3000 {
3001 struct elf_m68k_got_entry_key key_;
3002 struct elf_m68k_got_entry **got_entry_ptr;
3003 struct elf_m68k_got_entry *got_entry;
3004
3005 elf_m68k_init_got_entry_key (&key_, h, abfd, r_symndx,
3006 ELF32_R_TYPE (rel->r_info));
3007 got_entry_ptr = elf_m68k_find_got_entry_ptr (got, &key_);
3008
3009 got_entry = *got_entry_ptr;
3010
3011 if (got_entry->u.s1.refcount > 0)
3012 {
3013 --got_entry->u.s1.refcount;
3014
3015 if (got_entry->u.s1.refcount == 0)
3016 /* We don't need the .got entry any more. */
3017 elf_m68k_remove_got_entry (got, got_entry_ptr);
3018 }
3019 }
3020 break;
3021
3022 case R_68K_PLT8:
3023 case R_68K_PLT16:
3024 case R_68K_PLT32:
3025 case R_68K_PLT8O:
3026 case R_68K_PLT16O:
3027 case R_68K_PLT32O:
3028 case R_68K_PC8:
3029 case R_68K_PC16:
3030 case R_68K_PC32:
3031 case R_68K_8:
3032 case R_68K_16:
3033 case R_68K_32:
3034 if (h != NULL)
3035 {
3036 if (h->plt.refcount > 0)
3037 --h->plt.refcount;
3038 }
3039 break;
3040
3041 default:
3042 break;
3043 }
3044 }
3045
3046 return TRUE;
3047 }
3048 \f
3049 /* Return the type of PLT associated with OUTPUT_BFD. */
3050
3051 static const struct elf_m68k_plt_info *
3052 elf_m68k_get_plt_info (bfd *output_bfd)
3053 {
3054 unsigned int features;
3055
3056 features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd));
3057 if (features & cpu32)
3058 return &elf_cpu32_plt_info;
3059 if (features & mcfisa_b)
3060 return &elf_isab_plt_info;
3061 if (features & mcfisa_c)
3062 return &elf_isac_plt_info;
3063 return &elf_m68k_plt_info;
3064 }
3065
3066 /* This function is called after all the input files have been read,
3067 and the input sections have been assigned to output sections.
3068 It's a convenient place to determine the PLT style. */
3069
3070 static bfd_boolean
3071 elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
3072 {
3073 /* Bind input BFDs to GOTs and calculate sizes of .got and .rela.got
3074 sections. */
3075 if (!elf_m68k_partition_multi_got (info))
3076 return FALSE;
3077
3078 elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd);
3079 return TRUE;
3080 }
3081
3082 /* Adjust a symbol defined by a dynamic object and referenced by a
3083 regular object. The current definition is in some section of the
3084 dynamic object, but we're not including those sections. We have to
3085 change the definition to something the rest of the link can
3086 understand. */
3087
3088 static bfd_boolean
3089 elf_m68k_adjust_dynamic_symbol (struct bfd_link_info *info,
3090 struct elf_link_hash_entry *h)
3091 {
3092 struct elf_m68k_link_hash_table *htab;
3093 bfd *dynobj;
3094 asection *s;
3095
3096 htab = elf_m68k_hash_table (info);
3097 dynobj = elf_hash_table (info)->dynobj;
3098
3099 /* Make sure we know what is going on here. */
3100 BFD_ASSERT (dynobj != NULL
3101 && (h->needs_plt
3102 || h->u.weakdef != NULL
3103 || (h->def_dynamic
3104 && h->ref_regular
3105 && !h->def_regular)));
3106
3107 /* If this is a function, put it in the procedure linkage table. We
3108 will fill in the contents of the procedure linkage table later,
3109 when we know the address of the .got section. */
3110 if (h->type == STT_FUNC
3111 || h->needs_plt)
3112 {
3113 if ((h->plt.refcount <= 0
3114 || SYMBOL_CALLS_LOCAL (info, h)
3115 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3116 && h->root.type == bfd_link_hash_undefweak))
3117 /* We must always create the plt entry if it was referenced
3118 by a PLTxxO relocation. In this case we already recorded
3119 it as a dynamic symbol. */
3120 && h->dynindx == -1)
3121 {
3122 /* This case can occur if we saw a PLTxx reloc in an input
3123 file, but the symbol was never referred to by a dynamic
3124 object, or if all references were garbage collected. In
3125 such a case, we don't actually need to build a procedure
3126 linkage table, and we can just do a PCxx reloc instead. */
3127 h->plt.offset = (bfd_vma) -1;
3128 h->needs_plt = 0;
3129 return TRUE;
3130 }
3131
3132 /* Make sure this symbol is output as a dynamic symbol. */
3133 if (h->dynindx == -1
3134 && !h->forced_local)
3135 {
3136 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3137 return FALSE;
3138 }
3139
3140 s = bfd_get_linker_section (dynobj, ".plt");
3141 BFD_ASSERT (s != NULL);
3142
3143 /* If this is the first .plt entry, make room for the special
3144 first entry. */
3145 if (s->size == 0)
3146 s->size = htab->plt_info->size;
3147
3148 /* If this symbol is not defined in a regular file, and we are
3149 not generating a shared library, then set the symbol to this
3150 location in the .plt. This is required to make function
3151 pointers compare as equal between the normal executable and
3152 the shared library. */
3153 if (!info->shared
3154 && !h->def_regular)
3155 {
3156 h->root.u.def.section = s;
3157 h->root.u.def.value = s->size;
3158 }
3159
3160 h->plt.offset = s->size;
3161
3162 /* Make room for this entry. */
3163 s->size += htab->plt_info->size;
3164
3165 /* We also need to make an entry in the .got.plt section, which
3166 will be placed in the .got section by the linker script. */
3167 s = bfd_get_linker_section (dynobj, ".got.plt");
3168 BFD_ASSERT (s != NULL);
3169 s->size += 4;
3170
3171 /* We also need to make an entry in the .rela.plt section. */
3172 s = bfd_get_linker_section (dynobj, ".rela.plt");
3173 BFD_ASSERT (s != NULL);
3174 s->size += sizeof (Elf32_External_Rela);
3175
3176 return TRUE;
3177 }
3178
3179 /* Reinitialize the plt offset now that it is not used as a reference
3180 count any more. */
3181 h->plt.offset = (bfd_vma) -1;
3182
3183 /* If this is a weak symbol, and there is a real definition, the
3184 processor independent code will have arranged for us to see the
3185 real definition first, and we can just use the same value. */
3186 if (h->u.weakdef != NULL)
3187 {
3188 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3189 || h->u.weakdef->root.type == bfd_link_hash_defweak);
3190 h->root.u.def.section = h->u.weakdef->root.u.def.section;
3191 h->root.u.def.value = h->u.weakdef->root.u.def.value;
3192 return TRUE;
3193 }
3194
3195 /* This is a reference to a symbol defined by a dynamic object which
3196 is not a function. */
3197
3198 /* If we are creating a shared library, we must presume that the
3199 only references to the symbol are via the global offset table.
3200 For such cases we need not do anything here; the relocations will
3201 be handled correctly by relocate_section. */
3202 if (info->shared)
3203 return TRUE;
3204
3205 /* If there are no references to this symbol that do not use the
3206 GOT, we don't need to generate a copy reloc. */
3207 if (!h->non_got_ref)
3208 return TRUE;
3209
3210 /* We must allocate the symbol in our .dynbss section, which will
3211 become part of the .bss section of the executable. There will be
3212 an entry for this symbol in the .dynsym section. The dynamic
3213 object will contain position independent code, so all references
3214 from the dynamic object to this symbol will go through the global
3215 offset table. The dynamic linker will use the .dynsym entry to
3216 determine the address it must put in the global offset table, so
3217 both the dynamic object and the regular object will refer to the
3218 same memory location for the variable. */
3219
3220 s = bfd_get_linker_section (dynobj, ".dynbss");
3221 BFD_ASSERT (s != NULL);
3222
3223 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
3224 copy the initial value out of the dynamic object and into the
3225 runtime process image. We need to remember the offset into the
3226 .rela.bss section we are going to use. */
3227 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
3228 {
3229 asection *srel;
3230
3231 srel = bfd_get_linker_section (dynobj, ".rela.bss");
3232 BFD_ASSERT (srel != NULL);
3233 srel->size += sizeof (Elf32_External_Rela);
3234 h->needs_copy = 1;
3235 }
3236
3237 return _bfd_elf_adjust_dynamic_copy (h, s);
3238 }
3239
3240 /* Set the sizes of the dynamic sections. */
3241
3242 static bfd_boolean
3243 elf_m68k_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3244 struct bfd_link_info *info)
3245 {
3246 bfd *dynobj;
3247 asection *s;
3248 bfd_boolean plt;
3249 bfd_boolean relocs;
3250
3251 dynobj = elf_hash_table (info)->dynobj;
3252 BFD_ASSERT (dynobj != NULL);
3253
3254 if (elf_hash_table (info)->dynamic_sections_created)
3255 {
3256 /* Set the contents of the .interp section to the interpreter. */
3257 if (info->executable)
3258 {
3259 s = bfd_get_linker_section (dynobj, ".interp");
3260 BFD_ASSERT (s != NULL);
3261 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3262 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3263 }
3264 }
3265 else
3266 {
3267 /* We may have created entries in the .rela.got section.
3268 However, if we are not creating the dynamic sections, we will
3269 not actually use these entries. Reset the size of .rela.got,
3270 which will cause it to get stripped from the output file
3271 below. */
3272 s = bfd_get_linker_section (dynobj, ".rela.got");
3273 if (s != NULL)
3274 s->size = 0;
3275 }
3276
3277 /* If this is a -Bsymbolic shared link, then we need to discard all
3278 PC relative relocs against symbols defined in a regular object.
3279 For the normal shared case we discard the PC relative relocs
3280 against symbols that have become local due to visibility changes.
3281 We allocated space for them in the check_relocs routine, but we
3282 will not fill them in in the relocate_section routine. */
3283 if (info->shared)
3284 elf_link_hash_traverse (elf_hash_table (info),
3285 elf_m68k_discard_copies,
3286 info);
3287
3288 /* The check_relocs and adjust_dynamic_symbol entry points have
3289 determined the sizes of the various dynamic sections. Allocate
3290 memory for them. */
3291 plt = FALSE;
3292 relocs = FALSE;
3293 for (s = dynobj->sections; s != NULL; s = s->next)
3294 {
3295 const char *name;
3296
3297 if ((s->flags & SEC_LINKER_CREATED) == 0)
3298 continue;
3299
3300 /* It's OK to base decisions on the section name, because none
3301 of the dynobj section names depend upon the input files. */
3302 name = bfd_get_section_name (dynobj, s);
3303
3304 if (strcmp (name, ".plt") == 0)
3305 {
3306 /* Remember whether there is a PLT. */
3307 plt = s->size != 0;
3308 }
3309 else if (CONST_STRNEQ (name, ".rela"))
3310 {
3311 if (s->size != 0)
3312 {
3313 relocs = TRUE;
3314
3315 /* We use the reloc_count field as a counter if we need
3316 to copy relocs into the output file. */
3317 s->reloc_count = 0;
3318 }
3319 }
3320 else if (! CONST_STRNEQ (name, ".got")
3321 && strcmp (name, ".dynbss") != 0)
3322 {
3323 /* It's not one of our sections, so don't allocate space. */
3324 continue;
3325 }
3326
3327 if (s->size == 0)
3328 {
3329 /* If we don't need this section, strip it from the
3330 output file. This is mostly to handle .rela.bss and
3331 .rela.plt. We must create both sections in
3332 create_dynamic_sections, because they must be created
3333 before the linker maps input sections to output
3334 sections. The linker does that before
3335 adjust_dynamic_symbol is called, and it is that
3336 function which decides whether anything needs to go
3337 into these sections. */
3338 s->flags |= SEC_EXCLUDE;
3339 continue;
3340 }
3341
3342 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3343 continue;
3344
3345 /* Allocate memory for the section contents. */
3346 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
3347 Unused entries should be reclaimed before the section's contents
3348 are written out, but at the moment this does not happen. Thus in
3349 order to prevent writing out garbage, we initialise the section's
3350 contents to zero. */
3351 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3352 if (s->contents == NULL)
3353 return FALSE;
3354 }
3355
3356 if (elf_hash_table (info)->dynamic_sections_created)
3357 {
3358 /* Add some entries to the .dynamic section. We fill in the
3359 values later, in elf_m68k_finish_dynamic_sections, but we
3360 must add the entries now so that we get the correct size for
3361 the .dynamic section. The DT_DEBUG entry is filled in by the
3362 dynamic linker and used by the debugger. */
3363 #define add_dynamic_entry(TAG, VAL) \
3364 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3365
3366 if (!info->shared)
3367 {
3368 if (!add_dynamic_entry (DT_DEBUG, 0))
3369 return FALSE;
3370 }
3371
3372 if (plt)
3373 {
3374 if (!add_dynamic_entry (DT_PLTGOT, 0)
3375 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3376 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3377 || !add_dynamic_entry (DT_JMPREL, 0))
3378 return FALSE;
3379 }
3380
3381 if (relocs)
3382 {
3383 if (!add_dynamic_entry (DT_RELA, 0)
3384 || !add_dynamic_entry (DT_RELASZ, 0)
3385 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3386 return FALSE;
3387 }
3388
3389 if ((info->flags & DF_TEXTREL) != 0)
3390 {
3391 if (!add_dynamic_entry (DT_TEXTREL, 0))
3392 return FALSE;
3393 }
3394 }
3395 #undef add_dynamic_entry
3396
3397 return TRUE;
3398 }
3399
3400 /* This function is called via elf_link_hash_traverse if we are
3401 creating a shared object. In the -Bsymbolic case it discards the
3402 space allocated to copy PC relative relocs against symbols which
3403 are defined in regular objects. For the normal shared case, it
3404 discards space for pc-relative relocs that have become local due to
3405 symbol visibility changes. We allocated space for them in the
3406 check_relocs routine, but we won't fill them in in the
3407 relocate_section routine.
3408
3409 We also check whether any of the remaining relocations apply
3410 against a readonly section, and set the DF_TEXTREL flag in this
3411 case. */
3412
3413 static bfd_boolean
3414 elf_m68k_discard_copies (struct elf_link_hash_entry *h,
3415 void * inf)
3416 {
3417 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3418 struct elf_m68k_pcrel_relocs_copied *s;
3419
3420 if (!SYMBOL_CALLS_LOCAL (info, h))
3421 {
3422 if ((info->flags & DF_TEXTREL) == 0)
3423 {
3424 /* Look for relocations against read-only sections. */
3425 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3426 s != NULL;
3427 s = s->next)
3428 if ((s->section->flags & SEC_READONLY) != 0)
3429 {
3430 info->flags |= DF_TEXTREL;
3431 break;
3432 }
3433 }
3434
3435 /* Make sure undefined weak symbols are output as a dynamic symbol
3436 in PIEs. */
3437 if (h->non_got_ref
3438 && h->root.type == bfd_link_hash_undefweak
3439 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3440 && h->dynindx == -1
3441 && !h->forced_local)
3442 {
3443 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3444 return FALSE;
3445 }
3446
3447 return TRUE;
3448 }
3449
3450 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3451 s != NULL;
3452 s = s->next)
3453 s->section->size -= s->count * sizeof (Elf32_External_Rela);
3454
3455 return TRUE;
3456 }
3457
3458
3459 /* Install relocation RELA. */
3460
3461 static void
3462 elf_m68k_install_rela (bfd *output_bfd,
3463 asection *srela,
3464 Elf_Internal_Rela *rela)
3465 {
3466 bfd_byte *loc;
3467
3468 loc = srela->contents;
3469 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3470 bfd_elf32_swap_reloca_out (output_bfd, rela, loc);
3471 }
3472
3473 /* Find the base offsets for thread-local storage in this object,
3474 for GD/LD and IE/LE respectively. */
3475
3476 #define DTP_OFFSET 0x8000
3477 #define TP_OFFSET 0x7000
3478
3479 static bfd_vma
3480 dtpoff_base (struct bfd_link_info *info)
3481 {
3482 /* If tls_sec is NULL, we should have signalled an error already. */
3483 if (elf_hash_table (info)->tls_sec == NULL)
3484 return 0;
3485 return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
3486 }
3487
3488 static bfd_vma
3489 tpoff_base (struct bfd_link_info *info)
3490 {
3491 /* If tls_sec is NULL, we should have signalled an error already. */
3492 if (elf_hash_table (info)->tls_sec == NULL)
3493 return 0;
3494 return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
3495 }
3496
3497 /* Output necessary relocation to handle a symbol during static link.
3498 This function is called from elf_m68k_relocate_section. */
3499
3500 static void
3501 elf_m68k_init_got_entry_static (struct bfd_link_info *info,
3502 bfd *output_bfd,
3503 enum elf_m68k_reloc_type r_type,
3504 asection *sgot,
3505 bfd_vma got_entry_offset,
3506 bfd_vma relocation)
3507 {
3508 switch (elf_m68k_reloc_got_type (r_type))
3509 {
3510 case R_68K_GOT32O:
3511 bfd_put_32 (output_bfd, relocation, sgot->contents + got_entry_offset);
3512 break;
3513
3514 case R_68K_TLS_GD32:
3515 /* We know the offset within the module,
3516 put it into the second GOT slot. */
3517 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3518 sgot->contents + got_entry_offset + 4);
3519 /* FALLTHRU */
3520
3521 case R_68K_TLS_LDM32:
3522 /* Mark it as belonging to module 1, the executable. */
3523 bfd_put_32 (output_bfd, 1, sgot->contents + got_entry_offset);
3524 break;
3525
3526 case R_68K_TLS_IE32:
3527 bfd_put_32 (output_bfd, relocation - tpoff_base (info),
3528 sgot->contents + got_entry_offset);
3529 break;
3530
3531 default:
3532 BFD_ASSERT (FALSE);
3533 }
3534 }
3535
3536 /* Output necessary relocation to handle a local symbol
3537 during dynamic link.
3538 This function is called either from elf_m68k_relocate_section
3539 or from elf_m68k_finish_dynamic_symbol. */
3540
3541 static void
3542 elf_m68k_init_got_entry_local_shared (struct bfd_link_info *info,
3543 bfd *output_bfd,
3544 enum elf_m68k_reloc_type r_type,
3545 asection *sgot,
3546 bfd_vma got_entry_offset,
3547 bfd_vma relocation,
3548 asection *srela)
3549 {
3550 Elf_Internal_Rela outrel;
3551
3552 switch (elf_m68k_reloc_got_type (r_type))
3553 {
3554 case R_68K_GOT32O:
3555 /* Emit RELATIVE relocation to initialize GOT slot
3556 at run-time. */
3557 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
3558 outrel.r_addend = relocation;
3559 break;
3560
3561 case R_68K_TLS_GD32:
3562 /* We know the offset within the module,
3563 put it into the second GOT slot. */
3564 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3565 sgot->contents + got_entry_offset + 4);
3566 /* FALLTHRU */
3567
3568 case R_68K_TLS_LDM32:
3569 /* We don't know the module number,
3570 create a relocation for it. */
3571 outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_DTPMOD32);
3572 outrel.r_addend = 0;
3573 break;
3574
3575 case R_68K_TLS_IE32:
3576 /* Emit TPREL relocation to initialize GOT slot
3577 at run-time. */
3578 outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_TPREL32);
3579 outrel.r_addend = relocation - elf_hash_table (info)->tls_sec->vma;
3580 break;
3581
3582 default:
3583 BFD_ASSERT (FALSE);
3584 }
3585
3586 /* Offset of the GOT entry. */
3587 outrel.r_offset = (sgot->output_section->vma
3588 + sgot->output_offset
3589 + got_entry_offset);
3590
3591 /* Install one of the above relocations. */
3592 elf_m68k_install_rela (output_bfd, srela, &outrel);
3593
3594 bfd_put_32 (output_bfd, outrel.r_addend, sgot->contents + got_entry_offset);
3595 }
3596
3597 /* Relocate an M68K ELF section. */
3598
3599 static bfd_boolean
3600 elf_m68k_relocate_section (bfd *output_bfd,
3601 struct bfd_link_info *info,
3602 bfd *input_bfd,
3603 asection *input_section,
3604 bfd_byte *contents,
3605 Elf_Internal_Rela *relocs,
3606 Elf_Internal_Sym *local_syms,
3607 asection **local_sections)
3608 {
3609 bfd *dynobj;
3610 Elf_Internal_Shdr *symtab_hdr;
3611 struct elf_link_hash_entry **sym_hashes;
3612 asection *sgot;
3613 asection *splt;
3614 asection *sreloc;
3615 asection *srela;
3616 struct elf_m68k_got *got;
3617 Elf_Internal_Rela *rel;
3618 Elf_Internal_Rela *relend;
3619
3620 dynobj = elf_hash_table (info)->dynobj;
3621 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3622 sym_hashes = elf_sym_hashes (input_bfd);
3623
3624 sgot = NULL;
3625 splt = NULL;
3626 sreloc = NULL;
3627 srela = NULL;
3628
3629 got = NULL;
3630
3631 rel = relocs;
3632 relend = relocs + input_section->reloc_count;
3633 for (; rel < relend; rel++)
3634 {
3635 int r_type;
3636 reloc_howto_type *howto;
3637 unsigned long r_symndx;
3638 struct elf_link_hash_entry *h;
3639 Elf_Internal_Sym *sym;
3640 asection *sec;
3641 bfd_vma relocation;
3642 bfd_boolean unresolved_reloc;
3643 bfd_reloc_status_type r;
3644
3645 r_type = ELF32_R_TYPE (rel->r_info);
3646 if (r_type < 0 || r_type >= (int) R_68K_max)
3647 {
3648 bfd_set_error (bfd_error_bad_value);
3649 return FALSE;
3650 }
3651 howto = howto_table + r_type;
3652
3653 r_symndx = ELF32_R_SYM (rel->r_info);
3654
3655 h = NULL;
3656 sym = NULL;
3657 sec = NULL;
3658 unresolved_reloc = FALSE;
3659
3660 if (r_symndx < symtab_hdr->sh_info)
3661 {
3662 sym = local_syms + r_symndx;
3663 sec = local_sections[r_symndx];
3664 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3665 }
3666 else
3667 {
3668 bfd_boolean warned;
3669
3670 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3671 r_symndx, symtab_hdr, sym_hashes,
3672 h, sec, relocation,
3673 unresolved_reloc, warned);
3674 }
3675
3676 if (sec != NULL && discarded_section (sec))
3677 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3678 rel, 1, relend, howto, 0, contents);
3679
3680 if (info->relocatable)
3681 continue;
3682
3683 switch (r_type)
3684 {
3685 case R_68K_GOT8:
3686 case R_68K_GOT16:
3687 case R_68K_GOT32:
3688 /* Relocation is to the address of the entry for this symbol
3689 in the global offset table. */
3690 if (h != NULL
3691 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3692 {
3693 if (elf_m68k_hash_table (info)->local_gp_p)
3694 {
3695 bfd_vma sgot_output_offset;
3696 bfd_vma got_offset;
3697
3698 if (sgot == NULL)
3699 {
3700 sgot = bfd_get_linker_section (dynobj, ".got");
3701
3702 if (sgot != NULL)
3703 sgot_output_offset = sgot->output_offset;
3704 else
3705 /* In this case we have a reference to
3706 _GLOBAL_OFFSET_TABLE_, but the GOT itself is
3707 empty.
3708 ??? Issue a warning? */
3709 sgot_output_offset = 0;
3710 }
3711 else
3712 sgot_output_offset = sgot->output_offset;
3713
3714 if (got == NULL)
3715 {
3716 struct elf_m68k_bfd2got_entry *bfd2got_entry;
3717
3718 bfd2got_entry
3719 = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3720 input_bfd, SEARCH, NULL);
3721
3722 if (bfd2got_entry != NULL)
3723 {
3724 got = bfd2got_entry->got;
3725 BFD_ASSERT (got != NULL);
3726
3727 got_offset = got->offset;
3728 }
3729 else
3730 /* In this case we have a reference to
3731 _GLOBAL_OFFSET_TABLE_, but no other references
3732 accessing any GOT entries.
3733 ??? Issue a warning? */
3734 got_offset = 0;
3735 }
3736 else
3737 got_offset = got->offset;
3738
3739 /* Adjust GOT pointer to point to the GOT
3740 assigned to input_bfd. */
3741 rel->r_addend += sgot_output_offset + got_offset;
3742 }
3743 else
3744 BFD_ASSERT (got == NULL || got->offset == 0);
3745
3746 break;
3747 }
3748 /* Fall through. */
3749 case R_68K_GOT8O:
3750 case R_68K_GOT16O:
3751 case R_68K_GOT32O:
3752
3753 case R_68K_TLS_LDM32:
3754 case R_68K_TLS_LDM16:
3755 case R_68K_TLS_LDM8:
3756
3757 case R_68K_TLS_GD8:
3758 case R_68K_TLS_GD16:
3759 case R_68K_TLS_GD32:
3760
3761 case R_68K_TLS_IE8:
3762 case R_68K_TLS_IE16:
3763 case R_68K_TLS_IE32:
3764
3765 /* Relocation is the offset of the entry for this symbol in
3766 the global offset table. */
3767
3768 {
3769 struct elf_m68k_got_entry_key key_;
3770 bfd_vma *off_ptr;
3771 bfd_vma off;
3772
3773 if (sgot == NULL)
3774 {
3775 sgot = bfd_get_linker_section (dynobj, ".got");
3776 BFD_ASSERT (sgot != NULL);
3777 }
3778
3779 if (got == NULL)
3780 {
3781 got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3782 input_bfd, MUST_FIND,
3783 NULL)->got;
3784 BFD_ASSERT (got != NULL);
3785 }
3786
3787 /* Get GOT offset for this symbol. */
3788 elf_m68k_init_got_entry_key (&key_, h, input_bfd, r_symndx,
3789 r_type);
3790 off_ptr = &elf_m68k_get_got_entry (got, &key_, MUST_FIND,
3791 NULL)->u.s2.offset;
3792 off = *off_ptr;
3793
3794 /* The offset must always be a multiple of 4. We use
3795 the least significant bit to record whether we have
3796 already generated the necessary reloc. */
3797 if ((off & 1) != 0)
3798 off &= ~1;
3799 else
3800 {
3801 if (h != NULL
3802 /* @TLSLDM relocations are bounded to the module, in
3803 which the symbol is defined -- not to the symbol
3804 itself. */
3805 && elf_m68k_reloc_got_type (r_type) != R_68K_TLS_LDM32)
3806 {
3807 bfd_boolean dyn;
3808
3809 dyn = elf_hash_table (info)->dynamic_sections_created;
3810 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3811 || (info->shared
3812 && SYMBOL_REFERENCES_LOCAL (info, h))
3813 || (ELF_ST_VISIBILITY (h->other)
3814 && h->root.type == bfd_link_hash_undefweak))
3815 {
3816 /* This is actually a static link, or it is a
3817 -Bsymbolic link and the symbol is defined
3818 locally, or the symbol was forced to be local
3819 because of a version file. We must initialize
3820 this entry in the global offset table. Since
3821 the offset must always be a multiple of 4, we
3822 use the least significant bit to record whether
3823 we have initialized it already.
3824
3825 When doing a dynamic link, we create a .rela.got
3826 relocation entry to initialize the value. This
3827 is done in the finish_dynamic_symbol routine. */
3828
3829 elf_m68k_init_got_entry_static (info,
3830 output_bfd,
3831 r_type,
3832 sgot,
3833 off,
3834 relocation);
3835
3836 *off_ptr |= 1;
3837 }
3838 else
3839 unresolved_reloc = FALSE;
3840 }
3841 else if (info->shared) /* && h == NULL */
3842 /* Process local symbol during dynamic link. */
3843 {
3844 if (srela == NULL)
3845 {
3846 srela = bfd_get_linker_section (dynobj, ".rela.got");
3847 BFD_ASSERT (srela != NULL);
3848 }
3849
3850 elf_m68k_init_got_entry_local_shared (info,
3851 output_bfd,
3852 r_type,
3853 sgot,
3854 off,
3855 relocation,
3856 srela);
3857
3858 *off_ptr |= 1;
3859 }
3860 else /* h == NULL && !info->shared */
3861 {
3862 elf_m68k_init_got_entry_static (info,
3863 output_bfd,
3864 r_type,
3865 sgot,
3866 off,
3867 relocation);
3868
3869 *off_ptr |= 1;
3870 }
3871 }
3872
3873 /* We don't use elf_m68k_reloc_got_type in the condition below
3874 because this is the only place where difference between
3875 R_68K_GOTx and R_68K_GOTxO relocations matters. */
3876 if (r_type == R_68K_GOT32O
3877 || r_type == R_68K_GOT16O
3878 || r_type == R_68K_GOT8O
3879 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_GD32
3880 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_LDM32
3881 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_IE32)
3882 {
3883 /* GOT pointer is adjusted to point to the start/middle
3884 of local GOT. Adjust the offset accordingly. */
3885 BFD_ASSERT (elf_m68k_hash_table (info)->use_neg_got_offsets_p
3886 || off >= got->offset);
3887
3888 if (elf_m68k_hash_table (info)->local_gp_p)
3889 relocation = off - got->offset;
3890 else
3891 {
3892 BFD_ASSERT (got->offset == 0);
3893 relocation = sgot->output_offset + off;
3894 }
3895
3896 /* This relocation does not use the addend. */
3897 rel->r_addend = 0;
3898 }
3899 else
3900 relocation = (sgot->output_section->vma + sgot->output_offset
3901 + off);
3902 }
3903 break;
3904
3905 case R_68K_TLS_LDO32:
3906 case R_68K_TLS_LDO16:
3907 case R_68K_TLS_LDO8:
3908 relocation -= dtpoff_base (info);
3909 break;
3910
3911 case R_68K_TLS_LE32:
3912 case R_68K_TLS_LE16:
3913 case R_68K_TLS_LE8:
3914 if (info->shared && !info->pie)
3915 {
3916 (*_bfd_error_handler)
3917 (_("%B(%A+0x%lx): R_68K_TLS_LE32 relocation not permitted "
3918 "in shared object"),
3919 input_bfd, input_section, (long) rel->r_offset, howto->name);
3920
3921 return FALSE;
3922 }
3923 else
3924 relocation -= tpoff_base (info);
3925
3926 break;
3927
3928 case R_68K_PLT8:
3929 case R_68K_PLT16:
3930 case R_68K_PLT32:
3931 /* Relocation is to the entry for this symbol in the
3932 procedure linkage table. */
3933
3934 /* Resolve a PLTxx reloc against a local symbol directly,
3935 without using the procedure linkage table. */
3936 if (h == NULL)
3937 break;
3938
3939 if (h->plt.offset == (bfd_vma) -1
3940 || !elf_hash_table (info)->dynamic_sections_created)
3941 {
3942 /* We didn't make a PLT entry for this symbol. This
3943 happens when statically linking PIC code, or when
3944 using -Bsymbolic. */
3945 break;
3946 }
3947
3948 if (splt == NULL)
3949 {
3950 splt = bfd_get_linker_section (dynobj, ".plt");
3951 BFD_ASSERT (splt != NULL);
3952 }
3953
3954 relocation = (splt->output_section->vma
3955 + splt->output_offset
3956 + h->plt.offset);
3957 unresolved_reloc = FALSE;
3958 break;
3959
3960 case R_68K_PLT8O:
3961 case R_68K_PLT16O:
3962 case R_68K_PLT32O:
3963 /* Relocation is the offset of the entry for this symbol in
3964 the procedure linkage table. */
3965 BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
3966
3967 if (splt == NULL)
3968 {
3969 splt = bfd_get_linker_section (dynobj, ".plt");
3970 BFD_ASSERT (splt != NULL);
3971 }
3972
3973 relocation = h->plt.offset;
3974 unresolved_reloc = FALSE;
3975
3976 /* This relocation does not use the addend. */
3977 rel->r_addend = 0;
3978
3979 break;
3980
3981 case R_68K_8:
3982 case R_68K_16:
3983 case R_68K_32:
3984 case R_68K_PC8:
3985 case R_68K_PC16:
3986 case R_68K_PC32:
3987 if (info->shared
3988 && r_symndx != STN_UNDEF
3989 && (input_section->flags & SEC_ALLOC) != 0
3990 && (h == NULL
3991 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3992 || h->root.type != bfd_link_hash_undefweak)
3993 && ((r_type != R_68K_PC8
3994 && r_type != R_68K_PC16
3995 && r_type != R_68K_PC32)
3996 || !SYMBOL_CALLS_LOCAL (info, h)))
3997 {
3998 Elf_Internal_Rela outrel;
3999 bfd_byte *loc;
4000 bfd_boolean skip, relocate;
4001
4002 /* When generating a shared object, these relocations
4003 are copied into the output file to be resolved at run
4004 time. */
4005
4006 skip = FALSE;
4007 relocate = FALSE;
4008
4009 outrel.r_offset =
4010 _bfd_elf_section_offset (output_bfd, info, input_section,
4011 rel->r_offset);
4012 if (outrel.r_offset == (bfd_vma) -1)
4013 skip = TRUE;
4014 else if (outrel.r_offset == (bfd_vma) -2)
4015 skip = TRUE, relocate = TRUE;
4016 outrel.r_offset += (input_section->output_section->vma
4017 + input_section->output_offset);
4018
4019 if (skip)
4020 memset (&outrel, 0, sizeof outrel);
4021 else if (h != NULL
4022 && h->dynindx != -1
4023 && (r_type == R_68K_PC8
4024 || r_type == R_68K_PC16
4025 || r_type == R_68K_PC32
4026 || !info->shared
4027 || !info->symbolic
4028 || !h->def_regular))
4029 {
4030 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4031 outrel.r_addend = rel->r_addend;
4032 }
4033 else
4034 {
4035 /* This symbol is local, or marked to become local. */
4036 outrel.r_addend = relocation + rel->r_addend;
4037
4038 if (r_type == R_68K_32)
4039 {
4040 relocate = TRUE;
4041 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
4042 }
4043 else
4044 {
4045 long indx;
4046
4047 if (bfd_is_abs_section (sec))
4048 indx = 0;
4049 else if (sec == NULL || sec->owner == NULL)
4050 {
4051 bfd_set_error (bfd_error_bad_value);
4052 return FALSE;
4053 }
4054 else
4055 {
4056 asection *osec;
4057
4058 /* We are turning this relocation into one
4059 against a section symbol. It would be
4060 proper to subtract the symbol's value,
4061 osec->vma, from the emitted reloc addend,
4062 but ld.so expects buggy relocs. */
4063 osec = sec->output_section;
4064 indx = elf_section_data (osec)->dynindx;
4065 if (indx == 0)
4066 {
4067 struct elf_link_hash_table *htab;
4068 htab = elf_hash_table (info);
4069 osec = htab->text_index_section;
4070 indx = elf_section_data (osec)->dynindx;
4071 }
4072 BFD_ASSERT (indx != 0);
4073 }
4074
4075 outrel.r_info = ELF32_R_INFO (indx, r_type);
4076 }
4077 }
4078
4079 sreloc = elf_section_data (input_section)->sreloc;
4080 if (sreloc == NULL)
4081 abort ();
4082
4083 loc = sreloc->contents;
4084 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4085 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4086
4087 /* This reloc will be computed at runtime, so there's no
4088 need to do anything now, except for R_68K_32
4089 relocations that have been turned into
4090 R_68K_RELATIVE. */
4091 if (!relocate)
4092 continue;
4093 }
4094
4095 break;
4096
4097 case R_68K_GNU_VTINHERIT:
4098 case R_68K_GNU_VTENTRY:
4099 /* These are no-ops in the end. */
4100 continue;
4101
4102 default:
4103 break;
4104 }
4105
4106 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4107 because such sections are not SEC_ALLOC and thus ld.so will
4108 not process them. */
4109 if (unresolved_reloc
4110 && !((input_section->flags & SEC_DEBUGGING) != 0
4111 && h->def_dynamic)
4112 && _bfd_elf_section_offset (output_bfd, info, input_section,
4113 rel->r_offset) != (bfd_vma) -1)
4114 {
4115 (*_bfd_error_handler)
4116 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4117 input_bfd,
4118 input_section,
4119 (long) rel->r_offset,
4120 howto->name,
4121 h->root.root.string);
4122 return FALSE;
4123 }
4124
4125 if (r_symndx != STN_UNDEF
4126 && r_type != R_68K_NONE
4127 && (h == NULL
4128 || h->root.type == bfd_link_hash_defined
4129 || h->root.type == bfd_link_hash_defweak))
4130 {
4131 char sym_type;
4132
4133 sym_type = (sym != NULL) ? ELF32_ST_TYPE (sym->st_info) : h->type;
4134
4135 if (elf_m68k_reloc_tls_p (r_type) != (sym_type == STT_TLS))
4136 {
4137 const char *name;
4138
4139 if (h != NULL)
4140 name = h->root.root.string;
4141 else
4142 {
4143 name = (bfd_elf_string_from_elf_section
4144 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4145 if (name == NULL || *name == '\0')
4146 name = bfd_section_name (input_bfd, sec);
4147 }
4148
4149 (*_bfd_error_handler)
4150 ((sym_type == STT_TLS
4151 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
4152 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
4153 input_bfd,
4154 input_section,
4155 (long) rel->r_offset,
4156 howto->name,
4157 name);
4158 }
4159 }
4160
4161 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4162 contents, rel->r_offset,
4163 relocation, rel->r_addend);
4164
4165 if (r != bfd_reloc_ok)
4166 {
4167 const char *name;
4168
4169 if (h != NULL)
4170 name = h->root.root.string;
4171 else
4172 {
4173 name = bfd_elf_string_from_elf_section (input_bfd,
4174 symtab_hdr->sh_link,
4175 sym->st_name);
4176 if (name == NULL)
4177 return FALSE;
4178 if (*name == '\0')
4179 name = bfd_section_name (input_bfd, sec);
4180 }
4181
4182 if (r == bfd_reloc_overflow)
4183 {
4184 if (!(info->callbacks->reloc_overflow
4185 (info, (h ? &h->root : NULL), name, howto->name,
4186 (bfd_vma) 0, input_bfd, input_section,
4187 rel->r_offset)))
4188 return FALSE;
4189 }
4190 else
4191 {
4192 (*_bfd_error_handler)
4193 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4194 input_bfd, input_section,
4195 (long) rel->r_offset, name, (int) r);
4196 return FALSE;
4197 }
4198 }
4199 }
4200
4201 return TRUE;
4202 }
4203
4204 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
4205 into section SEC. */
4206
4207 static void
4208 elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value)
4209 {
4210 /* Make VALUE PC-relative. */
4211 value -= sec->output_section->vma + offset;
4212
4213 /* Apply any in-place addend. */
4214 value += bfd_get_32 (sec->owner, sec->contents + offset);
4215
4216 bfd_put_32 (sec->owner, value, sec->contents + offset);
4217 }
4218
4219 /* Finish up dynamic symbol handling. We set the contents of various
4220 dynamic sections here. */
4221
4222 static bfd_boolean
4223 elf_m68k_finish_dynamic_symbol (bfd *output_bfd,
4224 struct bfd_link_info *info,
4225 struct elf_link_hash_entry *h,
4226 Elf_Internal_Sym *sym)
4227 {
4228 bfd *dynobj;
4229
4230 dynobj = elf_hash_table (info)->dynobj;
4231
4232 if (h->plt.offset != (bfd_vma) -1)
4233 {
4234 const struct elf_m68k_plt_info *plt_info;
4235 asection *splt;
4236 asection *sgot;
4237 asection *srela;
4238 bfd_vma plt_index;
4239 bfd_vma got_offset;
4240 Elf_Internal_Rela rela;
4241 bfd_byte *loc;
4242
4243 /* This symbol has an entry in the procedure linkage table. Set
4244 it up. */
4245
4246 BFD_ASSERT (h->dynindx != -1);
4247
4248 plt_info = elf_m68k_hash_table (info)->plt_info;
4249 splt = bfd_get_linker_section (dynobj, ".plt");
4250 sgot = bfd_get_linker_section (dynobj, ".got.plt");
4251 srela = bfd_get_linker_section (dynobj, ".rela.plt");
4252 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
4253
4254 /* Get the index in the procedure linkage table which
4255 corresponds to this symbol. This is the index of this symbol
4256 in all the symbols for which we are making plt entries. The
4257 first entry in the procedure linkage table is reserved. */
4258 plt_index = (h->plt.offset / plt_info->size) - 1;
4259
4260 /* Get the offset into the .got table of the entry that
4261 corresponds to this function. Each .got entry is 4 bytes.
4262 The first three are reserved. */
4263 got_offset = (plt_index + 3) * 4;
4264
4265 memcpy (splt->contents + h->plt.offset,
4266 plt_info->symbol_entry,
4267 plt_info->size);
4268
4269 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got,
4270 (sgot->output_section->vma
4271 + sgot->output_offset
4272 + got_offset));
4273
4274 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4275 splt->contents
4276 + h->plt.offset
4277 + plt_info->symbol_resolve_entry + 2);
4278
4279 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt,
4280 splt->output_section->vma);
4281
4282 /* Fill in the entry in the global offset table. */
4283 bfd_put_32 (output_bfd,
4284 (splt->output_section->vma
4285 + splt->output_offset
4286 + h->plt.offset
4287 + plt_info->symbol_resolve_entry),
4288 sgot->contents + got_offset);
4289
4290 /* Fill in the entry in the .rela.plt section. */
4291 rela.r_offset = (sgot->output_section->vma
4292 + sgot->output_offset
4293 + got_offset);
4294 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
4295 rela.r_addend = 0;
4296 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
4297 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4298
4299 if (!h->def_regular)
4300 {
4301 /* Mark the symbol as undefined, rather than as defined in
4302 the .plt section. Leave the value alone. */
4303 sym->st_shndx = SHN_UNDEF;
4304 }
4305 }
4306
4307 if (elf_m68k_hash_entry (h)->glist != NULL)
4308 {
4309 asection *sgot;
4310 asection *srela;
4311 struct elf_m68k_got_entry *got_entry;
4312
4313 /* This symbol has an entry in the global offset table. Set it
4314 up. */
4315
4316 sgot = bfd_get_linker_section (dynobj, ".got");
4317 srela = bfd_get_linker_section (dynobj, ".rela.got");
4318 BFD_ASSERT (sgot != NULL && srela != NULL);
4319
4320 got_entry = elf_m68k_hash_entry (h)->glist;
4321
4322 while (got_entry != NULL)
4323 {
4324 enum elf_m68k_reloc_type r_type;
4325 bfd_vma got_entry_offset;
4326
4327 r_type = got_entry->key_.type;
4328 got_entry_offset = got_entry->u.s2.offset &~ (bfd_vma) 1;
4329
4330 /* If this is a -Bsymbolic link, and the symbol is defined
4331 locally, we just want to emit a RELATIVE reloc. Likewise if
4332 the symbol was forced to be local because of a version file.
4333 The entry in the global offset table already have been
4334 initialized in the relocate_section function. */
4335 if (info->shared
4336 && SYMBOL_REFERENCES_LOCAL (info, h))
4337 {
4338 bfd_vma relocation;
4339
4340 relocation = bfd_get_signed_32 (output_bfd,
4341 (sgot->contents
4342 + got_entry_offset));
4343
4344 /* Undo TP bias. */
4345 switch (elf_m68k_reloc_got_type (r_type))
4346 {
4347 case R_68K_GOT32O:
4348 case R_68K_TLS_LDM32:
4349 break;
4350
4351 case R_68K_TLS_GD32:
4352 /* The value for this relocation is actually put in
4353 the second GOT slot. */
4354 relocation = bfd_get_signed_32 (output_bfd,
4355 (sgot->contents
4356 + got_entry_offset + 4));
4357 relocation += dtpoff_base (info);
4358 break;
4359
4360 case R_68K_TLS_IE32:
4361 relocation += tpoff_base (info);
4362 break;
4363
4364 default:
4365 BFD_ASSERT (FALSE);
4366 }
4367
4368 elf_m68k_init_got_entry_local_shared (info,
4369 output_bfd,
4370 r_type,
4371 sgot,
4372 got_entry_offset,
4373 relocation,
4374 srela);
4375 }
4376 else
4377 {
4378 Elf_Internal_Rela rela;
4379
4380 /* Put zeros to GOT slots that will be initialized
4381 at run-time. */
4382 {
4383 bfd_vma n_slots;
4384
4385 n_slots = elf_m68k_reloc_got_n_slots (got_entry->key_.type);
4386 while (n_slots--)
4387 bfd_put_32 (output_bfd, (bfd_vma) 0,
4388 (sgot->contents + got_entry_offset
4389 + 4 * n_slots));
4390 }
4391
4392 rela.r_addend = 0;
4393 rela.r_offset = (sgot->output_section->vma
4394 + sgot->output_offset
4395 + got_entry_offset);
4396
4397 switch (elf_m68k_reloc_got_type (r_type))
4398 {
4399 case R_68K_GOT32O:
4400 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
4401 elf_m68k_install_rela (output_bfd, srela, &rela);
4402 break;
4403
4404 case R_68K_TLS_GD32:
4405 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_DTPMOD32);
4406 elf_m68k_install_rela (output_bfd, srela, &rela);
4407
4408 rela.r_offset += 4;
4409 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_DTPREL32);
4410 elf_m68k_install_rela (output_bfd, srela, &rela);
4411 break;
4412
4413 case R_68K_TLS_IE32:
4414 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_TPREL32);
4415 elf_m68k_install_rela (output_bfd, srela, &rela);
4416 break;
4417
4418 default:
4419 BFD_ASSERT (FALSE);
4420 break;
4421 }
4422 }
4423
4424 got_entry = got_entry->u.s2.next;
4425 }
4426 }
4427
4428 if (h->needs_copy)
4429 {
4430 asection *s;
4431 Elf_Internal_Rela rela;
4432 bfd_byte *loc;
4433
4434 /* This symbol needs a copy reloc. Set it up. */
4435
4436 BFD_ASSERT (h->dynindx != -1
4437 && (h->root.type == bfd_link_hash_defined
4438 || h->root.type == bfd_link_hash_defweak));
4439
4440 s = bfd_get_linker_section (dynobj, ".rela.bss");
4441 BFD_ASSERT (s != NULL);
4442
4443 rela.r_offset = (h->root.u.def.value
4444 + h->root.u.def.section->output_section->vma
4445 + h->root.u.def.section->output_offset);
4446 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
4447 rela.r_addend = 0;
4448 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
4449 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4450 }
4451
4452 return TRUE;
4453 }
4454
4455 /* Finish up the dynamic sections. */
4456
4457 static bfd_boolean
4458 elf_m68k_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4459 {
4460 bfd *dynobj;
4461 asection *sgot;
4462 asection *sdyn;
4463
4464 dynobj = elf_hash_table (info)->dynobj;
4465
4466 sgot = bfd_get_linker_section (dynobj, ".got.plt");
4467 BFD_ASSERT (sgot != NULL);
4468 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4469
4470 if (elf_hash_table (info)->dynamic_sections_created)
4471 {
4472 asection *splt;
4473 Elf32_External_Dyn *dyncon, *dynconend;
4474
4475 splt = bfd_get_linker_section (dynobj, ".plt");
4476 BFD_ASSERT (splt != NULL && sdyn != NULL);
4477
4478 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4479 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4480 for (; dyncon < dynconend; dyncon++)
4481 {
4482 Elf_Internal_Dyn dyn;
4483 const char *name;
4484 asection *s;
4485
4486 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4487
4488 switch (dyn.d_tag)
4489 {
4490 default:
4491 break;
4492
4493 case DT_PLTGOT:
4494 name = ".got";
4495 goto get_vma;
4496 case DT_JMPREL:
4497 name = ".rela.plt";
4498 get_vma:
4499 s = bfd_get_section_by_name (output_bfd, name);
4500 BFD_ASSERT (s != NULL);
4501 dyn.d_un.d_ptr = s->vma;
4502 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4503 break;
4504
4505 case DT_PLTRELSZ:
4506 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4507 BFD_ASSERT (s != NULL);
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_section_by_name (output_bfd, ".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 (abfd, info, datasec, relsec, errmsg)
4578 bfd *abfd;
4579 struct bfd_link_info *info;
4580 asection *datasec;
4581 asection *relsec;
4582 char **errmsg;
4583 {
4584 Elf_Internal_Shdr *symtab_hdr;
4585 Elf_Internal_Sym *isymbuf = NULL;
4586 Elf_Internal_Rela *internal_relocs = NULL;
4587 Elf_Internal_Rela *irel, *irelend;
4588 bfd_byte *p;
4589 bfd_size_type amt;
4590
4591 BFD_ASSERT (! info->relocatable);
4592
4593 *errmsg = NULL;
4594
4595 if (datasec->reloc_count == 0)
4596 return TRUE;
4597
4598 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4599
4600 /* Get a copy of the native relocations. */
4601 internal_relocs = (_bfd_elf_link_read_relocs
4602 (abfd, datasec, NULL, (Elf_Internal_Rela *) NULL,
4603 info->keep_memory));
4604 if (internal_relocs == NULL)
4605 goto error_return;
4606
4607 amt = (bfd_size_type) datasec->reloc_count * 12;
4608 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
4609 if (relsec->contents == NULL)
4610 goto error_return;
4611
4612 p = relsec->contents;
4613
4614 irelend = internal_relocs + datasec->reloc_count;
4615 for (irel = internal_relocs; irel < irelend; irel++, p += 12)
4616 {
4617 asection *targetsec;
4618
4619 /* We are going to write a four byte longword into the runtime
4620 reloc section. The longword will be the address in the data
4621 section which must be relocated. It is followed by the name
4622 of the target section NUL-padded or truncated to 8
4623 characters. */
4624
4625 /* We can only relocate absolute longword relocs at run time. */
4626 if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
4627 {
4628 *errmsg = _("unsupported reloc type");
4629 bfd_set_error (bfd_error_bad_value);
4630 goto error_return;
4631 }
4632
4633 /* Get the target section referred to by the reloc. */
4634 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
4635 {
4636 /* A local symbol. */
4637 Elf_Internal_Sym *isym;
4638
4639 /* Read this BFD's local symbols if we haven't done so already. */
4640 if (isymbuf == NULL)
4641 {
4642 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4643 if (isymbuf == NULL)
4644 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
4645 symtab_hdr->sh_info, 0,
4646 NULL, NULL, NULL);
4647 if (isymbuf == NULL)
4648 goto error_return;
4649 }
4650
4651 isym = isymbuf + ELF32_R_SYM (irel->r_info);
4652 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
4653 }
4654 else
4655 {
4656 unsigned long indx;
4657 struct elf_link_hash_entry *h;
4658
4659 /* An external symbol. */
4660 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
4661 h = elf_sym_hashes (abfd)[indx];
4662 BFD_ASSERT (h != NULL);
4663 if (h->root.type == bfd_link_hash_defined
4664 || h->root.type == bfd_link_hash_defweak)
4665 targetsec = h->root.u.def.section;
4666 else
4667 targetsec = NULL;
4668 }
4669
4670 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
4671 memset (p + 4, 0, 8);
4672 if (targetsec != NULL)
4673 strncpy ((char *) p + 4, targetsec->output_section->name, 8);
4674 }
4675
4676 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4677 free (isymbuf);
4678 if (internal_relocs != NULL
4679 && elf_section_data (datasec)->relocs != internal_relocs)
4680 free (internal_relocs);
4681 return TRUE;
4682
4683 error_return:
4684 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4685 free (isymbuf);
4686 if (internal_relocs != NULL
4687 && elf_section_data (datasec)->relocs != internal_relocs)
4688 free (internal_relocs);
4689 return FALSE;
4690 }
4691
4692 /* Set target options. */
4693
4694 void
4695 bfd_elf_m68k_set_target_options (struct bfd_link_info *info, int got_handling)
4696 {
4697 struct elf_m68k_link_hash_table *htab;
4698 bfd_boolean use_neg_got_offsets_p;
4699 bfd_boolean allow_multigot_p;
4700 bfd_boolean local_gp_p;
4701
4702 switch (got_handling)
4703 {
4704 case 0:
4705 /* --got=single. */
4706 local_gp_p = FALSE;
4707 use_neg_got_offsets_p = FALSE;
4708 allow_multigot_p = FALSE;
4709 break;
4710
4711 case 1:
4712 /* --got=negative. */
4713 local_gp_p = TRUE;
4714 use_neg_got_offsets_p = TRUE;
4715 allow_multigot_p = FALSE;
4716 break;
4717
4718 case 2:
4719 /* --got=multigot. */
4720 local_gp_p = TRUE;
4721 use_neg_got_offsets_p = TRUE;
4722 allow_multigot_p = TRUE;
4723 break;
4724
4725 default:
4726 BFD_ASSERT (FALSE);
4727 return;
4728 }
4729
4730 htab = elf_m68k_hash_table (info);
4731 if (htab != NULL)
4732 {
4733 htab->local_gp_p = local_gp_p;
4734 htab->use_neg_got_offsets_p = use_neg_got_offsets_p;
4735 htab->allow_multigot_p = allow_multigot_p;
4736 }
4737 }
4738
4739 static enum elf_reloc_type_class
4740 elf32_m68k_reloc_type_class (const Elf_Internal_Rela *rela)
4741 {
4742 switch ((int) ELF32_R_TYPE (rela->r_info))
4743 {
4744 case R_68K_RELATIVE:
4745 return reloc_class_relative;
4746 case R_68K_JMP_SLOT:
4747 return reloc_class_plt;
4748 case R_68K_COPY:
4749 return reloc_class_copy;
4750 default:
4751 return reloc_class_normal;
4752 }
4753 }
4754
4755 /* Return address for Ith PLT stub in section PLT, for relocation REL
4756 or (bfd_vma) -1 if it should not be included. */
4757
4758 static bfd_vma
4759 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
4760 const arelent *rel ATTRIBUTE_UNUSED)
4761 {
4762 return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
4763 }
4764
4765 /* Support for core dump NOTE sections. */
4766
4767 static bfd_boolean
4768 elf_m68k_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
4769 {
4770 int offset;
4771 size_t size;
4772
4773 switch (note->descsz)
4774 {
4775 default:
4776 return FALSE;
4777
4778 case 154: /* Linux/m68k */
4779 /* pr_cursig */
4780 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
4781
4782 /* pr_pid */
4783 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 22);
4784
4785 /* pr_reg */
4786 offset = 70;
4787 size = 80;
4788
4789 break;
4790 }
4791
4792 /* Make a ".reg/999" section. */
4793 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
4794 size, note->descpos + offset);
4795 }
4796
4797 static bfd_boolean
4798 elf_m68k_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
4799 {
4800 switch (note->descsz)
4801 {
4802 default:
4803 return FALSE;
4804
4805 case 124: /* Linux/m68k elf_prpsinfo. */
4806 elf_tdata (abfd)->core_pid
4807 = bfd_get_32 (abfd, note->descdata + 12);
4808 elf_tdata (abfd)->core_program
4809 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
4810 elf_tdata (abfd)->core_command
4811 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
4812 }
4813
4814 /* Note that for some reason, a spurious space is tacked
4815 onto the end of the args in some (at least one anyway)
4816 implementations, so strip it off if it exists. */
4817 {
4818 char *command = elf_tdata (abfd)->core_command;
4819 int n = strlen (command);
4820
4821 if (n > 0 && command[n - 1] == ' ')
4822 command[n - 1] = '\0';
4823 }
4824
4825 return TRUE;
4826 }
4827
4828 #define TARGET_BIG_SYM bfd_elf32_m68k_vec
4829 #define TARGET_BIG_NAME "elf32-m68k"
4830 #define ELF_MACHINE_CODE EM_68K
4831 #define ELF_MAXPAGESIZE 0x2000
4832 #define elf_backend_create_dynamic_sections \
4833 _bfd_elf_create_dynamic_sections
4834 #define bfd_elf32_bfd_link_hash_table_create \
4835 elf_m68k_link_hash_table_create
4836 /* ??? Should it be this macro or bfd_elfNN_bfd_link_hash_table_create? */
4837 #define bfd_elf32_bfd_link_hash_table_free \
4838 elf_m68k_link_hash_table_free
4839 #define bfd_elf32_bfd_final_link bfd_elf_final_link
4840
4841 #define elf_backend_check_relocs elf_m68k_check_relocs
4842 #define elf_backend_always_size_sections \
4843 elf_m68k_always_size_sections
4844 #define elf_backend_adjust_dynamic_symbol \
4845 elf_m68k_adjust_dynamic_symbol
4846 #define elf_backend_size_dynamic_sections \
4847 elf_m68k_size_dynamic_sections
4848 #define elf_backend_final_write_processing elf_m68k_final_write_processing
4849 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4850 #define elf_backend_relocate_section elf_m68k_relocate_section
4851 #define elf_backend_finish_dynamic_symbol \
4852 elf_m68k_finish_dynamic_symbol
4853 #define elf_backend_finish_dynamic_sections \
4854 elf_m68k_finish_dynamic_sections
4855 #define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook
4856 #define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook
4857 #define elf_backend_copy_indirect_symbol elf_m68k_copy_indirect_symbol
4858 #define bfd_elf32_bfd_merge_private_bfd_data \
4859 elf32_m68k_merge_private_bfd_data
4860 #define bfd_elf32_bfd_set_private_flags \
4861 elf32_m68k_set_private_flags
4862 #define bfd_elf32_bfd_print_private_bfd_data \
4863 elf32_m68k_print_private_bfd_data
4864 #define elf_backend_reloc_type_class elf32_m68k_reloc_type_class
4865 #define elf_backend_plt_sym_val elf_m68k_plt_sym_val
4866 #define elf_backend_object_p elf32_m68k_object_p
4867 #define elf_backend_grok_prstatus elf_m68k_grok_prstatus
4868 #define elf_backend_grok_psinfo elf_m68k_grok_psinfo
4869
4870 #define elf_backend_can_gc_sections 1
4871 #define elf_backend_can_refcount 1
4872 #define elf_backend_want_got_plt 1
4873 #define elf_backend_plt_readonly 1
4874 #define elf_backend_want_plt_sym 0
4875 #define elf_backend_got_header_size 12
4876 #define elf_backend_rela_normal 1
4877
4878 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.197345 seconds and 5 git commands to generate.