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