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


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