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