?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
daily update
[binutils.git] / bfd / elf32-m68k.c
blob580e4b5a30ffb1b7612f3136c9ec3e03c12c206b
1 /* Motorola 68k series support for 32-bit ELF
2 Copyright 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007 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 dynobj = elf_hash_table (info)->dynobj;
1569 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1570 sym_hashes = elf_sym_hashes (input_bfd);
1571 local_got_offsets = elf_local_got_offsets (input_bfd);
1572
1573 sgot = NULL;
1574 splt = NULL;
1575 sreloc = NULL;
1576
1577 rel = relocs;
1578 relend = relocs + input_section->reloc_count;
1579 for (; rel < relend; rel++)
1580 {
1581 int r_type;
1582 reloc_howto_type *howto;
1583 unsigned long r_symndx;
1584 struct elf_link_hash_entry *h;
1585 Elf_Internal_Sym *sym;
1586 asection *sec;
1587 bfd_vma relocation;
1588 bfd_boolean unresolved_reloc;
1589 bfd_reloc_status_type r;
1590
1591 r_type = ELF32_R_TYPE (rel->r_info);
1592 if (r_type < 0 || r_type >= (int) R_68K_max)
1593 {
1594 bfd_set_error (bfd_error_bad_value);
1595 return FALSE;
1596 }
1597 howto = howto_table + r_type;
1598
1599 r_symndx = ELF32_R_SYM (rel->r_info);
1600
1601 h = NULL;
1602 sym = NULL;
1603 sec = NULL;
1604 unresolved_reloc = FALSE;
1605
1606 if (r_symndx < symtab_hdr->sh_info)
1607 {
1608 sym = local_syms + r_symndx;
1609 sec = local_sections[r_symndx];
1610 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1611 }
1612 else
1613 {
1614 bfd_boolean warned;
1615
1616 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1617 r_symndx, symtab_hdr, sym_hashes,
1618 h, sec, relocation,
1619 unresolved_reloc, warned);
1620 }
1621
1622 if (sec != NULL && elf_discarded_section (sec))
1623 {
1624 /* For relocs against symbols from removed linkonce sections,
1625 or sections discarded by a linker script, we just want the
1626 section contents zeroed. Avoid any special processing. */
1627 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1628 rel->r_info = 0;
1629 rel->r_addend = 0;
1630 continue;
1631 }
1632
1633 if (info->relocatable)
1634 continue;
1635
1636 switch (r_type)
1637 {
1638 case R_68K_GOT8:
1639 case R_68K_GOT16:
1640 case R_68K_GOT32:
1641 /* Relocation is to the address of the entry for this symbol
1642 in the global offset table. */
1643 if (h != NULL
1644 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1645 break;
1646 /* Fall through. */
1647 case R_68K_GOT8O:
1648 case R_68K_GOT16O:
1649 case R_68K_GOT32O:
1650 /* Relocation is the offset of the entry for this symbol in
1651 the global offset table. */
1652
1653 {
1654 bfd_vma off;
1655
1656 if (sgot == NULL)
1657 {
1658 sgot = bfd_get_section_by_name (dynobj, ".got");
1659 BFD_ASSERT (sgot != NULL);
1660 }
1661
1662 if (h != NULL)
1663 {
1664 bfd_boolean dyn;
1665
1666 off = h->got.offset;
1667 BFD_ASSERT (off != (bfd_vma) -1);
1668
1669 dyn = elf_hash_table (info)->dynamic_sections_created;
1670 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1671 || (info->shared
1672 && (info->symbolic
1673 || h->dynindx == -1
1674 || h->forced_local)
1675 && h->def_regular))
1676 {
1677 /* This is actually a static link, or it is a
1678 -Bsymbolic link and the symbol is defined
1679 locally, or the symbol was forced to be local
1680 because of a version file.. We must initialize
1681 this entry in the global offset table. Since
1682 the offset must always be a multiple of 4, we
1683 use the least significant bit to record whether
1684 we have initialized it already.
1685
1686 When doing a dynamic link, we create a .rela.got
1687 relocation entry to initialize the value. This
1688 is done in the finish_dynamic_symbol routine. */
1689 if ((off & 1) != 0)
1690 off &= ~1;
1691 else
1692 {
1693 bfd_put_32 (output_bfd, relocation,
1694 sgot->contents + off);
1695 h->got.offset |= 1;
1696 }
1697 }
1698 else
1699 unresolved_reloc = FALSE;
1700 }
1701 else
1702 {
1703 BFD_ASSERT (local_got_offsets != NULL
1704 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1705
1706 off = local_got_offsets[r_symndx];
1707
1708 /* The offset must always be a multiple of 4. We use
1709 the least significant bit to record whether we have
1710 already generated the necessary reloc. */
1711 if ((off & 1) != 0)
1712 off &= ~1;
1713 else
1714 {
1715 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1716
1717 if (info->shared)
1718 {
1719 asection *s;
1720 Elf_Internal_Rela outrel;
1721 bfd_byte *loc;
1722
1723 s = bfd_get_section_by_name (dynobj, ".rela.got");
1724 BFD_ASSERT (s != NULL);
1725
1726 outrel.r_offset = (sgot->output_section->vma
1727 + sgot->output_offset
1728 + off);
1729 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1730 outrel.r_addend = relocation;
1731 loc = s->contents;
1732 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1733 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1734 }
1735
1736 local_got_offsets[r_symndx] |= 1;
1737 }
1738 }
1739
1740 relocation = sgot->output_offset + off;
1741 if (r_type == R_68K_GOT8O
1742 || r_type == R_68K_GOT16O
1743 || r_type == R_68K_GOT32O)
1744 {
1745 /* This relocation does not use the addend. */
1746 rel->r_addend = 0;
1747 }
1748 else
1749 relocation += sgot->output_section->vma;
1750 }
1751 break;
1752
1753 case R_68K_PLT8:
1754 case R_68K_PLT16:
1755 case R_68K_PLT32:
1756 /* Relocation is to the entry for this symbol in the
1757 procedure linkage table. */
1758
1759 /* Resolve a PLTxx reloc against a local symbol directly,
1760 without using the procedure linkage table. */
1761 if (h == NULL)
1762 break;
1763
1764 if (h->plt.offset == (bfd_vma) -1
1765 || !elf_hash_table (info)->dynamic_sections_created)
1766 {
1767 /* We didn't make a PLT entry for this symbol. This
1768 happens when statically linking PIC code, or when
1769 using -Bsymbolic. */
1770 break;
1771 }
1772
1773 if (splt == NULL)
1774 {
1775 splt = bfd_get_section_by_name (dynobj, ".plt");
1776 BFD_ASSERT (splt != NULL);
1777 }
1778
1779 relocation = (splt->output_section->vma
1780 + splt->output_offset
1781 + h->plt.offset);
1782 unresolved_reloc = FALSE;
1783 break;
1784
1785 case R_68K_PLT8O:
1786 case R_68K_PLT16O:
1787 case R_68K_PLT32O:
1788 /* Relocation is the offset of the entry for this symbol in
1789 the procedure linkage table. */
1790 BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
1791
1792 if (splt == NULL)
1793 {
1794 splt = bfd_get_section_by_name (dynobj, ".plt");
1795 BFD_ASSERT (splt != NULL);
1796 }
1797
1798 relocation = h->plt.offset;
1799 unresolved_reloc = FALSE;
1800
1801 /* This relocation does not use the addend. */
1802 rel->r_addend = 0;
1803
1804 break;
1805
1806 case R_68K_PC8:
1807 case R_68K_PC16:
1808 case R_68K_PC32:
1809 if (h == NULL
1810 || (info->shared
1811 && h->forced_local))
1812 break;
1813 /* Fall through. */
1814 case R_68K_8:
1815 case R_68K_16:
1816 case R_68K_32:
1817 if (info->shared
1818 && r_symndx != 0
1819 && (input_section->flags & SEC_ALLOC) != 0
1820 && (h == NULL
1821 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1822 || h->root.type != bfd_link_hash_undefweak)
1823 && ((r_type != R_68K_PC8
1824 && r_type != R_68K_PC16
1825 && r_type != R_68K_PC32)
1826 || (h != NULL
1827 && h->dynindx != -1
1828 && (!info->symbolic
1829 || !h->def_regular))))
1830 {
1831 Elf_Internal_Rela outrel;
1832 bfd_byte *loc;
1833 bfd_boolean skip, relocate;
1834
1835 /* When generating a shared object, these relocations
1836 are copied into the output file to be resolved at run
1837 time. */
1838
1839 skip = FALSE;
1840 relocate = FALSE;
1841
1842 outrel.r_offset =
1843 _bfd_elf_section_offset (output_bfd, info, input_section,
1844 rel->r_offset);
1845 if (outrel.r_offset == (bfd_vma) -1)
1846 skip = TRUE;
1847 else if (outrel.r_offset == (bfd_vma) -2)
1848 skip = TRUE, relocate = TRUE;
1849 outrel.r_offset += (input_section->output_section->vma
1850 + input_section->output_offset);
1851
1852 if (skip)
1853 memset (&outrel, 0, sizeof outrel);
1854 else if (h != NULL
1855 && h->dynindx != -1
1856 && (r_type == R_68K_PC8
1857 || r_type == R_68K_PC16
1858 || r_type == R_68K_PC32
1859 || !info->shared
1860 || !info->symbolic
1861 || !h->def_regular))
1862 {
1863 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1864 outrel.r_addend = rel->r_addend;
1865 }
1866 else
1867 {
1868 /* This symbol is local, or marked to become local. */
1869 outrel.r_addend = relocation + rel->r_addend;
1870
1871 if (r_type == R_68K_32)
1872 {
1873 relocate = TRUE;
1874 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1875 }
1876 else
1877 {
1878 long indx;
1879
1880 if (bfd_is_abs_section (sec))
1881 indx = 0;
1882 else if (sec == NULL || sec->owner == NULL)
1883 {
1884 bfd_set_error (bfd_error_bad_value);
1885 return FALSE;
1886 }
1887 else
1888 {
1889 asection *osec;
1890
1891 /* We are turning this relocation into one
1892 against a section symbol. It would be
1893 proper to subtract the symbol's value,
1894 osec->vma, from the emitted reloc addend,
1895 but ld.so expects buggy relocs. */
1896 osec = sec->output_section;
1897 indx = elf_section_data (osec)->dynindx;
1898 if (indx == 0)
1899 {
1900 struct elf_link_hash_table *htab;
1901 htab = elf_hash_table (info);
1902 osec = htab->text_index_section;
1903 indx = elf_section_data (osec)->dynindx;
1904 }
1905 BFD_ASSERT (indx != 0);
1906 }
1907
1908 outrel.r_info = ELF32_R_INFO (indx, r_type);
1909 }
1910 }
1911
1912 sreloc = elf_section_data (input_section)->sreloc;
1913 if (sreloc == NULL)
1914 abort ();
1915
1916 loc = sreloc->contents;
1917 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1918 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1919
1920 /* This reloc will be computed at runtime, so there's no
1921 need to do anything now, except for R_68K_32
1922 relocations that have been turned into
1923 R_68K_RELATIVE. */
1924 if (!relocate)
1925 continue;
1926 }
1927
1928 break;
1929
1930 case R_68K_GNU_VTINHERIT:
1931 case R_68K_GNU_VTENTRY:
1932 /* These are no-ops in the end. */
1933 continue;
1934
1935 default:
1936 break;
1937 }
1938
1939 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1940 because such sections are not SEC_ALLOC and thus ld.so will
1941 not process them. */
1942 if (unresolved_reloc
1943 && !((input_section->flags & SEC_DEBUGGING) != 0
1944 && h->def_dynamic))
1945 {
1946 (*_bfd_error_handler)
1947 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1948 input_bfd,
1949 input_section,
1950 (long) rel->r_offset,
1951 howto->name,
1952 h->root.root.string);
1953 return FALSE;
1954 }
1955
1956 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1957 contents, rel->r_offset,
1958 relocation, rel->r_addend);
1959
1960 if (r != bfd_reloc_ok)
1961 {
1962 const char *name;
1963
1964 if (h != NULL)
1965 name = h->root.root.string;
1966 else
1967 {
1968 name = bfd_elf_string_from_elf_section (input_bfd,
1969 symtab_hdr->sh_link,
1970 sym->st_name);
1971 if (name == NULL)
1972 return FALSE;
1973 if (*name == '\0')
1974 name = bfd_section_name (input_bfd, sec);
1975 }
1976
1977 if (r == bfd_reloc_overflow)
1978 {
1979 if (!(info->callbacks->reloc_overflow
1980 (info, (h ? &h->root : NULL), name, howto->name,
1981 (bfd_vma) 0, input_bfd, input_section,
1982 rel->r_offset)))
1983 return FALSE;
1984 }
1985 else
1986 {
1987 (*_bfd_error_handler)
1988 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
1989 input_bfd, input_section,
1990 (long) rel->r_offset, name, (int) r);
1991 return FALSE;
1992 }
1993 }
1994 }
1995
1996 return TRUE;
1997 }
1998
1999 /* Install an M_68K_PC32 relocation against VALUE at offset OFFSET
2000 into section SEC. */
2001
2002 static void
2003 elf_m68k_install_pc32 (asection *sec, bfd_vma offset, bfd_vma value)
2004 {
2005 /* Make VALUE PC-relative. */
2006 value -= sec->output_section->vma + offset;
2007
2008 /* Apply any in-place addend. */
2009 value += bfd_get_32 (sec->owner, sec->contents + offset);
2010
2011 bfd_put_32 (sec->owner, value, sec->contents + offset);
2012 }
2013
2014 /* Finish up dynamic symbol handling. We set the contents of various
2015 dynamic sections here. */
2016
2017 static bfd_boolean
2018 elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym)
2019 bfd *output_bfd;
2020 struct bfd_link_info *info;
2021 struct elf_link_hash_entry *h;
2022 Elf_Internal_Sym *sym;
2023 {
2024 bfd *dynobj;
2025
2026 dynobj = elf_hash_table (info)->dynobj;
2027
2028 if (h->plt.offset != (bfd_vma) -1)
2029 {
2030 const struct elf_m68k_plt_info *plt_info;
2031 asection *splt;
2032 asection *sgot;
2033 asection *srela;
2034 bfd_vma plt_index;
2035 bfd_vma got_offset;
2036 Elf_Internal_Rela rela;
2037 bfd_byte *loc;
2038
2039 /* This symbol has an entry in the procedure linkage table. Set
2040 it up. */
2041
2042 BFD_ASSERT (h->dynindx != -1);
2043
2044 plt_info = elf_m68k_hash_table (info)->plt_info;
2045 splt = bfd_get_section_by_name (dynobj, ".plt");
2046 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2047 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2048 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
2049
2050 /* Get the index in the procedure linkage table which
2051 corresponds to this symbol. This is the index of this symbol
2052 in all the symbols for which we are making plt entries. The
2053 first entry in the procedure linkage table is reserved. */
2054 plt_index = (h->plt.offset / plt_info->size) - 1;
2055
2056 /* Get the offset into the .got table of the entry that
2057 corresponds to this function. Each .got entry is 4 bytes.
2058 The first three are reserved. */
2059 got_offset = (plt_index + 3) * 4;
2060
2061 memcpy (splt->contents + h->plt.offset,
2062 plt_info->symbol_entry,
2063 plt_info->size);
2064
2065 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.got,
2066 (sgot->output_section->vma
2067 + sgot->output_offset
2068 + got_offset));
2069
2070 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
2071 splt->contents
2072 + h->plt.offset
2073 + plt_info->symbol_resolve_entry + 2);
2074
2075 elf_m68k_install_pc32 (splt, h->plt.offset + plt_info->symbol_relocs.plt,
2076 splt->output_section->vma);
2077
2078 /* Fill in the entry in the global offset table. */
2079 bfd_put_32 (output_bfd,
2080 (splt->output_section->vma
2081 + splt->output_offset
2082 + h->plt.offset
2083 + plt_info->symbol_resolve_entry),
2084 sgot->contents + got_offset);
2085
2086 /* Fill in the entry in the .rela.plt section. */
2087 rela.r_offset = (sgot->output_section->vma
2088 + sgot->output_offset
2089 + got_offset);
2090 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
2091 rela.r_addend = 0;
2092 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
2093 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2094
2095 if (!h->def_regular)
2096 {
2097 /* Mark the symbol as undefined, rather than as defined in
2098 the .plt section. Leave the value alone. */
2099 sym->st_shndx = SHN_UNDEF;
2100 }
2101 }
2102
2103 if (h->got.offset != (bfd_vma) -1)
2104 {
2105 asection *sgot;
2106 asection *srela;
2107 Elf_Internal_Rela rela;
2108 bfd_byte *loc;
2109
2110 /* This symbol has an entry in the global offset table. Set it
2111 up. */
2112
2113 sgot = bfd_get_section_by_name (dynobj, ".got");
2114 srela = bfd_get_section_by_name (dynobj, ".rela.got");
2115 BFD_ASSERT (sgot != NULL && srela != NULL);
2116
2117 rela.r_offset = (sgot->output_section->vma
2118 + sgot->output_offset
2119 + (h->got.offset &~ (bfd_vma) 1));
2120
2121 /* If this is a -Bsymbolic link, and the symbol is defined
2122 locally, we just want to emit a RELATIVE reloc. Likewise if
2123 the symbol was forced to be local because of a version file.
2124 The entry in the global offset table will already have been
2125 initialized in the relocate_section function. */
2126 if (info->shared
2127 && (info->symbolic
2128 || h->dynindx == -1
2129 || h->forced_local)
2130 && h->def_regular)
2131 {
2132 rela.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
2133 rela.r_addend = bfd_get_signed_32 (output_bfd,
2134 (sgot->contents
2135 + (h->got.offset &~ (bfd_vma) 1)));
2136 }
2137 else
2138 {
2139 bfd_put_32 (output_bfd, (bfd_vma) 0,
2140 sgot->contents + (h->got.offset &~ (bfd_vma) 1));
2141 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
2142 rela.r_addend = 0;
2143 }
2144
2145 loc = srela->contents;
2146 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
2147 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2148 }
2149
2150 if (h->needs_copy)
2151 {
2152 asection *s;
2153 Elf_Internal_Rela rela;
2154 bfd_byte *loc;
2155
2156 /* This symbol needs a copy reloc. Set it up. */
2157
2158 BFD_ASSERT (h->dynindx != -1
2159 && (h->root.type == bfd_link_hash_defined
2160 || h->root.type == bfd_link_hash_defweak));
2161
2162 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2163 ".rela.bss");
2164 BFD_ASSERT (s != NULL);
2165
2166 rela.r_offset = (h->root.u.def.value
2167 + h->root.u.def.section->output_section->vma
2168 + h->root.u.def.section->output_offset);
2169 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
2170 rela.r_addend = 0;
2171 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
2172 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2173 }
2174
2175 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2176 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2177 || h == elf_hash_table (info)->hgot)
2178 sym->st_shndx = SHN_ABS;
2179
2180 return TRUE;
2181 }
2182
2183 /* Finish up the dynamic sections. */
2184
2185 static bfd_boolean
2186 elf_m68k_finish_dynamic_sections (output_bfd, info)
2187 bfd *output_bfd;
2188 struct bfd_link_info *info;
2189 {
2190 bfd *dynobj;
2191 asection *sgot;
2192 asection *sdyn;
2193
2194 dynobj = elf_hash_table (info)->dynobj;
2195
2196 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2197 BFD_ASSERT (sgot != NULL);
2198 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2199
2200 if (elf_hash_table (info)->dynamic_sections_created)
2201 {
2202 asection *splt;
2203 Elf32_External_Dyn *dyncon, *dynconend;
2204
2205 splt = bfd_get_section_by_name (dynobj, ".plt");
2206 BFD_ASSERT (splt != NULL && sdyn != NULL);
2207
2208 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2209 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2210 for (; dyncon < dynconend; dyncon++)
2211 {
2212 Elf_Internal_Dyn dyn;
2213 const char *name;
2214 asection *s;
2215
2216 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2217
2218 switch (dyn.d_tag)
2219 {
2220 default:
2221 break;
2222
2223 case DT_PLTGOT:
2224 name = ".got";
2225 goto get_vma;
2226 case DT_JMPREL:
2227 name = ".rela.plt";
2228 get_vma:
2229 s = bfd_get_section_by_name (output_bfd, name);
2230 BFD_ASSERT (s != NULL);
2231 dyn.d_un.d_ptr = s->vma;
2232 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2233 break;
2234
2235 case DT_PLTRELSZ:
2236 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2237 BFD_ASSERT (s != NULL);
2238 dyn.d_un.d_val = s->size;
2239 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2240 break;
2241
2242 case DT_RELASZ:
2243 /* The procedure linkage table relocs (DT_JMPREL) should
2244 not be included in the overall relocs (DT_RELA).
2245 Therefore, we override the DT_RELASZ entry here to
2246 make it not include the JMPREL relocs. Since the
2247 linker script arranges for .rela.plt to follow all
2248 other relocation sections, we don't have to worry
2249 about changing the DT_RELA entry. */
2250 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2251 if (s != NULL)
2252 dyn.d_un.d_val -= s->size;
2253 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2254 break;
2255 }
2256 }
2257
2258 /* Fill in the first entry in the procedure linkage table. */
2259 if (splt->size > 0)
2260 {
2261 const struct elf_m68k_plt_info *plt_info;
2262
2263 plt_info = elf_m68k_hash_table (info)->plt_info;
2264 memcpy (splt->contents, plt_info->plt0_entry, plt_info->size);
2265
2266 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got4,
2267 (sgot->output_section->vma
2268 + sgot->output_offset
2269 + 4));
2270
2271 elf_m68k_install_pc32 (splt, plt_info->plt0_relocs.got8,
2272 (sgot->output_section->vma
2273 + sgot->output_offset
2274 + 8));
2275
2276 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2277 = plt_info->size;
2278 }
2279 }
2280
2281 /* Fill in the first three entries in the global offset table. */
2282 if (sgot->size > 0)
2283 {
2284 if (sdyn == NULL)
2285 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2286 else
2287 bfd_put_32 (output_bfd,
2288 sdyn->output_section->vma + sdyn->output_offset,
2289 sgot->contents);
2290 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2291 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2292 }
2293
2294 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2295
2296 return TRUE;
2297 }
2298
2299 /* Given a .data section and a .emreloc in-memory section, store
2300 relocation information into the .emreloc section which can be
2301 used at runtime to relocate the section. This is called by the
2302 linker when the --embedded-relocs switch is used. This is called
2303 after the add_symbols entry point has been called for all the
2304 objects, and before the final_link entry point is called. */
2305
2306 bfd_boolean
2307 bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
2308 bfd *abfd;
2309 struct bfd_link_info *info;
2310 asection *datasec;
2311 asection *relsec;
2312 char **errmsg;
2313 {
2314 Elf_Internal_Shdr *symtab_hdr;
2315 Elf_Internal_Sym *isymbuf = NULL;
2316 Elf_Internal_Rela *internal_relocs = NULL;
2317 Elf_Internal_Rela *irel, *irelend;
2318 bfd_byte *p;
2319 bfd_size_type amt;
2320
2321 BFD_ASSERT (! info->relocatable);
2322
2323 *errmsg = NULL;
2324
2325 if (datasec->reloc_count == 0)
2326 return TRUE;
2327
2328 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2329
2330 /* Get a copy of the native relocations. */
2331 internal_relocs = (_bfd_elf_link_read_relocs
2332 (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2333 info->keep_memory));
2334 if (internal_relocs == NULL)
2335 goto error_return;
2336
2337 amt = (bfd_size_type) datasec->reloc_count * 12;
2338 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2339 if (relsec->contents == NULL)
2340 goto error_return;
2341
2342 p = relsec->contents;
2343
2344 irelend = internal_relocs + datasec->reloc_count;
2345 for (irel = internal_relocs; irel < irelend; irel++, p += 12)
2346 {
2347 asection *targetsec;
2348
2349 /* We are going to write a four byte longword into the runtime
2350 reloc section. The longword will be the address in the data
2351 section which must be relocated. It is followed by the name
2352 of the target section NUL-padded or truncated to 8
2353 characters. */
2354
2355 /* We can only relocate absolute longword relocs at run time. */
2356 if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
2357 {
2358 *errmsg = _("unsupported reloc type");
2359 bfd_set_error (bfd_error_bad_value);
2360 goto error_return;
2361 }
2362
2363 /* Get the target section referred to by the reloc. */
2364 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2365 {
2366 /* A local symbol. */
2367 Elf_Internal_Sym *isym;
2368
2369 /* Read this BFD's local symbols if we haven't done so already. */
2370 if (isymbuf == NULL)
2371 {
2372 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2373 if (isymbuf == NULL)
2374 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2375 symtab_hdr->sh_info, 0,
2376 NULL, NULL, NULL);
2377 if (isymbuf == NULL)
2378 goto error_return;
2379 }
2380
2381 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2382 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2383 }
2384 else
2385 {
2386 unsigned long indx;
2387 struct elf_link_hash_entry *h;
2388
2389 /* An external symbol. */
2390 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2391 h = elf_sym_hashes (abfd)[indx];
2392 BFD_ASSERT (h != NULL);
2393 if (h->root.type == bfd_link_hash_defined
2394 || h->root.type == bfd_link_hash_defweak)
2395 targetsec = h->root.u.def.section;
2396 else
2397 targetsec = NULL;
2398 }
2399
2400 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
2401 memset (p + 4, 0, 8);
2402 if (targetsec != NULL)
2403 strncpy ((char *) p + 4, targetsec->output_section->name, 8);
2404 }
2405
2406 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2407 free (isymbuf);
2408 if (internal_relocs != NULL
2409 && elf_section_data (datasec)->relocs != internal_relocs)
2410 free (internal_relocs);
2411 return TRUE;
2412
2413 error_return:
2414 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2415 free (isymbuf);
2416 if (internal_relocs != NULL
2417 && elf_section_data (datasec)->relocs != internal_relocs)
2418 free (internal_relocs);
2419 return FALSE;
2420 }
2421
2422 static enum elf_reloc_type_class
2423 elf32_m68k_reloc_type_class (rela)
2424 const Elf_Internal_Rela *rela;
2425 {
2426 switch ((int) ELF32_R_TYPE (rela->r_info))
2427 {
2428 case R_68K_RELATIVE:
2429 return reloc_class_relative;
2430 case R_68K_JMP_SLOT:
2431 return reloc_class_plt;
2432 case R_68K_COPY:
2433 return reloc_class_copy;
2434 default:
2435 return reloc_class_normal;
2436 }
2437 }
2438
2439 /* Return address for Ith PLT stub in section PLT, for relocation REL
2440 or (bfd_vma) -1 if it should not be included. */
2441
2442 static bfd_vma
2443 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
2444 const arelent *rel ATTRIBUTE_UNUSED)
2445 {
2446 return plt->vma + (i + 1) * elf_m68k_get_plt_info (plt->owner)->size;
2447 }
2448
2449 #define TARGET_BIG_SYM bfd_elf32_m68k_vec
2450 #define TARGET_BIG_NAME "elf32-m68k"
2451 #define ELF_MACHINE_CODE EM_68K
2452 #define ELF_MAXPAGESIZE 0x2000
2453 #define elf_backend_create_dynamic_sections \
2454 _bfd_elf_create_dynamic_sections
2455 #define bfd_elf32_bfd_link_hash_table_create \
2456 elf_m68k_link_hash_table_create
2457 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
2458
2459 #define elf_backend_check_relocs elf_m68k_check_relocs
2460 #define elf_backend_always_size_sections \
2461 elf_m68k_always_size_sections
2462 #define elf_backend_adjust_dynamic_symbol \
2463 elf_m68k_adjust_dynamic_symbol
2464 #define elf_backend_size_dynamic_sections \
2465 elf_m68k_size_dynamic_sections
2466 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
2467 #define elf_backend_relocate_section elf_m68k_relocate_section
2468 #define elf_backend_finish_dynamic_symbol \
2469 elf_m68k_finish_dynamic_symbol
2470 #define elf_backend_finish_dynamic_sections \
2471 elf_m68k_finish_dynamic_sections
2472 #define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook
2473 #define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook
2474 #define bfd_elf32_bfd_merge_private_bfd_data \
2475 elf32_m68k_merge_private_bfd_data
2476 #define bfd_elf32_bfd_set_private_flags \
2477 elf32_m68k_set_private_flags
2478 #define bfd_elf32_bfd_print_private_bfd_data \
2479 elf32_m68k_print_private_bfd_data
2480 #define elf_backend_reloc_type_class elf32_m68k_reloc_type_class
2481 #define elf_backend_plt_sym_val elf_m68k_plt_sym_val
2482 #define elf_backend_object_p elf32_m68k_object_p
2483
2484 #define elf_backend_can_gc_sections 1
2485 #define elf_backend_can_refcount 1
2486 #define elf_backend_want_got_plt 1
2487 #define elf_backend_plt_readonly 1
2488 #define elf_backend_want_plt_sym 0
2489 #define elf_backend_got_header_size 12
2490 #define elf_backend_rela_normal 1
2491
2492 #include "elf32-target.h"
git-cvsimport of binutils cvsroot