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