Add target_id to elf_backend_data.
[binutils.git] / bfd / elf32-m68k.c
blob732361217613c2e294f72cd3e175d9d89faf0734
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 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "bfdlink.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "elf/m68k.h"
28 #include "opcode/m68k.h"
30 static reloc_howto_type *reloc_type_lookup
31 PARAMS ((bfd *, bfd_reloc_code_real_type));
32 static void rtype_to_howto
33 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
34 static struct bfd_hash_entry *elf_m68k_link_hash_newfunc
35 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
36 static struct bfd_link_hash_table *elf_m68k_link_hash_table_create
37 PARAMS ((bfd *));
38 static bfd_boolean elf_m68k_check_relocs
39 PARAMS ((bfd *, struct bfd_link_info *, asection *,
40 const Elf_Internal_Rela *));
41 static bfd_boolean elf_m68k_adjust_dynamic_symbol
42 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
43 static bfd_boolean elf_m68k_size_dynamic_sections
44 PARAMS ((bfd *, struct bfd_link_info *));
45 static bfd_boolean elf_m68k_discard_copies
46 PARAMS ((struct elf_link_hash_entry *, PTR));
47 static bfd_boolean elf_m68k_relocate_section
48 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
49 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
50 static bfd_boolean elf_m68k_finish_dynamic_symbol
51 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
52 Elf_Internal_Sym *));
53 static bfd_boolean elf_m68k_finish_dynamic_sections
54 PARAMS ((bfd *, struct bfd_link_info *));
56 static bfd_boolean elf32_m68k_set_private_flags
57 PARAMS ((bfd *, flagword));
58 static bfd_boolean elf32_m68k_merge_private_bfd_data
59 PARAMS ((bfd *, bfd *));
60 static bfd_boolean elf32_m68k_print_private_bfd_data
61 PARAMS ((bfd *, PTR));
62 static enum elf_reloc_type_class elf32_m68k_reloc_type_class
63 PARAMS ((const Elf_Internal_Rela *));
65 static reloc_howto_type howto_table[] = {
66 HOWTO(R_68K_NONE, 0, 0, 0, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_NONE", FALSE, 0, 0x00000000,FALSE),
67 HOWTO(R_68K_32, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_32", FALSE, 0, 0xffffffff,FALSE),
68 HOWTO(R_68K_16, 0, 1,16, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_16", FALSE, 0, 0x0000ffff,FALSE),
69 HOWTO(R_68K_8, 0, 0, 8, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_8", FALSE, 0, 0x000000ff,FALSE),
70 HOWTO(R_68K_PC32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PC32", FALSE, 0, 0xffffffff,TRUE),
71 HOWTO(R_68K_PC16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PC16", FALSE, 0, 0x0000ffff,TRUE),
72 HOWTO(R_68K_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PC8", FALSE, 0, 0x000000ff,TRUE),
73 HOWTO(R_68K_GOT32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32", FALSE, 0, 0xffffffff,TRUE),
74 HOWTO(R_68K_GOT16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT16", FALSE, 0, 0x0000ffff,TRUE),
75 HOWTO(R_68K_GOT8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT8", FALSE, 0, 0x000000ff,TRUE),
76 HOWTO(R_68K_GOT32O, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32O", FALSE, 0, 0xffffffff,FALSE),
77 HOWTO(R_68K_GOT16O, 0, 1,16, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT16O", FALSE, 0, 0x0000ffff,FALSE),
78 HOWTO(R_68K_GOT8O, 0, 0, 8, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT8O", FALSE, 0, 0x000000ff,FALSE),
79 HOWTO(R_68K_PLT32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32", FALSE, 0, 0xffffffff,TRUE),
80 HOWTO(R_68K_PLT16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT16", FALSE, 0, 0x0000ffff,TRUE),
81 HOWTO(R_68K_PLT8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT8", FALSE, 0, 0x000000ff,TRUE),
82 HOWTO(R_68K_PLT32O, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32O", FALSE, 0, 0xffffffff,FALSE),
83 HOWTO(R_68K_PLT16O, 0, 1,16, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT16O", FALSE, 0, 0x0000ffff,FALSE),
84 HOWTO(R_68K_PLT8O, 0, 0, 8, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT8O", FALSE, 0, 0x000000ff,FALSE),
85 HOWTO(R_68K_COPY, 0, 0, 0, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_COPY", FALSE, 0, 0xffffffff,FALSE),
86 HOWTO(R_68K_GLOB_DAT, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_GLOB_DAT", FALSE, 0, 0xffffffff,FALSE),
87 HOWTO(R_68K_JMP_SLOT, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_JMP_SLOT", FALSE, 0, 0xffffffff,FALSE),
88 HOWTO(R_68K_RELATIVE, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_RELATIVE", FALSE, 0, 0xffffffff,FALSE),
89 /* GNU extension to record C++ vtable hierarchy. */
90 HOWTO (R_68K_GNU_VTINHERIT, /* type */
91 0, /* rightshift */
92 2, /* size (0 = byte, 1 = short, 2 = long) */
93 0, /* bitsize */
94 FALSE, /* pc_relative */
95 0, /* bitpos */
96 complain_overflow_dont, /* complain_on_overflow */
97 NULL, /* special_function */
98 "R_68K_GNU_VTINHERIT", /* name */
99 FALSE, /* partial_inplace */
100 0, /* src_mask */
101 0, /* dst_mask */
102 FALSE),
103 /* GNU extension to record C++ vtable member usage. */
104 HOWTO (R_68K_GNU_VTENTRY, /* type */
105 0, /* rightshift */
106 2, /* size (0 = byte, 1 = short, 2 = long) */
107 0, /* bitsize */
108 FALSE, /* pc_relative */
109 0, /* bitpos */
110 complain_overflow_dont, /* complain_on_overflow */
111 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
112 "R_68K_GNU_VTENTRY", /* name */
113 FALSE, /* partial_inplace */
114 0, /* src_mask */
115 0, /* dst_mask */
116 FALSE),
118 /* TLS general dynamic variable reference. */
119 HOWTO (R_68K_TLS_GD32, /* type */
120 0, /* rightshift */
121 2, /* size (0 = byte, 1 = short, 2 = long) */
122 32, /* bitsize */
123 FALSE, /* pc_relative */
124 0, /* bitpos */
125 complain_overflow_bitfield, /* complain_on_overflow */
126 bfd_elf_generic_reloc, /* special_function */
127 "R_68K_TLS_GD32", /* name */
128 FALSE, /* partial_inplace */
129 0, /* src_mask */
130 0xffffffff, /* dst_mask */
131 FALSE), /* pcrel_offset */
133 HOWTO (R_68K_TLS_GD16, /* type */
134 0, /* rightshift */
135 1, /* size (0 = byte, 1 = short, 2 = long) */
136 16, /* bitsize */
137 FALSE, /* pc_relative */
138 0, /* bitpos */
139 complain_overflow_signed, /* complain_on_overflow */
140 bfd_elf_generic_reloc, /* special_function */
141 "R_68K_TLS_GD16", /* name */
142 FALSE, /* partial_inplace */
143 0, /* src_mask */
144 0x0000ffff, /* dst_mask */
145 FALSE), /* pcrel_offset */
147 HOWTO (R_68K_TLS_GD8, /* type */
148 0, /* rightshift */
149 0, /* size (0 = byte, 1 = short, 2 = long) */
150 8, /* bitsize */
151 FALSE, /* pc_relative */
152 0, /* bitpos */
153 complain_overflow_signed, /* complain_on_overflow */
154 bfd_elf_generic_reloc, /* special_function */
155 "R_68K_TLS_GD8", /* name */
156 FALSE, /* partial_inplace */
157 0, /* src_mask */
158 0x000000ff, /* dst_mask */
159 FALSE), /* pcrel_offset */
161 /* TLS local dynamic variable reference. */
162 HOWTO (R_68K_TLS_LDM32, /* type */
163 0, /* rightshift */
164 2, /* size (0 = byte, 1 = short, 2 = long) */
165 32, /* bitsize */
166 FALSE, /* pc_relative */
167 0, /* bitpos */
168 complain_overflow_bitfield, /* complain_on_overflow */
169 bfd_elf_generic_reloc, /* special_function */
170 "R_68K_TLS_LDM32", /* name */
171 FALSE, /* partial_inplace */
172 0, /* src_mask */
173 0xffffffff, /* dst_mask */
174 FALSE), /* pcrel_offset */
176 HOWTO (R_68K_TLS_LDM16, /* type */
177 0, /* rightshift */
178 1, /* size (0 = byte, 1 = short, 2 = long) */
179 16, /* bitsize */
180 FALSE, /* pc_relative */
181 0, /* bitpos */
182 complain_overflow_signed, /* complain_on_overflow */
183 bfd_elf_generic_reloc, /* special_function */
184 "R_68K_TLS_LDM16", /* name */
185 FALSE, /* partial_inplace */
186 0, /* src_mask */
187 0x0000ffff, /* dst_mask */
188 FALSE), /* pcrel_offset */
190 HOWTO (R_68K_TLS_LDM8, /* type */
191 0, /* rightshift */
192 0, /* size (0 = byte, 1 = short, 2 = long) */
193 8, /* bitsize */
194 FALSE, /* pc_relative */
195 0, /* bitpos */
196 complain_overflow_signed, /* complain_on_overflow */
197 bfd_elf_generic_reloc, /* special_function */
198 "R_68K_TLS_LDM8", /* name */
199 FALSE, /* partial_inplace */
200 0, /* src_mask */
201 0x000000ff, /* dst_mask */
202 FALSE), /* pcrel_offset */
204 HOWTO (R_68K_TLS_LDO32, /* type */
205 0, /* rightshift */
206 2, /* size (0 = byte, 1 = short, 2 = long) */
207 32, /* bitsize */
208 FALSE, /* pc_relative */
209 0, /* bitpos */
210 complain_overflow_bitfield, /* complain_on_overflow */
211 bfd_elf_generic_reloc, /* special_function */
212 "R_68K_TLS_LDO32", /* name */
213 FALSE, /* partial_inplace */
214 0, /* src_mask */
215 0xffffffff, /* dst_mask */
216 FALSE), /* pcrel_offset */
218 HOWTO (R_68K_TLS_LDO16, /* type */
219 0, /* rightshift */
220 1, /* size (0 = byte, 1 = short, 2 = long) */
221 16, /* bitsize */
222 FALSE, /* pc_relative */
223 0, /* bitpos */
224 complain_overflow_signed, /* complain_on_overflow */
225 bfd_elf_generic_reloc, /* special_function */
226 "R_68K_TLS_LDO16", /* name */
227 FALSE, /* partial_inplace */
228 0, /* src_mask */
229 0x0000ffff, /* dst_mask */
230 FALSE), /* pcrel_offset */
232 HOWTO (R_68K_TLS_LDO8, /* type */
233 0, /* rightshift */
234 0, /* size (0 = byte, 1 = short, 2 = long) */
235 8, /* bitsize */
236 FALSE, /* pc_relative */
237 0, /* bitpos */
238 complain_overflow_signed, /* complain_on_overflow */
239 bfd_elf_generic_reloc, /* special_function */
240 "R_68K_TLS_LDO8", /* name */
241 FALSE, /* partial_inplace */
242 0, /* src_mask */
243 0x000000ff, /* dst_mask */
244 FALSE), /* pcrel_offset */
246 /* TLS initial execution variable reference. */
247 HOWTO (R_68K_TLS_IE32, /* type */
248 0, /* rightshift */
249 2, /* size (0 = byte, 1 = short, 2 = long) */
250 32, /* bitsize */
251 FALSE, /* pc_relative */
252 0, /* bitpos */
253 complain_overflow_bitfield, /* complain_on_overflow */
254 bfd_elf_generic_reloc, /* special_function */
255 "R_68K_TLS_IE32", /* name */
256 FALSE, /* partial_inplace */
257 0, /* src_mask */
258 0xffffffff, /* dst_mask */
259 FALSE), /* pcrel_offset */
261 HOWTO (R_68K_TLS_IE16, /* type */
262 0, /* rightshift */
263 1, /* size (0 = byte, 1 = short, 2 = long) */
264 16, /* bitsize */
265 FALSE, /* pc_relative */
266 0, /* bitpos */
267 complain_overflow_signed, /* complain_on_overflow */
268 bfd_elf_generic_reloc, /* special_function */
269 "R_68K_TLS_IE16", /* name */
270 FALSE, /* partial_inplace */
271 0, /* src_mask */
272 0x0000ffff, /* dst_mask */
273 FALSE), /* pcrel_offset */
275 HOWTO (R_68K_TLS_IE8, /* type */
276 0, /* rightshift */
277 0, /* size (0 = byte, 1 = short, 2 = long) */
278 8, /* bitsize */
279 FALSE, /* pc_relative */
280 0, /* bitpos */
281 complain_overflow_signed, /* complain_on_overflow */
282 bfd_elf_generic_reloc, /* special_function */
283 "R_68K_TLS_IE8", /* name */
284 FALSE, /* partial_inplace */
285 0, /* src_mask */
286 0x000000ff, /* dst_mask */
287 FALSE), /* pcrel_offset */
289 /* TLS local execution variable reference. */
290 HOWTO (R_68K_TLS_LE32, /* type */
291 0, /* rightshift */
292 2, /* size (0 = byte, 1 = short, 2 = long) */
293 32, /* bitsize */
294 FALSE, /* pc_relative */
295 0, /* bitpos */
296 complain_overflow_bitfield, /* complain_on_overflow */
297 bfd_elf_generic_reloc, /* special_function */
298 "R_68K_TLS_LE32", /* name */
299 FALSE, /* partial_inplace */
300 0, /* src_mask */
301 0xffffffff, /* dst_mask */
302 FALSE), /* pcrel_offset */
304 HOWTO (R_68K_TLS_LE16, /* type */
305 0, /* rightshift */
306 1, /* size (0 = byte, 1 = short, 2 = long) */
307 16, /* bitsize */
308 FALSE, /* pc_relative */
309 0, /* bitpos */
310 complain_overflow_signed, /* complain_on_overflow */
311 bfd_elf_generic_reloc, /* special_function */
312 "R_68K_TLS_LE16", /* name */
313 FALSE, /* partial_inplace */
314 0, /* src_mask */
315 0x0000ffff, /* dst_mask */
316 FALSE), /* pcrel_offset */
318 HOWTO (R_68K_TLS_LE8, /* type */
319 0, /* rightshift */
320 0, /* size (0 = byte, 1 = short, 2 = long) */
321 8, /* bitsize */
322 FALSE, /* pc_relative */
323 0, /* bitpos */
324 complain_overflow_signed, /* complain_on_overflow */
325 bfd_elf_generic_reloc, /* special_function */
326 "R_68K_TLS_LE8", /* name */
327 FALSE, /* partial_inplace */
328 0, /* src_mask */
329 0x000000ff, /* dst_mask */
330 FALSE), /* pcrel_offset */
332 /* TLS GD/LD dynamic relocations. */
333 HOWTO (R_68K_TLS_DTPMOD32, /* type */
334 0, /* rightshift */
335 2, /* size (0 = byte, 1 = short, 2 = long) */
336 32, /* bitsize */
337 FALSE, /* pc_relative */
338 0, /* bitpos */
339 complain_overflow_dont, /* complain_on_overflow */
340 bfd_elf_generic_reloc, /* special_function */
341 "R_68K_TLS_DTPMOD32", /* name */
342 FALSE, /* partial_inplace */
343 0, /* src_mask */
344 0xffffffff, /* dst_mask */
345 FALSE), /* pcrel_offset */
347 HOWTO (R_68K_TLS_DTPREL32, /* type */
348 0, /* rightshift */
349 2, /* size (0 = byte, 1 = short, 2 = long) */
350 32, /* bitsize */
351 FALSE, /* pc_relative */
352 0, /* bitpos */
353 complain_overflow_dont, /* complain_on_overflow */
354 bfd_elf_generic_reloc, /* special_function */
355 "R_68K_TLS_DTPREL32", /* name */
356 FALSE, /* partial_inplace */
357 0, /* src_mask */
358 0xffffffff, /* dst_mask */
359 FALSE), /* pcrel_offset */
361 HOWTO (R_68K_TLS_TPREL32, /* type */
362 0, /* rightshift */
363 2, /* size (0 = byte, 1 = short, 2 = long) */
364 32, /* bitsize */
365 FALSE, /* pc_relative */
366 0, /* bitpos */
367 complain_overflow_dont, /* complain_on_overflow */
368 bfd_elf_generic_reloc, /* special_function */
369 "R_68K_TLS_TPREL32", /* name */
370 FALSE, /* partial_inplace */
371 0, /* src_mask */
372 0xffffffff, /* dst_mask */
373 FALSE), /* pcrel_offset */
376 static void
377 rtype_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
379 unsigned int indx = ELF32_R_TYPE (dst->r_info);
381 if (indx >= (unsigned int) R_68K_max)
383 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
384 abfd, (int) indx);
385 indx = R_68K_NONE;
387 cache_ptr->howto = &howto_table[indx];
390 #define elf_info_to_howto rtype_to_howto
392 static const struct
394 bfd_reloc_code_real_type bfd_val;
395 int elf_val;
397 reloc_map[] =
399 { BFD_RELOC_NONE, R_68K_NONE },
400 { BFD_RELOC_32, R_68K_32 },
401 { BFD_RELOC_16, R_68K_16 },
402 { BFD_RELOC_8, R_68K_8 },
403 { BFD_RELOC_32_PCREL, R_68K_PC32 },
404 { BFD_RELOC_16_PCREL, R_68K_PC16 },
405 { BFD_RELOC_8_PCREL, R_68K_PC8 },
406 { BFD_RELOC_32_GOT_PCREL, R_68K_GOT32 },
407 { BFD_RELOC_16_GOT_PCREL, R_68K_GOT16 },
408 { BFD_RELOC_8_GOT_PCREL, R_68K_GOT8 },
409 { BFD_RELOC_32_GOTOFF, R_68K_GOT32O },
410 { BFD_RELOC_16_GOTOFF, R_68K_GOT16O },
411 { BFD_RELOC_8_GOTOFF, R_68K_GOT8O },
412 { BFD_RELOC_32_PLT_PCREL, R_68K_PLT32 },
413 { BFD_RELOC_16_PLT_PCREL, R_68K_PLT16 },
414 { BFD_RELOC_8_PLT_PCREL, R_68K_PLT8 },
415 { BFD_RELOC_32_PLTOFF, R_68K_PLT32O },
416 { BFD_RELOC_16_PLTOFF, R_68K_PLT16O },
417 { BFD_RELOC_8_PLTOFF, R_68K_PLT8O },
418 { BFD_RELOC_NONE, R_68K_COPY },
419 { BFD_RELOC_68K_GLOB_DAT, R_68K_GLOB_DAT },
420 { BFD_RELOC_68K_JMP_SLOT, R_68K_JMP_SLOT },
421 { BFD_RELOC_68K_RELATIVE, R_68K_RELATIVE },
422 { BFD_RELOC_CTOR, R_68K_32 },
423 { BFD_RELOC_VTABLE_INHERIT, R_68K_GNU_VTINHERIT },
424 { BFD_RELOC_VTABLE_ENTRY, R_68K_GNU_VTENTRY },
425 { BFD_RELOC_68K_TLS_GD32, R_68K_TLS_GD32 },
426 { BFD_RELOC_68K_TLS_GD16, R_68K_TLS_GD16 },
427 { BFD_RELOC_68K_TLS_GD8, R_68K_TLS_GD8 },
428 { BFD_RELOC_68K_TLS_LDM32, R_68K_TLS_LDM32 },
429 { BFD_RELOC_68K_TLS_LDM16, R_68K_TLS_LDM16 },
430 { BFD_RELOC_68K_TLS_LDM8, R_68K_TLS_LDM8 },
431 { BFD_RELOC_68K_TLS_LDO32, R_68K_TLS_LDO32 },
432 { BFD_RELOC_68K_TLS_LDO16, R_68K_TLS_LDO16 },
433 { BFD_RELOC_68K_TLS_LDO8, R_68K_TLS_LDO8 },
434 { BFD_RELOC_68K_TLS_IE32, R_68K_TLS_IE32 },
435 { BFD_RELOC_68K_TLS_IE16, R_68K_TLS_IE16 },
436 { BFD_RELOC_68K_TLS_IE8, R_68K_TLS_IE8 },
437 { BFD_RELOC_68K_TLS_LE32, R_68K_TLS_LE32 },
438 { BFD_RELOC_68K_TLS_LE16, R_68K_TLS_LE16 },
439 { BFD_RELOC_68K_TLS_LE8, R_68K_TLS_LE8 },
442 static reloc_howto_type *
443 reloc_type_lookup (abfd, code)
444 bfd *abfd ATTRIBUTE_UNUSED;
445 bfd_reloc_code_real_type code;
447 unsigned int i;
448 for (i = 0; i < sizeof (reloc_map) / sizeof (reloc_map[0]); i++)
450 if (reloc_map[i].bfd_val == code)
451 return &howto_table[reloc_map[i].elf_val];
453 return 0;
456 static reloc_howto_type *
457 reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
459 unsigned int i;
461 for (i = 0; i < sizeof (howto_table) / sizeof (howto_table[0]); i++)
462 if (howto_table[i].name != NULL
463 && strcasecmp (howto_table[i].name, r_name) == 0)
464 return &howto_table[i];
466 return NULL;
469 #define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup
470 #define bfd_elf32_bfd_reloc_name_lookup reloc_name_lookup
471 #define ELF_ARCH bfd_arch_m68k
472 #define ELF_TARGET_ID M68K_ELF_DATA
474 /* Functions for the m68k ELF linker. */
476 /* The name of the dynamic interpreter. This is put in the .interp
477 section. */
479 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
481 /* Describes one of the various PLT styles. */
483 struct elf_m68k_plt_info
485 /* The size of each PLT entry. */
486 bfd_vma size;
488 /* The template for the first PLT entry. */
489 const bfd_byte *plt0_entry;
491 /* Offsets of fields in PLT0_ENTRY that require R_68K_PC32 relocations.
492 The comments by each member indicate the value that the relocation
493 is against. */
494 struct {
495 unsigned int got4; /* .got + 4 */
496 unsigned int got8; /* .got + 8 */
497 } plt0_relocs;
499 /* The template for a symbol's PLT entry. */
500 const bfd_byte *symbol_entry;
502 /* Offsets of fields in SYMBOL_ENTRY that require R_68K_PC32 relocations.
503 The comments by each member indicate the value that the relocation
504 is against. */
505 struct {
506 unsigned int got; /* the symbol's .got.plt entry */
507 unsigned int plt; /* .plt */
508 } symbol_relocs;
510 /* The offset of the resolver stub from the start of SYMBOL_ENTRY.
511 The stub starts with "move.l #relocoffset,%d0". */
512 bfd_vma symbol_resolve_entry;
515 /* The size in bytes of an entry in the procedure linkage table. */
517 #define PLT_ENTRY_SIZE 20
519 /* The first entry in a procedure linkage table looks like this. See
520 the SVR4 ABI m68k supplement to see how this works. */
522 static const bfd_byte elf_m68k_plt0_entry[PLT_ENTRY_SIZE] =
524 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
525 0, 0, 0, 2, /* + (.got + 4) - . */
526 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,addr]) */
527 0, 0, 0, 2, /* + (.got + 8) - . */
528 0, 0, 0, 0 /* pad out to 20 bytes. */
531 /* Subsequent entries in a procedure linkage table look like this. */
533 static const bfd_byte elf_m68k_plt_entry[PLT_ENTRY_SIZE] =
535 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,symbol@GOTPC]) */
536 0, 0, 0, 2, /* + (.got.plt entry) - . */
537 0x2f, 0x3c, /* move.l #offset,-(%sp) */
538 0, 0, 0, 0, /* + reloc index */
539 0x60, 0xff, /* bra.l .plt */
540 0, 0, 0, 0 /* + .plt - . */
543 static const struct elf_m68k_plt_info elf_m68k_plt_info = {
544 PLT_ENTRY_SIZE,
545 elf_m68k_plt0_entry, { 4, 12 },
546 elf_m68k_plt_entry, { 4, 16 }, 8
549 #define ISAB_PLT_ENTRY_SIZE 24
551 static const bfd_byte elf_isab_plt0_entry[ISAB_PLT_ENTRY_SIZE] =
553 0x20, 0x3c, /* move.l #offset,%d0 */
554 0, 0, 0, 0, /* + (.got + 4) - . */
555 0x2f, 0x3b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),-(%sp) */
556 0x20, 0x3c, /* move.l #offset,%d0 */
557 0, 0, 0, 0, /* + (.got + 8) - . */
558 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
559 0x4e, 0xd0, /* jmp (%a0) */
560 0x4e, 0x71 /* nop */
563 /* Subsequent entries in a procedure linkage table look like this. */
565 static const bfd_byte elf_isab_plt_entry[ISAB_PLT_ENTRY_SIZE] =
567 0x20, 0x3c, /* move.l #offset,%d0 */
568 0, 0, 0, 0, /* + (.got.plt entry) - . */
569 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
570 0x4e, 0xd0, /* jmp (%a0) */
571 0x2f, 0x3c, /* move.l #offset,-(%sp) */
572 0, 0, 0, 0, /* + reloc index */
573 0x60, 0xff, /* bra.l .plt */
574 0, 0, 0, 0 /* + .plt - . */
577 static const struct elf_m68k_plt_info elf_isab_plt_info = {
578 ISAB_PLT_ENTRY_SIZE,
579 elf_isab_plt0_entry, { 2, 12 },
580 elf_isab_plt_entry, { 2, 20 }, 12
583 #define ISAC_PLT_ENTRY_SIZE 24
585 static const bfd_byte elf_isac_plt0_entry[ISAC_PLT_ENTRY_SIZE] =
587 0x20, 0x3c, /* move.l #offset,%d0 */
588 0, 0, 0, 0, /* replaced with .got + 4 - . */
589 0x2e, 0xbb, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),(%sp) */
590 0x20, 0x3c, /* move.l #offset,%d0 */
591 0, 0, 0, 0, /* replaced with .got + 8 - . */
592 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
593 0x4e, 0xd0, /* jmp (%a0) */
594 0x4e, 0x71 /* nop */
597 /* Subsequent entries in a procedure linkage table look like this. */
599 static const bfd_byte elf_isac_plt_entry[ISAC_PLT_ENTRY_SIZE] =
601 0x20, 0x3c, /* move.l #offset,%d0 */
602 0, 0, 0, 0, /* replaced with (.got entry) - . */
603 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
604 0x4e, 0xd0, /* jmp (%a0) */
605 0x2f, 0x3c, /* move.l #offset,-(%sp) */
606 0, 0, 0, 0, /* replaced with offset into relocation table */
607 0x61, 0xff, /* bsr.l .plt */
608 0, 0, 0, 0 /* replaced with .plt - . */
611 static const struct elf_m68k_plt_info elf_isac_plt_info = {
612 ISAC_PLT_ENTRY_SIZE,
613 elf_isac_plt0_entry, { 2, 12},
614 elf_isac_plt_entry, { 2, 20 }, 12
617 #define CPU32_PLT_ENTRY_SIZE 24
618 /* Procedure linkage table entries for the cpu32 */
619 static const bfd_byte elf_cpu32_plt0_entry[CPU32_PLT_ENTRY_SIZE] =
621 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
622 0, 0, 0, 2, /* + (.got + 4) - . */
623 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
624 0, 0, 0, 2, /* + (.got + 8) - . */
625 0x4e, 0xd1, /* jmp %a1@ */
626 0, 0, 0, 0, /* pad out to 24 bytes. */
627 0, 0
630 static const bfd_byte elf_cpu32_plt_entry[CPU32_PLT_ENTRY_SIZE] =
632 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
633 0, 0, 0, 2, /* + (.got.plt entry) - . */
634 0x4e, 0xd1, /* jmp %a1@ */
635 0x2f, 0x3c, /* move.l #offset,-(%sp) */
636 0, 0, 0, 0, /* + reloc index */
637 0x60, 0xff, /* bra.l .plt */
638 0, 0, 0, 0, /* + .plt - . */
639 0, 0
642 static const struct elf_m68k_plt_info elf_cpu32_plt_info = {
643 CPU32_PLT_ENTRY_SIZE,
644 elf_cpu32_plt0_entry, { 4, 12 },
645 elf_cpu32_plt_entry, { 4, 18 }, 10
648 /* The m68k linker needs to keep track of the number of relocs that it
649 decides to copy in check_relocs for each symbol. This is so that it
650 can discard PC relative relocs if it doesn't need them when linking
651 with -Bsymbolic. We store the information in a field extending the
652 regular ELF linker hash table. */
654 /* This structure keeps track of the number of PC relative relocs we have
655 copied for a given symbol. */
657 struct elf_m68k_pcrel_relocs_copied
659 /* Next section. */
660 struct elf_m68k_pcrel_relocs_copied *next;
661 /* A section in dynobj. */
662 asection *section;
663 /* Number of relocs copied in this section. */
664 bfd_size_type count;
667 /* Forward declaration. */
668 struct elf_m68k_got_entry;
670 /* m68k ELF linker hash entry. */
672 struct elf_m68k_link_hash_entry
674 struct elf_link_hash_entry root;
676 /* Number of PC relative relocs copied for this symbol. */
677 struct elf_m68k_pcrel_relocs_copied *pcrel_relocs_copied;
679 /* Key to got_entries. */
680 unsigned long got_entry_key;
682 /* List of GOT entries for this symbol. This list is build during
683 offset finalization and is used within elf_m68k_finish_dynamic_symbol
684 to traverse all GOT entries for a particular symbol.
686 ??? We could've used root.got.glist field instead, but having
687 a separate field is cleaner. */
688 struct elf_m68k_got_entry *glist;
691 #define elf_m68k_hash_entry(ent) ((struct elf_m68k_link_hash_entry *) (ent))
693 /* Key part of GOT entry in hashtable. */
694 struct elf_m68k_got_entry_key
696 /* BFD in which this symbol was defined. NULL for global symbols. */
697 const bfd *bfd;
699 /* Symbol index. Either local symbol index or h->got_entry_key. */
700 unsigned long symndx;
702 /* Type is one of R_68K_GOT{8, 16, 32}O, R_68K_TLS_GD{8, 16, 32},
703 R_68K_TLS_LDM{8, 16, 32} or R_68K_TLS_IE{8, 16, 32}.
705 From perspective of hashtable key, only elf_m68k_got_reloc_type (type)
706 matters. That is, we distinguish between, say, R_68K_GOT16O
707 and R_68K_GOT32O when allocating offsets, but they are considered to be
708 the same when searching got->entries. */
709 enum elf_m68k_reloc_type type;
712 /* Size of the GOT offset suitable for relocation. */
713 enum elf_m68k_got_offset_size { R_8, R_16, R_32, R_LAST };
715 /* Entry of the GOT. */
716 struct elf_m68k_got_entry
718 /* GOT entries are put into a got->entries hashtable. This is the key. */
719 struct elf_m68k_got_entry_key key_;
721 /* GOT entry data. We need s1 before offset finalization and s2 after. */
722 union
724 struct
726 /* Number of times this entry is referenced. It is used to
727 filter out unnecessary GOT slots in elf_m68k_gc_sweep_hook. */
728 bfd_vma refcount;
729 } s1;
731 struct
733 /* Offset from the start of .got section. To calculate offset relative
734 to GOT pointer one should substract got->offset from this value. */
735 bfd_vma offset;
737 /* Pointer to the next GOT entry for this global symbol.
738 Symbols have at most one entry in one GOT, but might
739 have entries in more than one GOT.
740 Root of this list is h->glist.
741 NULL for local symbols. */
742 struct elf_m68k_got_entry *next;
743 } s2;
744 } u;
747 /* Return representative type for relocation R_TYPE.
748 This is used to avoid enumerating many relocations in comparisons,
749 switches etc. */
751 static enum elf_m68k_reloc_type
752 elf_m68k_reloc_got_type (enum elf_m68k_reloc_type r_type)
754 switch (r_type)
756 /* In most cases R_68K_GOTx relocations require the very same
757 handling as R_68K_GOT32O relocation. In cases when we need
758 to distinguish between the two, we use explicitly compare against
759 r_type. */
760 case R_68K_GOT32:
761 case R_68K_GOT16:
762 case R_68K_GOT8:
763 case R_68K_GOT32O:
764 case R_68K_GOT16O:
765 case R_68K_GOT8O:
766 return R_68K_GOT32O;
768 case R_68K_TLS_GD32:
769 case R_68K_TLS_GD16:
770 case R_68K_TLS_GD8:
771 return R_68K_TLS_GD32;
773 case R_68K_TLS_LDM32:
774 case R_68K_TLS_LDM16:
775 case R_68K_TLS_LDM8:
776 return R_68K_TLS_LDM32;
778 case R_68K_TLS_IE32:
779 case R_68K_TLS_IE16:
780 case R_68K_TLS_IE8:
781 return R_68K_TLS_IE32;
783 default:
784 BFD_ASSERT (FALSE);
785 return 0;
789 /* Return size of the GOT entry offset for relocation R_TYPE. */
791 static enum elf_m68k_got_offset_size
792 elf_m68k_reloc_got_offset_size (enum elf_m68k_reloc_type r_type)
794 switch (r_type)
796 case R_68K_GOT32: case R_68K_GOT16: case R_68K_GOT8:
797 case R_68K_GOT32O: case R_68K_TLS_GD32: case R_68K_TLS_LDM32:
798 case R_68K_TLS_IE32:
799 return R_32;
801 case R_68K_GOT16O: case R_68K_TLS_GD16: case R_68K_TLS_LDM16:
802 case R_68K_TLS_IE16:
803 return R_16;
805 case R_68K_GOT8O: case R_68K_TLS_GD8: case R_68K_TLS_LDM8:
806 case R_68K_TLS_IE8:
807 return R_8;
809 default:
810 BFD_ASSERT (FALSE);
811 return 0;
815 /* Return number of GOT entries we need to allocate in GOT for
816 relocation R_TYPE. */
818 static bfd_vma
819 elf_m68k_reloc_got_n_slots (enum elf_m68k_reloc_type r_type)
821 switch (elf_m68k_reloc_got_type (r_type))
823 case R_68K_GOT32O:
824 case R_68K_TLS_IE32:
825 return 1;
827 case R_68K_TLS_GD32:
828 case R_68K_TLS_LDM32:
829 return 2;
831 default:
832 BFD_ASSERT (FALSE);
833 return 0;
837 /* Return TRUE if relocation R_TYPE is a TLS one. */
839 static bfd_boolean
840 elf_m68k_reloc_tls_p (enum elf_m68k_reloc_type r_type)
842 switch (r_type)
844 case R_68K_TLS_GD32: case R_68K_TLS_GD16: case R_68K_TLS_GD8:
845 case R_68K_TLS_LDM32: case R_68K_TLS_LDM16: case R_68K_TLS_LDM8:
846 case R_68K_TLS_LDO32: case R_68K_TLS_LDO16: case R_68K_TLS_LDO8:
847 case R_68K_TLS_IE32: case R_68K_TLS_IE16: case R_68K_TLS_IE8:
848 case R_68K_TLS_LE32: case R_68K_TLS_LE16: case R_68K_TLS_LE8:
849 case R_68K_TLS_DTPMOD32: case R_68K_TLS_DTPREL32: case R_68K_TLS_TPREL32:
850 return TRUE;
852 default:
853 return FALSE;
857 /* Data structure representing a single GOT. */
858 struct elf_m68k_got
860 /* Hashtable of 'struct elf_m68k_got_entry's.
861 Starting size of this table is the maximum number of
862 R_68K_GOT8O entries. */
863 htab_t entries;
865 /* Number of R_x slots in this GOT. Some (e.g., TLS) entries require
866 several GOT slots.
868 n_slots[R_8] is the count of R_8 slots in this GOT.
869 n_slots[R_16] is the cumulative count of R_8 and R_16 slots
870 in this GOT.
871 n_slots[R_32] is the cumulative count of R_8, R_16 and R_32 slots
872 in this GOT. This is the total number of slots. */
873 bfd_vma n_slots[R_LAST];
875 /* Number of local (entry->key_.h == NULL) slots in this GOT.
876 This is only used to properly calculate size of .rela.got section;
877 see elf_m68k_partition_multi_got. */
878 bfd_vma local_n_slots;
880 /* Offset of this GOT relative to beginning of .got section. */
881 bfd_vma offset;
884 /* BFD and its GOT. This is an entry in multi_got->bfd2got hashtable. */
885 struct elf_m68k_bfd2got_entry
887 /* BFD. */
888 const bfd *bfd;
890 /* Assigned GOT. Before partitioning multi-GOT each BFD has its own
891 GOT structure. After partitioning several BFD's might [and often do]
892 share a single GOT. */
893 struct elf_m68k_got *got;
896 /* The main data structure holding all the pieces. */
897 struct elf_m68k_multi_got
899 /* Hashtable mapping each BFD to its GOT. If a BFD doesn't have an entry
900 here, then it doesn't need a GOT (this includes the case of a BFD
901 having an empty GOT).
903 ??? This hashtable can be replaced by an array indexed by bfd->id. */
904 htab_t bfd2got;
906 /* Next symndx to assign a global symbol.
907 h->got_entry_key is initialized from this counter. */
908 unsigned long global_symndx;
911 /* m68k ELF linker hash table. */
913 struct elf_m68k_link_hash_table
915 struct elf_link_hash_table root;
917 /* Small local sym cache. */
918 struct sym_cache sym_cache;
920 /* The PLT format used by this link, or NULL if the format has not
921 yet been chosen. */
922 const struct elf_m68k_plt_info *plt_info;
924 /* True, if GP is loaded within each function which uses it.
925 Set to TRUE when GOT negative offsets or multi-GOT is enabled. */
926 bfd_boolean local_gp_p;
928 /* Switch controlling use of negative offsets to double the size of GOTs. */
929 bfd_boolean use_neg_got_offsets_p;
931 /* Switch controlling generation of multiple GOTs. */
932 bfd_boolean allow_multigot_p;
934 /* Multi-GOT data structure. */
935 struct elf_m68k_multi_got multi_got_;
938 /* Get the m68k ELF linker hash table from a link_info structure. */
940 #define elf_m68k_hash_table(p) \
941 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
942 == M68K_ELF_DATA ? ((struct elf_m68k_link_hash_table *) ((p)->hash)) : NULL)
944 /* Shortcut to multi-GOT data. */
945 #define elf_m68k_multi_got(INFO) (&elf_m68k_hash_table (INFO)->multi_got_)
947 /* Create an entry in an m68k ELF linker hash table. */
949 static struct bfd_hash_entry *
950 elf_m68k_link_hash_newfunc (struct bfd_hash_entry *entry,
951 struct bfd_hash_table *table,
952 const char *string)
954 struct bfd_hash_entry *ret = entry;
956 /* Allocate the structure if it has not already been allocated by a
957 subclass. */
958 if (ret == NULL)
959 ret = bfd_hash_allocate (table,
960 sizeof (struct elf_m68k_link_hash_entry));
961 if (ret == NULL)
962 return ret;
964 /* Call the allocation method of the superclass. */
965 ret = _bfd_elf_link_hash_newfunc (ret, table, string);
966 if (ret != NULL)
968 elf_m68k_hash_entry (ret)->pcrel_relocs_copied = NULL;
969 elf_m68k_hash_entry (ret)->got_entry_key = 0;
970 elf_m68k_hash_entry (ret)->glist = NULL;
973 return ret;
976 /* Create an m68k ELF linker hash table. */
978 static struct bfd_link_hash_table *
979 elf_m68k_link_hash_table_create (bfd *abfd)
981 struct elf_m68k_link_hash_table *ret;
982 bfd_size_type amt = sizeof (struct elf_m68k_link_hash_table);
984 ret = (struct elf_m68k_link_hash_table *) bfd_malloc (amt);
985 if (ret == (struct elf_m68k_link_hash_table *) NULL)
986 return NULL;
988 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
989 elf_m68k_link_hash_newfunc,
990 sizeof (struct elf_m68k_link_hash_entry),
991 M68K_ELF_DATA))
993 free (ret);
994 return NULL;
997 ret->sym_cache.abfd = NULL;
998 ret->plt_info = NULL;
999 ret->local_gp_p = FALSE;
1000 ret->use_neg_got_offsets_p = FALSE;
1001 ret->allow_multigot_p = FALSE;
1002 ret->multi_got_.bfd2got = NULL;
1003 ret->multi_got_.global_symndx = 1;
1005 return &ret->root.root;
1008 /* Destruct local data. */
1010 static void
1011 elf_m68k_link_hash_table_free (struct bfd_link_hash_table *_htab)
1013 struct elf_m68k_link_hash_table *htab;
1015 htab = (struct elf_m68k_link_hash_table *) _htab;
1017 if (htab->multi_got_.bfd2got != NULL)
1019 htab_delete (htab->multi_got_.bfd2got);
1020 htab->multi_got_.bfd2got = NULL;
1024 /* Set the right machine number. */
1026 static bfd_boolean
1027 elf32_m68k_object_p (bfd *abfd)
1029 unsigned int mach = 0;
1030 unsigned features = 0;
1031 flagword eflags = elf_elfheader (abfd)->e_flags;
1033 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
1034 features |= m68000;
1035 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1036 features |= cpu32;
1037 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1038 features |= fido_a;
1039 else
1041 switch (eflags & EF_M68K_CF_ISA_MASK)
1043 case EF_M68K_CF_ISA_A_NODIV:
1044 features |= mcfisa_a;
1045 break;
1046 case EF_M68K_CF_ISA_A:
1047 features |= mcfisa_a|mcfhwdiv;
1048 break;
1049 case EF_M68K_CF_ISA_A_PLUS:
1050 features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp;
1051 break;
1052 case EF_M68K_CF_ISA_B_NOUSP:
1053 features |= mcfisa_a|mcfisa_b|mcfhwdiv;
1054 break;
1055 case EF_M68K_CF_ISA_B:
1056 features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp;
1057 break;
1058 case EF_M68K_CF_ISA_C:
1059 features |= mcfisa_a|mcfisa_c|mcfhwdiv|mcfusp;
1060 break;
1061 case EF_M68K_CF_ISA_C_NODIV:
1062 features |= mcfisa_a|mcfisa_c|mcfusp;
1063 break;
1065 switch (eflags & EF_M68K_CF_MAC_MASK)
1067 case EF_M68K_CF_MAC:
1068 features |= mcfmac;
1069 break;
1070 case EF_M68K_CF_EMAC:
1071 features |= mcfemac;
1072 break;
1074 if (eflags & EF_M68K_CF_FLOAT)
1075 features |= cfloat;
1078 mach = bfd_m68k_features_to_mach (features);
1079 bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach);
1081 return TRUE;
1084 /* Somewhat reverse of elf32_m68k_object_p, this sets the e_flag
1085 field based on the machine number. */
1087 static void
1088 elf_m68k_final_write_processing (bfd *abfd,
1089 bfd_boolean linker ATTRIBUTE_UNUSED)
1091 int mach = bfd_get_mach (abfd);
1092 unsigned long e_flags = elf_elfheader (abfd)->e_flags;
1094 if (!e_flags)
1096 unsigned int arch_mask;
1098 arch_mask = bfd_m68k_mach_to_features (mach);
1100 if (arch_mask & m68000)
1101 e_flags = EF_M68K_M68000;
1102 else if (arch_mask & cpu32)
1103 e_flags = EF_M68K_CPU32;
1104 else if (arch_mask & fido_a)
1105 e_flags = EF_M68K_FIDO;
1106 else
1108 switch (arch_mask
1109 & (mcfisa_a | mcfisa_aa | mcfisa_b | mcfisa_c | mcfhwdiv | mcfusp))
1111 case mcfisa_a:
1112 e_flags |= EF_M68K_CF_ISA_A_NODIV;
1113 break;
1114 case mcfisa_a | mcfhwdiv:
1115 e_flags |= EF_M68K_CF_ISA_A;
1116 break;
1117 case mcfisa_a | mcfisa_aa | mcfhwdiv | mcfusp:
1118 e_flags |= EF_M68K_CF_ISA_A_PLUS;
1119 break;
1120 case mcfisa_a | mcfisa_b | mcfhwdiv:
1121 e_flags |= EF_M68K_CF_ISA_B_NOUSP;
1122 break;
1123 case mcfisa_a | mcfisa_b | mcfhwdiv | mcfusp:
1124 e_flags |= EF_M68K_CF_ISA_B;
1125 break;
1126 case mcfisa_a | mcfisa_c | mcfhwdiv | mcfusp:
1127 e_flags |= EF_M68K_CF_ISA_C;
1128 break;
1129 case mcfisa_a | mcfisa_c | mcfusp:
1130 e_flags |= EF_M68K_CF_ISA_C_NODIV;
1131 break;
1133 if (arch_mask & mcfmac)
1134 e_flags |= EF_M68K_CF_MAC;
1135 else if (arch_mask & mcfemac)
1136 e_flags |= EF_M68K_CF_EMAC;
1137 if (arch_mask & cfloat)
1138 e_flags |= EF_M68K_CF_FLOAT | EF_M68K_CFV4E;
1140 elf_elfheader (abfd)->e_flags = e_flags;
1144 /* Keep m68k-specific flags in the ELF header. */
1146 static bfd_boolean
1147 elf32_m68k_set_private_flags (abfd, flags)
1148 bfd *abfd;
1149 flagword flags;
1151 elf_elfheader (abfd)->e_flags = flags;
1152 elf_flags_init (abfd) = TRUE;
1153 return TRUE;
1156 /* Merge backend specific data from an object file to the output
1157 object file when linking. */
1158 static bfd_boolean
1159 elf32_m68k_merge_private_bfd_data (ibfd, obfd)
1160 bfd *ibfd;
1161 bfd *obfd;
1163 flagword out_flags;
1164 flagword in_flags;
1165 flagword out_isa;
1166 flagword in_isa;
1167 const bfd_arch_info_type *arch_info;
1169 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1170 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1171 return FALSE;
1173 /* Get the merged machine. This checks for incompatibility between
1174 Coldfire & non-Coldfire flags, incompability between different
1175 Coldfire ISAs, and incompability between different MAC types. */
1176 arch_info = bfd_arch_get_compatible (ibfd, obfd, FALSE);
1177 if (!arch_info)
1178 return FALSE;
1180 bfd_set_arch_mach (obfd, bfd_arch_m68k, arch_info->mach);
1182 in_flags = elf_elfheader (ibfd)->e_flags;
1183 if (!elf_flags_init (obfd))
1185 elf_flags_init (obfd) = TRUE;
1186 out_flags = in_flags;
1188 else
1190 out_flags = elf_elfheader (obfd)->e_flags;
1191 unsigned int variant_mask;
1193 if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
1194 variant_mask = 0;
1195 else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1196 variant_mask = 0;
1197 else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1198 variant_mask = 0;
1199 else
1200 variant_mask = EF_M68K_CF_ISA_MASK;
1202 in_isa = (in_flags & variant_mask);
1203 out_isa = (out_flags & variant_mask);
1204 if (in_isa > out_isa)
1205 out_flags ^= in_isa ^ out_isa;
1206 if (((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32
1207 && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1208 || ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO
1209 && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32))
1210 out_flags = EF_M68K_FIDO;
1211 else
1212 out_flags |= in_flags ^ in_isa;
1214 elf_elfheader (obfd)->e_flags = out_flags;
1216 return TRUE;
1219 /* Display the flags field. */
1221 static bfd_boolean
1222 elf32_m68k_print_private_bfd_data (bfd *abfd, void * ptr)
1224 FILE *file = (FILE *) ptr;
1225 flagword eflags = elf_elfheader (abfd)->e_flags;
1227 BFD_ASSERT (abfd != NULL && ptr != NULL);
1229 /* Print normal ELF private data. */
1230 _bfd_elf_print_private_bfd_data (abfd, ptr);
1232 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
1234 /* xgettext:c-format */
1235 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1237 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
1238 fprintf (file, " [m68000]");
1239 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
1240 fprintf (file, " [cpu32]");
1241 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
1242 fprintf (file, " [fido]");
1243 else
1245 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CFV4E)
1246 fprintf (file, " [cfv4e]");
1248 if (eflags & EF_M68K_CF_ISA_MASK)
1250 char const *isa = _("unknown");
1251 char const *mac = _("unknown");
1252 char const *additional = "";
1254 switch (eflags & EF_M68K_CF_ISA_MASK)
1256 case EF_M68K_CF_ISA_A_NODIV:
1257 isa = "A";
1258 additional = " [nodiv]";
1259 break;
1260 case EF_M68K_CF_ISA_A:
1261 isa = "A";
1262 break;
1263 case EF_M68K_CF_ISA_A_PLUS:
1264 isa = "A+";
1265 break;
1266 case EF_M68K_CF_ISA_B_NOUSP:
1267 isa = "B";
1268 additional = " [nousp]";
1269 break;
1270 case EF_M68K_CF_ISA_B:
1271 isa = "B";
1272 break;
1273 case EF_M68K_CF_ISA_C:
1274 isa = "C";
1275 break;
1276 case EF_M68K_CF_ISA_C_NODIV:
1277 isa = "C";
1278 additional = " [nodiv]";
1279 break;
1281 fprintf (file, " [isa %s]%s", isa, additional);
1283 if (eflags & EF_M68K_CF_FLOAT)
1284 fprintf (file, " [float]");
1286 switch (eflags & EF_M68K_CF_MAC_MASK)
1288 case 0:
1289 mac = NULL;
1290 break;
1291 case EF_M68K_CF_MAC:
1292 mac = "mac";
1293 break;
1294 case EF_M68K_CF_EMAC:
1295 mac = "emac";
1296 break;
1297 case EF_M68K_CF_EMAC_B:
1298 mac = "emac_b";
1299 break;
1301 if (mac)
1302 fprintf (file, " [%s]", mac);
1306 fputc ('\n', file);
1308 return TRUE;
1311 /* Multi-GOT support implementation design:
1313 Multi-GOT starts in check_relocs hook. There we scan all
1314 relocations of a BFD and build a local GOT (struct elf_m68k_got)
1315 for it. If a single BFD appears to require too many GOT slots with
1316 R_68K_GOT8O or R_68K_GOT16O relocations, we fail with notification
1317 to user.
1318 After check_relocs has been invoked for each input BFD, we have
1319 constructed a GOT for each input BFD.
1321 To minimize total number of GOTs required for a particular output BFD
1322 (as some environments support only 1 GOT per output object) we try
1323 to merge some of the GOTs to share an offset space. Ideally [and in most
1324 cases] we end up with a single GOT. In cases when there are too many
1325 restricted relocations (e.g., R_68K_GOT16O relocations) we end up with
1326 several GOTs, assuming the environment can handle them.
1328 Partitioning is done in elf_m68k_partition_multi_got. We start with
1329 an empty GOT and traverse bfd2got hashtable putting got_entries from
1330 local GOTs to the new 'big' one. We do that by constructing an
1331 intermediate GOT holding all the entries the local GOT has and the big
1332 GOT lacks. Then we check if there is room in the big GOT to accomodate
1333 all the entries from diff. On success we add those entries to the big
1334 GOT; on failure we start the new 'big' GOT and retry the adding of
1335 entries from the local GOT. Note that this retry will always succeed as
1336 each local GOT doesn't overflow the limits. After partitioning we
1337 end up with each bfd assigned one of the big GOTs. GOT entries in the
1338 big GOTs are initialized with GOT offsets. Note that big GOTs are
1339 positioned consequently in program space and represent a single huge GOT
1340 to the outside world.
1342 After that we get to elf_m68k_relocate_section. There we
1343 adjust relocations of GOT pointer (_GLOBAL_OFFSET_TABLE_) and symbol
1344 relocations to refer to appropriate [assigned to current input_bfd]
1345 big GOT.
1347 Notes:
1349 GOT entry type: We have several types of GOT entries.
1350 * R_8 type is used in entries for symbols that have at least one
1351 R_68K_GOT8O or R_68K_TLS_*8 relocation. We can have at most 0x40
1352 such entries in one GOT.
1353 * R_16 type is used in entries for symbols that have at least one
1354 R_68K_GOT16O or R_68K_TLS_*16 relocation and no R_8 relocations.
1355 We can have at most 0x4000 such entries in one GOT.
1356 * R_32 type is used in all other cases. We can have as many
1357 such entries in one GOT as we'd like.
1358 When counting relocations we have to include the count of the smaller
1359 ranged relocations in the counts of the larger ranged ones in order
1360 to correctly detect overflow.
1362 Sorting the GOT: In each GOT starting offsets are assigned to
1363 R_8 entries, which are followed by R_16 entries, and
1364 R_32 entries go at the end. See finalize_got_offsets for details.
1366 Negative GOT offsets: To double usable offset range of GOTs we use
1367 negative offsets. As we assign entries with GOT offsets relative to
1368 start of .got section, the offset values are positive. They become
1369 negative only in relocate_section where got->offset value is
1370 subtracted from them.
1372 3 special GOT entries: There are 3 special GOT entries used internally
1373 by loader. These entries happen to be placed to .got.plt section,
1374 so we don't do anything about them in multi-GOT support.
1376 Memory management: All data except for hashtables
1377 multi_got->bfd2got and got->entries are allocated on
1378 elf_hash_table (info)->dynobj bfd (for this reason we pass 'info'
1379 to most functions), so we don't need to care to free them. At the
1380 moment of allocation hashtables are being linked into main data
1381 structure (multi_got), all pieces of which are reachable from
1382 elf_m68k_multi_got (info). We deallocate them in
1383 elf_m68k_link_hash_table_free. */
1385 /* Initialize GOT. */
1387 static void
1388 elf_m68k_init_got (struct elf_m68k_got *got)
1390 got->entries = NULL;
1391 got->n_slots[R_8] = 0;
1392 got->n_slots[R_16] = 0;
1393 got->n_slots[R_32] = 0;
1394 got->local_n_slots = 0;
1395 got->offset = (bfd_vma) -1;
1398 /* Destruct GOT. */
1400 static void
1401 elf_m68k_clear_got (struct elf_m68k_got *got)
1403 if (got->entries != NULL)
1405 htab_delete (got->entries);
1406 got->entries = NULL;
1410 /* Create and empty GOT structure. INFO is the context where memory
1411 should be allocated. */
1413 static struct elf_m68k_got *
1414 elf_m68k_create_empty_got (struct bfd_link_info *info)
1416 struct elf_m68k_got *got;
1418 got = bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*got));
1419 if (got == NULL)
1420 return NULL;
1422 elf_m68k_init_got (got);
1424 return got;
1427 /* Initialize KEY. */
1429 static void
1430 elf_m68k_init_got_entry_key (struct elf_m68k_got_entry_key *key,
1431 struct elf_link_hash_entry *h,
1432 const bfd *abfd, unsigned long symndx,
1433 enum elf_m68k_reloc_type reloc_type)
1435 if (elf_m68k_reloc_got_type (reloc_type) == R_68K_TLS_LDM32)
1436 /* All TLS_LDM relocations share a single GOT entry. */
1438 key->bfd = NULL;
1439 key->symndx = 0;
1441 else if (h != NULL)
1442 /* Global symbols are identified with their got_entry_key. */
1444 key->bfd = NULL;
1445 key->symndx = elf_m68k_hash_entry (h)->got_entry_key;
1446 BFD_ASSERT (key->symndx != 0);
1448 else
1449 /* Local symbols are identified by BFD they appear in and symndx. */
1451 key->bfd = abfd;
1452 key->symndx = symndx;
1455 key->type = reloc_type;
1458 /* Calculate hash of got_entry.
1459 ??? Is it good? */
1461 static hashval_t
1462 elf_m68k_got_entry_hash (const void *_entry)
1464 const struct elf_m68k_got_entry_key *key;
1466 key = &((const struct elf_m68k_got_entry *) _entry)->key_;
1468 return (key->symndx
1469 + (key->bfd != NULL ? (int) key->bfd->id : -1)
1470 + elf_m68k_reloc_got_type (key->type));
1473 /* Check if two got entries are equal. */
1475 static int
1476 elf_m68k_got_entry_eq (const void *_entry1, const void *_entry2)
1478 const struct elf_m68k_got_entry_key *key1;
1479 const struct elf_m68k_got_entry_key *key2;
1481 key1 = &((const struct elf_m68k_got_entry *) _entry1)->key_;
1482 key2 = &((const struct elf_m68k_got_entry *) _entry2)->key_;
1484 return (key1->bfd == key2->bfd
1485 && key1->symndx == key2->symndx
1486 && (elf_m68k_reloc_got_type (key1->type)
1487 == elf_m68k_reloc_got_type (key2->type)));
1490 /* When using negative offsets, we allocate one extra R_8, one extra R_16
1491 and one extra R_32 slots to simplify handling of 2-slot entries during
1492 offset allocation -- hence -1 for R_8 slots and -2 for R_16 slots. */
1494 /* Maximal number of R_8 slots in a single GOT. */
1495 #define ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT(INFO) \
1496 (elf_m68k_hash_table (INFO)->use_neg_got_offsets_p \
1497 ? (0x40 - 1) \
1498 : 0x20)
1500 /* Maximal number of R_8 and R_16 slots in a single GOT. */
1501 #define ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT(INFO) \
1502 (elf_m68k_hash_table (INFO)->use_neg_got_offsets_p \
1503 ? (0x4000 - 2) \
1504 : 0x2000)
1506 /* SEARCH - simply search the hashtable, don't insert new entries or fail when
1507 the entry cannot be found.
1508 FIND_OR_CREATE - search for an existing entry, but create new if there's
1509 no such.
1510 MUST_FIND - search for an existing entry and assert that it exist.
1511 MUST_CREATE - assert that there's no such entry and create new one. */
1512 enum elf_m68k_get_entry_howto
1514 SEARCH,
1515 FIND_OR_CREATE,
1516 MUST_FIND,
1517 MUST_CREATE
1520 /* Get or create (depending on HOWTO) entry with KEY in GOT.
1521 INFO is context in which memory should be allocated (can be NULL if
1522 HOWTO is SEARCH or MUST_FIND). */
1524 static struct elf_m68k_got_entry *
1525 elf_m68k_get_got_entry (struct elf_m68k_got *got,
1526 const struct elf_m68k_got_entry_key *key,
1527 enum elf_m68k_get_entry_howto howto,
1528 struct bfd_link_info *info)
1530 struct elf_m68k_got_entry entry_;
1531 struct elf_m68k_got_entry *entry;
1532 void **ptr;
1534 BFD_ASSERT ((info == NULL) == (howto == SEARCH || howto == MUST_FIND));
1536 if (got->entries == NULL)
1537 /* This is the first entry in ABFD. Initialize hashtable. */
1539 if (howto == SEARCH)
1540 return NULL;
1542 got->entries = htab_try_create (ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT
1543 (info),
1544 elf_m68k_got_entry_hash,
1545 elf_m68k_got_entry_eq, NULL);
1546 if (got->entries == NULL)
1548 bfd_set_error (bfd_error_no_memory);
1549 return NULL;
1553 entry_.key_ = *key;
1554 ptr = htab_find_slot (got->entries, &entry_, (howto != SEARCH
1555 ? INSERT : NO_INSERT));
1556 if (ptr == NULL)
1558 if (howto == SEARCH)
1559 /* Entry not found. */
1560 return NULL;
1562 /* We're out of memory. */
1563 bfd_set_error (bfd_error_no_memory);
1564 return NULL;
1567 if (*ptr == NULL)
1568 /* We didn't find the entry and we're asked to create a new one. */
1570 BFD_ASSERT (howto != MUST_FIND && howto != SEARCH);
1572 entry = bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*entry));
1573 if (entry == NULL)
1574 return NULL;
1576 /* Initialize new entry. */
1577 entry->key_ = *key;
1579 entry->u.s1.refcount = 0;
1581 /* Mark the entry as not initialized. */
1582 entry->key_.type = R_68K_max;
1584 *ptr = entry;
1586 else
1587 /* We found the entry. */
1589 BFD_ASSERT (howto != MUST_CREATE);
1591 entry = *ptr;
1594 return entry;
1597 /* Update GOT counters when merging entry of WAS type with entry of NEW type.
1598 Return the value to which ENTRY's type should be set. */
1600 static enum elf_m68k_reloc_type
1601 elf_m68k_update_got_entry_type (struct elf_m68k_got *got,
1602 enum elf_m68k_reloc_type was,
1603 enum elf_m68k_reloc_type new_reloc)
1605 enum elf_m68k_got_offset_size was_size;
1606 enum elf_m68k_got_offset_size new_size;
1607 bfd_vma n_slots;
1609 if (was == R_68K_max)
1610 /* The type of the entry is not initialized yet. */
1612 /* Update all got->n_slots counters, including n_slots[R_32]. */
1613 was_size = R_LAST;
1615 was = new_reloc;
1617 else
1619 /* !!! We, probably, should emit an error rather then fail on assert
1620 in such a case. */
1621 BFD_ASSERT (elf_m68k_reloc_got_type (was)
1622 == elf_m68k_reloc_got_type (new_reloc));
1624 was_size = elf_m68k_reloc_got_offset_size (was);
1627 new_size = elf_m68k_reloc_got_offset_size (new_reloc);
1628 n_slots = elf_m68k_reloc_got_n_slots (new_reloc);
1630 while (was_size > new_size)
1632 --was_size;
1633 got->n_slots[was_size] += n_slots;
1636 if (new_reloc > was)
1637 /* Relocations are ordered from bigger got offset size to lesser,
1638 so choose the relocation type with lesser offset size. */
1639 was = new_reloc;
1641 return was;
1644 /* Update GOT counters when removing an entry of type TYPE. */
1646 static void
1647 elf_m68k_remove_got_entry_type (struct elf_m68k_got *got,
1648 enum elf_m68k_reloc_type type)
1650 enum elf_m68k_got_offset_size os;
1651 bfd_vma n_slots;
1653 n_slots = elf_m68k_reloc_got_n_slots (type);
1655 /* Decrese counter of slots with offset size corresponding to TYPE
1656 and all greater offset sizes. */
1657 for (os = elf_m68k_reloc_got_offset_size (type); os <= R_32; ++os)
1659 BFD_ASSERT (got->n_slots[os] >= n_slots);
1661 got->n_slots[os] -= n_slots;
1665 /* Add new or update existing entry to GOT.
1666 H, ABFD, TYPE and SYMNDX is data for the entry.
1667 INFO is a context where memory should be allocated. */
1669 static struct elf_m68k_got_entry *
1670 elf_m68k_add_entry_to_got (struct elf_m68k_got *got,
1671 struct elf_link_hash_entry *h,
1672 const bfd *abfd,
1673 enum elf_m68k_reloc_type reloc_type,
1674 unsigned long symndx,
1675 struct bfd_link_info *info)
1677 struct elf_m68k_got_entry_key key_;
1678 struct elf_m68k_got_entry *entry;
1680 if (h != NULL && elf_m68k_hash_entry (h)->got_entry_key == 0)
1681 elf_m68k_hash_entry (h)->got_entry_key
1682 = elf_m68k_multi_got (info)->global_symndx++;
1684 elf_m68k_init_got_entry_key (&key_, h, abfd, symndx, reloc_type);
1686 entry = elf_m68k_get_got_entry (got, &key_, FIND_OR_CREATE, info);
1687 if (entry == NULL)
1688 return NULL;
1690 /* Determine entry's type and update got->n_slots counters. */
1691 entry->key_.type = elf_m68k_update_got_entry_type (got,
1692 entry->key_.type,
1693 reloc_type);
1695 /* Update refcount. */
1696 ++entry->u.s1.refcount;
1698 if (entry->u.s1.refcount == 1)
1699 /* We see this entry for the first time. */
1701 if (entry->key_.bfd != NULL)
1702 got->local_n_slots += elf_m68k_reloc_got_n_slots (entry->key_.type);
1705 BFD_ASSERT (got->n_slots[R_32] >= got->local_n_slots);
1707 if ((got->n_slots[R_8]
1708 > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1709 || (got->n_slots[R_16]
1710 > ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info)))
1711 /* This BFD has too many relocation. */
1713 if (got->n_slots[R_8] > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1714 (*_bfd_error_handler) (_("%B: GOT overflow: "
1715 "Number of relocations with 8-bit "
1716 "offset > %d"),
1717 abfd,
1718 ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info));
1719 else
1720 (*_bfd_error_handler) (_("%B: GOT overflow: "
1721 "Number of relocations with 8- or 16-bit "
1722 "offset > %d"),
1723 abfd,
1724 ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info));
1726 return NULL;
1729 return entry;
1732 /* Compute the hash value of the bfd in a bfd2got hash entry. */
1734 static hashval_t
1735 elf_m68k_bfd2got_entry_hash (const void *entry)
1737 const struct elf_m68k_bfd2got_entry *e;
1739 e = (const struct elf_m68k_bfd2got_entry *) entry;
1741 return e->bfd->id;
1744 /* Check whether two hash entries have the same bfd. */
1746 static int
1747 elf_m68k_bfd2got_entry_eq (const void *entry1, const void *entry2)
1749 const struct elf_m68k_bfd2got_entry *e1;
1750 const struct elf_m68k_bfd2got_entry *e2;
1752 e1 = (const struct elf_m68k_bfd2got_entry *) entry1;
1753 e2 = (const struct elf_m68k_bfd2got_entry *) entry2;
1755 return e1->bfd == e2->bfd;
1758 /* Destruct a bfd2got entry. */
1760 static void
1761 elf_m68k_bfd2got_entry_del (void *_entry)
1763 struct elf_m68k_bfd2got_entry *entry;
1765 entry = (struct elf_m68k_bfd2got_entry *) _entry;
1767 BFD_ASSERT (entry->got != NULL);
1768 elf_m68k_clear_got (entry->got);
1771 /* Find existing or create new (depending on HOWTO) bfd2got entry in
1772 MULTI_GOT. ABFD is the bfd we need a GOT for. INFO is a context where
1773 memory should be allocated. */
1775 static struct elf_m68k_bfd2got_entry *
1776 elf_m68k_get_bfd2got_entry (struct elf_m68k_multi_got *multi_got,
1777 const bfd *abfd,
1778 enum elf_m68k_get_entry_howto howto,
1779 struct bfd_link_info *info)
1781 struct elf_m68k_bfd2got_entry entry_;
1782 void **ptr;
1783 struct elf_m68k_bfd2got_entry *entry;
1785 BFD_ASSERT ((info == NULL) == (howto == SEARCH || howto == MUST_FIND));
1787 if (multi_got->bfd2got == NULL)
1788 /* This is the first GOT. Initialize bfd2got. */
1790 if (howto == SEARCH)
1791 return NULL;
1793 multi_got->bfd2got = htab_try_create (1, elf_m68k_bfd2got_entry_hash,
1794 elf_m68k_bfd2got_entry_eq,
1795 elf_m68k_bfd2got_entry_del);
1796 if (multi_got->bfd2got == NULL)
1798 bfd_set_error (bfd_error_no_memory);
1799 return NULL;
1803 entry_.bfd = abfd;
1804 ptr = htab_find_slot (multi_got->bfd2got, &entry_, (howto != SEARCH
1805 ? INSERT : NO_INSERT));
1806 if (ptr == NULL)
1808 if (howto == SEARCH)
1809 /* Entry not found. */
1810 return NULL;
1812 /* We're out of memory. */
1813 bfd_set_error (bfd_error_no_memory);
1814 return NULL;
1817 if (*ptr == NULL)
1818 /* Entry was not found. Create new one. */
1820 BFD_ASSERT (howto != MUST_FIND && howto != SEARCH);
1822 entry = ((struct elf_m68k_bfd2got_entry *)
1823 bfd_alloc (elf_hash_table (info)->dynobj, sizeof (*entry)));
1824 if (entry == NULL)
1825 return NULL;
1827 entry->bfd = abfd;
1829 entry->got = elf_m68k_create_empty_got (info);
1830 if (entry->got == NULL)
1831 return NULL;
1833 *ptr = entry;
1835 else
1837 BFD_ASSERT (howto != MUST_CREATE);
1839 /* Return existing entry. */
1840 entry = *ptr;
1843 return entry;
1846 struct elf_m68k_can_merge_gots_arg
1848 /* A current_got that we constructing a DIFF against. */
1849 struct elf_m68k_got *big;
1851 /* GOT holding entries not present or that should be changed in
1852 BIG. */
1853 struct elf_m68k_got *diff;
1855 /* Context where to allocate memory. */
1856 struct bfd_link_info *info;
1858 /* Error flag. */
1859 bfd_boolean error_p;
1862 /* Process a single entry from the small GOT to see if it should be added
1863 or updated in the big GOT. */
1865 static int
1866 elf_m68k_can_merge_gots_1 (void **_entry_ptr, void *_arg)
1868 const struct elf_m68k_got_entry *entry1;
1869 struct elf_m68k_can_merge_gots_arg *arg;
1870 const struct elf_m68k_got_entry *entry2;
1871 enum elf_m68k_reloc_type type;
1873 entry1 = (const struct elf_m68k_got_entry *) *_entry_ptr;
1874 arg = (struct elf_m68k_can_merge_gots_arg *) _arg;
1876 entry2 = elf_m68k_get_got_entry (arg->big, &entry1->key_, SEARCH, NULL);
1878 if (entry2 != NULL)
1879 /* We found an existing entry. Check if we should update it. */
1881 type = elf_m68k_update_got_entry_type (arg->diff,
1882 entry2->key_.type,
1883 entry1->key_.type);
1885 if (type == entry2->key_.type)
1886 /* ENTRY1 doesn't update data in ENTRY2. Skip it.
1887 To skip creation of difference entry we use the type,
1888 which we won't see in GOT entries for sure. */
1889 type = R_68K_max;
1891 else
1892 /* We didn't find the entry. Add entry1 to DIFF. */
1894 BFD_ASSERT (entry1->key_.type != R_68K_max);
1896 type = elf_m68k_update_got_entry_type (arg->diff,
1897 R_68K_max, entry1->key_.type);
1899 if (entry1->key_.bfd != NULL)
1900 arg->diff->local_n_slots += elf_m68k_reloc_got_n_slots (type);
1903 if (type != R_68K_max)
1904 /* Create an entry in DIFF. */
1906 struct elf_m68k_got_entry *entry;
1908 entry = elf_m68k_get_got_entry (arg->diff, &entry1->key_, MUST_CREATE,
1909 arg->info);
1910 if (entry == NULL)
1912 arg->error_p = TRUE;
1913 return 0;
1916 entry->key_.type = type;
1919 return 1;
1922 /* Return TRUE if SMALL GOT can be added to BIG GOT without overflowing it.
1923 Construct DIFF GOT holding the entries which should be added or updated
1924 in BIG GOT to accumulate information from SMALL.
1925 INFO is the context where memory should be allocated. */
1927 static bfd_boolean
1928 elf_m68k_can_merge_gots (struct elf_m68k_got *big,
1929 const struct elf_m68k_got *small,
1930 struct bfd_link_info *info,
1931 struct elf_m68k_got *diff)
1933 struct elf_m68k_can_merge_gots_arg arg_;
1935 BFD_ASSERT (small->offset == (bfd_vma) -1);
1937 arg_.big = big;
1938 arg_.diff = diff;
1939 arg_.info = info;
1940 arg_.error_p = FALSE;
1941 htab_traverse_noresize (small->entries, elf_m68k_can_merge_gots_1, &arg_);
1942 if (arg_.error_p)
1944 diff->offset = 0;
1945 return FALSE;
1948 /* Check for overflow. */
1949 if ((big->n_slots[R_8] + arg_.diff->n_slots[R_8]
1950 > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
1951 || (big->n_slots[R_16] + arg_.diff->n_slots[R_16]
1952 > ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info)))
1953 return FALSE;
1955 return TRUE;
1958 struct elf_m68k_merge_gots_arg
1960 /* The BIG got. */
1961 struct elf_m68k_got *big;
1963 /* Context where memory should be allocated. */
1964 struct bfd_link_info *info;
1966 /* Error flag. */
1967 bfd_boolean error_p;
1970 /* Process a single entry from DIFF got. Add or update corresponding
1971 entry in the BIG got. */
1973 static int
1974 elf_m68k_merge_gots_1 (void **entry_ptr, void *_arg)
1976 const struct elf_m68k_got_entry *from;
1977 struct elf_m68k_merge_gots_arg *arg;
1978 struct elf_m68k_got_entry *to;
1980 from = (const struct elf_m68k_got_entry *) *entry_ptr;
1981 arg = (struct elf_m68k_merge_gots_arg *) _arg;
1983 to = elf_m68k_get_got_entry (arg->big, &from->key_, FIND_OR_CREATE,
1984 arg->info);
1985 if (to == NULL)
1987 arg->error_p = TRUE;
1988 return 0;
1991 BFD_ASSERT (to->u.s1.refcount == 0);
1992 /* All we need to merge is TYPE. */
1993 to->key_.type = from->key_.type;
1995 return 1;
1998 /* Merge data from DIFF to BIG. INFO is context where memory should be
1999 allocated. */
2001 static bfd_boolean
2002 elf_m68k_merge_gots (struct elf_m68k_got *big,
2003 struct elf_m68k_got *diff,
2004 struct bfd_link_info *info)
2006 if (diff->entries != NULL)
2007 /* DIFF is not empty. Merge it into BIG GOT. */
2009 struct elf_m68k_merge_gots_arg arg_;
2011 /* Merge entries. */
2012 arg_.big = big;
2013 arg_.info = info;
2014 arg_.error_p = FALSE;
2015 htab_traverse_noresize (diff->entries, elf_m68k_merge_gots_1, &arg_);
2016 if (arg_.error_p)
2017 return FALSE;
2019 /* Merge counters. */
2020 big->n_slots[R_8] += diff->n_slots[R_8];
2021 big->n_slots[R_16] += diff->n_slots[R_16];
2022 big->n_slots[R_32] += diff->n_slots[R_32];
2023 big->local_n_slots += diff->local_n_slots;
2025 else
2026 /* DIFF is empty. */
2028 BFD_ASSERT (diff->n_slots[R_8] == 0);
2029 BFD_ASSERT (diff->n_slots[R_16] == 0);
2030 BFD_ASSERT (diff->n_slots[R_32] == 0);
2031 BFD_ASSERT (diff->local_n_slots == 0);
2034 BFD_ASSERT (!elf_m68k_hash_table (info)->allow_multigot_p
2035 || ((big->n_slots[R_8]
2036 <= ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
2037 && (big->n_slots[R_16]
2038 <= ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info))));
2040 return TRUE;
2043 struct elf_m68k_finalize_got_offsets_arg
2045 /* Ranges of the offsets for GOT entries.
2046 R_x entries receive offsets between offset1[R_x] and offset2[R_x].
2047 R_x is R_8, R_16 and R_32. */
2048 bfd_vma *offset1;
2049 bfd_vma *offset2;
2051 /* Mapping from global symndx to global symbols.
2052 This is used to build lists of got entries for global symbols. */
2053 struct elf_m68k_link_hash_entry **symndx2h;
2055 bfd_vma n_ldm_entries;
2058 /* Assign ENTRY an offset. Build list of GOT entries for global symbols
2059 along the way. */
2061 static int
2062 elf_m68k_finalize_got_offsets_1 (void **entry_ptr, void *_arg)
2064 struct elf_m68k_got_entry *entry;
2065 struct elf_m68k_finalize_got_offsets_arg *arg;
2067 enum elf_m68k_got_offset_size got_offset_size;
2068 bfd_vma entry_size;
2070 entry = (struct elf_m68k_got_entry *) *entry_ptr;
2071 arg = (struct elf_m68k_finalize_got_offsets_arg *) _arg;
2073 /* This should be a fresh entry created in elf_m68k_can_merge_gots. */
2074 BFD_ASSERT (entry->u.s1.refcount == 0);
2076 /* Get GOT offset size for the entry . */
2077 got_offset_size = elf_m68k_reloc_got_offset_size (entry->key_.type);
2079 /* Calculate entry size in bytes. */
2080 entry_size = 4 * elf_m68k_reloc_got_n_slots (entry->key_.type);
2082 /* Check if we should switch to negative range of the offsets. */
2083 if (arg->offset1[got_offset_size] + entry_size
2084 > arg->offset2[got_offset_size])
2086 /* Verify that this is the only switch to negative range for
2087 got_offset_size. If this assertion fails, then we've miscalculated
2088 range for got_offset_size entries in
2089 elf_m68k_finalize_got_offsets. */
2090 BFD_ASSERT (arg->offset2[got_offset_size]
2091 != arg->offset2[-(int) got_offset_size - 1]);
2093 /* Switch. */
2094 arg->offset1[got_offset_size] = arg->offset1[-(int) got_offset_size - 1];
2095 arg->offset2[got_offset_size] = arg->offset2[-(int) got_offset_size - 1];
2097 /* Verify that now we have enough room for the entry. */
2098 BFD_ASSERT (arg->offset1[got_offset_size] + entry_size
2099 <= arg->offset2[got_offset_size]);
2102 /* Assign offset to entry. */
2103 entry->u.s2.offset = arg->offset1[got_offset_size];
2104 arg->offset1[got_offset_size] += entry_size;
2106 if (entry->key_.bfd == NULL)
2107 /* Hook up this entry into the list of got_entries of H. */
2109 struct elf_m68k_link_hash_entry *h;
2111 h = arg->symndx2h[entry->key_.symndx];
2112 if (h != NULL)
2114 entry->u.s2.next = h->glist;
2115 h->glist = entry;
2117 else
2118 /* This should be the entry for TLS_LDM relocation then. */
2120 BFD_ASSERT ((elf_m68k_reloc_got_type (entry->key_.type)
2121 == R_68K_TLS_LDM32)
2122 && entry->key_.symndx == 0);
2124 ++arg->n_ldm_entries;
2127 else
2128 /* This entry is for local symbol. */
2129 entry->u.s2.next = NULL;
2131 return 1;
2134 /* Assign offsets within GOT. USE_NEG_GOT_OFFSETS_P indicates if we
2135 should use negative offsets.
2136 Build list of GOT entries for global symbols along the way.
2137 SYMNDX2H is mapping from global symbol indices to actual
2138 global symbols.
2139 Return offset at which next GOT should start. */
2141 static void
2142 elf_m68k_finalize_got_offsets (struct elf_m68k_got *got,
2143 bfd_boolean use_neg_got_offsets_p,
2144 struct elf_m68k_link_hash_entry **symndx2h,
2145 bfd_vma *final_offset, bfd_vma *n_ldm_entries)
2147 struct elf_m68k_finalize_got_offsets_arg arg_;
2148 bfd_vma offset1_[2 * R_LAST];
2149 bfd_vma offset2_[2 * R_LAST];
2150 int i;
2151 bfd_vma start_offset;
2153 BFD_ASSERT (got->offset != (bfd_vma) -1);
2155 /* We set entry offsets relative to the .got section (and not the
2156 start of a particular GOT), so that we can use them in
2157 finish_dynamic_symbol without needing to know the GOT which they come
2158 from. */
2160 /* Put offset1 in the middle of offset1_, same for offset2. */
2161 arg_.offset1 = offset1_ + R_LAST;
2162 arg_.offset2 = offset2_ + R_LAST;
2164 start_offset = got->offset;
2166 if (use_neg_got_offsets_p)
2167 /* Setup both negative and positive ranges for R_8, R_16 and R_32. */
2168 i = -(int) R_32 - 1;
2169 else
2170 /* Setup positives ranges for R_8, R_16 and R_32. */
2171 i = (int) R_8;
2173 for (; i <= (int) R_32; ++i)
2175 int j;
2176 size_t n;
2178 /* Set beginning of the range of offsets I. */
2179 arg_.offset1[i] = start_offset;
2181 /* Calculate number of slots that require I offsets. */
2182 j = (i >= 0) ? i : -i - 1;
2183 n = (j >= 1) ? got->n_slots[j - 1] : 0;
2184 n = got->n_slots[j] - n;
2186 if (use_neg_got_offsets_p && n != 0)
2188 if (i < 0)
2189 /* We first fill the positive side of the range, so we might
2190 end up with one empty slot at that side when we can't fit
2191 whole 2-slot entry. Account for that at negative side of
2192 the interval with one additional entry. */
2193 n = n / 2 + 1;
2194 else
2195 /* When the number of slots is odd, make positive side of the
2196 range one entry bigger. */
2197 n = (n + 1) / 2;
2200 /* N is the number of slots that require I offsets.
2201 Calculate length of the range for I offsets. */
2202 n = 4 * n;
2204 /* Set end of the range. */
2205 arg_.offset2[i] = start_offset + n;
2207 start_offset = arg_.offset2[i];
2210 if (!use_neg_got_offsets_p)
2211 /* Make sure that if we try to switch to negative offsets in
2212 elf_m68k_finalize_got_offsets_1, the assert therein will catch
2213 the bug. */
2214 for (i = R_8; i <= R_32; ++i)
2215 arg_.offset2[-i - 1] = arg_.offset2[i];
2217 /* Setup got->offset. offset1[R_8] is either in the middle or at the
2218 beginning of GOT depending on use_neg_got_offsets_p. */
2219 got->offset = arg_.offset1[R_8];
2221 arg_.symndx2h = symndx2h;
2222 arg_.n_ldm_entries = 0;
2224 /* Assign offsets. */
2225 htab_traverse (got->entries, elf_m68k_finalize_got_offsets_1, &arg_);
2227 /* Check offset ranges we have actually assigned. */
2228 for (i = (int) R_8; i <= (int) R_32; ++i)
2229 BFD_ASSERT (arg_.offset2[i] - arg_.offset1[i] <= 4);
2231 *final_offset = start_offset;
2232 *n_ldm_entries = arg_.n_ldm_entries;
2235 struct elf_m68k_partition_multi_got_arg
2237 /* The GOT we are adding entries to. Aka big got. */
2238 struct elf_m68k_got *current_got;
2240 /* Offset to assign the next CURRENT_GOT. */
2241 bfd_vma offset;
2243 /* Context where memory should be allocated. */
2244 struct bfd_link_info *info;
2246 /* Total number of slots in the .got section.
2247 This is used to calculate size of the .got and .rela.got sections. */
2248 bfd_vma n_slots;
2250 /* Difference in numbers of allocated slots in the .got section
2251 and necessary relocations in the .rela.got section.
2252 This is used to calculate size of the .rela.got section. */
2253 bfd_vma slots_relas_diff;
2255 /* Error flag. */
2256 bfd_boolean error_p;
2258 /* Mapping from global symndx to global symbols.
2259 This is used to build lists of got entries for global symbols. */
2260 struct elf_m68k_link_hash_entry **symndx2h;
2263 static void
2264 elf_m68k_partition_multi_got_2 (struct elf_m68k_partition_multi_got_arg *arg)
2266 bfd_vma n_ldm_entries;
2268 elf_m68k_finalize_got_offsets (arg->current_got,
2269 (elf_m68k_hash_table (arg->info)
2270 ->use_neg_got_offsets_p),
2271 arg->symndx2h,
2272 &arg->offset, &n_ldm_entries);
2274 arg->n_slots += arg->current_got->n_slots[R_32];
2276 if (!arg->info->shared)
2277 /* If we are generating a shared object, we need to
2278 output a R_68K_RELATIVE reloc so that the dynamic
2279 linker can adjust this GOT entry. Overwise we
2280 don't need space in .rela.got for local symbols. */
2281 arg->slots_relas_diff += arg->current_got->local_n_slots;
2283 /* @LDM relocations require a 2-slot GOT entry, but only
2284 one relocation. Account for that. */
2285 arg->slots_relas_diff += n_ldm_entries;
2287 BFD_ASSERT (arg->slots_relas_diff <= arg->n_slots);
2291 /* Process a single BFD2GOT entry and either merge GOT to CURRENT_GOT
2292 or start a new CURRENT_GOT. */
2294 static int
2295 elf_m68k_partition_multi_got_1 (void **_entry, void *_arg)
2297 struct elf_m68k_bfd2got_entry *entry;
2298 struct elf_m68k_partition_multi_got_arg *arg;
2299 struct elf_m68k_got *got;
2300 struct elf_m68k_got diff_;
2301 struct elf_m68k_got *diff;
2303 entry = (struct elf_m68k_bfd2got_entry *) *_entry;
2304 arg = (struct elf_m68k_partition_multi_got_arg *) _arg;
2306 got = entry->got;
2307 BFD_ASSERT (got != NULL);
2308 BFD_ASSERT (got->offset == (bfd_vma) -1);
2310 diff = NULL;
2312 if (arg->current_got != NULL)
2313 /* Construct diff. */
2315 diff = &diff_;
2316 elf_m68k_init_got (diff);
2318 if (!elf_m68k_can_merge_gots (arg->current_got, got, arg->info, diff))
2320 if (diff->offset == 0)
2321 /* Offset set to 0 in the diff_ indicates an error. */
2323 arg->error_p = TRUE;
2324 goto final_return;
2327 if (elf_m68k_hash_table (arg->info)->allow_multigot_p)
2329 elf_m68k_clear_got (diff);
2330 /* Schedule to finish up current_got and start new one. */
2331 diff = NULL;
2333 /* else
2334 Merge GOTs no matter what. If big GOT overflows,
2335 we'll fail in relocate_section due to truncated relocations.
2337 ??? May be fail earlier? E.g., in can_merge_gots. */
2340 else
2341 /* Diff of got against empty current_got is got itself. */
2343 /* Create empty current_got to put subsequent GOTs to. */
2344 arg->current_got = elf_m68k_create_empty_got (arg->info);
2345 if (arg->current_got == NULL)
2347 arg->error_p = TRUE;
2348 goto final_return;
2351 arg->current_got->offset = arg->offset;
2353 diff = got;
2356 if (diff != NULL)
2358 if (!elf_m68k_merge_gots (arg->current_got, diff, arg->info))
2360 arg->error_p = TRUE;
2361 goto final_return;
2364 /* Now we can free GOT. */
2365 elf_m68k_clear_got (got);
2367 entry->got = arg->current_got;
2369 else
2371 /* Finish up current_got. */
2372 elf_m68k_partition_multi_got_2 (arg);
2374 /* Schedule to start a new current_got. */
2375 arg->current_got = NULL;
2377 /* Retry. */
2378 if (!elf_m68k_partition_multi_got_1 (_entry, _arg))
2380 BFD_ASSERT (arg->error_p);
2381 goto final_return;
2385 final_return:
2386 if (diff != NULL)
2387 elf_m68k_clear_got (diff);
2389 return arg->error_p == FALSE ? 1 : 0;
2392 /* Helper function to build symndx2h mapping. */
2394 static bfd_boolean
2395 elf_m68k_init_symndx2h_1 (struct elf_link_hash_entry *_h,
2396 void *_arg)
2398 struct elf_m68k_link_hash_entry *h;
2400 h = elf_m68k_hash_entry (_h);
2402 if (h->got_entry_key != 0)
2403 /* H has at least one entry in the GOT. */
2405 struct elf_m68k_partition_multi_got_arg *arg;
2407 arg = (struct elf_m68k_partition_multi_got_arg *) _arg;
2409 BFD_ASSERT (arg->symndx2h[h->got_entry_key] == NULL);
2410 arg->symndx2h[h->got_entry_key] = h;
2413 return TRUE;
2416 /* Merge GOTs of some BFDs, assign offsets to GOT entries and build
2417 lists of GOT entries for global symbols.
2418 Calculate sizes of .got and .rela.got sections. */
2420 static bfd_boolean
2421 elf_m68k_partition_multi_got (struct bfd_link_info *info)
2423 struct elf_m68k_multi_got *multi_got;
2424 struct elf_m68k_partition_multi_got_arg arg_;
2426 multi_got = elf_m68k_multi_got (info);
2428 arg_.current_got = NULL;
2429 arg_.offset = 0;
2430 arg_.info = info;
2431 arg_.n_slots = 0;
2432 arg_.slots_relas_diff = 0;
2433 arg_.error_p = FALSE;
2435 if (multi_got->bfd2got != NULL)
2437 /* Initialize symndx2h mapping. */
2439 arg_.symndx2h = bfd_zmalloc (multi_got->global_symndx
2440 * sizeof (*arg_.symndx2h));
2441 if (arg_.symndx2h == NULL)
2442 return FALSE;
2444 elf_link_hash_traverse (elf_hash_table (info),
2445 elf_m68k_init_symndx2h_1, &arg_);
2448 /* Partition. */
2449 htab_traverse (multi_got->bfd2got, elf_m68k_partition_multi_got_1,
2450 &arg_);
2451 if (arg_.error_p)
2453 free (arg_.symndx2h);
2454 arg_.symndx2h = NULL;
2456 return FALSE;
2459 /* Finish up last current_got. */
2460 elf_m68k_partition_multi_got_2 (&arg_);
2462 free (arg_.symndx2h);
2465 if (elf_hash_table (info)->dynobj != NULL)
2466 /* Set sizes of .got and .rela.got sections. */
2468 asection *s;
2470 s = bfd_get_section_by_name (elf_hash_table (info)->dynobj, ".got");
2471 if (s != NULL)
2472 s->size = arg_.offset;
2473 else
2474 BFD_ASSERT (arg_.offset == 0);
2476 BFD_ASSERT (arg_.slots_relas_diff <= arg_.n_slots);
2477 arg_.n_slots -= arg_.slots_relas_diff;
2479 s = bfd_get_section_by_name (elf_hash_table (info)->dynobj, ".rela.got");
2480 if (s != NULL)
2481 s->size = arg_.n_slots * sizeof (Elf32_External_Rela);
2482 else
2483 BFD_ASSERT (arg_.n_slots == 0);
2485 else
2486 BFD_ASSERT (multi_got->bfd2got == NULL);
2488 return TRUE;
2491 /* Specialized version of elf_m68k_get_got_entry that returns pointer
2492 to hashtable slot, thus allowing removal of entry via
2493 elf_m68k_remove_got_entry. */
2495 static struct elf_m68k_got_entry **
2496 elf_m68k_find_got_entry_ptr (struct elf_m68k_got *got,
2497 struct elf_m68k_got_entry_key *key)
2499 void **ptr;
2500 struct elf_m68k_got_entry entry_;
2501 struct elf_m68k_got_entry **entry_ptr;
2503 entry_.key_ = *key;
2504 ptr = htab_find_slot (got->entries, &entry_, NO_INSERT);
2505 BFD_ASSERT (ptr != NULL);
2507 entry_ptr = (struct elf_m68k_got_entry **) ptr;
2509 return entry_ptr;
2512 /* Remove entry pointed to by ENTRY_PTR from GOT. */
2514 static void
2515 elf_m68k_remove_got_entry (struct elf_m68k_got *got,
2516 struct elf_m68k_got_entry **entry_ptr)
2518 struct elf_m68k_got_entry *entry;
2520 entry = *entry_ptr;
2522 /* Check that offsets have not been finalized yet. */
2523 BFD_ASSERT (got->offset == (bfd_vma) -1);
2524 /* Check that this entry is indeed unused. */
2525 BFD_ASSERT (entry->u.s1.refcount == 0);
2527 elf_m68k_remove_got_entry_type (got, entry->key_.type);
2529 if (entry->key_.bfd != NULL)
2530 got->local_n_slots -= elf_m68k_reloc_got_n_slots (entry->key_.type);
2532 BFD_ASSERT (got->n_slots[R_32] >= got->local_n_slots);
2534 htab_clear_slot (got->entries, (void **) entry_ptr);
2537 /* Copy any information related to dynamic linking from a pre-existing
2538 symbol to a newly created symbol. Also called to copy flags and
2539 other back-end info to a weakdef, in which case the symbol is not
2540 newly created and plt/got refcounts and dynamic indices should not
2541 be copied. */
2543 static void
2544 elf_m68k_copy_indirect_symbol (struct bfd_link_info *info,
2545 struct elf_link_hash_entry *_dir,
2546 struct elf_link_hash_entry *_ind)
2548 struct elf_m68k_link_hash_entry *dir;
2549 struct elf_m68k_link_hash_entry *ind;
2551 _bfd_elf_link_hash_copy_indirect (info, _dir, _ind);
2553 if (_ind->root.type != bfd_link_hash_indirect)
2554 return;
2556 dir = elf_m68k_hash_entry (_dir);
2557 ind = elf_m68k_hash_entry (_ind);
2559 /* Any absolute non-dynamic relocations against an indirect or weak
2560 definition will be against the target symbol. */
2561 _dir->non_got_ref |= _ind->non_got_ref;
2563 /* We might have a direct symbol already having entries in the GOTs.
2564 Update its key only in case indirect symbol has GOT entries and
2565 assert that both indirect and direct symbols don't have GOT entries
2566 at the same time. */
2567 if (ind->got_entry_key != 0)
2569 BFD_ASSERT (dir->got_entry_key == 0);
2570 /* Assert that GOTs aren't partioned yet. */
2571 BFD_ASSERT (ind->glist == NULL);
2573 dir->got_entry_key = ind->got_entry_key;
2574 ind->got_entry_key = 0;
2578 /* Look through the relocs for a section during the first phase, and
2579 allocate space in the global offset table or procedure linkage
2580 table. */
2582 static bfd_boolean
2583 elf_m68k_check_relocs (abfd, info, sec, relocs)
2584 bfd *abfd;
2585 struct bfd_link_info *info;
2586 asection *sec;
2587 const Elf_Internal_Rela *relocs;
2589 bfd *dynobj;
2590 Elf_Internal_Shdr *symtab_hdr;
2591 struct elf_link_hash_entry **sym_hashes;
2592 const Elf_Internal_Rela *rel;
2593 const Elf_Internal_Rela *rel_end;
2594 asection *sgot;
2595 asection *srelgot;
2596 asection *sreloc;
2597 struct elf_m68k_got *got;
2599 if (info->relocatable)
2600 return TRUE;
2602 dynobj = elf_hash_table (info)->dynobj;
2603 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2604 sym_hashes = elf_sym_hashes (abfd);
2606 sgot = NULL;
2607 srelgot = NULL;
2608 sreloc = NULL;
2610 got = NULL;
2612 rel_end = relocs + sec->reloc_count;
2613 for (rel = relocs; rel < rel_end; rel++)
2615 unsigned long r_symndx;
2616 struct elf_link_hash_entry *h;
2618 r_symndx = ELF32_R_SYM (rel->r_info);
2620 if (r_symndx < symtab_hdr->sh_info)
2621 h = NULL;
2622 else
2624 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2625 while (h->root.type == bfd_link_hash_indirect
2626 || h->root.type == bfd_link_hash_warning)
2627 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2630 switch (ELF32_R_TYPE (rel->r_info))
2632 case R_68K_GOT8:
2633 case R_68K_GOT16:
2634 case R_68K_GOT32:
2635 if (h != NULL
2636 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2637 break;
2638 /* Fall through. */
2640 /* Relative GOT relocations. */
2641 case R_68K_GOT8O:
2642 case R_68K_GOT16O:
2643 case R_68K_GOT32O:
2644 /* Fall through. */
2646 /* TLS relocations. */
2647 case R_68K_TLS_GD8:
2648 case R_68K_TLS_GD16:
2649 case R_68K_TLS_GD32:
2650 case R_68K_TLS_LDM8:
2651 case R_68K_TLS_LDM16:
2652 case R_68K_TLS_LDM32:
2653 case R_68K_TLS_IE8:
2654 case R_68K_TLS_IE16:
2655 case R_68K_TLS_IE32:
2657 case R_68K_TLS_TPREL32:
2658 case R_68K_TLS_DTPREL32:
2660 if (ELF32_R_TYPE (rel->r_info) == R_68K_TLS_TPREL32
2661 && info->shared)
2662 /* Do the special chorus for libraries with static TLS. */
2663 info->flags |= DF_STATIC_TLS;
2665 /* This symbol requires a global offset table entry. */
2667 if (dynobj == NULL)
2669 /* Create the .got section. */
2670 elf_hash_table (info)->dynobj = dynobj = abfd;
2671 if (!_bfd_elf_create_got_section (dynobj, info))
2672 return FALSE;
2675 if (sgot == NULL)
2677 sgot = bfd_get_section_by_name (dynobj, ".got");
2678 BFD_ASSERT (sgot != NULL);
2681 if (srelgot == NULL
2682 && (h != NULL || info->shared))
2684 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2685 if (srelgot == NULL)
2687 srelgot = bfd_make_section_with_flags (dynobj,
2688 ".rela.got",
2689 (SEC_ALLOC
2690 | SEC_LOAD
2691 | SEC_HAS_CONTENTS
2692 | SEC_IN_MEMORY
2693 | SEC_LINKER_CREATED
2694 | SEC_READONLY));
2695 if (srelgot == NULL
2696 || !bfd_set_section_alignment (dynobj, srelgot, 2))
2697 return FALSE;
2701 if (got == NULL)
2703 struct elf_m68k_bfd2got_entry *bfd2got_entry;
2705 bfd2got_entry
2706 = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
2707 abfd, FIND_OR_CREATE, info);
2708 if (bfd2got_entry == NULL)
2709 return FALSE;
2711 got = bfd2got_entry->got;
2712 BFD_ASSERT (got != NULL);
2716 struct elf_m68k_got_entry *got_entry;
2718 /* Add entry to got. */
2719 got_entry = elf_m68k_add_entry_to_got (got, h, abfd,
2720 ELF32_R_TYPE (rel->r_info),
2721 r_symndx, info);
2722 if (got_entry == NULL)
2723 return FALSE;
2725 if (got_entry->u.s1.refcount == 1)
2727 /* Make sure this symbol is output as a dynamic symbol. */
2728 if (h != NULL
2729 && h->dynindx == -1
2730 && !h->forced_local)
2732 if (!bfd_elf_link_record_dynamic_symbol (info, h))
2733 return FALSE;
2738 break;
2740 case R_68K_PLT8:
2741 case R_68K_PLT16:
2742 case R_68K_PLT32:
2743 /* This symbol requires a procedure linkage table entry. We
2744 actually build the entry in adjust_dynamic_symbol,
2745 because this might be a case of linking PIC code which is
2746 never referenced by a dynamic object, in which case we
2747 don't need to generate a procedure linkage table entry
2748 after all. */
2750 /* If this is a local symbol, we resolve it directly without
2751 creating a procedure linkage table entry. */
2752 if (h == NULL)
2753 continue;
2755 h->needs_plt = 1;
2756 h->plt.refcount++;
2757 break;
2759 case R_68K_PLT8O:
2760 case R_68K_PLT16O:
2761 case R_68K_PLT32O:
2762 /* This symbol requires a procedure linkage table entry. */
2764 if (h == NULL)
2766 /* It does not make sense to have this relocation for a
2767 local symbol. FIXME: does it? How to handle it if
2768 it does make sense? */
2769 bfd_set_error (bfd_error_bad_value);
2770 return FALSE;
2773 /* Make sure this symbol is output as a dynamic symbol. */
2774 if (h->dynindx == -1
2775 && !h->forced_local)
2777 if (!bfd_elf_link_record_dynamic_symbol (info, h))
2778 return FALSE;
2781 h->needs_plt = 1;
2782 h->plt.refcount++;
2783 break;
2785 case R_68K_PC8:
2786 case R_68K_PC16:
2787 case R_68K_PC32:
2788 /* If we are creating a shared library and this is not a local
2789 symbol, we need to copy the reloc into the shared library.
2790 However when linking with -Bsymbolic and this is a global
2791 symbol which is defined in an object we are including in the
2792 link (i.e., DEF_REGULAR is set), then we can resolve the
2793 reloc directly. At this point we have not seen all the input
2794 files, so it is possible that DEF_REGULAR is not set now but
2795 will be set later (it is never cleared). We account for that
2796 possibility below by storing information in the
2797 pcrel_relocs_copied field of the hash table entry. */
2798 if (!(info->shared
2799 && (sec->flags & SEC_ALLOC) != 0
2800 && h != NULL
2801 && (!info->symbolic
2802 || h->root.type == bfd_link_hash_defweak
2803 || !h->def_regular)))
2805 if (h != NULL)
2807 /* Make sure a plt entry is created for this symbol if
2808 it turns out to be a function defined by a dynamic
2809 object. */
2810 h->plt.refcount++;
2812 break;
2814 /* Fall through. */
2815 case R_68K_8:
2816 case R_68K_16:
2817 case R_68K_32:
2818 if (h != NULL)
2820 /* Make sure a plt entry is created for this symbol if it
2821 turns out to be a function defined by a dynamic object. */
2822 h->plt.refcount++;
2824 if (!info->shared)
2825 /* This symbol needs a non-GOT reference. */
2826 h->non_got_ref = 1;
2829 /* If we are creating a shared library, we need to copy the
2830 reloc into the shared library. */
2831 if (info->shared
2832 && (sec->flags & SEC_ALLOC) != 0)
2834 /* When creating a shared object, we must copy these
2835 reloc types into the output file. We create a reloc
2836 section in dynobj and make room for this reloc. */
2837 if (sreloc == NULL)
2839 sreloc = _bfd_elf_make_dynamic_reloc_section
2840 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
2842 if (sreloc == NULL)
2843 return FALSE;
2846 if (sec->flags & SEC_READONLY
2847 /* Don't set DF_TEXTREL yet for PC relative
2848 relocations, they might be discarded later. */
2849 && !(ELF32_R_TYPE (rel->r_info) == R_68K_PC8
2850 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
2851 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32))
2852 info->flags |= DF_TEXTREL;
2854 sreloc->size += sizeof (Elf32_External_Rela);
2856 /* We count the number of PC relative relocations we have
2857 entered for this symbol, so that we can discard them
2858 again if, in the -Bsymbolic case, the symbol is later
2859 defined by a regular object, or, in the normal shared
2860 case, the symbol is forced to be local. Note that this
2861 function is only called if we are using an m68kelf linker
2862 hash table, which means that h is really a pointer to an
2863 elf_m68k_link_hash_entry. */
2864 if (ELF32_R_TYPE (rel->r_info) == R_68K_PC8
2865 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
2866 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)
2868 struct elf_m68k_pcrel_relocs_copied *p;
2869 struct elf_m68k_pcrel_relocs_copied **head;
2871 if (h != NULL)
2873 struct elf_m68k_link_hash_entry *eh
2874 = elf_m68k_hash_entry (h);
2875 head = &eh->pcrel_relocs_copied;
2877 else
2879 asection *s;
2880 void *vpp;
2881 Elf_Internal_Sym *isym;
2883 isym = bfd_sym_from_r_symndx (&elf_m68k_hash_table (info)->sym_cache,
2884 abfd, r_symndx);
2885 if (isym == NULL)
2886 return FALSE;
2888 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2889 if (s == NULL)
2890 s = sec;
2892 vpp = &elf_section_data (s)->local_dynrel;
2893 head = (struct elf_m68k_pcrel_relocs_copied **) vpp;
2896 for (p = *head; p != NULL; p = p->next)
2897 if (p->section == sreloc)
2898 break;
2900 if (p == NULL)
2902 p = ((struct elf_m68k_pcrel_relocs_copied *)
2903 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
2904 if (p == NULL)
2905 return FALSE;
2906 p->next = *head;
2907 *head = p;
2908 p->section = sreloc;
2909 p->count = 0;
2912 ++p->count;
2916 break;
2918 /* This relocation describes the C++ object vtable hierarchy.
2919 Reconstruct it for later use during GC. */
2920 case R_68K_GNU_VTINHERIT:
2921 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2922 return FALSE;
2923 break;
2925 /* This relocation describes which C++ vtable entries are actually
2926 used. Record for later use during GC. */
2927 case R_68K_GNU_VTENTRY:
2928 BFD_ASSERT (h != NULL);
2929 if (h != NULL
2930 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2931 return FALSE;
2932 break;
2934 default:
2935 break;
2939 return TRUE;
2942 /* Return the section that should be marked against GC for a given
2943 relocation. */
2945 static asection *
2946 elf_m68k_gc_mark_hook (asection *sec,
2947 struct bfd_link_info *info,
2948 Elf_Internal_Rela *rel,
2949 struct elf_link_hash_entry *h,
2950 Elf_Internal_Sym *sym)
2952 if (h != NULL)
2953 switch (ELF32_R_TYPE (rel->r_info))
2955 case R_68K_GNU_VTINHERIT:
2956 case R_68K_GNU_VTENTRY:
2957 return NULL;
2960 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2963 /* Update the got entry reference counts for the section being removed. */
2965 static bfd_boolean
2966 elf_m68k_gc_sweep_hook (bfd *abfd,
2967 struct bfd_link_info *info,
2968 asection *sec,
2969 const Elf_Internal_Rela *relocs)
2971 Elf_Internal_Shdr *symtab_hdr;
2972 struct elf_link_hash_entry **sym_hashes;
2973 const Elf_Internal_Rela *rel, *relend;
2974 bfd *dynobj;
2975 struct elf_m68k_got *got;
2977 if (info->relocatable)
2978 return TRUE;
2980 dynobj = elf_hash_table (info)->dynobj;
2981 if (dynobj == NULL)
2982 return TRUE;
2984 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2985 sym_hashes = elf_sym_hashes (abfd);
2986 got = NULL;
2988 relend = relocs + sec->reloc_count;
2989 for (rel = relocs; rel < relend; rel++)
2991 unsigned long r_symndx;
2992 struct elf_link_hash_entry *h = NULL;
2994 r_symndx = ELF32_R_SYM (rel->r_info);
2995 if (r_symndx >= symtab_hdr->sh_info)
2997 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2998 while (h->root.type == bfd_link_hash_indirect
2999 || h->root.type == bfd_link_hash_warning)
3000 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3003 switch (ELF32_R_TYPE (rel->r_info))
3005 case R_68K_GOT8:
3006 case R_68K_GOT16:
3007 case R_68K_GOT32:
3008 if (h != NULL
3009 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3010 break;
3012 /* FALLTHRU */
3013 case R_68K_GOT8O:
3014 case R_68K_GOT16O:
3015 case R_68K_GOT32O:
3016 /* Fall through. */
3018 /* TLS relocations. */
3019 case R_68K_TLS_GD8:
3020 case R_68K_TLS_GD16:
3021 case R_68K_TLS_GD32:
3022 case R_68K_TLS_LDM8:
3023 case R_68K_TLS_LDM16:
3024 case R_68K_TLS_LDM32:
3025 case R_68K_TLS_IE8:
3026 case R_68K_TLS_IE16:
3027 case R_68K_TLS_IE32:
3029 case R_68K_TLS_TPREL32:
3030 case R_68K_TLS_DTPREL32:
3032 if (got == NULL)
3034 got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3035 abfd, MUST_FIND, NULL)->got;
3036 BFD_ASSERT (got != NULL);
3040 struct elf_m68k_got_entry_key key_;
3041 struct elf_m68k_got_entry **got_entry_ptr;
3042 struct elf_m68k_got_entry *got_entry;
3044 elf_m68k_init_got_entry_key (&key_, h, abfd, r_symndx,
3045 ELF32_R_TYPE (rel->r_info));
3046 got_entry_ptr = elf_m68k_find_got_entry_ptr (got, &key_);
3048 got_entry = *got_entry_ptr;
3050 if (got_entry->u.s1.refcount > 0)
3052 --got_entry->u.s1.refcount;
3054 if (got_entry->u.s1.refcount == 0)
3055 /* We don't need the .got entry any more. */
3056 elf_m68k_remove_got_entry (got, got_entry_ptr);
3059 break;
3061 case R_68K_PLT8:
3062 case R_68K_PLT16:
3063 case R_68K_PLT32:
3064 case R_68K_PLT8O:
3065 case R_68K_PLT16O:
3066 case R_68K_PLT32O:
3067 case R_68K_PC8:
3068 case R_68K_PC16:
3069 case R_68K_PC32:
3070 case R_68K_8:
3071 case R_68K_16:
3072 case R_68K_32:
3073 if (h != NULL)
3075 if (h->plt.refcount > 0)
3076 --h->plt.refcount;
3078 break;
3080 default:
3081 break;
3085 return TRUE;
3088 /* Return the type of PLT associated with OUTPUT_BFD. */
3090 static const struct elf_m68k_plt_info *
3091 elf_m68k_get_plt_info (bfd *output_bfd)
3093 unsigned int features;
3095 features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd));
3096 if (features & cpu32)
3097 return &elf_cpu32_plt_info;
3098 if (features & mcfisa_b)
3099 return &elf_isab_plt_info;
3100 if (features & mcfisa_c)
3101 return &elf_isac_plt_info;
3102 return &elf_m68k_plt_info;
3105 /* This function is called after all the input files have been read,
3106 and the input sections have been assigned to output sections.
3107 It's a convenient place to determine the PLT style. */
3109 static bfd_boolean
3110 elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
3112 /* Bind input BFDs to GOTs and calculate sizes of .got and .rela.got
3113 sections. */
3114 if (!elf_m68k_partition_multi_got (info))
3115 return FALSE;
3117 elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd);
3118 return TRUE;
3121 /* Adjust a symbol defined by a dynamic object and referenced by a
3122 regular object. The current definition is in some section of the
3123 dynamic object, but we're not including those sections. We have to
3124 change the definition to something the rest of the link can
3125 understand. */
3127 static bfd_boolean
3128 elf_m68k_adjust_dynamic_symbol (info, h)
3129 struct bfd_link_info *info;
3130 struct elf_link_hash_entry *h;
3132 struct elf_m68k_link_hash_table *htab;
3133 bfd *dynobj;
3134 asection *s;
3136 htab = elf_m68k_hash_table (info);
3137 dynobj = elf_hash_table (info)->dynobj;
3139 /* Make sure we know what is going on here. */
3140 BFD_ASSERT (dynobj != NULL
3141 && (h->needs_plt
3142 || h->u.weakdef != NULL
3143 || (h->def_dynamic
3144 && h->ref_regular
3145 && !h->def_regular)));
3147 /* If this is a function, put it in the procedure linkage table. We
3148 will fill in the contents of the procedure linkage table later,
3149 when we know the address of the .got section. */
3150 if (h->type == STT_FUNC
3151 || h->needs_plt)
3153 if ((h->plt.refcount <= 0
3154 || SYMBOL_CALLS_LOCAL (info, h)
3155 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3156 && h->root.type == bfd_link_hash_undefweak))
3157 /* We must always create the plt entry if it was referenced
3158 by a PLTxxO relocation. In this case we already recorded
3159 it as a dynamic symbol. */
3160 && h->dynindx == -1)
3162 /* This case can occur if we saw a PLTxx reloc in an input
3163 file, but the symbol was never referred to by a dynamic
3164 object, or if all references were garbage collected. In
3165 such a case, we don't actually need to build a procedure
3166 linkage table, and we can just do a PCxx reloc instead. */
3167 h->plt.offset = (bfd_vma) -1;
3168 h->needs_plt = 0;
3169 return TRUE;
3172 /* Make sure this symbol is output as a dynamic symbol. */
3173 if (h->dynindx == -1
3174 && !h->forced_local)
3176 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3177 return FALSE;
3180 s = bfd_get_section_by_name (dynobj, ".plt");
3181 BFD_ASSERT (s != NULL);
3183 /* If this is the first .plt entry, make room for the special
3184 first entry. */
3185 if (s->size == 0)
3186 s->size = htab->plt_info->size;
3188 /* If this symbol is not defined in a regular file, and we are
3189 not generating a shared library, then set the symbol to this
3190 location in the .plt. This is required to make function
3191 pointers compare as equal between the normal executable and
3192 the shared library. */
3193 if (!info->shared
3194 && !h->def_regular)
3196 h->root.u.def.section = s;
3197 h->root.u.def.value = s->size;
3200 h->plt.offset = s->size;
3202 /* Make room for this entry. */
3203 s->size += htab->plt_info->size;
3205 /* We also need to make an entry in the .got.plt section, which
3206 will be placed in the .got section by the linker script. */
3207 s = bfd_get_section_by_name (dynobj, ".got.plt");
3208 BFD_ASSERT (s != NULL);
3209 s->size += 4;
3211 /* We also need to make an entry in the .rela.plt section. */
3212 s = bfd_get_section_by_name (dynobj, ".rela.plt");
3213 BFD_ASSERT (s != NULL);
3214 s->size += sizeof (Elf32_External_Rela);
3216 return TRUE;
3219 /* Reinitialize the plt offset now that it is not used as a reference
3220 count any more. */
3221 h->plt.offset = (bfd_vma) -1;
3223 /* If this is a weak symbol, and there is a real definition, the
3224 processor independent code will have arranged for us to see the
3225 real definition first, and we can just use the same value. */
3226 if (h->u.weakdef != NULL)
3228 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3229 || h->u.weakdef->root.type == bfd_link_hash_defweak);
3230 h->root.u.def.section = h->u.weakdef->root.u.def.section;
3231 h->root.u.def.value = h->u.weakdef->root.u.def.value;
3232 return TRUE;
3235 /* This is a reference to a symbol defined by a dynamic object which
3236 is not a function. */
3238 /* If we are creating a shared library, we must presume that the
3239 only references to the symbol are via the global offset table.
3240 For such cases we need not do anything here; the relocations will
3241 be handled correctly by relocate_section. */
3242 if (info->shared)
3243 return TRUE;
3245 /* If there are no references to this symbol that do not use the
3246 GOT, we don't need to generate a copy reloc. */
3247 if (!h->non_got_ref)
3248 return TRUE;
3250 if (h->size == 0)
3252 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
3253 h->root.root.string);
3254 return TRUE;
3257 /* We must allocate the symbol in our .dynbss section, which will
3258 become part of the .bss section of the executable. There will be
3259 an entry for this symbol in the .dynsym section. The dynamic
3260 object will contain position independent code, so all references
3261 from the dynamic object to this symbol will go through the global
3262 offset table. The dynamic linker will use the .dynsym entry to
3263 determine the address it must put in the global offset table, so
3264 both the dynamic object and the regular object will refer to the
3265 same memory location for the variable. */
3267 s = bfd_get_section_by_name (dynobj, ".dynbss");
3268 BFD_ASSERT (s != NULL);
3270 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
3271 copy the initial value out of the dynamic object and into the
3272 runtime process image. We need to remember the offset into the
3273 .rela.bss section we are going to use. */
3274 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3276 asection *srel;
3278 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
3279 BFD_ASSERT (srel != NULL);
3280 srel->size += sizeof (Elf32_External_Rela);
3281 h->needs_copy = 1;
3284 return _bfd_elf_adjust_dynamic_copy (h, s);
3287 /* Set the sizes of the dynamic sections. */
3289 static bfd_boolean
3290 elf_m68k_size_dynamic_sections (output_bfd, info)
3291 bfd *output_bfd ATTRIBUTE_UNUSED;
3292 struct bfd_link_info *info;
3294 bfd *dynobj;
3295 asection *s;
3296 bfd_boolean plt;
3297 bfd_boolean relocs;
3299 dynobj = elf_hash_table (info)->dynobj;
3300 BFD_ASSERT (dynobj != NULL);
3302 if (elf_hash_table (info)->dynamic_sections_created)
3304 /* Set the contents of the .interp section to the interpreter. */
3305 if (info->executable)
3307 s = bfd_get_section_by_name (dynobj, ".interp");
3308 BFD_ASSERT (s != NULL);
3309 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3310 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3313 else
3315 /* We may have created entries in the .rela.got section.
3316 However, if we are not creating the dynamic sections, we will
3317 not actually use these entries. Reset the size of .rela.got,
3318 which will cause it to get stripped from the output file
3319 below. */
3320 s = bfd_get_section_by_name (dynobj, ".rela.got");
3321 if (s != NULL)
3322 s->size = 0;
3325 /* If this is a -Bsymbolic shared link, then we need to discard all
3326 PC relative relocs against symbols defined in a regular object.
3327 For the normal shared case we discard the PC relative relocs
3328 against symbols that have become local due to visibility changes.
3329 We allocated space for them in the check_relocs routine, but we
3330 will not fill them in in the relocate_section routine. */
3331 if (info->shared)
3332 elf_link_hash_traverse (elf_hash_table (info),
3333 elf_m68k_discard_copies,
3334 (PTR) info);
3336 /* The check_relocs and adjust_dynamic_symbol entry points have
3337 determined the sizes of the various dynamic sections. Allocate
3338 memory for them. */
3339 plt = FALSE;
3340 relocs = FALSE;
3341 for (s = dynobj->sections; s != NULL; s = s->next)
3343 const char *name;
3345 if ((s->flags & SEC_LINKER_CREATED) == 0)
3346 continue;
3348 /* It's OK to base decisions on the section name, because none
3349 of the dynobj section names depend upon the input files. */
3350 name = bfd_get_section_name (dynobj, s);
3352 if (strcmp (name, ".plt") == 0)
3354 /* Remember whether there is a PLT. */
3355 plt = s->size != 0;
3357 else if (CONST_STRNEQ (name, ".rela"))
3359 if (s->size != 0)
3361 relocs = TRUE;
3363 /* We use the reloc_count field as a counter if we need
3364 to copy relocs into the output file. */
3365 s->reloc_count = 0;
3368 else if (! CONST_STRNEQ (name, ".got")
3369 && strcmp (name, ".dynbss") != 0)
3371 /* It's not one of our sections, so don't allocate space. */
3372 continue;
3375 if (s->size == 0)
3377 /* If we don't need this section, strip it from the
3378 output file. This is mostly to handle .rela.bss and
3379 .rela.plt. We must create both sections in
3380 create_dynamic_sections, because they must be created
3381 before the linker maps input sections to output
3382 sections. The linker does that before
3383 adjust_dynamic_symbol is called, and it is that
3384 function which decides whether anything needs to go
3385 into these sections. */
3386 s->flags |= SEC_EXCLUDE;
3387 continue;
3390 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3391 continue;
3393 /* Allocate memory for the section contents. */
3394 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
3395 Unused entries should be reclaimed before the section's contents
3396 are written out, but at the moment this does not happen. Thus in
3397 order to prevent writing out garbage, we initialise the section's
3398 contents to zero. */
3399 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3400 if (s->contents == NULL)
3401 return FALSE;
3404 if (elf_hash_table (info)->dynamic_sections_created)
3406 /* Add some entries to the .dynamic section. We fill in the
3407 values later, in elf_m68k_finish_dynamic_sections, but we
3408 must add the entries now so that we get the correct size for
3409 the .dynamic section. The DT_DEBUG entry is filled in by the
3410 dynamic linker and used by the debugger. */
3411 #define add_dynamic_entry(TAG, VAL) \
3412 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3414 if (!info->shared)
3416 if (!add_dynamic_entry (DT_DEBUG, 0))
3417 return FALSE;
3420 if (plt)
3422 if (!add_dynamic_entry (DT_PLTGOT, 0)
3423 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3424 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3425 || !add_dynamic_entry (DT_JMPREL, 0))
3426 return FALSE;
3429 if (relocs)
3431 if (!add_dynamic_entry (DT_RELA, 0)
3432 || !add_dynamic_entry (DT_RELASZ, 0)
3433 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3434 return FALSE;
3437 if ((info->flags & DF_TEXTREL) != 0)
3439 if (!add_dynamic_entry (DT_TEXTREL, 0))
3440 return FALSE;
3443 #undef add_dynamic_entry
3445 return TRUE;
3448 /* This function is called via elf_link_hash_traverse if we are
3449 creating a shared object. In the -Bsymbolic case it discards the
3450 space allocated to copy PC relative relocs against symbols which
3451 are defined in regular objects. For the normal shared case, it
3452 discards space for pc-relative relocs that have become local due to
3453 symbol visibility changes. We allocated space for them in the
3454 check_relocs routine, but we won't fill them in in the
3455 relocate_section routine.
3457 We also check whether any of the remaining relocations apply
3458 against a readonly section, and set the DF_TEXTREL flag in this
3459 case. */
3461 static bfd_boolean
3462 elf_m68k_discard_copies (h, inf)
3463 struct elf_link_hash_entry *h;
3464 PTR inf;
3466 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3467 struct elf_m68k_pcrel_relocs_copied *s;
3469 if (h->root.type == bfd_link_hash_warning)
3470 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3472 if (!SYMBOL_CALLS_LOCAL (info, h))
3474 if ((info->flags & DF_TEXTREL) == 0)
3476 /* Look for relocations against read-only sections. */
3477 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3478 s != NULL;
3479 s = s->next)
3480 if ((s->section->flags & SEC_READONLY) != 0)
3482 info->flags |= DF_TEXTREL;
3483 break;
3487 return TRUE;
3490 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
3491 s != NULL;
3492 s = s->next)
3493 s->section->size -= s->count * sizeof (Elf32_External_Rela);
3495 return TRUE;
3499 /* Install relocation RELA. */
3501 static void
3502 elf_m68k_install_rela (bfd *output_bfd,
3503 asection *srela,
3504 Elf_Internal_Rela *rela)
3506 bfd_byte *loc;
3508 loc = srela->contents;
3509 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3510 bfd_elf32_swap_reloca_out (output_bfd, rela, loc);
3513 /* Find the base offsets for thread-local storage in this object,
3514 for GD/LD and IE/LE respectively. */
3516 #define DTP_OFFSET 0x8000
3517 #define TP_OFFSET 0x7000
3519 static bfd_vma
3520 dtpoff_base (struct bfd_link_info *info)
3522 /* If tls_sec is NULL, we should have signalled an error already. */
3523 if (elf_hash_table (info)->tls_sec == NULL)
3524 return 0;
3525 return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
3528 static bfd_vma
3529 tpoff_base (struct bfd_link_info *info)
3531 /* If tls_sec is NULL, we should have signalled an error already. */
3532 if (elf_hash_table (info)->tls_sec == NULL)
3533 return 0;
3534 return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
3537 /* Output necessary relocation to handle a symbol during static link.
3538 This function is called from elf_m68k_relocate_section. */
3540 static void
3541 elf_m68k_init_got_entry_static (struct bfd_link_info *info,
3542 bfd *output_bfd,
3543 enum elf_m68k_reloc_type r_type,
3544 asection *sgot,
3545 bfd_vma got_entry_offset,
3546 bfd_vma relocation)
3548 switch (elf_m68k_reloc_got_type (r_type))
3550 case R_68K_GOT32O:
3551 bfd_put_32 (output_bfd, relocation, sgot->contents + got_entry_offset);
3552 break;
3554 case R_68K_TLS_GD32:
3555 /* We know the offset within the module,
3556 put it into the second GOT slot. */
3557 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3558 sgot->contents + got_entry_offset + 4);
3559 /* FALLTHRU */
3561 case R_68K_TLS_LDM32:
3562 /* Mark it as belonging to module 1, the executable. */
3563 bfd_put_32 (output_bfd, 1, sgot->contents + got_entry_offset);
3564 break;
3566 case R_68K_TLS_IE32:
3567 bfd_put_32 (output_bfd, relocation - tpoff_base (info),
3568 sgot->contents + got_entry_offset);
3569 break;
3571 default:
3572 BFD_ASSERT (FALSE);
3576 /* Output necessary relocation to handle a local symbol
3577 during dynamic link.
3578 This function is called either from elf_m68k_relocate_section
3579 or from elf_m68k_finish_dynamic_symbol. */
3581 static void
3582 elf_m68k_init_got_entry_local_shared (struct bfd_link_info *info,
3583 bfd *output_bfd,
3584 enum elf_m68k_reloc_type r_type,
3585 asection *sgot,
3586 bfd_vma got_entry_offset,
3587 bfd_vma relocation,
3588 asection *srela)
3590 Elf_Internal_Rela outrel;
3592 switch (elf_m68k_reloc_got_type (r_type))
3594 case R_68K_GOT32O:
3595 /* Emit RELATIVE relocation to initialize GOT slot
3596 at run-time. */
3597 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
3598 outrel.r_addend = relocation;
3599 break;
3601 case R_68K_TLS_GD32:
3602 /* We know the offset within the module,
3603 put it into the second GOT slot. */
3604 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3605 sgot->contents + got_entry_offset + 4);
3606 /* FALLTHRU */
3608 case R_68K_TLS_LDM32:
3609 /* We don't know the module number,
3610 create a relocation for it. */
3611 outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_DTPMOD32);
3612 outrel.r_addend = 0;
3613 break;
3615 case R_68K_TLS_IE32:
3616 /* Emit TPREL relocation to initialize GOT slot
3617 at run-time. */
3618 outrel.r_info = ELF32_R_INFO (0, R_68K_TLS_TPREL32);
3619 outrel.r_addend = relocation - elf_hash_table (info)->tls_sec->vma;
3620 break;
3622 default:
3623 BFD_ASSERT (FALSE);
3626 /* Offset of the GOT entry. */
3627 outrel.r_offset = (sgot->output_section->vma
3628 + sgot->output_offset
3629 + got_entry_offset);
3631 /* Install one of the above relocations. */
3632 elf_m68k_install_rela (output_bfd, srela, &outrel);
3634 bfd_put_32 (output_bfd, outrel.r_addend, sgot->contents + got_entry_offset);
3637 /* Relocate an M68K ELF section. */
3639 static bfd_boolean
3640 elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section,
3641 contents, relocs, local_syms, local_sections)
3642 bfd *output_bfd;
3643 struct bfd_link_info *info;
3644 bfd *input_bfd;
3645 asection *input_section;
3646 bfd_byte *contents;
3647 Elf_Internal_Rela *relocs;
3648 Elf_Internal_Sym *local_syms;
3649 asection **local_sections;
3651 bfd *dynobj;
3652 Elf_Internal_Shdr *symtab_hdr;
3653 struct elf_link_hash_entry **sym_hashes;
3654 asection *sgot;
3655 asection *splt;
3656 asection *sreloc;
3657 asection *srela;
3658 struct elf_m68k_got *got;
3659 Elf_Internal_Rela *rel;
3660 Elf_Internal_Rela *relend;
3662 dynobj = elf_hash_table (info)->dynobj;
3663 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3664 sym_hashes = elf_sym_hashes (input_bfd);
3666 sgot = NULL;
3667 splt = NULL;
3668 sreloc = NULL;
3669 srela = NULL;
3671 got = NULL;
3673 rel = relocs;
3674 relend = relocs + input_section->reloc_count;
3675 for (; rel < relend; rel++)
3677 int r_type;
3678 reloc_howto_type *howto;
3679 unsigned long r_symndx;
3680 struct elf_link_hash_entry *h;
3681 Elf_Internal_Sym *sym;
3682 asection *sec;
3683 bfd_vma relocation;
3684 bfd_boolean unresolved_reloc;
3685 bfd_reloc_status_type r;
3687 r_type = ELF32_R_TYPE (rel->r_info);
3688 if (r_type < 0 || r_type >= (int) R_68K_max)
3690 bfd_set_error (bfd_error_bad_value);
3691 return FALSE;
3693 howto = howto_table + r_type;
3695 r_symndx = ELF32_R_SYM (rel->r_info);
3697 h = NULL;
3698 sym = NULL;
3699 sec = NULL;
3700 unresolved_reloc = FALSE;
3702 if (r_symndx < symtab_hdr->sh_info)
3704 sym = local_syms + r_symndx;
3705 sec = local_sections[r_symndx];
3706 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3708 else
3710 bfd_boolean warned;
3712 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3713 r_symndx, symtab_hdr, sym_hashes,
3714 h, sec, relocation,
3715 unresolved_reloc, warned);
3718 if (sec != NULL && elf_discarded_section (sec))
3720 /* For relocs against symbols from removed linkonce sections,
3721 or sections discarded by a linker script, we just want the
3722 section contents zeroed. Avoid any special processing. */
3723 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
3724 rel->r_info = 0;
3725 rel->r_addend = 0;
3726 continue;
3729 if (info->relocatable)
3730 continue;
3732 switch (r_type)
3734 case R_68K_GOT8:
3735 case R_68K_GOT16:
3736 case R_68K_GOT32:
3737 /* Relocation is to the address of the entry for this symbol
3738 in the global offset table. */
3739 if (h != NULL
3740 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3742 if (elf_m68k_hash_table (info)->local_gp_p)
3744 bfd_vma sgot_output_offset;
3745 bfd_vma got_offset;
3747 if (sgot == NULL)
3749 sgot = bfd_get_section_by_name (dynobj, ".got");
3751 if (sgot != NULL)
3752 sgot_output_offset = sgot->output_offset;
3753 else
3754 /* In this case we have a reference to
3755 _GLOBAL_OFFSET_TABLE_, but the GOT itself is
3756 empty.
3757 ??? Issue a warning? */
3758 sgot_output_offset = 0;
3760 else
3761 sgot_output_offset = sgot->output_offset;
3763 if (got == NULL)
3765 struct elf_m68k_bfd2got_entry *bfd2got_entry;
3767 bfd2got_entry
3768 = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3769 input_bfd, SEARCH, NULL);
3771 if (bfd2got_entry != NULL)
3773 got = bfd2got_entry->got;
3774 BFD_ASSERT (got != NULL);
3776 got_offset = got->offset;
3778 else
3779 /* In this case we have a reference to
3780 _GLOBAL_OFFSET_TABLE_, but no other references
3781 accessing any GOT entries.
3782 ??? Issue a warning? */
3783 got_offset = 0;
3785 else
3786 got_offset = got->offset;
3788 /* Adjust GOT pointer to point to the GOT
3789 assigned to input_bfd. */
3790 rel->r_addend += sgot_output_offset + got_offset;
3792 else
3793 BFD_ASSERT (got == NULL || got->offset == 0);
3795 break;
3797 /* Fall through. */
3798 case R_68K_GOT8O:
3799 case R_68K_GOT16O:
3800 case R_68K_GOT32O:
3802 case R_68K_TLS_LDM32:
3803 case R_68K_TLS_LDM16:
3804 case R_68K_TLS_LDM8:
3806 case R_68K_TLS_GD8:
3807 case R_68K_TLS_GD16:
3808 case R_68K_TLS_GD32:
3810 case R_68K_TLS_IE8:
3811 case R_68K_TLS_IE16:
3812 case R_68K_TLS_IE32:
3814 /* Relocation is the offset of the entry for this symbol in
3815 the global offset table. */
3818 struct elf_m68k_got_entry_key key_;
3819 bfd_vma *off_ptr;
3820 bfd_vma off;
3822 if (sgot == NULL)
3824 sgot = bfd_get_section_by_name (dynobj, ".got");
3825 BFD_ASSERT (sgot != NULL);
3828 if (got == NULL)
3830 got = elf_m68k_get_bfd2got_entry (elf_m68k_multi_got (info),
3831 input_bfd, MUST_FIND,
3832 NULL)->got;
3833 BFD_ASSERT (got != NULL);
3836 /* Get GOT offset for this symbol. */
3837 elf_m68k_init_got_entry_key (&key_, h, input_bfd, r_symndx,
3838 r_type);
3839 off_ptr = &elf_m68k_get_got_entry (got, &key_, MUST_FIND,
3840 NULL)->u.s2.offset;
3841 off = *off_ptr;
3843 /* The offset must always be a multiple of 4. We use
3844 the least significant bit to record whether we have
3845 already generated the necessary reloc. */
3846 if ((off & 1) != 0)
3847 off &= ~1;
3848 else
3850 if (h != NULL
3851 /* @TLSLDM relocations are bounded to the module, in
3852 which the symbol is defined -- not to the symbol
3853 itself. */
3854 && elf_m68k_reloc_got_type (r_type) != R_68K_TLS_LDM32)
3856 bfd_boolean dyn;
3858 dyn = elf_hash_table (info)->dynamic_sections_created;
3859 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3860 || (info->shared
3861 && SYMBOL_REFERENCES_LOCAL (info, h))
3862 || (ELF_ST_VISIBILITY (h->other)
3863 && h->root.type == bfd_link_hash_undefweak))
3865 /* This is actually a static link, or it is a
3866 -Bsymbolic link and the symbol is defined
3867 locally, or the symbol was forced to be local
3868 because of a version file. We must initialize
3869 this entry in the global offset table. Since
3870 the offset must always be a multiple of 4, we
3871 use the least significant bit to record whether
3872 we have initialized it already.
3874 When doing a dynamic link, we create a .rela.got
3875 relocation entry to initialize the value. This
3876 is done in the finish_dynamic_symbol routine. */
3878 elf_m68k_init_got_entry_static (info,
3879 output_bfd,
3880 r_type,
3881 sgot,
3882 off,
3883 relocation);
3885 *off_ptr |= 1;
3887 else
3888 unresolved_reloc = FALSE;
3890 else if (info->shared) /* && h == NULL */
3891 /* Process local symbol during dynamic link. */
3893 if (srela == NULL)
3895 srela = bfd_get_section_by_name (dynobj, ".rela.got");
3896 BFD_ASSERT (srela != NULL);
3899 elf_m68k_init_got_entry_local_shared (info,
3900 output_bfd,
3901 r_type,
3902 sgot,
3903 off,
3904 relocation,
3905 srela);
3907 *off_ptr |= 1;
3909 else /* h == NULL && !info->shared */
3911 elf_m68k_init_got_entry_static (info,
3912 output_bfd,
3913 r_type,
3914 sgot,
3915 off,
3916 relocation);
3918 *off_ptr |= 1;
3922 /* We don't use elf_m68k_reloc_got_type in the condition below
3923 because this is the only place where difference between
3924 R_68K_GOTx and R_68K_GOTxO relocations matters. */
3925 if (r_type == R_68K_GOT32O
3926 || r_type == R_68K_GOT16O
3927 || r_type == R_68K_GOT8O
3928 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_GD32
3929 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_LDM32
3930 || elf_m68k_reloc_got_type (r_type) == R_68K_TLS_IE32)
3932 /* GOT pointer is adjusted to point to the start/middle
3933 of local GOT. Adjust the offset accordingly. */
3934 BFD_ASSERT (elf_m68k_hash_table (info)->use_neg_got_offsets_p
3935 || off >= got->offset);
3937 if (elf_m68k_hash_table (info)->local_gp_p)
3938 relocation = off - got->offset;
3939 else
3941 BFD_ASSERT (got->offset == 0);
3942 relocation = sgot->output_offset + off;
3945 /* This relocation does not use the addend. */
3946 rel->r_addend = 0;
3948 else
3949 relocation = (sgot->output_section->vma + sgot->output_offset
3950 + off);
3952 break;
3954 case R_68K_TLS_LDO32:
3955 case R_68K_TLS_LDO16:
3956 case R_68K_TLS_LDO8:
3957 relocation -= dtpoff_base (info);
3958 break;
3960 case R_68K_TLS_LE32:
3961 case R_68K_TLS_LE16:
3962 case R_68K_TLS_LE8:
3963 if (info->shared)
3965 (*_bfd_error_handler)
3966 (_("%B(%A+0x%lx): R_68K_TLS_LE32 relocation not permitted "
3967 "in shared object"),
3968 input_bfd, input_section, (long) rel->r_offset, howto->name);
3970 return FALSE;
3972 else
3973 relocation -= tpoff_base (info);
3975 break;
3977 case R_68K_PLT8:
3978 case R_68K_PLT16:
3979 case R_68K_PLT32:
3980 /* Relocation is to the entry for this symbol in the
3981 procedure linkage table. */
3983 /* Resolve a PLTxx reloc against a local symbol directly,
3984 without using the procedure linkage table. */
3985 if (h == NULL)
3986 break;
3988 if (h->plt.offset == (bfd_vma) -1
3989 || !elf_hash_table (info)->dynamic_sections_created)
3991 /* We didn't make a PLT entry for this symbol. This
3992 happens when statically linking PIC code, or when
3993 using -Bsymbolic. */
3994 break;
3997 if (splt == NULL)
3999 splt = bfd_get_section_by_name (dynobj, ".plt");
4000 BFD_ASSERT (splt != NULL);
4003 relocation = (splt->output_section->vma
4004 + splt->output_offset
4005 + h->plt.offset);
4006 unresolved_reloc = FALSE;
4007 break;
4009 case R_68K_PLT8O:
4010 case R_68K_PLT16O:
4011 case R_68K_PLT32O:
4012 /* Relocation is the offset of the entry for this symbol in
4013 the procedure linkage table. */
4014 BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
4016 if (splt == NULL)
4018 splt = bfd_get_section_by_name (dynobj, ".plt");
4019 BFD_ASSERT (splt != NULL);
4022 relocation = h->plt.offset;
4023 unresolved_reloc = FALSE;
4025 /* This relocation does not use the addend. */
4026 rel->r_addend = 0;
4028 break;
4030 case R_68K_8:
4031 case R_68K_16:
4032 case R_68K_32:
4033 case R_68K_PC8:
4034 case R_68K_PC16:
4035 case R_68K_PC32:
4036 if (info->shared
4037 && r_symndx != 0
4038 && (input_section->flags & SEC_ALLOC) != 0
4039 && (h == NULL
4040 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4041 || h->root.type != bfd_link_hash_undefweak)
4042 && ((r_type != R_68K_PC8
4043 && r_type != R_68K_PC16
4044 && r_type != R_68K_PC32)
4045 || !SYMBOL_CALLS_LOCAL (info, h)))
4047 Elf_Internal_Rela outrel;
4048 bfd_byte *loc;
4049 bfd_boolean skip, relocate;
4051 /* When generating a shared object, these relocations
4052 are copied into the output file to be resolved at run
4053 time. */
4055 skip = FALSE;
4056 relocate = FALSE;
4058 outrel.r_offset =
4059 _bfd_elf_section_offset (output_bfd, info, input_section,
4060 rel->r_offset);
4061 if (outrel.r_offset == (bfd_vma) -1)
4062 skip = TRUE;
4063 else if (outrel.r_offset == (bfd_vma) -2)
4064 skip = TRUE, relocate = TRUE;
4065 outrel.r_offset += (input_section->output_section->vma
4066 + input_section->output_offset);
4068 if (skip)
4069 memset (&outrel, 0, sizeof outrel);
4070 else if (h != NULL
4071 && h->dynindx != -1
4072 && (r_type == R_68K_PC8
4073 || r_type == R_68K_PC16
4074 || r_type == R_68K_PC32
4075 || !info->shared
4076 || !info->symbolic
4077 || !h->def_regular))
4079 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4080 outrel.r_addend = rel->r_addend;
4082 else
4084 /* This symbol is local, or marked to become local. */
4085 outrel.r_addend = relocation + rel->r_addend;
4087 if (r_type == R_68K_32)
4089 relocate = TRUE;
4090 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
4092 else
4094 long indx;
4096 if (bfd_is_abs_section (sec))
4097 indx = 0;
4098 else if (sec == NULL || sec->owner == NULL)
4100 bfd_set_error (bfd_error_bad_value);
4101 return FALSE;
4103 else
4105 asection *osec;
4107 /* We are turning this relocation into one
4108 against a section symbol. It would be
4109 proper to subtract the symbol's value,
4110 osec->vma, from the emitted reloc addend,
4111 but ld.so expects buggy relocs. */
4112 osec = sec->output_section;
4113 indx = elf_section_data (osec)->dynindx;
4114 if (indx == 0)
4116 struct elf_link_hash_table *htab;
4117 htab = elf_hash_table (info);
4118 osec = htab->text_index_section;
4119 indx = elf_section_data (osec)->dynindx;
4121 BFD_ASSERT (indx != 0);
4124 outrel.r_info = ELF32_R_INFO (indx, r_type);
4128 sreloc = elf_section_data (input_section)->sreloc;
4129 if (sreloc == NULL)
4130 abort ();
4132 loc = sreloc->contents;
4133 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4134 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4136 /* This reloc will be computed at runtime, so there's no
4137 need to do anything now, except for R_68K_32
4138 relocations that have been turned into
4139 R_68K_RELATIVE. */
4140 if (!relocate)
4141 continue;
4144 break;
4146 case R_68K_GNU_VTINHERIT:
4147 case R_68K_GNU_VTENTRY:
4148 /* These are no-ops in the end. */
4149 continue;
4151 default:
4152 break;
4155 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4156 because such sections are not SEC_ALLOC and thus ld.so will
4157 not process them. */
4158 if (unresolved_reloc
4159 && !((input_section->flags & SEC_DEBUGGING) != 0
4160 && h->def_dynamic))
4162 (*_bfd_error_handler)
4163 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4164 input_bfd,
4165 input_section,
4166 (long) rel->r_offset,
4167 howto->name,
4168 h->root.root.string);
4169 return FALSE;
4172 if (r_symndx != 0
4173 && r_type != R_68K_NONE
4174 && (h == NULL
4175 || h->root.type == bfd_link_hash_defined
4176 || h->root.type == bfd_link_hash_defweak))
4178 char sym_type;
4180 sym_type = (sym != NULL) ? ELF32_ST_TYPE (sym->st_info) : h->type;
4182 if (elf_m68k_reloc_tls_p (r_type) != (sym_type == STT_TLS))
4184 const char *name;
4186 if (h != NULL)
4187 name = h->root.root.string;
4188 else
4190 name = (bfd_elf_string_from_elf_section
4191 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4192 if (name == NULL || *name == '\0')
4193 name = bfd_section_name (input_bfd, sec);
4196 (*_bfd_error_handler)
4197 ((sym_type == STT_TLS
4198 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
4199 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
4200 input_bfd,
4201 input_section,
4202 (long) rel->r_offset,
4203 howto->name,
4204 name);
4208 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4209 contents, rel->r_offset,
4210 relocation, rel->r_addend);
4212 if (r != bfd_reloc_ok)
4214 const char *name;
4216 if (h != NULL)
4217 name = h->root.root.string;
4218 else
4220 name = bfd_elf_string_from_elf_section (input_bfd,
4221 symtab_hdr->sh_link,
4222 sym->st_name);
4223 if (name == NULL)
4224 return FALSE;
4225 if (*name == '\0')
4226 name = bfd_section_name (input_bfd, sec);
4229 if (r == bfd_reloc_overflow)
4231 if (!(info->callbacks->reloc_overflow
4232 (info, (h ? &h->root : NULL), name, howto->name,
4233 (bfd_vma) 0, input_bfd, input_section,
4234 rel->r_offset)))
4235 return FALSE;
4237 else
4239 (*_bfd_error_handler)
4240 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4241 input_bfd, input_section,
4242 (long) rel->r_offset, name, (int) r);
4243 return FALSE;
4248 return TRUE;
4251 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
4252 into section SEC. */
4254 static void
4255 elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value)
4257 /* Make VALUE PC-relative. */
4258 value -= sec->output_section->vma + offset;
4260 /* Apply any in-place addend. */
4261 value += bfd_get_32 (sec->owner, sec->contents + offset);
4263 bfd_put_32 (sec->owner, value, sec->contents + offset);
4266 /* Finish up dynamic symbol handling. We set the contents of various
4267 dynamic sections here. */
4269 static bfd_boolean
4270 elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym)
4271 bfd *output_bfd;
4272 struct bfd_link_info *info;
4273 struct elf_link_hash_entry *h;
4274 Elf_Internal_Sym *sym;
4276 bfd *dynobj;
4278 dynobj = elf_hash_table (info)->dynobj;
4280 if (h->plt.offset != (bfd_vma) -1)
4282 const struct elf_m68k_plt_info *plt_info;
4283 asection *splt;
4284 asection *sgot;
4285 asection *srela;
4286 bfd_vma plt_index;
4287 bfd_vma got_offset;
4288 Elf_Internal_Rela rela;
4289 bfd_byte *loc;
4291 /* This symbol has an entry in the procedure linkage table. Set
4292 it up. */
4294 BFD_ASSERT (h->dynindx != -1);
4296 plt_info = elf_m68k_hash_table (info)->plt_info;
4297 splt = bfd_get_section_by_name (dynobj, ".plt");
4298 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4299 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
4300 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
4302 /* Get the index in the procedure linkage table which
4303 corresponds to this symbol. This is the index of this symbol
4304 in all the symbols for which we are making plt entries. The
4305 first entry in the procedure linkage table is reserved. */
4306 plt_index = (h->plt.offset / plt_info->size) - 1;
4308 /* Get the offset into the .got table of the entry that
4309 corresponds to this function. Each .got entry is 4 bytes.
4310 The first three are reserved. */
4311 got_offset = (plt_index + 3) * 4;
4313 memcpy (splt->contents + h->plt.offset,
4314 plt_info->symbol_entry,
4315 plt_info->size);
4317 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got,
4318 (sgot->output_section->vma
4319 + sgot->output_offset
4320 + got_offset));
4322 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4323 splt->contents
4324 + h->plt.offset
4325 + plt_info->symbol_resolve_entry + 2);
4327 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt,
4328 splt->output_section->vma);
4330 /* Fill in the entry in the global offset table. */
4331 bfd_put_32 (output_bfd,
4332 (splt->output_section->vma
4333 + splt->output_offset
4334 + h->plt.offset
4335 + plt_info->symbol_resolve_entry),
4336 sgot->contents + got_offset);
4338 /* Fill in the entry in the .rela.plt section. */
4339 rela.r_offset = (sgot->output_section->vma
4340 + sgot->output_offset
4341 + got_offset);
4342 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
4343 rela.r_addend = 0;
4344 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
4345 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4347 if (!h->def_regular)
4349 /* Mark the symbol as undefined, rather than as defined in
4350 the .plt section. Leave the value alone. */
4351 sym->st_shndx = SHN_UNDEF;
4355 if (elf_m68k_hash_entry (h)->glist != NULL)
4357 asection *sgot;
4358 asection *srela;
4359 struct elf_m68k_got_entry *got_entry;
4361 /* This symbol has an entry in the global offset table. Set it
4362 up. */
4364 sgot = bfd_get_section_by_name (dynobj, ".got");
4365 srela = bfd_get_section_by_name (dynobj, ".rela.got");
4366 BFD_ASSERT (sgot != NULL && srela != NULL);
4368 got_entry = elf_m68k_hash_entry (h)->glist;
4370 while (got_entry != NULL)
4372 enum elf_m68k_reloc_type r_type;
4373 bfd_vma got_entry_offset;
4375 r_type = got_entry->key_.type;
4376 got_entry_offset = got_entry->u.s2.offset &~ (bfd_vma) 1;
4378 /* If this is a -Bsymbolic link, and the symbol is defined
4379 locally, we just want to emit a RELATIVE reloc. Likewise if
4380 the symbol was forced to be local because of a version file.
4381 The entry in the global offset table already have been
4382 initialized in the relocate_section function. */
4383 if (info->shared
4384 && SYMBOL_REFERENCES_LOCAL (info, h))
4386 bfd_vma relocation;
4388 relocation = bfd_get_signed_32 (output_bfd,
4389 (sgot->contents
4390 + got_entry_offset));
4392 /* Undo TP bias. */
4393 switch (elf_m68k_reloc_got_type (r_type))
4395 case R_68K_GOT32O:
4396 case R_68K_TLS_LDM32:
4397 break;
4399 case R_68K_TLS_GD32:
4400 relocation += dtpoff_base (info);
4401 break;
4403 case R_68K_TLS_IE32:
4404 relocation += tpoff_base (info);
4405 break;
4407 default:
4408 BFD_ASSERT (FALSE);
4411 elf_m68k_init_got_entry_local_shared (info,
4412 output_bfd,
4413 r_type,
4414 sgot,
4415 got_entry_offset,
4416 relocation,
4417 srela);
4419 else
4421 Elf_Internal_Rela rela;
4423 /* Put zeros to GOT slots that will be initialized
4424 at run-time. */
4426 bfd_vma n_slots;
4428 n_slots = elf_m68k_reloc_got_n_slots (got_entry->key_.type);
4429 while (n_slots--)
4430 bfd_put_32 (output_bfd, (bfd_vma) 0,
4431 (sgot->contents + got_entry_offset
4432 + 4 * n_slots));
4435 rela.r_addend = 0;
4436 rela.r_offset = (sgot->output_section->vma
4437 + sgot->output_offset
4438 + got_entry_offset);
4440 switch (elf_m68k_reloc_got_type (r_type))
4442 case R_68K_GOT32O:
4443 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
4444 elf_m68k_install_rela (output_bfd, srela, &rela);
4445 break;
4447 case R_68K_TLS_GD32:
4448 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_DTPMOD32);
4449 elf_m68k_install_rela (output_bfd, srela, &rela);
4451 rela.r_offset += 4;
4452 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_DTPREL32);
4453 elf_m68k_install_rela (output_bfd, srela, &rela);
4454 break;
4456 case R_68K_TLS_IE32:
4457 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_TLS_TPREL32);
4458 elf_m68k_install_rela (output_bfd, srela, &rela);
4459 break;
4461 default:
4462 BFD_ASSERT (FALSE);
4463 break;
4467 got_entry = got_entry->u.s2.next;
4471 if (h->needs_copy)
4473 asection *s;
4474 Elf_Internal_Rela rela;
4475 bfd_byte *loc;
4477 /* This symbol needs a copy reloc. Set it up. */
4479 BFD_ASSERT (h->dynindx != -1
4480 && (h->root.type == bfd_link_hash_defined
4481 || h->root.type == bfd_link_hash_defweak));
4483 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4484 ".rela.bss");
4485 BFD_ASSERT (s != NULL);
4487 rela.r_offset = (h->root.u.def.value
4488 + h->root.u.def.section->output_section->vma
4489 + h->root.u.def.section->output_offset);
4490 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
4491 rela.r_addend = 0;
4492 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
4493 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4496 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4497 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4498 || h == elf_hash_table (info)->hgot)
4499 sym->st_shndx = SHN_ABS;
4501 return TRUE;
4504 /* Finish up the dynamic sections. */
4506 static bfd_boolean
4507 elf_m68k_finish_dynamic_sections (output_bfd, info)
4508 bfd *output_bfd;
4509 struct bfd_link_info *info;
4511 bfd *dynobj;
4512 asection *sgot;
4513 asection *sdyn;
4515 dynobj = elf_hash_table (info)->dynobj;
4517 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4518 BFD_ASSERT (sgot != NULL);
4519 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4521 if (elf_hash_table (info)->dynamic_sections_created)
4523 asection *splt;
4524 Elf32_External_Dyn *dyncon, *dynconend;
4526 splt = bfd_get_section_by_name (dynobj, ".plt");
4527 BFD_ASSERT (splt != NULL && sdyn != NULL);
4529 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4530 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4531 for (; dyncon < dynconend; dyncon++)
4533 Elf_Internal_Dyn dyn;
4534 const char *name;
4535 asection *s;
4537 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4539 switch (dyn.d_tag)
4541 default:
4542 break;
4544 case DT_PLTGOT:
4545 name = ".got";
4546 goto get_vma;
4547 case DT_JMPREL:
4548 name = ".rela.plt";
4549 get_vma:
4550 s = bfd_get_section_by_name (output_bfd, name);
4551 BFD_ASSERT (s != NULL);
4552 dyn.d_un.d_ptr = s->vma;
4553 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4554 break;
4556 case DT_PLTRELSZ:
4557 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4558 BFD_ASSERT (s != NULL);
4559 dyn.d_un.d_val = s->size;
4560 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4561 break;
4563 case DT_RELASZ:
4564 /* The procedure linkage table relocs (DT_JMPREL) should
4565 not be included in the overall relocs (DT_RELA).
4566 Therefore, we override the DT_RELASZ entry here to
4567 make it not include the JMPREL relocs. Since the
4568 linker script arranges for .rela.plt to follow all
4569 other relocation sections, we don't have to worry
4570 about changing the DT_RELA entry. */
4571 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4572 if (s != NULL)
4573 dyn.d_un.d_val -= s->size;
4574 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4575 break;
4579 /* Fill in the first entry in the procedure linkage table. */
4580 if (splt->size > 0)
4582 const struct elf_m68k_plt_info *plt_info;
4584 plt_info = elf_m68k_hash_table (info)->plt_info;
4585 memcpy (splt->contents, plt_info->plt0_entry, plt_info->size);
4587 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4,
4588 (sgot->output_section->vma
4589 + sgot->output_offset
4590 + 4));
4592 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8,
4593 (sgot->output_section->vma
4594 + sgot->output_offset
4595 + 8));
4597 elf_section_data (splt->output_section)->this_hdr.sh_entsize
4598 = plt_info->size;
4602 /* Fill in the first three entries in the global offset table. */
4603 if (sgot->size > 0)
4605 if (sdyn == NULL)
4606 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4607 else
4608 bfd_put_32 (output_bfd,
4609 sdyn->output_section->vma + sdyn->output_offset,
4610 sgot->contents);
4611 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4612 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4615 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4617 return TRUE;
4620 /* Given a .data section and a .emreloc in-memory section, store
4621 relocation information into the .emreloc section which can be
4622 used at runtime to relocate the section. This is called by the
4623 linker when the --embedded-relocs switch is used. This is called
4624 after the add_symbols entry point has been called for all the
4625 objects, and before the final_link entry point is called. */
4627 bfd_boolean
4628 bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
4629 bfd *abfd;
4630 struct bfd_link_info *info;
4631 asection *datasec;
4632 asection *relsec;
4633 char **errmsg;
4635 Elf_Internal_Shdr *symtab_hdr;
4636 Elf_Internal_Sym *isymbuf = NULL;
4637 Elf_Internal_Rela *internal_relocs = NULL;
4638 Elf_Internal_Rela *irel, *irelend;
4639 bfd_byte *p;
4640 bfd_size_type amt;
4642 BFD_ASSERT (! info->relocatable);
4644 *errmsg = NULL;
4646 if (datasec->reloc_count == 0)
4647 return TRUE;
4649 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4651 /* Get a copy of the native relocations. */
4652 internal_relocs = (_bfd_elf_link_read_relocs
4653 (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
4654 info->keep_memory));
4655 if (internal_relocs == NULL)
4656 goto error_return;
4658 amt = (bfd_size_type) datasec->reloc_count * 12;
4659 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
4660 if (relsec->contents == NULL)
4661 goto error_return;
4663 p = relsec->contents;
4665 irelend = internal_relocs + datasec->reloc_count;
4666 for (irel = internal_relocs; irel < irelend; irel++, p += 12)
4668 asection *targetsec;
4670 /* We are going to write a four byte longword into the runtime
4671 reloc section. The longword will be the address in the data
4672 section which must be relocated. It is followed by the name
4673 of the target section NUL-padded or truncated to 8
4674 characters. */
4676 /* We can only relocate absolute longword relocs at run time. */
4677 if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
4679 *errmsg = _("unsupported reloc type");
4680 bfd_set_error (bfd_error_bad_value);
4681 goto error_return;
4684 /* Get the target section referred to by the reloc. */
4685 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
4687 /* A local symbol. */
4688 Elf_Internal_Sym *isym;
4690 /* Read this BFD's local symbols if we haven't done so already. */
4691 if (isymbuf == NULL)
4693 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4694 if (isymbuf == NULL)
4695 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
4696 symtab_hdr->sh_info, 0,
4697 NULL, NULL, NULL);
4698 if (isymbuf == NULL)
4699 goto error_return;
4702 isym = isymbuf + ELF32_R_SYM (irel->r_info);
4703 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
4705 else
4707 unsigned long indx;
4708 struct elf_link_hash_entry *h;
4710 /* An external symbol. */
4711 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
4712 h = elf_sym_hashes (abfd)[indx];
4713 BFD_ASSERT (h != NULL);
4714 if (h->root.type == bfd_link_hash_defined
4715 || h->root.type == bfd_link_hash_defweak)
4716 targetsec = h->root.u.def.section;
4717 else
4718 targetsec = NULL;
4721 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
4722 memset (p + 4, 0, 8);
4723 if (targetsec != NULL)
4724 strncpy ((char *) p + 4, targetsec->output_section->name, 8);
4727 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4728 free (isymbuf);
4729 if (internal_relocs != NULL
4730 && elf_section_data (datasec)->relocs != internal_relocs)
4731 free (internal_relocs);
4732 return TRUE;
4734 error_return:
4735 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4736 free (isymbuf);
4737 if (internal_relocs != NULL
4738 && elf_section_data (datasec)->relocs != internal_relocs)
4739 free (internal_relocs);
4740 return FALSE;
4743 /* Set target options. */
4745 void
4746 bfd_elf_m68k_set_target_options (struct bfd_link_info *info, int got_handling)
4748 struct elf_m68k_link_hash_table *htab;
4749 bfd_boolean use_neg_got_offsets_p;
4750 bfd_boolean allow_multigot_p;
4751 bfd_boolean local_gp_p;
4753 switch (got_handling)
4755 case 0:
4756 /* --got=single. */
4757 local_gp_p = FALSE;
4758 use_neg_got_offsets_p = FALSE;
4759 allow_multigot_p = FALSE;
4760 break;
4762 case 1:
4763 /* --got=negative. */
4764 local_gp_p = TRUE;
4765 use_neg_got_offsets_p = TRUE;
4766 allow_multigot_p = FALSE;
4767 break;
4769 case 2:
4770 /* --got=multigot. */
4771 local_gp_p = TRUE;
4772 use_neg_got_offsets_p = TRUE;
4773 allow_multigot_p = TRUE;
4774 break;
4776 default:
4777 BFD_ASSERT (FALSE);
4778 return;
4781 htab = elf_m68k_hash_table (info);
4782 if (htab != NULL)
4784 htab->local_gp_p = local_gp_p;
4785 htab->use_neg_got_offsets_p = use_neg_got_offsets_p;
4786 htab->allow_multigot_p = allow_multigot_p;
4790 static enum elf_reloc_type_class
4791 elf32_m68k_reloc_type_class (rela)
4792 const Elf_Internal_Rela *rela;
4794 switch ((int) ELF32_R_TYPE (rela->r_info))
4796 case R_68K_RELATIVE:
4797 return reloc_class_relative;
4798 case R_68K_JMP_SLOT:
4799 return reloc_class_plt;
4800 case R_68K_COPY:
4801 return reloc_class_copy;
4802 default:
4803 return reloc_class_normal;
4807 /* Return address for Ith PLT stub in section PLT, for relocation REL
4808 or (bfd_vma) -1 if it should not be included. */
4810 static bfd_vma
4811 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
4812 const arelent *rel ATTRIBUTE_UNUSED)
4814 return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
4817 #define TARGET_BIG_SYM bfd_elf32_m68k_vec
4818 #define TARGET_BIG_NAME "elf32-m68k"
4819 #define ELF_MACHINE_CODE EM_68K
4820 #define ELF_MAXPAGESIZE 0x2000
4821 #define elf_backend_create_dynamic_sections \
4822 _bfd_elf_create_dynamic_sections
4823 #define bfd_elf32_bfd_link_hash_table_create \
4824 elf_m68k_link_hash_table_create
4825 /* ??? Should it be this macro or bfd_elfNN_bfd_link_hash_table_create? */
4826 #define bfd_elf32_bfd_link_hash_table_free \
4827 elf_m68k_link_hash_table_free
4828 #define bfd_elf32_bfd_final_link bfd_elf_final_link
4830 #define elf_backend_check_relocs elf_m68k_check_relocs
4831 #define elf_backend_always_size_sections \
4832 elf_m68k_always_size_sections
4833 #define elf_backend_adjust_dynamic_symbol \
4834 elf_m68k_adjust_dynamic_symbol
4835 #define elf_backend_size_dynamic_sections \
4836 elf_m68k_size_dynamic_sections
4837 #define elf_backend_final_write_processing elf_m68k_final_write_processing
4838 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4839 #define elf_backend_relocate_section elf_m68k_relocate_section
4840 #define elf_backend_finish_dynamic_symbol \
4841 elf_m68k_finish_dynamic_symbol
4842 #define elf_backend_finish_dynamic_sections \
4843 elf_m68k_finish_dynamic_sections
4844 #define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook
4845 #define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook
4846 #define elf_backend_copy_indirect_symbol elf_m68k_copy_indirect_symbol
4847 #define bfd_elf32_bfd_merge_private_bfd_data \
4848 elf32_m68k_merge_private_bfd_data
4849 #define bfd_elf32_bfd_set_private_flags \
4850 elf32_m68k_set_private_flags
4851 #define bfd_elf32_bfd_print_private_bfd_data \
4852 elf32_m68k_print_private_bfd_data
4853 #define elf_backend_reloc_type_class elf32_m68k_reloc_type_class
4854 #define elf_backend_plt_sym_val elf_m68k_plt_sym_val
4855 #define elf_backend_object_p elf32_m68k_object_p
4857 #define elf_backend_can_gc_sections 1
4858 #define elf_backend_can_refcount 1
4859 #define elf_backend_want_got_plt 1
4860 #define elf_backend_plt_readonly 1
4861 #define elf_backend_want_plt_sym 0
4862 #define elf_backend_got_header_size 12
4863 #define elf_backend_rela_normal 1
4865 #include "elf32-target.h"