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


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