projects / binutils-gdb.git / blob
? search:


50b962dad3fc213528d036910869d2deeb6c8b98
[binutils-gdb.git] / bfd / elf32-m68k.c
1 /* Motorola 68k series support for 32-bit ELF
2 Copyright 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "bfdlink.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/m68k.h"
27 #include "opcode/m68k.h"
28
29 static reloc_howto_type *reloc_type_lookup
30 PARAMS ((bfd *, bfd_reloc_code_real_type));
31 static void rtype_to_howto
32 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
33 static struct bfd_hash_entry *elf_m68k_link_hash_newfunc
34 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
35 static struct bfd_link_hash_table *elf_m68k_link_hash_table_create
36 PARAMS ((bfd *));
37 static bfd_boolean elf_m68k_check_relocs
38 PARAMS ((bfd *, struct bfd_link_info *, asection *,
39 const Elf_Internal_Rela *));
40 static bfd_boolean elf_m68k_adjust_dynamic_symbol
41 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
42 static bfd_boolean elf_m68k_size_dynamic_sections
43 PARAMS ((bfd *, struct bfd_link_info *));
44 static bfd_boolean elf_m68k_discard_copies
45 PARAMS ((struct elf_link_hash_entry *, PTR));
46 static bfd_boolean elf_m68k_relocate_section
47 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
48 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
49 static bfd_boolean elf_m68k_finish_dynamic_symbol
50 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
51 Elf_Internal_Sym *));
52 static bfd_boolean elf_m68k_finish_dynamic_sections
53 PARAMS ((bfd *, struct bfd_link_info *));
54
55 static bfd_boolean elf32_m68k_set_private_flags
56 PARAMS ((bfd *, flagword));
57 static bfd_boolean elf32_m68k_merge_private_bfd_data
58 PARAMS ((bfd *, bfd *));
59 static bfd_boolean elf32_m68k_print_private_bfd_data
60 PARAMS ((bfd *, PTR));
61 static enum elf_reloc_type_class elf32_m68k_reloc_type_class
62 PARAMS ((const Elf_Internal_Rela *));
63
64 static reloc_howto_type howto_table[] = {
65 HOWTO(R_68K_NONE, 0, 0, 0, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_NONE", FALSE, 0, 0x00000000,FALSE),
66 HOWTO(R_68K_32, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_32", FALSE, 0, 0xffffffff,FALSE),
67 HOWTO(R_68K_16, 0, 1,16, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_16", FALSE, 0, 0x0000ffff,FALSE),
68 HOWTO(R_68K_8, 0, 0, 8, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_8", FALSE, 0, 0x000000ff,FALSE),
69 HOWTO(R_68K_PC32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PC32", FALSE, 0, 0xffffffff,TRUE),
70 HOWTO(R_68K_PC16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PC16", FALSE, 0, 0x0000ffff,TRUE),
71 HOWTO(R_68K_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PC8", FALSE, 0, 0x000000ff,TRUE),
72 HOWTO(R_68K_GOT32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32", FALSE, 0, 0xffffffff,TRUE),
73 HOWTO(R_68K_GOT16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT16", FALSE, 0, 0x0000ffff,TRUE),
74 HOWTO(R_68K_GOT8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT8", FALSE, 0, 0x000000ff,TRUE),
75 HOWTO(R_68K_GOT32O, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_GOT32O", FALSE, 0, 0xffffffff,FALSE),
76 HOWTO(R_68K_GOT16O, 0, 1,16, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT16O", FALSE, 0, 0x0000ffff,FALSE),
77 HOWTO(R_68K_GOT8O, 0, 0, 8, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_GOT8O", FALSE, 0, 0x000000ff,FALSE),
78 HOWTO(R_68K_PLT32, 0, 2,32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32", FALSE, 0, 0xffffffff,TRUE),
79 HOWTO(R_68K_PLT16, 0, 1,16, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT16", FALSE, 0, 0x0000ffff,TRUE),
80 HOWTO(R_68K_PLT8, 0, 0, 8, TRUE, 0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT8", FALSE, 0, 0x000000ff,TRUE),
81 HOWTO(R_68K_PLT32O, 0, 2,32, FALSE,0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_68K_PLT32O", FALSE, 0, 0xffffffff,FALSE),
82 HOWTO(R_68K_PLT16O, 0, 1,16, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT16O", FALSE, 0, 0x0000ffff,FALSE),
83 HOWTO(R_68K_PLT8O, 0, 0, 8, FALSE,0, complain_overflow_signed, bfd_elf_generic_reloc, "R_68K_PLT8O", FALSE, 0, 0x000000ff,FALSE),
84 HOWTO(R_68K_COPY, 0, 0, 0, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_COPY", FALSE, 0, 0xffffffff,FALSE),
85 HOWTO(R_68K_GLOB_DAT, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_GLOB_DAT", FALSE, 0, 0xffffffff,FALSE),
86 HOWTO(R_68K_JMP_SLOT, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_JMP_SLOT", FALSE, 0, 0xffffffff,FALSE),
87 HOWTO(R_68K_RELATIVE, 0, 2,32, FALSE,0, complain_overflow_dont, bfd_elf_generic_reloc, "R_68K_RELATIVE", FALSE, 0, 0xffffffff,FALSE),
88 /* GNU extension to record C++ vtable hierarchy. */
89 HOWTO (R_68K_GNU_VTINHERIT, /* type */
90 0, /* rightshift */
91 2, /* size (0 = byte, 1 = short, 2 = long) */
92 0, /* bitsize */
93 FALSE, /* pc_relative */
94 0, /* bitpos */
95 complain_overflow_dont, /* complain_on_overflow */
96 NULL, /* special_function */
97 "R_68K_GNU_VTINHERIT", /* name */
98 FALSE, /* partial_inplace */
99 0, /* src_mask */
100 0, /* dst_mask */
101 FALSE),
102 /* GNU extension to record C++ vtable member usage. */
103 HOWTO (R_68K_GNU_VTENTRY, /* type */
104 0, /* rightshift */
105 2, /* size (0 = byte, 1 = short, 2 = long) */
106 0, /* bitsize */
107 FALSE, /* pc_relative */
108 0, /* bitpos */
109 complain_overflow_dont, /* complain_on_overflow */
110 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
111 "R_68K_GNU_VTENTRY", /* name */
112 FALSE, /* partial_inplace */
113 0, /* src_mask */
114 0, /* dst_mask */
115 FALSE),
116 };
117
118 static void
119 rtype_to_howto (abfd, cache_ptr, dst)
120 bfd *abfd ATTRIBUTE_UNUSED;
121 arelent *cache_ptr;
122 Elf_Internal_Rela *dst;
123 {
124 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_68K_max);
125 cache_ptr->howto = &howto_table[ELF32_R_TYPE(dst->r_info)];
126 }
127
128 #define elf_info_to_howto rtype_to_howto
129
130 static const struct
131 {
132 bfd_reloc_code_real_type bfd_val;
133 int elf_val;
134 } reloc_map[] = {
135 { BFD_RELOC_NONE, R_68K_NONE },
136 { BFD_RELOC_32, R_68K_32 },
137 { BFD_RELOC_16, R_68K_16 },
138 { BFD_RELOC_8, R_68K_8 },
139 { BFD_RELOC_32_PCREL, R_68K_PC32 },
140 { BFD_RELOC_16_PCREL, R_68K_PC16 },
141 { BFD_RELOC_8_PCREL, R_68K_PC8 },
142 { BFD_RELOC_32_GOT_PCREL, R_68K_GOT32 },
143 { BFD_RELOC_16_GOT_PCREL, R_68K_GOT16 },
144 { BFD_RELOC_8_GOT_PCREL, R_68K_GOT8 },
145 { BFD_RELOC_32_GOTOFF, R_68K_GOT32O },
146 { BFD_RELOC_16_GOTOFF, R_68K_GOT16O },
147 { BFD_RELOC_8_GOTOFF, R_68K_GOT8O },
148 { BFD_RELOC_32_PLT_PCREL, R_68K_PLT32 },
149 { BFD_RELOC_16_PLT_PCREL, R_68K_PLT16 },
150 { BFD_RELOC_8_PLT_PCREL, R_68K_PLT8 },
151 { BFD_RELOC_32_PLTOFF, R_68K_PLT32O },
152 { BFD_RELOC_16_PLTOFF, R_68K_PLT16O },
153 { BFD_RELOC_8_PLTOFF, R_68K_PLT8O },
154 { BFD_RELOC_NONE, R_68K_COPY },
155 { BFD_RELOC_68K_GLOB_DAT, R_68K_GLOB_DAT },
156 { BFD_RELOC_68K_JMP_SLOT, R_68K_JMP_SLOT },
157 { BFD_RELOC_68K_RELATIVE, R_68K_RELATIVE },
158 { BFD_RELOC_CTOR, R_68K_32 },
159 { BFD_RELOC_VTABLE_INHERIT, R_68K_GNU_VTINHERIT },
160 { BFD_RELOC_VTABLE_ENTRY, R_68K_GNU_VTENTRY },
161 };
162
163 static reloc_howto_type *
164 reloc_type_lookup (abfd, code)
165 bfd *abfd ATTRIBUTE_UNUSED;
166 bfd_reloc_code_real_type code;
167 {
168 unsigned int i;
169 for (i = 0; i < sizeof (reloc_map) / sizeof (reloc_map[0]); i++)
170 {
171 if (reloc_map[i].bfd_val == code)
172 return &howto_table[reloc_map[i].elf_val];
173 }
174 return 0;
175 }
176
177 #define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup
178 #define ELF_ARCH bfd_arch_m68k
179 \f
180 /* Functions for the m68k ELF linker. */
181
182 /* The name of the dynamic interpreter. This is put in the .interp
183 section. */
184
185 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
186
187 /* Describes one of the various PLT styles. */
188
189 struct elf_m68k_plt_info
190 {
191 /* The size of each PLT entry. */
192 bfd_vma size;
193
194 /* The template for the first PLT entry. */
195 const bfd_byte *plt0_entry;
196
197 /* Offsets of fields in PLT0_ENTRY that require R_68K_PC32 relocations.
198 The comments by each member indicate the value that the relocation
199 is against. */
200 struct {
201 unsigned int got4; /* .got + 4 */
202 unsigned int got8; /* .got + 8 */
203 } plt0_relocs;
204
205 /* The template for a symbol's PLT entry. */
206 const bfd_byte *symbol_entry;
207
208 /* Offsets of fields in SYMBOL_ENTRY that require R_68K_PC32 relocations.
209 The comments by each member indicate the value that the relocation
210 is against. */
211 struct {
212 unsigned int got; /* the symbol's .got.plt entry */
213 unsigned int plt; /* .plt */
214 } symbol_relocs;
215
216 /* The offset of the resolver stub from the start of SYMBOL_ENTRY.
217 The stub starts with "move.l #relocoffset,%d0". */
218 bfd_vma symbol_resolve_entry;
219 };
220
221 /* The size in bytes of an entry in the procedure linkage table. */
222
223 #define PLT_ENTRY_SIZE 20
224
225 /* The first entry in a procedure linkage table looks like this. See
226 the SVR4 ABI m68k supplement to see how this works. */
227
228 static const bfd_byte elf_m68k_plt0_entry[PLT_ENTRY_SIZE] =
229 {
230 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
231 0, 0, 0, 2, /* + (.got + 4) - . */
232 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,addr]) */
233 0, 0, 0, 2, /* + (.got + 8) - . */
234 0, 0, 0, 0 /* pad out to 20 bytes. */
235 };
236
237 /* Subsequent entries in a procedure linkage table look like this. */
238
239 static const bfd_byte elf_m68k_plt_entry[PLT_ENTRY_SIZE] =
240 {
241 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,symbol@GOTPC]) */
242 0, 0, 0, 2, /* + (.got.plt entry) - . */
243 0x2f, 0x3c, /* move.l #offset,-(%sp) */
244 0, 0, 0, 0, /* + reloc index */
245 0x60, 0xff, /* bra.l .plt */
246 0, 0, 0, 0 /* + .plt - . */
247 };
248
249 static const struct elf_m68k_plt_info elf_m68k_plt_info = {
250 PLT_ENTRY_SIZE,
251 elf_m68k_plt0_entry, { 4, 12 },
252 elf_m68k_plt_entry, { 4, 16 }, 8
253 };
254
255 #define ISAB_PLT_ENTRY_SIZE 24
256
257 static const bfd_byte elf_isab_plt0_entry[ISAB_PLT_ENTRY_SIZE] =
258 {
259 0x20, 0x3c, /* move.l #offset,%d0 */
260 0, 0, 0, 0, /* + (.got + 4) - . */
261 0x2f, 0x3b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l),-(%sp) */
262 0x20, 0x3c, /* move.l #offset,%d0 */
263 0, 0, 0, 0, /* + (.got + 8) - . */
264 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
265 0x4e, 0xd0, /* jmp (%a0) */
266 0x4e, 0x71 /* nop */
267 };
268
269 /* Subsequent entries in a procedure linkage table look like this. */
270
271 static const bfd_byte elf_isab_plt_entry[ISAB_PLT_ENTRY_SIZE] =
272 {
273 0x20, 0x3c, /* move.l #offset,%d0 */
274 0, 0, 0, 0, /* + (.got.plt entry) - . */
275 0x20, 0x7b, 0x08, 0xfa, /* move.l (-6,%pc,%d0:l), %a0 */
276 0x4e, 0xd0, /* jmp (%a0) */
277 0x2f, 0x3c, /* move.l #offset,-(%sp) */
278 0, 0, 0, 0, /* + reloc index */
279 0x60, 0xff, /* bra.l .plt */
280 0, 0, 0, 0 /* + .plt - . */
281 };
282
283 static const struct elf_m68k_plt_info elf_isab_plt_info = {
284 ISAB_PLT_ENTRY_SIZE,
285 elf_isab_plt0_entry, { 2, 12 },
286 elf_isab_plt_entry, { 2, 20 }, 12
287 };
288
289 #define CPU32_PLT_ENTRY_SIZE 24
290 /* Procedure linkage table entries for the cpu32 */
291 static const bfd_byte elf_cpu32_plt0_entry[CPU32_PLT_ENTRY_SIZE] =
292 {
293 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
294 0, 0, 0, 2, /* + (.got + 4) - . */
295 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
296 0, 0, 0, 2, /* + (.got + 8) - . */
297 0x4e, 0xd1, /* jmp %a1@ */
298 0, 0, 0, 0, /* pad out to 24 bytes. */
299 0, 0
300 };
301
302 static const bfd_byte elf_cpu32_plt_entry[CPU32_PLT_ENTRY_SIZE] =
303 {
304 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
305 0, 0, 0, 2, /* + (.got.plt entry) - . */
306 0x4e, 0xd1, /* jmp %a1@ */
307 0x2f, 0x3c, /* move.l #offset,-(%sp) */
308 0, 0, 0, 0, /* + reloc index */
309 0x60, 0xff, /* bra.l .plt */
310 0, 0, 0, 0, /* + .plt - . */
311 0, 0
312 };
313
314 static const struct elf_m68k_plt_info elf_cpu32_plt_info = {
315 CPU32_PLT_ENTRY_SIZE,
316 elf_cpu32_plt0_entry, { 4, 12 },
317 elf_cpu32_plt_entry, { 4, 18 }, 10
318 };
319
320 /* The m68k linker needs to keep track of the number of relocs that it
321 decides to copy in check_relocs for each symbol. This is so that it
322 can discard PC relative relocs if it doesn't need them when linking
323 with -Bsymbolic. We store the information in a field extending the
324 regular ELF linker hash table. */
325
326 /* This structure keeps track of the number of PC relative relocs we have
327 copied for a given symbol. */
328
329 struct elf_m68k_pcrel_relocs_copied
330 {
331 /* Next section. */
332 struct elf_m68k_pcrel_relocs_copied *next;
333 /* A section in dynobj. */
334 asection *section;
335 /* Number of relocs copied in this section. */
336 bfd_size_type count;
337 };
338
339 /* m68k ELF linker hash entry. */
340
341 struct elf_m68k_link_hash_entry
342 {
343 struct elf_link_hash_entry root;
344
345 /* Number of PC relative relocs copied for this symbol. */
346 struct elf_m68k_pcrel_relocs_copied *pcrel_relocs_copied;
347 };
348
349 #define elf_m68k_hash_entry(ent) ((struct elf_m68k_link_hash_entry *) (ent))
350
351 /* m68k ELF linker hash table. */
352
353 struct elf_m68k_link_hash_table
354 {
355 struct elf_link_hash_table root;
356
357 /* Small local sym to section mapping cache. */
358 struct sym_sec_cache sym_sec;
359
360 /* The PLT format used by this link, or NULL if the format has not
361 yet been chosen. */
362 const struct elf_m68k_plt_info *plt_info;
363 };
364
365 /* Get the m68k ELF linker hash table from a link_info structure. */
366
367 #define elf_m68k_hash_table(p) \
368 ((struct elf_m68k_link_hash_table *) (p)->hash)
369
370 /* Create an entry in an m68k ELF linker hash table. */
371
372 static struct bfd_hash_entry *
373 elf_m68k_link_hash_newfunc (entry, table, string)
374 struct bfd_hash_entry *entry;
375 struct bfd_hash_table *table;
376 const char *string;
377 {
378 struct bfd_hash_entry *ret = entry;
379
380 /* Allocate the structure if it has not already been allocated by a
381 subclass. */
382 if (ret == NULL)
383 ret = bfd_hash_allocate (table,
384 sizeof (struct elf_m68k_link_hash_entry));
385 if (ret == NULL)
386 return ret;
387
388 /* Call the allocation method of the superclass. */
389 ret = _bfd_elf_link_hash_newfunc (ret, table, string);
390 if (ret != NULL)
391 elf_m68k_hash_entry (ret)->pcrel_relocs_copied = NULL;
392
393 return ret;
394 }
395
396 /* Create an m68k ELF linker hash table. */
397
398 static struct bfd_link_hash_table *
399 elf_m68k_link_hash_table_create (abfd)
400 bfd *abfd;
401 {
402 struct elf_m68k_link_hash_table *ret;
403 bfd_size_type amt = sizeof (struct elf_m68k_link_hash_table);
404
405 ret = (struct elf_m68k_link_hash_table *) bfd_malloc (amt);
406 if (ret == (struct elf_m68k_link_hash_table *) NULL)
407 return NULL;
408
409 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
410 elf_m68k_link_hash_newfunc,
411 sizeof (struct elf_m68k_link_hash_entry)))
412 {
413 free (ret);
414 return NULL;
415 }
416
417 ret->sym_sec.abfd = NULL;
418 ret->plt_info = NULL;
419
420 return &ret->root.root;
421 }
422
423 /* Set the right machine number. */
424
425 static bfd_boolean
426 elf32_m68k_object_p (bfd *abfd)
427 {
428 unsigned int mach = 0;
429 unsigned features = 0;
430 flagword eflags = elf_elfheader (abfd)->e_flags;
431
432 if (eflags & EF_M68K_M68000)
433 features |= m68000;
434 else if (eflags & EF_M68K_CPU32)
435 features |= cpu32;
436 else if (eflags & EF_M68K_ISA_MASK)
437 {
438 switch (eflags & EF_M68K_ISA_MASK)
439 {
440 case EF_M68K_ISA_A_NODIV:
441 features |= mcfisa_a;
442 break;
443 case EF_M68K_ISA_A:
444 features |= mcfisa_a|mcfhwdiv;
445 break;
446 case EF_M68K_ISA_A_PLUS:
447 features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp;
448 break;
449 case EF_M68K_ISA_B_NOUSP:
450 features |= mcfisa_a|mcfisa_b|mcfhwdiv;
451 break;
452 case EF_M68K_ISA_B:
453 features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp;
454 break;
455 }
456 switch (eflags & EF_M68K_MAC_MASK)
457 {
458 case EF_M68K_MAC:
459 features |= mcfmac;
460 break;
461 case EF_M68K_EMAC:
462 features |= mcfemac;
463 break;
464 }
465 if (eflags & EF_M68K_FLOAT)
466 features |= cfloat;
467 }
468
469 mach = bfd_m68k_features_to_mach (features);
470 bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach);
471
472 return TRUE;
473 }
474
475 /* Keep m68k-specific flags in the ELF header. */
476 static bfd_boolean
477 elf32_m68k_set_private_flags (abfd, flags)
478 bfd *abfd;
479 flagword flags;
480 {
481 elf_elfheader (abfd)->e_flags = flags;
482 elf_flags_init (abfd) = TRUE;
483 return TRUE;
484 }
485
486 /* Merge backend specific data from an object file to the output
487 object file when linking. */
488 static bfd_boolean
489 elf32_m68k_merge_private_bfd_data (ibfd, obfd)
490 bfd *ibfd;
491 bfd *obfd;
492 {
493 flagword out_flags;
494 flagword in_flags;
495 flagword out_isa;
496 flagword in_isa;
497 const bfd_arch_info_type *arch_info;
498
499 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
500 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
501 return FALSE;
502
503 /* Get the merged machine. This checks for incompatibility between
504 Coldfire & non-Coldfire flags, incompability between different
505 Coldfire ISAs, and incompability between different MAC types. */
506 arch_info = bfd_arch_get_compatible (ibfd, obfd, FALSE);
507 if (!arch_info)
508 return FALSE;
509
510 bfd_set_arch_mach (obfd, bfd_arch_m68k, arch_info->mach);
511
512 in_flags = elf_elfheader (ibfd)->e_flags;
513 if (!elf_flags_init (obfd))
514 {
515 elf_flags_init (obfd) = TRUE;
516 out_flags = in_flags;
517 }
518 else
519 {
520 out_flags = elf_elfheader (obfd)->e_flags;
521 in_isa = (in_flags & EF_M68K_ISA_MASK);
522 out_isa = (out_flags & EF_M68K_ISA_MASK);
523 if (in_isa > out_isa)
524 out_flags ^= in_isa ^ out_isa;
525 out_flags |= in_flags ^ in_isa;
526 }
527 elf_elfheader (obfd)->e_flags = out_flags;
528
529 return TRUE;
530 }
531
532 /* Display the flags field. */
533 static bfd_boolean
534 elf32_m68k_print_private_bfd_data (abfd, ptr)
535 bfd *abfd;
536 PTR ptr;
537 {
538 FILE *file = (FILE *) ptr;
539 flagword eflags = elf_elfheader (abfd)->e_flags;
540
541 BFD_ASSERT (abfd != NULL && ptr != NULL);
542
543 /* Print normal ELF private data. */
544 _bfd_elf_print_private_bfd_data (abfd, ptr);
545
546 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
547
548 /* xgettext:c-format */
549 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
550
551 if (eflags & EF_M68K_CPU32)
552 fprintf (file, " [cpu32]");
553
554 if (eflags & EF_M68K_M68000)
555 fprintf (file, " [m68000]");
556
557 if (eflags & EF_M68K_CFV4E)
558 fprintf (file, " [cfv4e]");
559
560 if (eflags & EF_M68K_ISA_MASK)
561 {
562 char const *isa = _("unknown");
563 char const *mac = _("unknown");
564 char const *additional = "";
565
566 switch (eflags & EF_M68K_ISA_MASK)
567 {
568 case EF_M68K_ISA_A_NODIV:
569 isa = "A";
570 additional = " [nodiv]";
571 break;
572 case EF_M68K_ISA_A:
573 isa = "A";
574 break;
575 case EF_M68K_ISA_A_PLUS:
576 isa = "A+";
577 break;
578 case EF_M68K_ISA_B_NOUSP:
579 isa = "B";
580 additional = " [nousp]";
581 break;
582 case EF_M68K_ISA_B:
583 isa = "B";
584 break;
585 }
586 fprintf (file, " [isa %s]%s", isa, additional);
587 if (eflags & EF_M68K_FLOAT)
588 fprintf (file, " [float]");
589 switch (eflags & EF_M68K_MAC_MASK)
590 {
591 case 0:
592 mac = NULL;
593 break;
594 case EF_M68K_MAC:
595 mac = "mac";
596 break;
597 case EF_M68K_EMAC:
598 mac = "emac";
599 break;
600 }
601 if (mac)
602 fprintf (file, " [%s]", mac);
603 }
604
605 fputc ('\n', file);
606
607 return TRUE;
608 }
609 /* Look through the relocs for a section during the first phase, and
610 allocate space in the global offset table or procedure linkage
611 table. */
612
613 static bfd_boolean
614 elf_m68k_check_relocs (abfd, info, sec, relocs)
615 bfd *abfd;
616 struct bfd_link_info *info;
617 asection *sec;
618 const Elf_Internal_Rela *relocs;
619 {
620 bfd *dynobj;
621 Elf_Internal_Shdr *symtab_hdr;
622 struct elf_link_hash_entry **sym_hashes;
623 bfd_signed_vma *local_got_refcounts;
624 const Elf_Internal_Rela *rel;
625 const Elf_Internal_Rela *rel_end;
626 asection *sgot;
627 asection *srelgot;
628 asection *sreloc;
629
630 if (info->relocatable)
631 return TRUE;
632
633 dynobj = elf_hash_table (info)->dynobj;
634 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
635 sym_hashes = elf_sym_hashes (abfd);
636 local_got_refcounts = elf_local_got_refcounts (abfd);
637
638 sgot = NULL;
639 srelgot = NULL;
640 sreloc = NULL;
641
642 rel_end = relocs + sec->reloc_count;
643 for (rel = relocs; rel < rel_end; rel++)
644 {
645 unsigned long r_symndx;
646 struct elf_link_hash_entry *h;
647
648 r_symndx = ELF32_R_SYM (rel->r_info);
649
650 if (r_symndx < symtab_hdr->sh_info)
651 h = NULL;
652 else
653 {
654 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
655 while (h->root.type == bfd_link_hash_indirect
656 || h->root.type == bfd_link_hash_warning)
657 h = (struct elf_link_hash_entry *) h->root.u.i.link;
658 }
659
660 switch (ELF32_R_TYPE (rel->r_info))
661 {
662 case R_68K_GOT8:
663 case R_68K_GOT16:
664 case R_68K_GOT32:
665 if (h != NULL
666 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
667 break;
668 /* Fall through. */
669 case R_68K_GOT8O:
670 case R_68K_GOT16O:
671 case R_68K_GOT32O:
672 /* This symbol requires a global offset table entry. */
673
674 if (dynobj == NULL)
675 {
676 /* Create the .got section. */
677 elf_hash_table (info)->dynobj = dynobj = abfd;
678 if (!_bfd_elf_create_got_section (dynobj, info))
679 return FALSE;
680 }
681
682 if (sgot == NULL)
683 {
684 sgot = bfd_get_section_by_name (dynobj, ".got");
685 BFD_ASSERT (sgot != NULL);
686 }
687
688 if (srelgot == NULL
689 && (h != NULL || info->shared))
690 {
691 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
692 if (srelgot == NULL)
693 {
694 srelgot = bfd_make_section_with_flags (dynobj,
695 ".rela.got",
696 (SEC_ALLOC
697 | SEC_LOAD
698 | SEC_HAS_CONTENTS
699 | SEC_IN_MEMORY
700 | SEC_LINKER_CREATED
701 | SEC_READONLY));
702 if (srelgot == NULL
703 || !bfd_set_section_alignment (dynobj, srelgot, 2))
704 return FALSE;
705 }
706 }
707
708 if (h != NULL)
709 {
710 if (h->got.refcount == 0)
711 {
712 /* Make sure this symbol is output as a dynamic symbol. */
713 if (h->dynindx == -1
714 && !h->forced_local)
715 {
716 if (!bfd_elf_link_record_dynamic_symbol (info, h))
717 return FALSE;
718 }
719
720 /* Allocate space in the .got section. */
721 sgot->size += 4;
722 /* Allocate relocation space. */
723 srelgot->size += sizeof (Elf32_External_Rela);
724 }
725 h->got.refcount++;
726 }
727 else
728 {
729 /* This is a global offset table entry for a local symbol. */
730 if (local_got_refcounts == NULL)
731 {
732 bfd_size_type size;
733
734 size = symtab_hdr->sh_info;
735 size *= sizeof (bfd_signed_vma);
736 local_got_refcounts = ((bfd_signed_vma *)
737 bfd_zalloc (abfd, size));
738 if (local_got_refcounts == NULL)
739 return FALSE;
740 elf_local_got_refcounts (abfd) = local_got_refcounts;
741 }
742 if (local_got_refcounts[r_symndx] == 0)
743 {
744 sgot->size += 4;
745 if (info->shared)
746 {
747 /* If we are generating a shared object, we need to
748 output a R_68K_RELATIVE reloc so that the dynamic
749 linker can adjust this GOT entry. */
750 srelgot->size += sizeof (Elf32_External_Rela);
751 }
752 }
753 local_got_refcounts[r_symndx]++;
754 }
755 break;
756
757 case R_68K_PLT8:
758 case R_68K_PLT16:
759 case R_68K_PLT32:
760 /* This symbol requires a procedure linkage table entry. We
761 actually build the entry in adjust_dynamic_symbol,
762 because this might be a case of linking PIC code which is
763 never referenced by a dynamic object, in which case we
764 don't need to generate a procedure linkage table entry
765 after all. */
766
767 /* If this is a local symbol, we resolve it directly without
768 creating a procedure linkage table entry. */
769 if (h == NULL)
770 continue;
771
772 h->needs_plt = 1;
773 h->plt.refcount++;
774 break;
775
776 case R_68K_PLT8O:
777 case R_68K_PLT16O:
778 case R_68K_PLT32O:
779 /* This symbol requires a procedure linkage table entry. */
780
781 if (h == NULL)
782 {
783 /* It does not make sense to have this relocation for a
784 local symbol. FIXME: does it? How to handle it if
785 it does make sense? */
786 bfd_set_error (bfd_error_bad_value);
787 return FALSE;
788 }
789
790 /* Make sure this symbol is output as a dynamic symbol. */
791 if (h->dynindx == -1
792 && !h->forced_local)
793 {
794 if (!bfd_elf_link_record_dynamic_symbol (info, h))
795 return FALSE;
796 }
797
798 h->needs_plt = 1;
799 h->plt.refcount++;
800 break;
801
802 case R_68K_PC8:
803 case R_68K_PC16:
804 case R_68K_PC32:
805 /* If we are creating a shared library and this is not a local
806 symbol, we need to copy the reloc into the shared library.
807 However when linking with -Bsymbolic and this is a global
808 symbol which is defined in an object we are including in the
809 link (i.e., DEF_REGULAR is set), then we can resolve the
810 reloc directly. At this point we have not seen all the input
811 files, so it is possible that DEF_REGULAR is not set now but
812 will be set later (it is never cleared). We account for that
813 possibility below by storing information in the
814 pcrel_relocs_copied field of the hash table entry. */
815 if (!(info->shared
816 && (sec->flags & SEC_ALLOC) != 0
817 && h != NULL
818 && (!info->symbolic
819 || h->root.type == bfd_link_hash_defweak
820 || !h->def_regular)))
821 {
822 if (h != NULL)
823 {
824 /* Make sure a plt entry is created for this symbol if
825 it turns out to be a function defined by a dynamic
826 object. */
827 h->plt.refcount++;
828 }
829 break;
830 }
831 /* Fall through. */
832 case R_68K_8:
833 case R_68K_16:
834 case R_68K_32:
835 if (h != NULL)
836 {
837 /* Make sure a plt entry is created for this symbol if it
838 turns out to be a function defined by a dynamic object. */
839 h->plt.refcount++;
840 }
841
842 /* If we are creating a shared library, we need to copy the
843 reloc into the shared library. */
844 if (info->shared
845 && (sec->flags & SEC_ALLOC) != 0)
846 {
847 /* When creating a shared object, we must copy these
848 reloc types into the output file. We create a reloc
849 section in dynobj and make room for this reloc. */
850 if (sreloc == NULL)
851 {
852 const char *name;
853
854 name = (bfd_elf_string_from_elf_section
855 (abfd,
856 elf_elfheader (abfd)->e_shstrndx,
857 elf_section_data (sec)->rel_hdr.sh_name));
858 if (name == NULL)
859 return FALSE;
860
861 BFD_ASSERT (CONST_STRNEQ (name, ".rela")
862 && strcmp (bfd_get_section_name (abfd, sec),
863 name + 5) == 0);
864
865 sreloc = bfd_get_section_by_name (dynobj, name);
866 if (sreloc == NULL)
867 {
868 sreloc = bfd_make_section_with_flags (dynobj,
869 name,
870 (SEC_ALLOC
871 | SEC_LOAD
872 | SEC_HAS_CONTENTS
873 | SEC_IN_MEMORY
874 | SEC_LINKER_CREATED
875 | SEC_READONLY));
876 if (sreloc == NULL
877 || !bfd_set_section_alignment (dynobj, sreloc, 2))
878 return FALSE;
879 }
880 elf_section_data (sec)->sreloc = sreloc;
881 }
882
883 if (sec->flags & SEC_READONLY
884 /* Don't set DF_TEXTREL yet for PC relative
885 relocations, they might be discarded later. */
886 && !(ELF32_R_TYPE (rel->r_info) == R_68K_PC8
887 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
888 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32))
889 info->flags |= DF_TEXTREL;
890
891 sreloc->size += sizeof (Elf32_External_Rela);
892
893 /* We count the number of PC relative relocations we have
894 entered for this symbol, so that we can discard them
895 again if, in the -Bsymbolic case, the symbol is later
896 defined by a regular object, or, in the normal shared
897 case, the symbol is forced to be local. Note that this
898 function is only called if we are using an m68kelf linker
899 hash table, which means that h is really a pointer to an
900 elf_m68k_link_hash_entry. */
901 if (ELF32_R_TYPE (rel->r_info) == R_68K_PC8
902 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
903 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)
904 {
905 struct elf_m68k_pcrel_relocs_copied *p;
906 struct elf_m68k_pcrel_relocs_copied **head;
907
908 if (h != NULL)
909 {
910 struct elf_m68k_link_hash_entry *eh
911 = elf_m68k_hash_entry (h);
912 head = &eh->pcrel_relocs_copied;
913 }
914 else
915 {
916 asection *s;
917 void *vpp;
918
919 s = (bfd_section_from_r_symndx
920 (abfd, &elf_m68k_hash_table (info)->sym_sec,
921 sec, r_symndx));
922 if (s == NULL)
923 return FALSE;
924
925 vpp = &elf_section_data (s)->local_dynrel;
926 head = (struct elf_m68k_pcrel_relocs_copied **) vpp;
927 }
928
929 for (p = *head; p != NULL; p = p->next)
930 if (p->section == sreloc)
931 break;
932
933 if (p == NULL)
934 {
935 p = ((struct elf_m68k_pcrel_relocs_copied *)
936 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
937 if (p == NULL)
938 return FALSE;
939 p->next = *head;
940 *head = p;
941 p->section = sreloc;
942 p->count = 0;
943 }
944
945 ++p->count;
946 }
947 }
948
949 break;
950
951 /* This relocation describes the C++ object vtable hierarchy.
952 Reconstruct it for later use during GC. */
953 case R_68K_GNU_VTINHERIT:
954 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
955 return FALSE;
956 break;
957
958 /* This relocation describes which C++ vtable entries are actually
959 used. Record for later use during GC. */
960 case R_68K_GNU_VTENTRY:
961 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
962 return FALSE;
963 break;
964
965 default:
966 break;
967 }
968 }
969
970 return TRUE;
971 }
972
973 /* Return the section that should be marked against GC for a given
974 relocation. */
975
976 static asection *
977 elf_m68k_gc_mark_hook (asection *sec,
978 struct bfd_link_info *info,
979 Elf_Internal_Rela *rel,
980 struct elf_link_hash_entry *h,
981 Elf_Internal_Sym *sym)
982 {
983 if (h != NULL)
984 switch (ELF32_R_TYPE (rel->r_info))
985 {
986 case R_68K_GNU_VTINHERIT:
987 case R_68K_GNU_VTENTRY:
988 return NULL;
989 }
990
991 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
992 }
993
994 /* Update the got entry reference counts for the section being removed. */
995
996 static bfd_boolean
997 elf_m68k_gc_sweep_hook (bfd *abfd,
998 struct bfd_link_info *info,
999 asection *sec,
1000 const Elf_Internal_Rela *relocs)
1001 {
1002 Elf_Internal_Shdr *symtab_hdr;
1003 struct elf_link_hash_entry **sym_hashes;
1004 bfd_signed_vma *local_got_refcounts;
1005 const Elf_Internal_Rela *rel, *relend;
1006 bfd *dynobj;
1007 asection *sgot;
1008 asection *srelgot;
1009
1010 dynobj = elf_hash_table (info)->dynobj;
1011 if (dynobj == NULL)
1012 return TRUE;
1013
1014 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1015 sym_hashes = elf_sym_hashes (abfd);
1016 local_got_refcounts = elf_local_got_refcounts (abfd);
1017
1018 sgot = bfd_get_section_by_name (dynobj, ".got");
1019 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1020
1021 relend = relocs + sec->reloc_count;
1022 for (rel = relocs; rel < relend; rel++)
1023 {
1024 unsigned long r_symndx;
1025 struct elf_link_hash_entry *h = NULL;
1026
1027 r_symndx = ELF32_R_SYM (rel->r_info);
1028 if (r_symndx >= symtab_hdr->sh_info)
1029 {
1030 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1031 while (h->root.type == bfd_link_hash_indirect
1032 || h->root.type == bfd_link_hash_warning)
1033 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1034 }
1035
1036 switch (ELF32_R_TYPE (rel->r_info))
1037 {
1038 case R_68K_GOT8:
1039 case R_68K_GOT16:
1040 case R_68K_GOT32:
1041 case R_68K_GOT8O:
1042 case R_68K_GOT16O:
1043 case R_68K_GOT32O:
1044 if (h != NULL)
1045 {
1046 if (h->got.refcount > 0)
1047 {
1048 --h->got.refcount;
1049 if (h->got.refcount == 0)
1050 {
1051 /* We don't need the .got entry any more. */
1052 sgot->size -= 4;
1053 srelgot->size -= sizeof (Elf32_External_Rela);
1054 }
1055 }
1056 }
1057 else if (local_got_refcounts != NULL)
1058 {
1059 if (local_got_refcounts[r_symndx] > 0)
1060 {
1061 --local_got_refcounts[r_symndx];
1062 if (local_got_refcounts[r_symndx] == 0)
1063 {
1064 /* We don't need the .got entry any more. */
1065 sgot->size -= 4;
1066 if (info->shared)
1067 srelgot->size -= sizeof (Elf32_External_Rela);
1068 }
1069 }
1070 }
1071 break;
1072
1073 case R_68K_PLT8:
1074 case R_68K_PLT16:
1075 case R_68K_PLT32:
1076 case R_68K_PLT8O:
1077 case R_68K_PLT16O:
1078 case R_68K_PLT32O:
1079 case R_68K_PC8:
1080 case R_68K_PC16:
1081 case R_68K_PC32:
1082 case R_68K_8:
1083 case R_68K_16:
1084 case R_68K_32:
1085 if (h != NULL)
1086 {
1087 if (h->plt.refcount > 0)
1088 --h->plt.refcount;
1089 }
1090 break;
1091
1092 default:
1093 break;
1094 }
1095 }
1096
1097 return TRUE;
1098 }
1099 \f
1100 /* Return the type of PLT associated with OUTPUT_BFD. */
1101
1102 static const struct elf_m68k_plt_info *
1103 elf_m68k_get_plt_info (bfd *output_bfd)
1104 {
1105 unsigned int features;
1106
1107 features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd));
1108 if (features & cpu32)
1109 return &elf_cpu32_plt_info;
1110 if (features & mcfisa_b)
1111 return &elf_isab_plt_info;
1112 return &elf_m68k_plt_info;
1113 }
1114
1115 /* This function is called after all the input files have been read,
1116 and the input sections have been assigned to output sections.
1117 It's a convenient place to determine the PLT style. */
1118
1119 static bfd_boolean
1120 elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
1121 {
1122 elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd);
1123 return TRUE;
1124 }
1125
1126 /* Adjust a symbol defined by a dynamic object and referenced by a
1127 regular object. The current definition is in some section of the
1128 dynamic object, but we're not including those sections. We have to
1129 change the definition to something the rest of the link can
1130 understand. */
1131
1132 static bfd_boolean
1133 elf_m68k_adjust_dynamic_symbol (info, h)
1134 struct bfd_link_info *info;
1135 struct elf_link_hash_entry *h;
1136 {
1137 struct elf_m68k_link_hash_table *htab;
1138 bfd *dynobj;
1139 asection *s;
1140 unsigned int power_of_two;
1141
1142 htab = elf_m68k_hash_table (info);
1143 dynobj = elf_hash_table (info)->dynobj;
1144
1145 /* Make sure we know what is going on here. */
1146 BFD_ASSERT (dynobj != NULL
1147 && (h->needs_plt
1148 || h->u.weakdef != NULL
1149 || (h->def_dynamic
1150 && h->ref_regular
1151 && !h->def_regular)));
1152
1153 /* If this is a function, put it in the procedure linkage table. We
1154 will fill in the contents of the procedure linkage table later,
1155 when we know the address of the .got section. */
1156 if (h->type == STT_FUNC
1157 || h->needs_plt)
1158 {
1159 if ((h->plt.refcount <= 0
1160 || SYMBOL_CALLS_LOCAL (info, h)
1161 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1162 && h->root.type == bfd_link_hash_undefweak))
1163 /* We must always create the plt entry if it was referenced
1164 by a PLTxxO relocation. In this case we already recorded
1165 it as a dynamic symbol. */
1166 && h->dynindx == -1)
1167 {
1168 /* This case can occur if we saw a PLTxx reloc in an input
1169 file, but the symbol was never referred to by a dynamic
1170 object, or if all references were garbage collected. In
1171 such a case, we don't actually need to build a procedure
1172 linkage table, and we can just do a PCxx reloc instead. */
1173 h->plt.offset = (bfd_vma) -1;
1174 h->needs_plt = 0;
1175 return TRUE;
1176 }
1177
1178 /* Make sure this symbol is output as a dynamic symbol. */
1179 if (h->dynindx == -1
1180 && !h->forced_local)
1181 {
1182 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1183 return FALSE;
1184 }
1185
1186 s = bfd_get_section_by_name (dynobj, ".plt");
1187 BFD_ASSERT (s != NULL);
1188
1189 /* If this is the first .plt entry, make room for the special
1190 first entry. */
1191 if (s->size == 0)
1192 s->size = htab->plt_info->size;
1193
1194 /* If this symbol is not defined in a regular file, and we are
1195 not generating a shared library, then set the symbol to this
1196 location in the .plt. This is required to make function
1197 pointers compare as equal between the normal executable and
1198 the shared library. */
1199 if (!info->shared
1200 && !h->def_regular)
1201 {
1202 h->root.u.def.section = s;
1203 h->root.u.def.value = s->size;
1204 }
1205
1206 h->plt.offset = s->size;
1207
1208 /* Make room for this entry. */
1209 s->size += htab->plt_info->size;
1210
1211 /* We also need to make an entry in the .got.plt section, which
1212 will be placed in the .got section by the linker script. */
1213 s = bfd_get_section_by_name (dynobj, ".got.plt");
1214 BFD_ASSERT (s != NULL);
1215 s->size += 4;
1216
1217 /* We also need to make an entry in the .rela.plt section. */
1218 s = bfd_get_section_by_name (dynobj, ".rela.plt");
1219 BFD_ASSERT (s != NULL);
1220 s->size += sizeof (Elf32_External_Rela);
1221
1222 return TRUE;
1223 }
1224
1225 /* Reinitialize the plt offset now that it is not used as a reference
1226 count any more. */
1227 h->plt.offset = (bfd_vma) -1;
1228
1229 /* If this is a weak symbol, and there is a real definition, the
1230 processor independent code will have arranged for us to see the
1231 real definition first, and we can just use the same value. */
1232 if (h->u.weakdef != NULL)
1233 {
1234 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1235 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1236 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1237 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1238 return TRUE;
1239 }
1240
1241 /* This is a reference to a symbol defined by a dynamic object which
1242 is not a function. */
1243
1244 /* If we are creating a shared library, we must presume that the
1245 only references to the symbol are via the global offset table.
1246 For such cases we need not do anything here; the relocations will
1247 be handled correctly by relocate_section. */
1248 if (info->shared)
1249 return TRUE;
1250
1251 if (h->size == 0)
1252 {
1253 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1254 h->root.root.string);
1255 return TRUE;
1256 }
1257
1258 /* We must allocate the symbol in our .dynbss section, which will
1259 become part of the .bss section of the executable. There will be
1260 an entry for this symbol in the .dynsym section. The dynamic
1261 object will contain position independent code, so all references
1262 from the dynamic object to this symbol will go through the global
1263 offset table. The dynamic linker will use the .dynsym entry to
1264 determine the address it must put in the global offset table, so
1265 both the dynamic object and the regular object will refer to the
1266 same memory location for the variable. */
1267
1268 s = bfd_get_section_by_name (dynobj, ".dynbss");
1269 BFD_ASSERT (s != NULL);
1270
1271 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
1272 copy the initial value out of the dynamic object and into the
1273 runtime process image. We need to remember the offset into the
1274 .rela.bss section we are going to use. */
1275 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1276 {
1277 asection *srel;
1278
1279 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1280 BFD_ASSERT (srel != NULL);
1281 srel->size += sizeof (Elf32_External_Rela);
1282 h->needs_copy = 1;
1283 }
1284
1285 /* We need to figure out the alignment required for this symbol. I
1286 have no idea how ELF linkers handle this. */
1287 power_of_two = bfd_log2 (h->size);
1288 if (power_of_two > 3)
1289 power_of_two = 3;
1290
1291 /* Apply the required alignment. */
1292 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1293 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1294 {
1295 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
1296 return FALSE;
1297 }
1298
1299 /* Define the symbol as being at this point in the section. */
1300 h->root.u.def.section = s;
1301 h->root.u.def.value = s->size;
1302
1303 /* Increment the section size to make room for the symbol. */
1304 s->size += h->size;
1305
1306 return TRUE;
1307 }
1308
1309 /* Set the sizes of the dynamic sections. */
1310
1311 static bfd_boolean
1312 elf_m68k_size_dynamic_sections (output_bfd, info)
1313 bfd *output_bfd ATTRIBUTE_UNUSED;
1314 struct bfd_link_info *info;
1315 {
1316 bfd *dynobj;
1317 asection *s;
1318 bfd_boolean plt;
1319 bfd_boolean relocs;
1320
1321 dynobj = elf_hash_table (info)->dynobj;
1322 BFD_ASSERT (dynobj != NULL);
1323
1324 if (elf_hash_table (info)->dynamic_sections_created)
1325 {
1326 /* Set the contents of the .interp section to the interpreter. */
1327 if (info->executable)
1328 {
1329 s = bfd_get_section_by_name (dynobj, ".interp");
1330 BFD_ASSERT (s != NULL);
1331 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1332 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1333 }
1334 }
1335 else
1336 {
1337 /* We may have created entries in the .rela.got section.
1338 However, if we are not creating the dynamic sections, we will
1339 not actually use these entries. Reset the size of .rela.got,
1340 which will cause it to get stripped from the output file
1341 below. */
1342 s = bfd_get_section_by_name (dynobj, ".rela.got");
1343 if (s != NULL)
1344 s->size = 0;
1345 }
1346
1347 /* If this is a -Bsymbolic shared link, then we need to discard all
1348 PC relative relocs against symbols defined in a regular object.
1349 For the normal shared case we discard the PC relative relocs
1350 against symbols that have become local due to visibility changes.
1351 We allocated space for them in the check_relocs routine, but we
1352 will not fill them in in the relocate_section routine. */
1353 if (info->shared)
1354 elf_link_hash_traverse (elf_hash_table (info),
1355 elf_m68k_discard_copies,
1356 (PTR) info);
1357
1358 /* The check_relocs and adjust_dynamic_symbol entry points have
1359 determined the sizes of the various dynamic sections. Allocate
1360 memory for them. */
1361 plt = FALSE;
1362 relocs = FALSE;
1363 for (s = dynobj->sections; s != NULL; s = s->next)
1364 {
1365 const char *name;
1366
1367 if ((s->flags & SEC_LINKER_CREATED) == 0)
1368 continue;
1369
1370 /* It's OK to base decisions on the section name, because none
1371 of the dynobj section names depend upon the input files. */
1372 name = bfd_get_section_name (dynobj, s);
1373
1374 if (strcmp (name, ".plt") == 0)
1375 {
1376 /* Remember whether there is a PLT. */
1377 plt = s->size != 0;
1378 }
1379 else if (CONST_STRNEQ (name, ".rela"))
1380 {
1381 if (s->size != 0)
1382 {
1383 relocs = TRUE;
1384
1385 /* We use the reloc_count field as a counter if we need
1386 to copy relocs into the output file. */
1387 s->reloc_count = 0;
1388 }
1389 }
1390 else if (! CONST_STRNEQ (name, ".got")
1391 && strcmp (name, ".dynbss") != 0)
1392 {
1393 /* It's not one of our sections, so don't allocate space. */
1394 continue;
1395 }
1396
1397 if (s->size == 0)
1398 {
1399 /* If we don't need this section, strip it from the
1400 output file. This is mostly to handle .rela.bss and
1401 .rela.plt. We must create both sections in
1402 create_dynamic_sections, because they must be created
1403 before the linker maps input sections to output
1404 sections. The linker does that before
1405 adjust_dynamic_symbol is called, and it is that
1406 function which decides whether anything needs to go
1407 into these sections. */
1408 s->flags |= SEC_EXCLUDE;
1409 continue;
1410 }
1411
1412 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1413 continue;
1414
1415 /* Allocate memory for the section contents. */
1416 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1417 Unused entries should be reclaimed before the section's contents
1418 are written out, but at the moment this does not happen. Thus in
1419 order to prevent writing out garbage, we initialise the section's
1420 contents to zero. */
1421 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1422 if (s->contents == NULL)
1423 return FALSE;
1424 }
1425
1426 if (elf_hash_table (info)->dynamic_sections_created)
1427 {
1428 /* Add some entries to the .dynamic section. We fill in the
1429 values later, in elf_m68k_finish_dynamic_sections, but we
1430 must add the entries now so that we get the correct size for
1431 the .dynamic section. The DT_DEBUG entry is filled in by the
1432 dynamic linker and used by the debugger. */
1433 #define add_dynamic_entry(TAG, VAL) \
1434 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1435
1436 if (!info->shared)
1437 {
1438 if (!add_dynamic_entry (DT_DEBUG, 0))
1439 return FALSE;
1440 }
1441
1442 if (plt)
1443 {
1444 if (!add_dynamic_entry (DT_PLTGOT, 0)
1445 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1446 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1447 || !add_dynamic_entry (DT_JMPREL, 0))
1448 return FALSE;
1449 }
1450
1451 if (relocs)
1452 {
1453 if (!add_dynamic_entry (DT_RELA, 0)
1454 || !add_dynamic_entry (DT_RELASZ, 0)
1455 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1456 return FALSE;
1457 }
1458
1459 if ((info->flags & DF_TEXTREL) != 0)
1460 {
1461 if (!add_dynamic_entry (DT_TEXTREL, 0))
1462 return FALSE;
1463 }
1464 }
1465 #undef add_dynamic_entry
1466
1467 return TRUE;
1468 }
1469
1470 /* This function is called via elf_link_hash_traverse if we are
1471 creating a shared object. In the -Bsymbolic case it discards the
1472 space allocated to copy PC relative relocs against symbols which
1473 are defined in regular objects. For the normal shared case, it
1474 discards space for pc-relative relocs that have become local due to
1475 symbol visibility changes. We allocated space for them in the
1476 check_relocs routine, but we won't fill them in in the
1477 relocate_section routine.
1478
1479 We also check whether any of the remaining relocations apply
1480 against a readonly section, and set the DF_TEXTREL flag in this
1481 case. */
1482
1483 static bfd_boolean
1484 elf_m68k_discard_copies (h, inf)
1485 struct elf_link_hash_entry *h;
1486 PTR inf;
1487 {
1488 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1489 struct elf_m68k_pcrel_relocs_copied *s;
1490
1491 if (h->root.type == bfd_link_hash_warning)
1492 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1493
1494 if (!h->def_regular
1495 || (!info->symbolic
1496 && !h->forced_local))
1497 {
1498 if ((info->flags & DF_TEXTREL) == 0)
1499 {
1500 /* Look for relocations against read-only sections. */
1501 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
1502 s != NULL;
1503 s = s->next)
1504 if ((s->section->flags & SEC_READONLY) != 0)
1505 {
1506 info->flags |= DF_TEXTREL;
1507 break;
1508 }
1509 }
1510
1511 return TRUE;
1512 }
1513
1514 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
1515 s != NULL;
1516 s = s->next)
1517 s->section->size -= s->count * sizeof (Elf32_External_Rela);
1518
1519 return TRUE;
1520 }
1521
1522 /* Relocate an M68K ELF section. */
1523
1524 static bfd_boolean
1525 elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section,
1526 contents, relocs, local_syms, local_sections)
1527 bfd *output_bfd;
1528 struct bfd_link_info *info;
1529 bfd *input_bfd;
1530 asection *input_section;
1531 bfd_byte *contents;
1532 Elf_Internal_Rela *relocs;
1533 Elf_Internal_Sym *local_syms;
1534 asection **local_sections;
1535 {
1536 bfd *dynobj;
1537 Elf_Internal_Shdr *symtab_hdr;
1538 struct elf_link_hash_entry **sym_hashes;
1539 bfd_vma *local_got_offsets;
1540 asection *sgot;
1541 asection *splt;
1542 asection *sreloc;
1543 Elf_Internal_Rela *rel;
1544 Elf_Internal_Rela *relend;
1545
1546 if (info->relocatable)
1547 return TRUE;
1548
1549 dynobj = elf_hash_table (info)->dynobj;
1550 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1551 sym_hashes = elf_sym_hashes (input_bfd);
1552 local_got_offsets = elf_local_got_offsets (input_bfd);
1553
1554 sgot = NULL;
1555 splt = NULL;
1556 sreloc = NULL;
1557
1558 rel = relocs;
1559 relend = relocs + input_section->reloc_count;
1560 for (; rel < relend; rel++)
1561 {
1562 int r_type;
1563 reloc_howto_type *howto;
1564 unsigned long r_symndx;
1565 struct elf_link_hash_entry *h;
1566 Elf_Internal_Sym *sym;
1567 asection *sec;
1568 bfd_vma relocation;
1569 bfd_boolean unresolved_reloc;
1570 bfd_reloc_status_type r;
1571
1572 r_type = ELF32_R_TYPE (rel->r_info);
1573 if (r_type < 0 || r_type >= (int) R_68K_max)
1574 {
1575 bfd_set_error (bfd_error_bad_value);
1576 return FALSE;
1577 }
1578 howto = howto_table + r_type;
1579
1580 r_symndx = ELF32_R_SYM (rel->r_info);
1581
1582 h = NULL;
1583 sym = NULL;
1584 sec = NULL;
1585 unresolved_reloc = FALSE;
1586
1587 if (r_symndx < symtab_hdr->sh_info)
1588 {
1589 sym = local_syms + r_symndx;
1590 sec = local_sections[r_symndx];
1591 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1592 }
1593 else
1594 {
1595 bfd_boolean warned;
1596
1597 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1598 r_symndx, symtab_hdr, sym_hashes,
1599 h, sec, relocation,
1600 unresolved_reloc, warned);
1601 }
1602
1603 switch (r_type)
1604 {
1605 case R_68K_GOT8:
1606 case R_68K_GOT16:
1607 case R_68K_GOT32:
1608 /* Relocation is to the address of the entry for this symbol
1609 in the global offset table. */
1610 if (h != NULL
1611 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1612 break;
1613 /* Fall through. */
1614 case R_68K_GOT8O:
1615 case R_68K_GOT16O:
1616 case R_68K_GOT32O:
1617 /* Relocation is the offset of the entry for this symbol in
1618 the global offset table. */
1619
1620 {
1621 bfd_vma off;
1622
1623 if (sgot == NULL)
1624 {
1625 sgot = bfd_get_section_by_name (dynobj, ".got");
1626 BFD_ASSERT (sgot != NULL);
1627 }
1628
1629 if (h != NULL)
1630 {
1631 bfd_boolean dyn;
1632
1633 off = h->got.offset;
1634 BFD_ASSERT (off != (bfd_vma) -1);
1635
1636 dyn = elf_hash_table (info)->dynamic_sections_created;
1637 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1638 || (info->shared
1639 && (info->symbolic
1640 || h->dynindx == -1
1641 || h->forced_local)
1642 && h->def_regular))
1643 {
1644 /* This is actually a static link, or it is a
1645 -Bsymbolic link and the symbol is defined
1646 locally, or the symbol was forced to be local
1647 because of a version file.. We must initialize
1648 this entry in the global offset table. Since
1649 the offset must always be a multiple of 4, we
1650 use the least significant bit to record whether
1651 we have initialized it already.
1652
1653 When doing a dynamic link, we create a .rela.got
1654 relocation entry to initialize the value. This
1655 is done in the finish_dynamic_symbol routine. */
1656 if ((off & 1) != 0)
1657 off &= ~1;
1658 else
1659 {
1660 bfd_put_32 (output_bfd, relocation,
1661 sgot->contents + off);
1662 h->got.offset |= 1;
1663 }
1664 }
1665 else
1666 unresolved_reloc = FALSE;
1667 }
1668 else
1669 {
1670 BFD_ASSERT (local_got_offsets != NULL
1671 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1672
1673 off = local_got_offsets[r_symndx];
1674
1675 /* The offset must always be a multiple of 4. We use
1676 the least significant bit to record whether we have
1677 already generated the necessary reloc. */
1678 if ((off & 1) != 0)
1679 off &= ~1;
1680 else
1681 {
1682 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1683
1684 if (info->shared)
1685 {
1686 asection *s;
1687 Elf_Internal_Rela outrel;
1688 bfd_byte *loc;
1689
1690 s = bfd_get_section_by_name (dynobj, ".rela.got");
1691 BFD_ASSERT (s != NULL);
1692
1693 outrel.r_offset = (sgot->output_section->vma
1694 + sgot->output_offset
1695 + off);
1696 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1697 outrel.r_addend = relocation;
1698 loc = s->contents;
1699 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1700 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1701 }
1702
1703 local_got_offsets[r_symndx] |= 1;
1704 }
1705 }
1706
1707 relocation = sgot->output_offset + off;
1708 if (r_type == R_68K_GOT8O
1709 || r_type == R_68K_GOT16O
1710 || r_type == R_68K_GOT32O)
1711 {
1712 /* This relocation does not use the addend. */
1713 rel->r_addend = 0;
1714 }
1715 else
1716 relocation += sgot->output_section->vma;
1717 }
1718 break;
1719
1720 case R_68K_PLT8:
1721 case R_68K_PLT16:
1722 case R_68K_PLT32:
1723 /* Relocation is to the entry for this symbol in the
1724 procedure linkage table. */
1725
1726 /* Resolve a PLTxx reloc against a local symbol directly,
1727 without using the procedure linkage table. */
1728 if (h == NULL)
1729 break;
1730
1731 if (h->plt.offset == (bfd_vma) -1
1732 || !elf_hash_table (info)->dynamic_sections_created)
1733 {
1734 /* We didn't make a PLT entry for this symbol. This
1735 happens when statically linking PIC code, or when
1736 using -Bsymbolic. */
1737 break;
1738 }
1739
1740 if (splt == NULL)
1741 {
1742 splt = bfd_get_section_by_name (dynobj, ".plt");
1743 BFD_ASSERT (splt != NULL);
1744 }
1745
1746 relocation = (splt->output_section->vma
1747 + splt->output_offset
1748 + h->plt.offset);
1749 unresolved_reloc = FALSE;
1750 break;
1751
1752 case R_68K_PLT8O:
1753 case R_68K_PLT16O:
1754 case R_68K_PLT32O:
1755 /* Relocation is the offset of the entry for this symbol in
1756 the procedure linkage table. */
1757 BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
1758
1759 if (splt == NULL)
1760 {
1761 splt = bfd_get_section_by_name (dynobj, ".plt");
1762 BFD_ASSERT (splt != NULL);
1763 }
1764
1765 relocation = h->plt.offset;
1766 unresolved_reloc = FALSE;
1767
1768 /* This relocation does not use the addend. */
1769 rel->r_addend = 0;
1770
1771 break;
1772
1773 case R_68K_PC8:
1774 case R_68K_PC16:
1775 case R_68K_PC32:
1776 if (h == NULL
1777 || (info->shared
1778 && h->forced_local))
1779 break;
1780 /* Fall through. */
1781 case R_68K_8:
1782 case R_68K_16:
1783 case R_68K_32:
1784 if (info->shared
1785 && r_symndx != 0
1786 && (input_section->flags & SEC_ALLOC) != 0
1787 && (h == NULL
1788 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1789 || h->root.type != bfd_link_hash_undefweak)
1790 && ((r_type != R_68K_PC8
1791 && r_type != R_68K_PC16
1792 && r_type != R_68K_PC32)
1793 || (h != NULL
1794 && h->dynindx != -1
1795 && (!info->symbolic
1796 || !h->def_regular))))
1797 {
1798 Elf_Internal_Rela outrel;
1799 bfd_byte *loc;
1800 bfd_boolean skip, relocate;
1801
1802 /* When generating a shared object, these relocations
1803 are copied into the output file to be resolved at run
1804 time. */
1805
1806 skip = FALSE;
1807 relocate = FALSE;
1808
1809 outrel.r_offset =
1810 _bfd_elf_section_offset (output_bfd, info, input_section,
1811 rel->r_offset);
1812 if (outrel.r_offset == (bfd_vma) -1)
1813 skip = TRUE;
1814 else if (outrel.r_offset == (bfd_vma) -2)
1815 skip = TRUE, relocate = TRUE;
1816 outrel.r_offset += (input_section->output_section->vma
1817 + input_section->output_offset);
1818
1819 if (skip)
1820 memset (&outrel, 0, sizeof outrel);
1821 else if (h != NULL
1822 && h->dynindx != -1
1823 && (r_type == R_68K_PC8
1824 || r_type == R_68K_PC16
1825 || r_type == R_68K_PC32
1826 || !info->shared
1827 || !info->symbolic
1828 || !h->def_regular))
1829 {
1830 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1831 outrel.r_addend = rel->r_addend;
1832 }
1833 else
1834 {
1835 /* This symbol is local, or marked to become local. */
1836 if (r_type == R_68K_32)
1837 {
1838 relocate = TRUE;
1839 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1840 outrel.r_addend = relocation + rel->r_addend;
1841 }
1842 else
1843 {
1844 long indx;
1845
1846 if (bfd_is_abs_section (sec))
1847 indx = 0;
1848 else if (sec == NULL || sec->owner == NULL)
1849 {
1850 bfd_set_error (bfd_error_bad_value);
1851 return FALSE;
1852 }
1853 else
1854 {
1855 asection *osec;
1856
1857 osec = sec->output_section;
1858 indx = elf_section_data (osec)->dynindx;
1859 BFD_ASSERT (indx > 0);
1860 }
1861
1862 outrel.r_info = ELF32_R_INFO (indx, r_type);
1863 outrel.r_addend = relocation + rel->r_addend;
1864 }
1865 }
1866
1867 sreloc = elf_section_data (input_section)->sreloc;
1868 if (sreloc == NULL)
1869 abort ();
1870
1871 loc = sreloc->contents;
1872 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1873 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1874
1875 /* This reloc will be computed at runtime, so there's no
1876 need to do anything now, except for R_68K_32
1877 relocations that have been turned into
1878 R_68K_RELATIVE. */
1879 if (!relocate)
1880 continue;
1881 }
1882
1883 break;
1884
1885 case R_68K_GNU_VTINHERIT:
1886 case R_68K_GNU_VTENTRY:
1887 /* These are no-ops in the end. */
1888 continue;
1889
1890 default:
1891 break;
1892 }
1893
1894 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1895 because such sections are not SEC_ALLOC and thus ld.so will
1896 not process them. */
1897 if (unresolved_reloc
1898 && !((input_section->flags & SEC_DEBUGGING) != 0
1899 && h->def_dynamic))
1900 {
1901 (*_bfd_error_handler)
1902 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1903 input_bfd,
1904 input_section,
1905 (long) rel->r_offset,
1906 howto->name,
1907 h->root.root.string);
1908 return FALSE;
1909 }
1910
1911 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1912 contents, rel->r_offset,
1913 relocation, rel->r_addend);
1914
1915 if (r != bfd_reloc_ok)
1916 {
1917 const char *name;
1918
1919 if (h != NULL)
1920 name = h->root.root.string;
1921 else
1922 {
1923 name = bfd_elf_string_from_elf_section (input_bfd,
1924 symtab_hdr->sh_link,
1925 sym->st_name);
1926 if (name == NULL)
1927 return FALSE;
1928 if (*name == '\0')
1929 name = bfd_section_name (input_bfd, sec);
1930 }
1931
1932 if (r == bfd_reloc_overflow)
1933 {
1934 if (!(info->callbacks->reloc_overflow
1935 (info, (h ? &h->root : NULL), name, howto->name,
1936 (bfd_vma) 0, input_bfd, input_section,
1937 rel->r_offset)))
1938 return FALSE;
1939 }
1940 else
1941 {
1942 (*_bfd_error_handler)
1943 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
1944 input_bfd, input_section,
1945 (long) rel->r_offset, name, (int) r);
1946 return FALSE;
1947 }
1948 }
1949 }
1950
1951 return TRUE;
1952 }
1953
1954 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
1955 into section SEC. */
1956
1957 static void
1958 elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value)
1959 {
1960 /* Make VALUE PC-relative. */
1961 value -= sec->output_section->vma + offset;
1962
1963 /* Apply any in-place addend. */
1964 value += bfd_get_32 (sec->owner, sec->contents + offset);
1965
1966 bfd_put_32 (sec->owner, value, sec->contents + offset);
1967 }
1968
1969 /* Finish up dynamic symbol handling. We set the contents of various
1970 dynamic sections here. */
1971
1972 static bfd_boolean
1973 elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym)
1974 bfd *output_bfd;
1975 struct bfd_link_info *info;
1976 struct elf_link_hash_entry *h;
1977 Elf_Internal_Sym *sym;
1978 {
1979 bfd *dynobj;
1980
1981 dynobj = elf_hash_table (info)->dynobj;
1982
1983 if (h->plt.offset != (bfd_vma) -1)
1984 {
1985 const struct elf_m68k_plt_info *plt_info;
1986 asection *splt;
1987 asection *sgot;
1988 asection *srela;
1989 bfd_vma plt_index;
1990 bfd_vma got_offset;
1991 Elf_Internal_Rela rela;
1992 bfd_byte *loc;
1993
1994 /* This symbol has an entry in the procedure linkage table. Set
1995 it up. */
1996
1997 BFD_ASSERT (h->dynindx != -1);
1998
1999 plt_info = elf_m68k_hash_table (info)->plt_info;
2000 splt = bfd_get_section_by_name (dynobj, ".plt");
2001 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2002 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2003 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
2004
2005 /* Get the index in the procedure linkage table which
2006 corresponds to this symbol. This is the index of this symbol
2007 in all the symbols for which we are making plt entries. The
2008 first entry in the procedure linkage table is reserved. */
2009 plt_index = (h->plt.offset / plt_info->size) - 1;
2010
2011 /* Get the offset into the .got table of the entry that
2012 corresponds to this function. Each .got entry is 4 bytes.
2013 The first three are reserved. */
2014 got_offset = (plt_index + 3) * 4;
2015
2016 memcpy (splt->contents + h->plt.offset,
2017 plt_info->symbol_entry,
2018 plt_info->size);
2019
2020 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got,
2021 (sgot->output_section->vma
2022 + sgot->output_offset
2023 + got_offset));
2024
2025 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
2026 splt->contents
2027 + h->plt.offset
2028 + plt_info->symbol_resolve_entry + 2);
2029
2030 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt,
2031 splt->output_section->vma);
2032
2033 /* Fill in the entry in the global offset table. */
2034 bfd_put_32 (output_bfd,
2035 (splt->output_section->vma
2036 + splt->output_offset
2037 + h->plt.offset
2038 + plt_info->symbol_resolve_entry),
2039 sgot->contents + got_offset);
2040
2041 /* Fill in the entry in the .rela.plt section. */
2042 rela.r_offset = (sgot->output_section->vma
2043 + sgot->output_offset
2044 + got_offset);
2045 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
2046 rela.r_addend = 0;
2047 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
2048 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2049
2050 if (!h->def_regular)
2051 {
2052 /* Mark the symbol as undefined, rather than as defined in
2053 the .plt section. Leave the value alone. */
2054 sym->st_shndx = SHN_UNDEF;
2055 }
2056 }
2057
2058 if (h->got.offset != (bfd_vma) -1)
2059 {
2060 asection *sgot;
2061 asection *srela;
2062 Elf_Internal_Rela rela;
2063 bfd_byte *loc;
2064
2065 /* This symbol has an entry in the global offset table. Set it
2066 up. */
2067
2068 sgot = bfd_get_section_by_name (dynobj, ".got");
2069 srela = bfd_get_section_by_name (dynobj, ".rela.got");
2070 BFD_ASSERT (sgot != NULL && srela != NULL);
2071
2072 rela.r_offset = (sgot->output_section->vma
2073 + sgot->output_offset
2074 + (h->got.offset &~ (bfd_vma) 1));
2075
2076 /* If this is a -Bsymbolic link, and the symbol is defined
2077 locally, we just want to emit a RELATIVE reloc. Likewise if
2078 the symbol was forced to be local because of a version file.
2079 The entry in the global offset table will already have been
2080 initialized in the relocate_section function. */
2081 if (info->shared
2082 && (info->symbolic
2083 || h->dynindx == -1
2084 || h->forced_local)
2085 && h->def_regular)
2086 {
2087 rela.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
2088 rela.r_addend = bfd_get_signed_32 (output_bfd,
2089 (sgot->contents
2090 + (h->got.offset &~ (bfd_vma) 1)));
2091 }
2092 else
2093 {
2094 bfd_put_32 (output_bfd, (bfd_vma) 0,
2095 sgot->contents + (h->got.offset &~ (bfd_vma) 1));
2096 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
2097 rela.r_addend = 0;
2098 }
2099
2100 loc = srela->contents;
2101 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
2102 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2103 }
2104
2105 if (h->needs_copy)
2106 {
2107 asection *s;
2108 Elf_Internal_Rela rela;
2109 bfd_byte *loc;
2110
2111 /* This symbol needs a copy reloc. Set it up. */
2112
2113 BFD_ASSERT (h->dynindx != -1
2114 && (h->root.type == bfd_link_hash_defined
2115 || h->root.type == bfd_link_hash_defweak));
2116
2117 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2118 ".rela.bss");
2119 BFD_ASSERT (s != NULL);
2120
2121 rela.r_offset = (h->root.u.def.value
2122 + h->root.u.def.section->output_section->vma
2123 + h->root.u.def.section->output_offset);
2124 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
2125 rela.r_addend = 0;
2126 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
2127 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2128 }
2129
2130 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2131 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2132 || h == elf_hash_table (info)->hgot)
2133 sym->st_shndx = SHN_ABS;
2134
2135 return TRUE;
2136 }
2137
2138 /* Finish up the dynamic sections. */
2139
2140 static bfd_boolean
2141 elf_m68k_finish_dynamic_sections (output_bfd, info)
2142 bfd *output_bfd;
2143 struct bfd_link_info *info;
2144 {
2145 bfd *dynobj;
2146 asection *sgot;
2147 asection *sdyn;
2148
2149 dynobj = elf_hash_table (info)->dynobj;
2150
2151 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2152 BFD_ASSERT (sgot != NULL);
2153 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2154
2155 if (elf_hash_table (info)->dynamic_sections_created)
2156 {
2157 asection *splt;
2158 Elf32_External_Dyn *dyncon, *dynconend;
2159
2160 splt = bfd_get_section_by_name (dynobj, ".plt");
2161 BFD_ASSERT (splt != NULL && sdyn != NULL);
2162
2163 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2164 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2165 for (; dyncon < dynconend; dyncon++)
2166 {
2167 Elf_Internal_Dyn dyn;
2168 const char *name;
2169 asection *s;
2170
2171 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2172
2173 switch (dyn.d_tag)
2174 {
2175 default:
2176 break;
2177
2178 case DT_PLTGOT:
2179 name = ".got";
2180 goto get_vma;
2181 case DT_JMPREL:
2182 name = ".rela.plt";
2183 get_vma:
2184 s = bfd_get_section_by_name (output_bfd, name);
2185 BFD_ASSERT (s != NULL);
2186 dyn.d_un.d_ptr = s->vma;
2187 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2188 break;
2189
2190 case DT_PLTRELSZ:
2191 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2192 BFD_ASSERT (s != NULL);
2193 dyn.d_un.d_val = s->size;
2194 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2195 break;
2196
2197 case DT_RELASZ:
2198 /* The procedure linkage table relocs (DT_JMPREL) should
2199 not be included in the overall relocs (DT_RELA).
2200 Therefore, we override the DT_RELASZ entry here to
2201 make it not include the JMPREL relocs. Since the
2202 linker script arranges for .rela.plt to follow all
2203 other relocation sections, we don't have to worry
2204 about changing the DT_RELA entry. */
2205 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2206 if (s != NULL)
2207 dyn.d_un.d_val -= s->size;
2208 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2209 break;
2210 }
2211 }
2212
2213 /* Fill in the first entry in the procedure linkage table. */
2214 if (splt->size > 0)
2215 {
2216 const struct elf_m68k_plt_info *plt_info;
2217
2218 plt_info = elf_m68k_hash_table (info)->plt_info;
2219 memcpy (splt->contents, plt_info->plt0_entry, plt_info->size);
2220
2221 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4,
2222 (sgot->output_section->vma
2223 + sgot->output_offset
2224 + 4));
2225
2226 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8,
2227 (sgot->output_section->vma
2228 + sgot->output_offset
2229 + 8));
2230
2231 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2232 = plt_info->size;
2233 }
2234 }
2235
2236 /* Fill in the first three entries in the global offset table. */
2237 if (sgot->size > 0)
2238 {
2239 if (sdyn == NULL)
2240 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2241 else
2242 bfd_put_32 (output_bfd,
2243 sdyn->output_section->vma + sdyn->output_offset,
2244 sgot->contents);
2245 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2246 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2247 }
2248
2249 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2250
2251 return TRUE;
2252 }
2253
2254 /* Given a .data section and a .emreloc in-memory section, store
2255 relocation information into the .emreloc section which can be
2256 used at runtime to relocate the section. This is called by the
2257 linker when the --embedded-relocs switch is used. This is called
2258 after the add_symbols entry point has been called for all the
2259 objects, and before the final_link entry point is called. */
2260
2261 bfd_boolean
2262 bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
2263 bfd *abfd;
2264 struct bfd_link_info *info;
2265 asection *datasec;
2266 asection *relsec;
2267 char **errmsg;
2268 {
2269 Elf_Internal_Shdr *symtab_hdr;
2270 Elf_Internal_Sym *isymbuf = NULL;
2271 Elf_Internal_Rela *internal_relocs = NULL;
2272 Elf_Internal_Rela *irel, *irelend;
2273 bfd_byte *p;
2274 bfd_size_type amt;
2275
2276 BFD_ASSERT (! info->relocatable);
2277
2278 *errmsg = NULL;
2279
2280 if (datasec->reloc_count == 0)
2281 return TRUE;
2282
2283 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2284
2285 /* Get a copy of the native relocations. */
2286 internal_relocs = (_bfd_elf_link_read_relocs
2287 (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2288 info->keep_memory));
2289 if (internal_relocs == NULL)
2290 goto error_return;
2291
2292 amt = (bfd_size_type) datasec->reloc_count * 12;
2293 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2294 if (relsec->contents == NULL)
2295 goto error_return;
2296
2297 p = relsec->contents;
2298
2299 irelend = internal_relocs + datasec->reloc_count;
2300 for (irel = internal_relocs; irel < irelend; irel++, p += 12)
2301 {
2302 asection *targetsec;
2303
2304 /* We are going to write a four byte longword into the runtime
2305 reloc section. The longword will be the address in the data
2306 section which must be relocated. It is followed by the name
2307 of the target section NUL-padded or truncated to 8
2308 characters. */
2309
2310 /* We can only relocate absolute longword relocs at run time. */
2311 if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
2312 {
2313 *errmsg = _("unsupported reloc type");
2314 bfd_set_error (bfd_error_bad_value);
2315 goto error_return;
2316 }
2317
2318 /* Get the target section referred to by the reloc. */
2319 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2320 {
2321 /* A local symbol. */
2322 Elf_Internal_Sym *isym;
2323
2324 /* Read this BFD's local symbols if we haven't done so already. */
2325 if (isymbuf == NULL)
2326 {
2327 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2328 if (isymbuf == NULL)
2329 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2330 symtab_hdr->sh_info, 0,
2331 NULL, NULL, NULL);
2332 if (isymbuf == NULL)
2333 goto error_return;
2334 }
2335
2336 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2337 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2338 }
2339 else
2340 {
2341 unsigned long indx;
2342 struct elf_link_hash_entry *h;
2343
2344 /* An external symbol. */
2345 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2346 h = elf_sym_hashes (abfd)[indx];
2347 BFD_ASSERT (h != NULL);
2348 if (h->root.type == bfd_link_hash_defined
2349 || h->root.type == bfd_link_hash_defweak)
2350 targetsec = h->root.u.def.section;
2351 else
2352 targetsec = NULL;
2353 }
2354
2355 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
2356 memset (p + 4, 0, 8);
2357 if (targetsec != NULL)
2358 strncpy ((char *) p + 4, targetsec->output_section->name, 8);
2359 }
2360
2361 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2362 free (isymbuf);
2363 if (internal_relocs != NULL
2364 && elf_section_data (datasec)->relocs != internal_relocs)
2365 free (internal_relocs);
2366 return TRUE;
2367
2368 error_return:
2369 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2370 free (isymbuf);
2371 if (internal_relocs != NULL
2372 && elf_section_data (datasec)->relocs != internal_relocs)
2373 free (internal_relocs);
2374 return FALSE;
2375 }
2376
2377 static enum elf_reloc_type_class
2378 elf32_m68k_reloc_type_class (rela)
2379 const Elf_Internal_Rela *rela;
2380 {
2381 switch ((int) ELF32_R_TYPE (rela->r_info))
2382 {
2383 case R_68K_RELATIVE:
2384 return reloc_class_relative;
2385 case R_68K_JMP_SLOT:
2386 return reloc_class_plt;
2387 case R_68K_COPY:
2388 return reloc_class_copy;
2389 default:
2390 return reloc_class_normal;
2391 }
2392 }
2393
2394 /* Return address for Ith PLT stub in section PLT, for relocation REL
2395 or (bfd_vma) -1 if it should not be included. */
2396
2397 static bfd_vma
2398 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
2399 const arelent *rel ATTRIBUTE_UNUSED)
2400 {
2401 return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
2402 }
2403
2404 #define TARGET_BIG_SYM bfd_elf32_m68k_vec
2405 #define TARGET_BIG_NAME "elf32-m68k"
2406 #define ELF_MACHINE_CODE EM_68K
2407 #define ELF_MAXPAGESIZE 0x2000
2408 #define elf_backend_create_dynamic_sections \
2409 _bfd_elf_create_dynamic_sections
2410 #define bfd_elf32_bfd_link_hash_table_create \
2411 elf_m68k_link_hash_table_create
2412 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
2413
2414 #define elf_backend_check_relocs elf_m68k_check_relocs
2415 #define elf_backend_always_size_sections \
2416 elf_m68k_always_size_sections
2417 #define elf_backend_adjust_dynamic_symbol \
2418 elf_m68k_adjust_dynamic_symbol
2419 #define elf_backend_size_dynamic_sections \
2420 elf_m68k_size_dynamic_sections
2421 #define elf_backend_relocate_section elf_m68k_relocate_section
2422 #define elf_backend_finish_dynamic_symbol \
2423 elf_m68k_finish_dynamic_symbol
2424 #define elf_backend_finish_dynamic_sections \
2425 elf_m68k_finish_dynamic_sections
2426 #define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook
2427 #define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook
2428 #define bfd_elf32_bfd_merge_private_bfd_data \
2429 elf32_m68k_merge_private_bfd_data
2430 #define bfd_elf32_bfd_set_private_flags \
2431 elf32_m68k_set_private_flags
2432 #define bfd_elf32_bfd_print_private_bfd_data \
2433 elf32_m68k_print_private_bfd_data
2434 #define elf_backend_reloc_type_class elf32_m68k_reloc_type_class
2435 #define elf_backend_plt_sym_val elf_m68k_plt_sym_val
2436 #define elf_backend_object_p elf32_m68k_object_p
2437
2438 #define elf_backend_can_gc_sections 1
2439 #define elf_backend_can_refcount 1
2440 #define elf_backend_want_got_plt 1
2441 #define elf_backend_plt_readonly 1
2442 #define elf_backend_want_plt_sym 0
2443 #define elf_backend_got_header_size 12
2444 #define elf_backend_rela_normal 1
2445
2446 #include "elf32-target.h"