?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* ld-elf/header.d: Reduce page size, restrict to linux & vxworks
[binutils.git] / bfd / elf32-m68k.c
blobad7e56f1ded7f8f48889d352cecf131739d24de4
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_ARCH_MASK) == EF_M68K_M68000)
433 features |= m68000;
434 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
435 features |= cpu32;
436 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
437 features |= fido_a;
438 else
439 {
440 switch (eflags & EF_M68K_CF_ISA_MASK)
441 {
442 case EF_M68K_CF_ISA_A_NODIV:
443 features |= mcfisa_a;
444 break;
445 case EF_M68K_CF_ISA_A:
446 features |= mcfisa_a|mcfhwdiv;
447 break;
448 case EF_M68K_CF_ISA_A_PLUS:
449 features |= mcfisa_a|mcfisa_aa|mcfhwdiv|mcfusp;
450 break;
451 case EF_M68K_CF_ISA_B_NOUSP:
452 features |= mcfisa_a|mcfisa_b|mcfhwdiv;
453 break;
454 case EF_M68K_CF_ISA_B:
455 features |= mcfisa_a|mcfisa_b|mcfhwdiv|mcfusp;
456 break;
457 }
458 switch (eflags & EF_M68K_CF_MAC_MASK)
459 {
460 case EF_M68K_CF_MAC:
461 features |= mcfmac;
462 break;
463 case EF_M68K_CF_EMAC:
464 features |= mcfemac;
465 break;
466 }
467 if (eflags & EF_M68K_CF_FLOAT)
468 features |= cfloat;
469 }
470
471 mach = bfd_m68k_features_to_mach (features);
472 bfd_default_set_arch_mach (abfd, bfd_arch_m68k, mach);
473
474 return TRUE;
475 }
476
477 /* Keep m68k-specific flags in the ELF header. */
478 static bfd_boolean
479 elf32_m68k_set_private_flags (abfd, flags)
480 bfd *abfd;
481 flagword flags;
482 {
483 elf_elfheader (abfd)->e_flags = flags;
484 elf_flags_init (abfd) = TRUE;
485 return TRUE;
486 }
487
488 /* Merge backend specific data from an object file to the output
489 object file when linking. */
490 static bfd_boolean
491 elf32_m68k_merge_private_bfd_data (ibfd, obfd)
492 bfd *ibfd;
493 bfd *obfd;
494 {
495 flagword out_flags;
496 flagword in_flags;
497 flagword out_isa;
498 flagword in_isa;
499 const bfd_arch_info_type *arch_info;
500
501 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
502 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
503 return FALSE;
504
505 /* Get the merged machine. This checks for incompatibility between
506 Coldfire & non-Coldfire flags, incompability between different
507 Coldfire ISAs, and incompability between different MAC types. */
508 arch_info = bfd_arch_get_compatible (ibfd, obfd, FALSE);
509 if (!arch_info)
510 return FALSE;
511
512 bfd_set_arch_mach (obfd, bfd_arch_m68k, arch_info->mach);
513
514 in_flags = elf_elfheader (ibfd)->e_flags;
515 if (!elf_flags_init (obfd))
516 {
517 elf_flags_init (obfd) = TRUE;
518 out_flags = in_flags;
519 }
520 else
521 {
522 out_flags = elf_elfheader (obfd)->e_flags;
523 unsigned int variant_mask;
524
525 if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
526 variant_mask = 0;
527 else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
528 variant_mask = 0;
529 else if ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
530 variant_mask = 0;
531 else
532 variant_mask = EF_M68K_CF_ISA_MASK;
533
534 in_isa = (in_flags & variant_mask);
535 out_isa = (out_flags & variant_mask);
536 if (in_isa > out_isa)
537 out_flags ^= in_isa ^ out_isa;
538 if (((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32
539 && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
540 || ((in_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO
541 && (out_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32))
542 out_flags = EF_M68K_FIDO;
543 else
544 out_flags |= in_flags ^ in_isa;
545 }
546 elf_elfheader (obfd)->e_flags = out_flags;
547
548 return TRUE;
549 }
550
551 /* Display the flags field. */
552 static bfd_boolean
553 elf32_m68k_print_private_bfd_data (abfd, ptr)
554 bfd *abfd;
555 PTR ptr;
556 {
557 FILE *file = (FILE *) ptr;
558 flagword eflags = elf_elfheader (abfd)->e_flags;
559
560 BFD_ASSERT (abfd != NULL && ptr != NULL);
561
562 /* Print normal ELF private data. */
563 _bfd_elf_print_private_bfd_data (abfd, ptr);
564
565 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
566
567 /* xgettext:c-format */
568 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
569
570 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
571 fprintf (file, " [m68000]");
572 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
573 fprintf (file, " [cpu32]");
574 else if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
575 fprintf (file, " [fido]");
576 else
577 {
578 if ((eflags & EF_M68K_ARCH_MASK) == EF_M68K_CFV4E)
579 fprintf (file, " [cfv4e]");
580
581 if (eflags & EF_M68K_CF_ISA_MASK)
582 {
583 char const *isa = _("unknown");
584 char const *mac = _("unknown");
585 char const *additional = "";
586
587 switch (eflags & EF_M68K_CF_ISA_MASK)
588 {
589 case EF_M68K_CF_ISA_A_NODIV:
590 isa = "A";
591 additional = " [nodiv]";
592 break;
593 case EF_M68K_CF_ISA_A:
594 isa = "A";
595 break;
596 case EF_M68K_CF_ISA_A_PLUS:
597 isa = "A+";
598 break;
599 case EF_M68K_CF_ISA_B_NOUSP:
600 isa = "B";
601 additional = " [nousp]";
602 break;
603 case EF_M68K_CF_ISA_B:
604 isa = "B";
605 break;
606 }
607 fprintf (file, " [isa %s]%s", isa, additional);
608 if (eflags & EF_M68K_CF_FLOAT)
609 fprintf (file, " [float]");
610 switch (eflags & EF_M68K_CF_MAC_MASK)
611 {
612 case 0:
613 mac = NULL;
614 break;
615 case EF_M68K_CF_MAC:
616 mac = "mac";
617 break;
618 case EF_M68K_CF_EMAC:
619 mac = "emac";
620 break;
621 }
622 if (mac)
623 fprintf (file, " [%s]", mac);
624 }
625 }
626
627 fputc ('\n', file);
628
629 return TRUE;
630 }
631 /* Look through the relocs for a section during the first phase, and
632 allocate space in the global offset table or procedure linkage
633 table. */
634
635 static bfd_boolean
636 elf_m68k_check_relocs (abfd, info, sec, relocs)
637 bfd *abfd;
638 struct bfd_link_info *info;
639 asection *sec;
640 const Elf_Internal_Rela *relocs;
641 {
642 bfd *dynobj;
643 Elf_Internal_Shdr *symtab_hdr;
644 struct elf_link_hash_entry **sym_hashes;
645 bfd_signed_vma *local_got_refcounts;
646 const Elf_Internal_Rela *rel;
647 const Elf_Internal_Rela *rel_end;
648 asection *sgot;
649 asection *srelgot;
650 asection *sreloc;
651
652 if (info->relocatable)
653 return TRUE;
654
655 dynobj = elf_hash_table (info)->dynobj;
656 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
657 sym_hashes = elf_sym_hashes (abfd);
658 local_got_refcounts = elf_local_got_refcounts (abfd);
659
660 sgot = NULL;
661 srelgot = NULL;
662 sreloc = NULL;
663
664 rel_end = relocs + sec->reloc_count;
665 for (rel = relocs; rel < rel_end; rel++)
666 {
667 unsigned long r_symndx;
668 struct elf_link_hash_entry *h;
669
670 r_symndx = ELF32_R_SYM (rel->r_info);
671
672 if (r_symndx < symtab_hdr->sh_info)
673 h = NULL;
674 else
675 {
676 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
677 while (h->root.type == bfd_link_hash_indirect
678 || h->root.type == bfd_link_hash_warning)
679 h = (struct elf_link_hash_entry *) h->root.u.i.link;
680 }
681
682 switch (ELF32_R_TYPE (rel->r_info))
683 {
684 case R_68K_GOT8:
685 case R_68K_GOT16:
686 case R_68K_GOT32:
687 if (h != NULL
688 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
689 break;
690 /* Fall through. */
691 case R_68K_GOT8O:
692 case R_68K_GOT16O:
693 case R_68K_GOT32O:
694 /* This symbol requires a global offset table entry. */
695
696 if (dynobj == NULL)
697 {
698 /* Create the .got section. */
699 elf_hash_table (info)->dynobj = dynobj = abfd;
700 if (!_bfd_elf_create_got_section (dynobj, info))
701 return FALSE;
702 }
703
704 if (sgot == NULL)
705 {
706 sgot = bfd_get_section_by_name (dynobj, ".got");
707 BFD_ASSERT (sgot != NULL);
708 }
709
710 if (srelgot == NULL
711 && (h != NULL || info->shared))
712 {
713 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
714 if (srelgot == NULL)
715 {
716 srelgot = bfd_make_section_with_flags (dynobj,
717 ".rela.got",
718 (SEC_ALLOC
719 | SEC_LOAD
720 | SEC_HAS_CONTENTS
721 | SEC_IN_MEMORY
722 | SEC_LINKER_CREATED
723 | SEC_READONLY));
724 if (srelgot == NULL
725 || !bfd_set_section_alignment (dynobj, srelgot, 2))
726 return FALSE;
727 }
728 }
729
730 if (h != NULL)
731 {
732 if (h->got.refcount == 0)
733 {
734 /* Make sure this symbol is output as a dynamic symbol. */
735 if (h->dynindx == -1
736 && !h->forced_local)
737 {
738 if (!bfd_elf_link_record_dynamic_symbol (info, h))
739 return FALSE;
740 }
741
742 /* Allocate space in the .got section. */
743 sgot->size += 4;
744 /* Allocate relocation space. */
745 srelgot->size += sizeof (Elf32_External_Rela);
746 }
747 h->got.refcount++;
748 }
749 else
750 {
751 /* This is a global offset table entry for a local symbol. */
752 if (local_got_refcounts == NULL)
753 {
754 bfd_size_type size;
755
756 size = symtab_hdr->sh_info;
757 size *= sizeof (bfd_signed_vma);
758 local_got_refcounts = ((bfd_signed_vma *)
759 bfd_zalloc (abfd, size));
760 if (local_got_refcounts == NULL)
761 return FALSE;
762 elf_local_got_refcounts (abfd) = local_got_refcounts;
763 }
764 if (local_got_refcounts[r_symndx] == 0)
765 {
766 sgot->size += 4;
767 if (info->shared)
768 {
769 /* If we are generating a shared object, we need to
770 output a R_68K_RELATIVE reloc so that the dynamic
771 linker can adjust this GOT entry. */
772 srelgot->size += sizeof (Elf32_External_Rela);
773 }
774 }
775 local_got_refcounts[r_symndx]++;
776 }
777 break;
778
779 case R_68K_PLT8:
780 case R_68K_PLT16:
781 case R_68K_PLT32:
782 /* This symbol requires a procedure linkage table entry. We
783 actually build the entry in adjust_dynamic_symbol,
784 because this might be a case of linking PIC code which is
785 never referenced by a dynamic object, in which case we
786 don't need to generate a procedure linkage table entry
787 after all. */
788
789 /* If this is a local symbol, we resolve it directly without
790 creating a procedure linkage table entry. */
791 if (h == NULL)
792 continue;
793
794 h->needs_plt = 1;
795 h->plt.refcount++;
796 break;
797
798 case R_68K_PLT8O:
799 case R_68K_PLT16O:
800 case R_68K_PLT32O:
801 /* This symbol requires a procedure linkage table entry. */
802
803 if (h == NULL)
804 {
805 /* It does not make sense to have this relocation for a
806 local symbol. FIXME: does it? How to handle it if
807 it does make sense? */
808 bfd_set_error (bfd_error_bad_value);
809 return FALSE;
810 }
811
812 /* Make sure this symbol is output as a dynamic symbol. */
813 if (h->dynindx == -1
814 && !h->forced_local)
815 {
816 if (!bfd_elf_link_record_dynamic_symbol (info, h))
817 return FALSE;
818 }
819
820 h->needs_plt = 1;
821 h->plt.refcount++;
822 break;
823
824 case R_68K_PC8:
825 case R_68K_PC16:
826 case R_68K_PC32:
827 /* If we are creating a shared library and this is not a local
828 symbol, we need to copy the reloc into the shared library.
829 However when linking with -Bsymbolic and this is a global
830 symbol which is defined in an object we are including in the
831 link (i.e., DEF_REGULAR is set), then we can resolve the
832 reloc directly. At this point we have not seen all the input
833 files, so it is possible that DEF_REGULAR is not set now but
834 will be set later (it is never cleared). We account for that
835 possibility below by storing information in the
836 pcrel_relocs_copied field of the hash table entry. */
837 if (!(info->shared
838 && (sec->flags & SEC_ALLOC) != 0
839 && h != NULL
840 && (!info->symbolic
841 || h->root.type == bfd_link_hash_defweak
842 || !h->def_regular)))
843 {
844 if (h != NULL)
845 {
846 /* Make sure a plt entry is created for this symbol if
847 it turns out to be a function defined by a dynamic
848 object. */
849 h->plt.refcount++;
850 }
851 break;
852 }
853 /* Fall through. */
854 case R_68K_8:
855 case R_68K_16:
856 case R_68K_32:
857 if (h != NULL)
858 {
859 /* Make sure a plt entry is created for this symbol if it
860 turns out to be a function defined by a dynamic object. */
861 h->plt.refcount++;
862 }
863
864 /* If we are creating a shared library, we need to copy the
865 reloc into the shared library. */
866 if (info->shared
867 && (sec->flags & SEC_ALLOC) != 0)
868 {
869 /* When creating a shared object, we must copy these
870 reloc types into the output file. We create a reloc
871 section in dynobj and make room for this reloc. */
872 if (sreloc == NULL)
873 {
874 const char *name;
875
876 name = (bfd_elf_string_from_elf_section
877 (abfd,
878 elf_elfheader (abfd)->e_shstrndx,
879 elf_section_data (sec)->rel_hdr.sh_name));
880 if (name == NULL)
881 return FALSE;
882
883 BFD_ASSERT (CONST_STRNEQ (name, ".rela")
884 && strcmp (bfd_get_section_name (abfd, sec),
885 name + 5) == 0);
886
887 sreloc = bfd_get_section_by_name (dynobj, name);
888 if (sreloc == NULL)
889 {
890 sreloc = bfd_make_section_with_flags (dynobj,
891 name,
892 (SEC_ALLOC
893 | SEC_LOAD
894 | SEC_HAS_CONTENTS
895 | SEC_IN_MEMORY
896 | SEC_LINKER_CREATED
897 | SEC_READONLY));
898 if (sreloc == NULL
899 || !bfd_set_section_alignment (dynobj, sreloc, 2))
900 return FALSE;
901 }
902 elf_section_data (sec)->sreloc = sreloc;
903 }
904
905 if (sec->flags & SEC_READONLY
906 /* Don't set DF_TEXTREL yet for PC relative
907 relocations, they might be discarded later. */
908 && !(ELF32_R_TYPE (rel->r_info) == R_68K_PC8
909 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
910 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32))
911 info->flags |= DF_TEXTREL;
912
913 sreloc->size += sizeof (Elf32_External_Rela);
914
915 /* We count the number of PC relative relocations we have
916 entered for this symbol, so that we can discard them
917 again if, in the -Bsymbolic case, the symbol is later
918 defined by a regular object, or, in the normal shared
919 case, the symbol is forced to be local. Note that this
920 function is only called if we are using an m68kelf linker
921 hash table, which means that h is really a pointer to an
922 elf_m68k_link_hash_entry. */
923 if (ELF32_R_TYPE (rel->r_info) == R_68K_PC8
924 || ELF32_R_TYPE (rel->r_info) == R_68K_PC16
925 || ELF32_R_TYPE (rel->r_info) == R_68K_PC32)
926 {
927 struct elf_m68k_pcrel_relocs_copied *p;
928 struct elf_m68k_pcrel_relocs_copied **head;
929
930 if (h != NULL)
931 {
932 struct elf_m68k_link_hash_entry *eh
933 = elf_m68k_hash_entry (h);
934 head = &eh->pcrel_relocs_copied;
935 }
936 else
937 {
938 asection *s;
939 void *vpp;
940
941 s = (bfd_section_from_r_symndx
942 (abfd, &elf_m68k_hash_table (info)->sym_sec,
943 sec, r_symndx));
944 if (s == NULL)
945 return FALSE;
946
947 vpp = &elf_section_data (s)->local_dynrel;
948 head = (struct elf_m68k_pcrel_relocs_copied **) vpp;
949 }
950
951 for (p = *head; p != NULL; p = p->next)
952 if (p->section == sreloc)
953 break;
954
955 if (p == NULL)
956 {
957 p = ((struct elf_m68k_pcrel_relocs_copied *)
958 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
959 if (p == NULL)
960 return FALSE;
961 p->next = *head;
962 *head = p;
963 p->section = sreloc;
964 p->count = 0;
965 }
966
967 ++p->count;
968 }
969 }
970
971 break;
972
973 /* This relocation describes the C++ object vtable hierarchy.
974 Reconstruct it for later use during GC. */
975 case R_68K_GNU_VTINHERIT:
976 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
977 return FALSE;
978 break;
979
980 /* This relocation describes which C++ vtable entries are actually
981 used. Record for later use during GC. */
982 case R_68K_GNU_VTENTRY:
983 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
984 return FALSE;
985 break;
986
987 default:
988 break;
989 }
990 }
991
992 return TRUE;
993 }
994
995 /* Return the section that should be marked against GC for a given
996 relocation. */
997
998 static asection *
999 elf_m68k_gc_mark_hook (asection *sec,
1000 struct bfd_link_info *info,
1001 Elf_Internal_Rela *rel,
1002 struct elf_link_hash_entry *h,
1003 Elf_Internal_Sym *sym)
1004 {
1005 if (h != NULL)
1006 switch (ELF32_R_TYPE (rel->r_info))
1007 {
1008 case R_68K_GNU_VTINHERIT:
1009 case R_68K_GNU_VTENTRY:
1010 return NULL;
1011 }
1012
1013 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1014 }
1015
1016 /* Update the got entry reference counts for the section being removed. */
1017
1018 static bfd_boolean
1019 elf_m68k_gc_sweep_hook (bfd *abfd,
1020 struct bfd_link_info *info,
1021 asection *sec,
1022 const Elf_Internal_Rela *relocs)
1023 {
1024 Elf_Internal_Shdr *symtab_hdr;
1025 struct elf_link_hash_entry **sym_hashes;
1026 bfd_signed_vma *local_got_refcounts;
1027 const Elf_Internal_Rela *rel, *relend;
1028 bfd *dynobj;
1029 asection *sgot;
1030 asection *srelgot;
1031
1032 dynobj = elf_hash_table (info)->dynobj;
1033 if (dynobj == NULL)
1034 return TRUE;
1035
1036 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1037 sym_hashes = elf_sym_hashes (abfd);
1038 local_got_refcounts = elf_local_got_refcounts (abfd);
1039
1040 sgot = bfd_get_section_by_name (dynobj, ".got");
1041 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1042
1043 relend = relocs + sec->reloc_count;
1044 for (rel = relocs; rel < relend; rel++)
1045 {
1046 unsigned long r_symndx;
1047 struct elf_link_hash_entry *h = NULL;
1048
1049 r_symndx = ELF32_R_SYM (rel->r_info);
1050 if (r_symndx >= symtab_hdr->sh_info)
1051 {
1052 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1053 while (h->root.type == bfd_link_hash_indirect
1054 || h->root.type == bfd_link_hash_warning)
1055 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1056 }
1057
1058 switch (ELF32_R_TYPE (rel->r_info))
1059 {
1060 case R_68K_GOT8:
1061 case R_68K_GOT16:
1062 case R_68K_GOT32:
1063 case R_68K_GOT8O:
1064 case R_68K_GOT16O:
1065 case R_68K_GOT32O:
1066 if (h != NULL)
1067 {
1068 if (h->got.refcount > 0)
1069 {
1070 --h->got.refcount;
1071 if (h->got.refcount == 0)
1072 {
1073 /* We don't need the .got entry any more. */
1074 sgot->size -= 4;
1075 srelgot->size -= sizeof (Elf32_External_Rela);
1076 }
1077 }
1078 }
1079 else if (local_got_refcounts != NULL)
1080 {
1081 if (local_got_refcounts[r_symndx] > 0)
1082 {
1083 --local_got_refcounts[r_symndx];
1084 if (local_got_refcounts[r_symndx] == 0)
1085 {
1086 /* We don't need the .got entry any more. */
1087 sgot->size -= 4;
1088 if (info->shared)
1089 srelgot->size -= sizeof (Elf32_External_Rela);
1090 }
1091 }
1092 }
1093 break;
1094
1095 case R_68K_PLT8:
1096 case R_68K_PLT16:
1097 case R_68K_PLT32:
1098 case R_68K_PLT8O:
1099 case R_68K_PLT16O:
1100 case R_68K_PLT32O:
1101 case R_68K_PC8:
1102 case R_68K_PC16:
1103 case R_68K_PC32:
1104 case R_68K_8:
1105 case R_68K_16:
1106 case R_68K_32:
1107 if (h != NULL)
1108 {
1109 if (h->plt.refcount > 0)
1110 --h->plt.refcount;
1111 }
1112 break;
1113
1114 default:
1115 break;
1116 }
1117 }
1118
1119 return TRUE;
1120 }
1121 \f
1122 /* Return the type of PLT associated with OUTPUT_BFD. */
1123
1124 static const struct elf_m68k_plt_info *
1125 elf_m68k_get_plt_info (bfd *output_bfd)
1126 {
1127 unsigned int features;
1128
1129 features = bfd_m68k_mach_to_features (bfd_get_mach (output_bfd));
1130 if (features & cpu32)
1131 return &elf_cpu32_plt_info;
1132 if (features & mcfisa_b)
1133 return &elf_isab_plt_info;
1134 return &elf_m68k_plt_info;
1135 }
1136
1137 /* This function is called after all the input files have been read,
1138 and the input sections have been assigned to output sections.
1139 It's a convenient place to determine the PLT style. */
1140
1141 static bfd_boolean
1142 elf_m68k_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
1143 {
1144 elf_m68k_hash_table (info)->plt_info = elf_m68k_get_plt_info (output_bfd);
1145 return TRUE;
1146 }
1147
1148 /* Adjust a symbol defined by a dynamic object and referenced by a
1149 regular object. The current definition is in some section of the
1150 dynamic object, but we're not including those sections. We have to
1151 change the definition to something the rest of the link can
1152 understand. */
1153
1154 static bfd_boolean
1155 elf_m68k_adjust_dynamic_symbol (info, h)
1156 struct bfd_link_info *info;
1157 struct elf_link_hash_entry *h;
1158 {
1159 struct elf_m68k_link_hash_table *htab;
1160 bfd *dynobj;
1161 asection *s;
1162 unsigned int power_of_two;
1163
1164 htab = elf_m68k_hash_table (info);
1165 dynobj = elf_hash_table (info)->dynobj;
1166
1167 /* Make sure we know what is going on here. */
1168 BFD_ASSERT (dynobj != NULL
1169 && (h->needs_plt
1170 || h->u.weakdef != NULL
1171 || (h->def_dynamic
1172 && h->ref_regular
1173 && !h->def_regular)));
1174
1175 /* If this is a function, put it in the procedure linkage table. We
1176 will fill in the contents of the procedure linkage table later,
1177 when we know the address of the .got section. */
1178 if (h->type == STT_FUNC
1179 || h->needs_plt)
1180 {
1181 if ((h->plt.refcount <= 0
1182 || SYMBOL_CALLS_LOCAL (info, h)
1183 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1184 && h->root.type == bfd_link_hash_undefweak))
1185 /* We must always create the plt entry if it was referenced
1186 by a PLTxxO relocation. In this case we already recorded
1187 it as a dynamic symbol. */
1188 && h->dynindx == -1)
1189 {
1190 /* This case can occur if we saw a PLTxx reloc in an input
1191 file, but the symbol was never referred to by a dynamic
1192 object, or if all references were garbage collected. In
1193 such a case, we don't actually need to build a procedure
1194 linkage table, and we can just do a PCxx reloc instead. */
1195 h->plt.offset = (bfd_vma) -1;
1196 h->needs_plt = 0;
1197 return TRUE;
1198 }
1199
1200 /* Make sure this symbol is output as a dynamic symbol. */
1201 if (h->dynindx == -1
1202 && !h->forced_local)
1203 {
1204 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1205 return FALSE;
1206 }
1207
1208 s = bfd_get_section_by_name (dynobj, ".plt");
1209 BFD_ASSERT (s != NULL);
1210
1211 /* If this is the first .plt entry, make room for the special
1212 first entry. */
1213 if (s->size == 0)
1214 s->size = htab->plt_info->size;
1215
1216 /* If this symbol is not defined in a regular file, and we are
1217 not generating a shared library, then set the symbol to this
1218 location in the .plt. This is required to make function
1219 pointers compare as equal between the normal executable and
1220 the shared library. */
1221 if (!info->shared
1222 && !h->def_regular)
1223 {
1224 h->root.u.def.section = s;
1225 h->root.u.def.value = s->size;
1226 }
1227
1228 h->plt.offset = s->size;
1229
1230 /* Make room for this entry. */
1231 s->size += htab->plt_info->size;
1232
1233 /* We also need to make an entry in the .got.plt section, which
1234 will be placed in the .got section by the linker script. */
1235 s = bfd_get_section_by_name (dynobj, ".got.plt");
1236 BFD_ASSERT (s != NULL);
1237 s->size += 4;
1238
1239 /* We also need to make an entry in the .rela.plt section. */
1240 s = bfd_get_section_by_name (dynobj, ".rela.plt");
1241 BFD_ASSERT (s != NULL);
1242 s->size += sizeof (Elf32_External_Rela);
1243
1244 return TRUE;
1245 }
1246
1247 /* Reinitialize the plt offset now that it is not used as a reference
1248 count any more. */
1249 h->plt.offset = (bfd_vma) -1;
1250
1251 /* If this is a weak symbol, and there is a real definition, the
1252 processor independent code will have arranged for us to see the
1253 real definition first, and we can just use the same value. */
1254 if (h->u.weakdef != NULL)
1255 {
1256 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1257 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1258 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1259 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1260 return TRUE;
1261 }
1262
1263 /* This is a reference to a symbol defined by a dynamic object which
1264 is not a function. */
1265
1266 /* If we are creating a shared library, we must presume that the
1267 only references to the symbol are via the global offset table.
1268 For such cases we need not do anything here; the relocations will
1269 be handled correctly by relocate_section. */
1270 if (info->shared)
1271 return TRUE;
1272
1273 if (h->size == 0)
1274 {
1275 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1276 h->root.root.string);
1277 return TRUE;
1278 }
1279
1280 /* We must allocate the symbol in our .dynbss section, which will
1281 become part of the .bss section of the executable. There will be
1282 an entry for this symbol in the .dynsym section. The dynamic
1283 object will contain position independent code, so all references
1284 from the dynamic object to this symbol will go through the global
1285 offset table. The dynamic linker will use the .dynsym entry to
1286 determine the address it must put in the global offset table, so
1287 both the dynamic object and the regular object will refer to the
1288 same memory location for the variable. */
1289
1290 s = bfd_get_section_by_name (dynobj, ".dynbss");
1291 BFD_ASSERT (s != NULL);
1292
1293 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
1294 copy the initial value out of the dynamic object and into the
1295 runtime process image. We need to remember the offset into the
1296 .rela.bss section we are going to use. */
1297 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1298 {
1299 asection *srel;
1300
1301 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1302 BFD_ASSERT (srel != NULL);
1303 srel->size += sizeof (Elf32_External_Rela);
1304 h->needs_copy = 1;
1305 }
1306
1307 /* We need to figure out the alignment required for this symbol. I
1308 have no idea how ELF linkers handle this. */
1309 power_of_two = bfd_log2 (h->size);
1310 if (power_of_two > 3)
1311 power_of_two = 3;
1312
1313 /* Apply the required alignment. */
1314 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1315 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1316 {
1317 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
1318 return FALSE;
1319 }
1320
1321 /* Define the symbol as being at this point in the section. */
1322 h->root.u.def.section = s;
1323 h->root.u.def.value = s->size;
1324
1325 /* Increment the section size to make room for the symbol. */
1326 s->size += h->size;
1327
1328 return TRUE;
1329 }
1330
1331 /* Set the sizes of the dynamic sections. */
1332
1333 static bfd_boolean
1334 elf_m68k_size_dynamic_sections (output_bfd, info)
1335 bfd *output_bfd ATTRIBUTE_UNUSED;
1336 struct bfd_link_info *info;
1337 {
1338 bfd *dynobj;
1339 asection *s;
1340 bfd_boolean plt;
1341 bfd_boolean relocs;
1342
1343 dynobj = elf_hash_table (info)->dynobj;
1344 BFD_ASSERT (dynobj != NULL);
1345
1346 if (elf_hash_table (info)->dynamic_sections_created)
1347 {
1348 /* Set the contents of the .interp section to the interpreter. */
1349 if (info->executable)
1350 {
1351 s = bfd_get_section_by_name (dynobj, ".interp");
1352 BFD_ASSERT (s != NULL);
1353 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1354 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1355 }
1356 }
1357 else
1358 {
1359 /* We may have created entries in the .rela.got section.
1360 However, if we are not creating the dynamic sections, we will
1361 not actually use these entries. Reset the size of .rela.got,
1362 which will cause it to get stripped from the output file
1363 below. */
1364 s = bfd_get_section_by_name (dynobj, ".rela.got");
1365 if (s != NULL)
1366 s->size = 0;
1367 }
1368
1369 /* If this is a -Bsymbolic shared link, then we need to discard all
1370 PC relative relocs against symbols defined in a regular object.
1371 For the normal shared case we discard the PC relative relocs
1372 against symbols that have become local due to visibility changes.
1373 We allocated space for them in the check_relocs routine, but we
1374 will not fill them in in the relocate_section routine. */
1375 if (info->shared)
1376 elf_link_hash_traverse (elf_hash_table (info),
1377 elf_m68k_discard_copies,
1378 (PTR) info);
1379
1380 /* The check_relocs and adjust_dynamic_symbol entry points have
1381 determined the sizes of the various dynamic sections. Allocate
1382 memory for them. */
1383 plt = FALSE;
1384 relocs = FALSE;
1385 for (s = dynobj->sections; s != NULL; s = s->next)
1386 {
1387 const char *name;
1388
1389 if ((s->flags & SEC_LINKER_CREATED) == 0)
1390 continue;
1391
1392 /* It's OK to base decisions on the section name, because none
1393 of the dynobj section names depend upon the input files. */
1394 name = bfd_get_section_name (dynobj, s);
1395
1396 if (strcmp (name, ".plt") == 0)
1397 {
1398 /* Remember whether there is a PLT. */
1399 plt = s->size != 0;
1400 }
1401 else if (CONST_STRNEQ (name, ".rela"))
1402 {
1403 if (s->size != 0)
1404 {
1405 relocs = TRUE;
1406
1407 /* We use the reloc_count field as a counter if we need
1408 to copy relocs into the output file. */
1409 s->reloc_count = 0;
1410 }
1411 }
1412 else if (! CONST_STRNEQ (name, ".got")
1413 && strcmp (name, ".dynbss") != 0)
1414 {
1415 /* It's not one of our sections, so don't allocate space. */
1416 continue;
1417 }
1418
1419 if (s->size == 0)
1420 {
1421 /* If we don't need this section, strip it from the
1422 output file. This is mostly to handle .rela.bss and
1423 .rela.plt. We must create both sections in
1424 create_dynamic_sections, because they must be created
1425 before the linker maps input sections to output
1426 sections. The linker does that before
1427 adjust_dynamic_symbol is called, and it is that
1428 function which decides whether anything needs to go
1429 into these sections. */
1430 s->flags |= SEC_EXCLUDE;
1431 continue;
1432 }
1433
1434 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1435 continue;
1436
1437 /* Allocate memory for the section contents. */
1438 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1439 Unused entries should be reclaimed before the section's contents
1440 are written out, but at the moment this does not happen. Thus in
1441 order to prevent writing out garbage, we initialise the section's
1442 contents to zero. */
1443 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1444 if (s->contents == NULL)
1445 return FALSE;
1446 }
1447
1448 if (elf_hash_table (info)->dynamic_sections_created)
1449 {
1450 /* Add some entries to the .dynamic section. We fill in the
1451 values later, in elf_m68k_finish_dynamic_sections, but we
1452 must add the entries now so that we get the correct size for
1453 the .dynamic section. The DT_DEBUG entry is filled in by the
1454 dynamic linker and used by the debugger. */
1455 #define add_dynamic_entry(TAG, VAL) \
1456 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1457
1458 if (!info->shared)
1459 {
1460 if (!add_dynamic_entry (DT_DEBUG, 0))
1461 return FALSE;
1462 }
1463
1464 if (plt)
1465 {
1466 if (!add_dynamic_entry (DT_PLTGOT, 0)
1467 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1468 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1469 || !add_dynamic_entry (DT_JMPREL, 0))
1470 return FALSE;
1471 }
1472
1473 if (relocs)
1474 {
1475 if (!add_dynamic_entry (DT_RELA, 0)
1476 || !add_dynamic_entry (DT_RELASZ, 0)
1477 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1478 return FALSE;
1479 }
1480
1481 if ((info->flags & DF_TEXTREL) != 0)
1482 {
1483 if (!add_dynamic_entry (DT_TEXTREL, 0))
1484 return FALSE;
1485 }
1486 }
1487 #undef add_dynamic_entry
1488
1489 return TRUE;
1490 }
1491
1492 /* This function is called via elf_link_hash_traverse if we are
1493 creating a shared object. In the -Bsymbolic case it discards the
1494 space allocated to copy PC relative relocs against symbols which
1495 are defined in regular objects. For the normal shared case, it
1496 discards space for pc-relative relocs that have become local due to
1497 symbol visibility changes. We allocated space for them in the
1498 check_relocs routine, but we won't fill them in in the
1499 relocate_section routine.
1500
1501 We also check whether any of the remaining relocations apply
1502 against a readonly section, and set the DF_TEXTREL flag in this
1503 case. */
1504
1505 static bfd_boolean
1506 elf_m68k_discard_copies (h, inf)
1507 struct elf_link_hash_entry *h;
1508 PTR inf;
1509 {
1510 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1511 struct elf_m68k_pcrel_relocs_copied *s;
1512
1513 if (h->root.type == bfd_link_hash_warning)
1514 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1515
1516 if (!h->def_regular
1517 || (!info->symbolic
1518 && !h->forced_local))
1519 {
1520 if ((info->flags & DF_TEXTREL) == 0)
1521 {
1522 /* Look for relocations against read-only sections. */
1523 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
1524 s != NULL;
1525 s = s->next)
1526 if ((s->section->flags & SEC_READONLY) != 0)
1527 {
1528 info->flags |= DF_TEXTREL;
1529 break;
1530 }
1531 }
1532
1533 return TRUE;
1534 }
1535
1536 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
1537 s != NULL;
1538 s = s->next)
1539 s->section->size -= s->count * sizeof (Elf32_External_Rela);
1540
1541 return TRUE;
1542 }
1543
1544 /* Relocate an M68K ELF section. */
1545
1546 static bfd_boolean
1547 elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section,
1548 contents, relocs, local_syms, local_sections)
1549 bfd *output_bfd;
1550 struct bfd_link_info *info;
1551 bfd *input_bfd;
1552 asection *input_section;
1553 bfd_byte *contents;
1554 Elf_Internal_Rela *relocs;
1555 Elf_Internal_Sym *local_syms;
1556 asection **local_sections;
1557 {
1558 bfd *dynobj;
1559 Elf_Internal_Shdr *symtab_hdr;
1560 struct elf_link_hash_entry **sym_hashes;
1561 bfd_vma *local_got_offsets;
1562 asection *sgot;
1563 asection *splt;
1564 asection *sreloc;
1565 Elf_Internal_Rela *rel;
1566 Elf_Internal_Rela *relend;
1567
1568 if (info->relocatable)
1569 return TRUE;
1570
1571 dynobj = elf_hash_table (info)->dynobj;
1572 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1573 sym_hashes = elf_sym_hashes (input_bfd);
1574 local_got_offsets = elf_local_got_offsets (input_bfd);
1575
1576 sgot = NULL;
1577 splt = NULL;
1578 sreloc = NULL;
1579
1580 rel = relocs;
1581 relend = relocs + input_section->reloc_count;
1582 for (; rel < relend; rel++)
1583 {
1584 int r_type;
1585 reloc_howto_type *howto;
1586 unsigned long r_symndx;
1587 struct elf_link_hash_entry *h;
1588 Elf_Internal_Sym *sym;
1589 asection *sec;
1590 bfd_vma relocation;
1591 bfd_boolean unresolved_reloc;
1592 bfd_reloc_status_type r;
1593
1594 r_type = ELF32_R_TYPE (rel->r_info);
1595 if (r_type < 0 || r_type >= (int) R_68K_max)
1596 {
1597 bfd_set_error (bfd_error_bad_value);
1598 return FALSE;
1599 }
1600 howto = howto_table + r_type;
1601
1602 r_symndx = ELF32_R_SYM (rel->r_info);
1603
1604 h = NULL;
1605 sym = NULL;
1606 sec = NULL;
1607 unresolved_reloc = FALSE;
1608
1609 if (r_symndx < symtab_hdr->sh_info)
1610 {
1611 sym = local_syms + r_symndx;
1612 sec = local_sections[r_symndx];
1613 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1614 }
1615 else
1616 {
1617 bfd_boolean warned;
1618
1619 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1620 r_symndx, symtab_hdr, sym_hashes,
1621 h, sec, relocation,
1622 unresolved_reloc, warned);
1623 }
1624
1625 switch (r_type)
1626 {
1627 case R_68K_GOT8:
1628 case R_68K_GOT16:
1629 case R_68K_GOT32:
1630 /* Relocation is to the address of the entry for this symbol
1631 in the global offset table. */
1632 if (h != NULL
1633 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1634 break;
1635 /* Fall through. */
1636 case R_68K_GOT8O:
1637 case R_68K_GOT16O:
1638 case R_68K_GOT32O:
1639 /* Relocation is the offset of the entry for this symbol in
1640 the global offset table. */
1641
1642 {
1643 bfd_vma off;
1644
1645 if (sgot == NULL)
1646 {
1647 sgot = bfd_get_section_by_name (dynobj, ".got");
1648 BFD_ASSERT (sgot != NULL);
1649 }
1650
1651 if (h != NULL)
1652 {
1653 bfd_boolean dyn;
1654
1655 off = h->got.offset;
1656 BFD_ASSERT (off != (bfd_vma) -1);
1657
1658 dyn = elf_hash_table (info)->dynamic_sections_created;
1659 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1660 || (info->shared
1661 && (info->symbolic
1662 || h->dynindx == -1
1663 || h->forced_local)
1664 && h->def_regular))
1665 {
1666 /* This is actually a static link, or it is a
1667 -Bsymbolic link and the symbol is defined
1668 locally, or the symbol was forced to be local
1669 because of a version file.. We must initialize
1670 this entry in the global offset table. Since
1671 the offset must always be a multiple of 4, we
1672 use the least significant bit to record whether
1673 we have initialized it already.
1674
1675 When doing a dynamic link, we create a .rela.got
1676 relocation entry to initialize the value. This
1677 is done in the finish_dynamic_symbol routine. */
1678 if ((off & 1) != 0)
1679 off &= ~1;
1680 else
1681 {
1682 bfd_put_32 (output_bfd, relocation,
1683 sgot->contents + off);
1684 h->got.offset |= 1;
1685 }
1686 }
1687 else
1688 unresolved_reloc = FALSE;
1689 }
1690 else
1691 {
1692 BFD_ASSERT (local_got_offsets != NULL
1693 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1694
1695 off = local_got_offsets[r_symndx];
1696
1697 /* The offset must always be a multiple of 4. We use
1698 the least significant bit to record whether we have
1699 already generated the necessary reloc. */
1700 if ((off & 1) != 0)
1701 off &= ~1;
1702 else
1703 {
1704 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1705
1706 if (info->shared)
1707 {
1708 asection *s;
1709 Elf_Internal_Rela outrel;
1710 bfd_byte *loc;
1711
1712 s = bfd_get_section_by_name (dynobj, ".rela.got");
1713 BFD_ASSERT (s != NULL);
1714
1715 outrel.r_offset = (sgot->output_section->vma
1716 + sgot->output_offset
1717 + off);
1718 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1719 outrel.r_addend = relocation;
1720 loc = s->contents;
1721 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1722 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1723 }
1724
1725 local_got_offsets[r_symndx] |= 1;
1726 }
1727 }
1728
1729 relocation = sgot->output_offset + off;
1730 if (r_type == R_68K_GOT8O
1731 || r_type == R_68K_GOT16O
1732 || r_type == R_68K_GOT32O)
1733 {
1734 /* This relocation does not use the addend. */
1735 rel->r_addend = 0;
1736 }
1737 else
1738 relocation += sgot->output_section->vma;
1739 }
1740 break;
1741
1742 case R_68K_PLT8:
1743 case R_68K_PLT16:
1744 case R_68K_PLT32:
1745 /* Relocation is to the entry for this symbol in the
1746 procedure linkage table. */
1747
1748 /* Resolve a PLTxx reloc against a local symbol directly,
1749 without using the procedure linkage table. */
1750 if (h == NULL)
1751 break;
1752
1753 if (h->plt.offset == (bfd_vma) -1
1754 || !elf_hash_table (info)->dynamic_sections_created)
1755 {
1756 /* We didn't make a PLT entry for this symbol. This
1757 happens when statically linking PIC code, or when
1758 using -Bsymbolic. */
1759 break;
1760 }
1761
1762 if (splt == NULL)
1763 {
1764 splt = bfd_get_section_by_name (dynobj, ".plt");
1765 BFD_ASSERT (splt != NULL);
1766 }
1767
1768 relocation = (splt->output_section->vma
1769 + splt->output_offset
1770 + h->plt.offset);
1771 unresolved_reloc = FALSE;
1772 break;
1773
1774 case R_68K_PLT8O:
1775 case R_68K_PLT16O:
1776 case R_68K_PLT32O:
1777 /* Relocation is the offset of the entry for this symbol in
1778 the procedure linkage table. */
1779 BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
1780
1781 if (splt == NULL)
1782 {
1783 splt = bfd_get_section_by_name (dynobj, ".plt");
1784 BFD_ASSERT (splt != NULL);
1785 }
1786
1787 relocation = h->plt.offset;
1788 unresolved_reloc = FALSE;
1789
1790 /* This relocation does not use the addend. */
1791 rel->r_addend = 0;
1792
1793 break;
1794
1795 case R_68K_PC8:
1796 case R_68K_PC16:
1797 case R_68K_PC32:
1798 if (h == NULL
1799 || (info->shared
1800 && h->forced_local))
1801 break;
1802 /* Fall through. */
1803 case R_68K_8:
1804 case R_68K_16:
1805 case R_68K_32:
1806 if (info->shared
1807 && r_symndx != 0
1808 && (input_section->flags & SEC_ALLOC) != 0
1809 && (h == NULL
1810 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1811 || h->root.type != bfd_link_hash_undefweak)
1812 && ((r_type != R_68K_PC8
1813 && r_type != R_68K_PC16
1814 && r_type != R_68K_PC32)
1815 || (h != NULL
1816 && h->dynindx != -1
1817 && (!info->symbolic
1818 || !h->def_regular))))
1819 {
1820 Elf_Internal_Rela outrel;
1821 bfd_byte *loc;
1822 bfd_boolean skip, relocate;
1823
1824 /* When generating a shared object, these relocations
1825 are copied into the output file to be resolved at run
1826 time. */
1827
1828 skip = FALSE;
1829 relocate = FALSE;
1830
1831 outrel.r_offset =
1832 _bfd_elf_section_offset (output_bfd, info, input_section,
1833 rel->r_offset);
1834 if (outrel.r_offset == (bfd_vma) -1)
1835 skip = TRUE;
1836 else if (outrel.r_offset == (bfd_vma) -2)
1837 skip = TRUE, relocate = TRUE;
1838 outrel.r_offset += (input_section->output_section->vma
1839 + input_section->output_offset);
1840
1841 if (skip)
1842 memset (&outrel, 0, sizeof outrel);
1843 else if (h != NULL
1844 && h->dynindx != -1
1845 && (r_type == R_68K_PC8
1846 || r_type == R_68K_PC16
1847 || r_type == R_68K_PC32
1848 || !info->shared
1849 || !info->symbolic
1850 || !h->def_regular))
1851 {
1852 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1853 outrel.r_addend = rel->r_addend;
1854 }
1855 else
1856 {
1857 /* This symbol is local, or marked to become local. */
1858 outrel.r_addend = relocation + rel->r_addend;
1859
1860 if (r_type == R_68K_32)
1861 {
1862 relocate = TRUE;
1863 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1864 }
1865 else
1866 {
1867 long indx;
1868
1869 if (bfd_is_abs_section (sec))
1870 indx = 0;
1871 else if (sec == NULL || sec->owner == NULL)
1872 {
1873 bfd_set_error (bfd_error_bad_value);
1874 return FALSE;
1875 }
1876 else
1877 {
1878 asection *osec;
1879
1880 /* We are turning this relocation into one
1881 against a section symbol. It would be
1882 proper to subtract the symbol's value,
1883 osec->vma, from the emitted reloc addend,
1884 but ld.so expects buggy relocs. */
1885 osec = sec->output_section;
1886 indx = elf_section_data (osec)->dynindx;
1887 if (indx == 0)
1888 {
1889 struct elf_link_hash_table *htab;
1890 htab = elf_hash_table (info);
1891 osec = htab->text_index_section;
1892 indx = elf_section_data (osec)->dynindx;
1893 }
1894 BFD_ASSERT (indx != 0);
1895 }
1896
1897 outrel.r_info = ELF32_R_INFO (indx, r_type);
1898 }
1899 }
1900
1901 sreloc = elf_section_data (input_section)->sreloc;
1902 if (sreloc == NULL)
1903 abort ();
1904
1905 loc = sreloc->contents;
1906 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1907 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1908
1909 /* This reloc will be computed at runtime, so there's no
1910 need to do anything now, except for R_68K_32
1911 relocations that have been turned into
1912 R_68K_RELATIVE. */
1913 if (!relocate)
1914 continue;
1915 }
1916
1917 break;
1918
1919 case R_68K_GNU_VTINHERIT:
1920 case R_68K_GNU_VTENTRY:
1921 /* These are no-ops in the end. */
1922 continue;
1923
1924 default:
1925 break;
1926 }
1927
1928 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1929 because such sections are not SEC_ALLOC and thus ld.so will
1930 not process them. */
1931 if (unresolved_reloc
1932 && !((input_section->flags & SEC_DEBUGGING) != 0
1933 && h->def_dynamic))
1934 {
1935 (*_bfd_error_handler)
1936 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1937 input_bfd,
1938 input_section,
1939 (long) rel->r_offset,
1940 howto->name,
1941 h->root.root.string);
1942 return FALSE;
1943 }
1944
1945 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1946 contents, rel->r_offset,
1947 relocation, rel->r_addend);
1948
1949 if (r != bfd_reloc_ok)
1950 {
1951 const char *name;
1952
1953 if (h != NULL)
1954 name = h->root.root.string;
1955 else
1956 {
1957 name = bfd_elf_string_from_elf_section (input_bfd,
1958 symtab_hdr->sh_link,
1959 sym->st_name);
1960 if (name == NULL)
1961 return FALSE;
1962 if (*name == '\0')
1963 name = bfd_section_name (input_bfd, sec);
1964 }
1965
1966 if (r == bfd_reloc_overflow)
1967 {
1968 if (!(info->callbacks->reloc_overflow
1969 (info, (h ? &h->root : NULL), name, howto->name,
1970 (bfd_vma) 0, input_bfd, input_section,
1971 rel->r_offset)))
1972 return FALSE;
1973 }
1974 else
1975 {
1976 (*_bfd_error_handler)
1977 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
1978 input_bfd, input_section,
1979 (long) rel->r_offset, name, (int) r);
1980 return FALSE;
1981 }
1982 }
1983 }
1984
1985 return TRUE;
1986 }
1987
1988 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
1989 into section SEC. */
1990
1991 static void
1992 elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value)
1993 {
1994 /* Make VALUE PC-relative. */
1995 value -= sec->output_section->vma + offset;
1996
1997 /* Apply any in-place addend. */
1998 value += bfd_get_32 (sec->owner, sec->contents + offset);
1999
2000 bfd_put_32 (sec->owner, value, sec->contents + offset);
2001 }
2002
2003 /* Finish up dynamic symbol handling. We set the contents of various
2004 dynamic sections here. */
2005
2006 static bfd_boolean
2007 elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym)
2008 bfd *output_bfd;
2009 struct bfd_link_info *info;
2010 struct elf_link_hash_entry *h;
2011 Elf_Internal_Sym *sym;
2012 {
2013 bfd *dynobj;
2014
2015 dynobj = elf_hash_table (info)->dynobj;
2016
2017 if (h->plt.offset != (bfd_vma) -1)
2018 {
2019 const struct elf_m68k_plt_info *plt_info;
2020 asection *splt;
2021 asection *sgot;
2022 asection *srela;
2023 bfd_vma plt_index;
2024 bfd_vma got_offset;
2025 Elf_Internal_Rela rela;
2026 bfd_byte *loc;
2027
2028 /* This symbol has an entry in the procedure linkage table. Set
2029 it up. */
2030
2031 BFD_ASSERT (h->dynindx != -1);
2032
2033 plt_info = elf_m68k_hash_table (info)->plt_info;
2034 splt = bfd_get_section_by_name (dynobj, ".plt");
2035 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2036 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2037 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
2038
2039 /* Get the index in the procedure linkage table which
2040 corresponds to this symbol. This is the index of this symbol
2041 in all the symbols for which we are making plt entries. The
2042 first entry in the procedure linkage table is reserved. */
2043 plt_index = (h->plt.offset / plt_info->size) - 1;
2044
2045 /* Get the offset into the .got table of the entry that
2046 corresponds to this function. Each .got entry is 4 bytes.
2047 The first three are reserved. */
2048 got_offset = (plt_index + 3) * 4;
2049
2050 memcpy (splt->contents + h->plt.offset,
2051 plt_info->symbol_entry,
2052 plt_info->size);
2053
2054 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got,
2055 (sgot->output_section->vma
2056 + sgot->output_offset
2057 + got_offset));
2058
2059 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
2060 splt->contents
2061 + h->plt.offset
2062 + plt_info->symbol_resolve_entry + 2);
2063
2064 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt,
2065 splt->output_section->vma);
2066
2067 /* Fill in the entry in the global offset table. */
2068 bfd_put_32 (output_bfd,
2069 (splt->output_section->vma
2070 + splt->output_offset
2071 + h->plt.offset
2072 + plt_info->symbol_resolve_entry),
2073 sgot->contents + got_offset);
2074
2075 /* Fill in the entry in the .rela.plt section. */
2076 rela.r_offset = (sgot->output_section->vma
2077 + sgot->output_offset
2078 + got_offset);
2079 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
2080 rela.r_addend = 0;
2081 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
2082 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2083
2084 if (!h->def_regular)
2085 {
2086 /* Mark the symbol as undefined, rather than as defined in
2087 the .plt section. Leave the value alone. */
2088 sym->st_shndx = SHN_UNDEF;
2089 }
2090 }
2091
2092 if (h->got.offset != (bfd_vma) -1)
2093 {
2094 asection *sgot;
2095 asection *srela;
2096 Elf_Internal_Rela rela;
2097 bfd_byte *loc;
2098
2099 /* This symbol has an entry in the global offset table. Set it
2100 up. */
2101
2102 sgot = bfd_get_section_by_name (dynobj, ".got");
2103 srela = bfd_get_section_by_name (dynobj, ".rela.got");
2104 BFD_ASSERT (sgot != NULL && srela != NULL);
2105
2106 rela.r_offset = (sgot->output_section->vma
2107 + sgot->output_offset
2108 + (h->got.offset &~ (bfd_vma) 1));
2109
2110 /* If this is a -Bsymbolic link, and the symbol is defined
2111 locally, we just want to emit a RELATIVE reloc. Likewise if
2112 the symbol was forced to be local because of a version file.
2113 The entry in the global offset table will already have been
2114 initialized in the relocate_section function. */
2115 if (info->shared
2116 && (info->symbolic
2117 || h->dynindx == -1
2118 || h->forced_local)
2119 && h->def_regular)
2120 {
2121 rela.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
2122 rela.r_addend = bfd_get_signed_32 (output_bfd,
2123 (sgot->contents
2124 + (h->got.offset &~ (bfd_vma) 1)));
2125 }
2126 else
2127 {
2128 bfd_put_32 (output_bfd, (bfd_vma) 0,
2129 sgot->contents + (h->got.offset &~ (bfd_vma) 1));
2130 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
2131 rela.r_addend = 0;
2132 }
2133
2134 loc = srela->contents;
2135 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
2136 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2137 }
2138
2139 if (h->needs_copy)
2140 {
2141 asection *s;
2142 Elf_Internal_Rela rela;
2143 bfd_byte *loc;
2144
2145 /* This symbol needs a copy reloc. Set it up. */
2146
2147 BFD_ASSERT (h->dynindx != -1
2148 && (h->root.type == bfd_link_hash_defined
2149 || h->root.type == bfd_link_hash_defweak));
2150
2151 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2152 ".rela.bss");
2153 BFD_ASSERT (s != NULL);
2154
2155 rela.r_offset = (h->root.u.def.value
2156 + h->root.u.def.section->output_section->vma
2157 + h->root.u.def.section->output_offset);
2158 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
2159 rela.r_addend = 0;
2160 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
2161 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2162 }
2163
2164 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2165 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2166 || h == elf_hash_table (info)->hgot)
2167 sym->st_shndx = SHN_ABS;
2168
2169 return TRUE;
2170 }
2171
2172 /* Finish up the dynamic sections. */
2173
2174 static bfd_boolean
2175 elf_m68k_finish_dynamic_sections (output_bfd, info)
2176 bfd *output_bfd;
2177 struct bfd_link_info *info;
2178 {
2179 bfd *dynobj;
2180 asection *sgot;
2181 asection *sdyn;
2182
2183 dynobj = elf_hash_table (info)->dynobj;
2184
2185 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2186 BFD_ASSERT (sgot != NULL);
2187 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2188
2189 if (elf_hash_table (info)->dynamic_sections_created)
2190 {
2191 asection *splt;
2192 Elf32_External_Dyn *dyncon, *dynconend;
2193
2194 splt = bfd_get_section_by_name (dynobj, ".plt");
2195 BFD_ASSERT (splt != NULL && sdyn != NULL);
2196
2197 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2198 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2199 for (; dyncon < dynconend; dyncon++)
2200 {
2201 Elf_Internal_Dyn dyn;
2202 const char *name;
2203 asection *s;
2204
2205 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2206
2207 switch (dyn.d_tag)
2208 {
2209 default:
2210 break;
2211
2212 case DT_PLTGOT:
2213 name = ".got";
2214 goto get_vma;
2215 case DT_JMPREL:
2216 name = ".rela.plt";
2217 get_vma:
2218 s = bfd_get_section_by_name (output_bfd, name);
2219 BFD_ASSERT (s != NULL);
2220 dyn.d_un.d_ptr = s->vma;
2221 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2222 break;
2223
2224 case DT_PLTRELSZ:
2225 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2226 BFD_ASSERT (s != NULL);
2227 dyn.d_un.d_val = s->size;
2228 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2229 break;
2230
2231 case DT_RELASZ:
2232 /* The procedure linkage table relocs (DT_JMPREL) should
2233 not be included in the overall relocs (DT_RELA).
2234 Therefore, we override the DT_RELASZ entry here to
2235 make it not include the JMPREL relocs. Since the
2236 linker script arranges for .rela.plt to follow all
2237 other relocation sections, we don't have to worry
2238 about changing the DT_RELA entry. */
2239 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2240 if (s != NULL)
2241 dyn.d_un.d_val -= s->size;
2242 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2243 break;
2244 }
2245 }
2246
2247 /* Fill in the first entry in the procedure linkage table. */
2248 if (splt->size > 0)
2249 {
2250 const struct elf_m68k_plt_info *plt_info;
2251
2252 plt_info = elf_m68k_hash_table (info)->plt_info;
2253 memcpy (splt->contents, plt_info->plt0_entry, plt_info->size);
2254
2255 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4,
2256 (sgot->output_section->vma
2257 + sgot->output_offset
2258 + 4));
2259
2260 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8,
2261 (sgot->output_section->vma
2262 + sgot->output_offset
2263 + 8));
2264
2265 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2266 = plt_info->size;
2267 }
2268 }
2269
2270 /* Fill in the first three entries in the global offset table. */
2271 if (sgot->size > 0)
2272 {
2273 if (sdyn == NULL)
2274 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2275 else
2276 bfd_put_32 (output_bfd,
2277 sdyn->output_section->vma + sdyn->output_offset,
2278 sgot->contents);
2279 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2280 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2281 }
2282
2283 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2284
2285 return TRUE;
2286 }
2287
2288 /* Given a .data section and a .emreloc in-memory section, store
2289 relocation information into the .emreloc section which can be
2290 used at runtime to relocate the section. This is called by the
2291 linker when the --embedded-relocs switch is used. This is called
2292 after the add_symbols entry point has been called for all the
2293 objects, and before the final_link entry point is called. */
2294
2295 bfd_boolean
2296 bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
2297 bfd *abfd;
2298 struct bfd_link_info *info;
2299 asection *datasec;
2300 asection *relsec;
2301 char **errmsg;
2302 {
2303 Elf_Internal_Shdr *symtab_hdr;
2304 Elf_Internal_Sym *isymbuf = NULL;
2305 Elf_Internal_Rela *internal_relocs = NULL;
2306 Elf_Internal_Rela *irel, *irelend;
2307 bfd_byte *p;
2308 bfd_size_type amt;
2309
2310 BFD_ASSERT (! info->relocatable);
2311
2312 *errmsg = NULL;
2313
2314 if (datasec->reloc_count == 0)
2315 return TRUE;
2316
2317 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2318
2319 /* Get a copy of the native relocations. */
2320 internal_relocs = (_bfd_elf_link_read_relocs
2321 (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2322 info->keep_memory));
2323 if (internal_relocs == NULL)
2324 goto error_return;
2325
2326 amt = (bfd_size_type) datasec->reloc_count * 12;
2327 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2328 if (relsec->contents == NULL)
2329 goto error_return;
2330
2331 p = relsec->contents;
2332
2333 irelend = internal_relocs + datasec->reloc_count;
2334 for (irel = internal_relocs; irel < irelend; irel++, p += 12)
2335 {
2336 asection *targetsec;
2337
2338 /* We are going to write a four byte longword into the runtime
2339 reloc section. The longword will be the address in the data
2340 section which must be relocated. It is followed by the name
2341 of the target section NUL-padded or truncated to 8
2342 characters. */
2343
2344 /* We can only relocate absolute longword relocs at run time. */
2345 if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
2346 {
2347 *errmsg = _("unsupported reloc type");
2348 bfd_set_error (bfd_error_bad_value);
2349 goto error_return;
2350 }
2351
2352 /* Get the target section referred to by the reloc. */
2353 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2354 {
2355 /* A local symbol. */
2356 Elf_Internal_Sym *isym;
2357
2358 /* Read this BFD's local symbols if we haven't done so already. */
2359 if (isymbuf == NULL)
2360 {
2361 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2362 if (isymbuf == NULL)
2363 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2364 symtab_hdr->sh_info, 0,
2365 NULL, NULL, NULL);
2366 if (isymbuf == NULL)
2367 goto error_return;
2368 }
2369
2370 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2371 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2372 }
2373 else
2374 {
2375 unsigned long indx;
2376 struct elf_link_hash_entry *h;
2377
2378 /* An external symbol. */
2379 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2380 h = elf_sym_hashes (abfd)[indx];
2381 BFD_ASSERT (h != NULL);
2382 if (h->root.type == bfd_link_hash_defined
2383 || h->root.type == bfd_link_hash_defweak)
2384 targetsec = h->root.u.def.section;
2385 else
2386 targetsec = NULL;
2387 }
2388
2389 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
2390 memset (p + 4, 0, 8);
2391 if (targetsec != NULL)
2392 strncpy ((char *) p + 4, targetsec->output_section->name, 8);
2393 }
2394
2395 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2396 free (isymbuf);
2397 if (internal_relocs != NULL
2398 && elf_section_data (datasec)->relocs != internal_relocs)
2399 free (internal_relocs);
2400 return TRUE;
2401
2402 error_return:
2403 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2404 free (isymbuf);
2405 if (internal_relocs != NULL
2406 && elf_section_data (datasec)->relocs != internal_relocs)
2407 free (internal_relocs);
2408 return FALSE;
2409 }
2410
2411 static enum elf_reloc_type_class
2412 elf32_m68k_reloc_type_class (rela)
2413 const Elf_Internal_Rela *rela;
2414 {
2415 switch ((int) ELF32_R_TYPE (rela->r_info))
2416 {
2417 case R_68K_RELATIVE:
2418 return reloc_class_relative;
2419 case R_68K_JMP_SLOT:
2420 return reloc_class_plt;
2421 case R_68K_COPY:
2422 return reloc_class_copy;
2423 default:
2424 return reloc_class_normal;
2425 }
2426 }
2427
2428 /* Return address for Ith PLT stub in section PLT, for relocation REL
2429 or (bfd_vma) -1 if it should not be included. */
2430
2431 static bfd_vma
2432 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
2433 const arelent *rel ATTRIBUTE_UNUSED)
2434 {
2435 return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
2436 }
2437
2438 #define TARGET_BIG_SYM bfd_elf32_m68k_vec
2439 #define TARGET_BIG_NAME "elf32-m68k"
2440 #define ELF_MACHINE_CODE EM_68K
2441 #define ELF_MAXPAGESIZE 0x2000
2442 #define elf_backend_create_dynamic_sections \
2443 _bfd_elf_create_dynamic_sections
2444 #define bfd_elf32_bfd_link_hash_table_create \
2445 elf_m68k_link_hash_table_create
2446 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
2447
2448 #define elf_backend_check_relocs elf_m68k_check_relocs
2449 #define elf_backend_always_size_sections \
2450 elf_m68k_always_size_sections
2451 #define elf_backend_adjust_dynamic_symbol \
2452 elf_m68k_adjust_dynamic_symbol
2453 #define elf_backend_size_dynamic_sections \
2454 elf_m68k_size_dynamic_sections
2455 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
2456 #define elf_backend_relocate_section elf_m68k_relocate_section
2457 #define elf_backend_finish_dynamic_symbol \
2458 elf_m68k_finish_dynamic_symbol
2459 #define elf_backend_finish_dynamic_sections \
2460 elf_m68k_finish_dynamic_sections
2461 #define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook
2462 #define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook
2463 #define bfd_elf32_bfd_merge_private_bfd_data \
2464 elf32_m68k_merge_private_bfd_data
2465 #define bfd_elf32_bfd_set_private_flags \
2466 elf32_m68k_set_private_flags
2467 #define bfd_elf32_bfd_print_private_bfd_data \
2468 elf32_m68k_print_private_bfd_data
2469 #define elf_backend_reloc_type_class elf32_m68k_reloc_type_class
2470 #define elf_backend_plt_sym_val elf_m68k_plt_sym_val
2471 #define elf_backend_object_p elf32_m68k_object_p
2472
2473 #define elf_backend_can_gc_sections 1
2474 #define elf_backend_can_refcount 1
2475 #define elf_backend_want_got_plt 1
2476 #define elf_backend_plt_readonly 1
2477 #define elf_backend_want_plt_sym 0
2478 #define elf_backend_got_header_size 12
2479 #define elf_backend_rela_normal 1
2480
2481 #include "elf32-target.h"
git-cvsimport of binutils cvsroot