?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merge from gcc
[binutils.git] / bfd / elf32-m68k.c
blob146a86d312038476eb64f5585492286133312898
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 if (h->size == 0)
1085 {
1086 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1087 h->root.root.string);
1088 return TRUE;
1089 }
1090
1091 /* We must allocate the symbol in our .dynbss section, which will
1092 become part of the .bss section of the executable. There will be
1093 an entry for this symbol in the .dynsym section. The dynamic
1094 object will contain position independent code, so all references
1095 from the dynamic object to this symbol will go through the global
1096 offset table. The dynamic linker will use the .dynsym entry to
1097 determine the address it must put in the global offset table, so
1098 both the dynamic object and the regular object will refer to the
1099 same memory location for the variable. */
1100
1101 s = bfd_get_section_by_name (dynobj, ".dynbss");
1102 BFD_ASSERT (s != NULL);
1103
1104 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
1105 copy the initial value out of the dynamic object and into the
1106 runtime process image. We need to remember the offset into the
1107 .rela.bss section we are going to use. */
1108 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1109 {
1110 asection *srel;
1111
1112 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1113 BFD_ASSERT (srel != NULL);
1114 srel->size += sizeof (Elf32_External_Rela);
1115 h->needs_copy = 1;
1116 }
1117
1118 /* We need to figure out the alignment required for this symbol. I
1119 have no idea how ELF linkers handle this. */
1120 power_of_two = bfd_log2 (h->size);
1121 if (power_of_two > 3)
1122 power_of_two = 3;
1123
1124 /* Apply the required alignment. */
1125 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1126 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1127 {
1128 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
1129 return FALSE;
1130 }
1131
1132 /* Define the symbol as being at this point in the section. */
1133 h->root.u.def.section = s;
1134 h->root.u.def.value = s->size;
1135
1136 /* Increment the section size to make room for the symbol. */
1137 s->size += h->size;
1138
1139 return TRUE;
1140 }
1141
1142 /* Set the sizes of the dynamic sections. */
1143
1144 static bfd_boolean
1145 elf_m68k_size_dynamic_sections (output_bfd, info)
1146 bfd *output_bfd ATTRIBUTE_UNUSED;
1147 struct bfd_link_info *info;
1148 {
1149 bfd *dynobj;
1150 asection *s;
1151 bfd_boolean plt;
1152 bfd_boolean relocs;
1153
1154 dynobj = elf_hash_table (info)->dynobj;
1155 BFD_ASSERT (dynobj != NULL);
1156
1157 if (elf_hash_table (info)->dynamic_sections_created)
1158 {
1159 /* Set the contents of the .interp section to the interpreter. */
1160 if (info->executable)
1161 {
1162 s = bfd_get_section_by_name (dynobj, ".interp");
1163 BFD_ASSERT (s != NULL);
1164 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1165 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1166 }
1167 }
1168 else
1169 {
1170 /* We may have created entries in the .rela.got section.
1171 However, if we are not creating the dynamic sections, we will
1172 not actually use these entries. Reset the size of .rela.got,
1173 which will cause it to get stripped from the output file
1174 below. */
1175 s = bfd_get_section_by_name (dynobj, ".rela.got");
1176 if (s != NULL)
1177 s->size = 0;
1178 }
1179
1180 /* If this is a -Bsymbolic shared link, then we need to discard all
1181 PC relative relocs against symbols defined in a regular object.
1182 For the normal shared case we discard the PC relative relocs
1183 against symbols that have become local due to visibility changes.
1184 We allocated space for them in the check_relocs routine, but we
1185 will not fill them in in the relocate_section routine. */
1186 if (info->shared)
1187 elf_link_hash_traverse (elf_hash_table (info),
1188 elf_m68k_discard_copies,
1189 (PTR) info);
1190
1191 /* The check_relocs and adjust_dynamic_symbol entry points have
1192 determined the sizes of the various dynamic sections. Allocate
1193 memory for them. */
1194 plt = FALSE;
1195 relocs = FALSE;
1196 for (s = dynobj->sections; s != NULL; s = s->next)
1197 {
1198 const char *name;
1199
1200 if ((s->flags & SEC_LINKER_CREATED) == 0)
1201 continue;
1202
1203 /* It's OK to base decisions on the section name, because none
1204 of the dynobj section names depend upon the input files. */
1205 name = bfd_get_section_name (dynobj, s);
1206
1207 if (strcmp (name, ".plt") == 0)
1208 {
1209 /* Remember whether there is a PLT. */
1210 plt = s->size != 0;
1211 }
1212 else if (strncmp (name, ".rela", 5) == 0)
1213 {
1214 if (s->size != 0)
1215 {
1216 relocs = TRUE;
1217
1218 /* We use the reloc_count field as a counter if we need
1219 to copy relocs into the output file. */
1220 s->reloc_count = 0;
1221 }
1222 }
1223 else if (strncmp (name, ".got", 4) != 0
1224 && strcmp (name, ".dynbss") != 0)
1225 {
1226 /* It's not one of our sections, so don't allocate space. */
1227 continue;
1228 }
1229
1230 if (s->size == 0)
1231 {
1232 /* If we don't need this section, strip it from the
1233 output file. This is mostly to handle .rela.bss and
1234 .rela.plt. We must create both sections in
1235 create_dynamic_sections, because they must be created
1236 before the linker maps input sections to output
1237 sections. The linker does that before
1238 adjust_dynamic_symbol is called, and it is that
1239 function which decides whether anything needs to go
1240 into these sections. */
1241 s->flags |= SEC_EXCLUDE;
1242 continue;
1243 }
1244
1245 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1246 continue;
1247
1248 /* Allocate memory for the section contents. */
1249 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1250 Unused entries should be reclaimed before the section's contents
1251 are written out, but at the moment this does not happen. Thus in
1252 order to prevent writing out garbage, we initialise the section's
1253 contents to zero. */
1254 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1255 if (s->contents == NULL)
1256 return FALSE;
1257 }
1258
1259 if (elf_hash_table (info)->dynamic_sections_created)
1260 {
1261 /* Add some entries to the .dynamic section. We fill in the
1262 values later, in elf_m68k_finish_dynamic_sections, but we
1263 must add the entries now so that we get the correct size for
1264 the .dynamic section. The DT_DEBUG entry is filled in by the
1265 dynamic linker and used by the debugger. */
1266 #define add_dynamic_entry(TAG, VAL) \
1267 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1268
1269 if (!info->shared)
1270 {
1271 if (!add_dynamic_entry (DT_DEBUG, 0))
1272 return FALSE;
1273 }
1274
1275 if (plt)
1276 {
1277 if (!add_dynamic_entry (DT_PLTGOT, 0)
1278 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1279 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1280 || !add_dynamic_entry (DT_JMPREL, 0))
1281 return FALSE;
1282 }
1283
1284 if (relocs)
1285 {
1286 if (!add_dynamic_entry (DT_RELA, 0)
1287 || !add_dynamic_entry (DT_RELASZ, 0)
1288 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1289 return FALSE;
1290 }
1291
1292 if ((info->flags & DF_TEXTREL) != 0)
1293 {
1294 if (!add_dynamic_entry (DT_TEXTREL, 0))
1295 return FALSE;
1296 }
1297 }
1298 #undef add_dynamic_entry
1299
1300 return TRUE;
1301 }
1302
1303 /* This function is called via elf_link_hash_traverse if we are
1304 creating a shared object. In the -Bsymbolic case it discards the
1305 space allocated to copy PC relative relocs against symbols which
1306 are defined in regular objects. For the normal shared case, it
1307 discards space for pc-relative relocs that have become local due to
1308 symbol visibility changes. We allocated space for them in the
1309 check_relocs routine, but we won't fill them in in the
1310 relocate_section routine.
1311
1312 We also check whether any of the remaining relocations apply
1313 against a readonly section, and set the DF_TEXTREL flag in this
1314 case. */
1315
1316 static bfd_boolean
1317 elf_m68k_discard_copies (h, inf)
1318 struct elf_link_hash_entry *h;
1319 PTR inf;
1320 {
1321 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1322 struct elf_m68k_pcrel_relocs_copied *s;
1323
1324 if (h->root.type == bfd_link_hash_warning)
1325 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1326
1327 if (!h->def_regular
1328 || (!info->symbolic
1329 && !h->forced_local))
1330 {
1331 if ((info->flags & DF_TEXTREL) == 0)
1332 {
1333 /* Look for relocations against read-only sections. */
1334 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
1335 s != NULL;
1336 s = s->next)
1337 if ((s->section->flags & SEC_READONLY) != 0)
1338 {
1339 info->flags |= DF_TEXTREL;
1340 break;
1341 }
1342 }
1343
1344 return TRUE;
1345 }
1346
1347 for (s = elf_m68k_hash_entry (h)->pcrel_relocs_copied;
1348 s != NULL;
1349 s = s->next)
1350 s->section->size -= s->count * sizeof (Elf32_External_Rela);
1351
1352 return TRUE;
1353 }
1354
1355 /* Relocate an M68K ELF section. */
1356
1357 static bfd_boolean
1358 elf_m68k_relocate_section (output_bfd, info, input_bfd, input_section,
1359 contents, relocs, local_syms, local_sections)
1360 bfd *output_bfd;
1361 struct bfd_link_info *info;
1362 bfd *input_bfd;
1363 asection *input_section;
1364 bfd_byte *contents;
1365 Elf_Internal_Rela *relocs;
1366 Elf_Internal_Sym *local_syms;
1367 asection **local_sections;
1368 {
1369 bfd *dynobj;
1370 Elf_Internal_Shdr *symtab_hdr;
1371 struct elf_link_hash_entry **sym_hashes;
1372 bfd_vma *local_got_offsets;
1373 asection *sgot;
1374 asection *splt;
1375 asection *sreloc;
1376 Elf_Internal_Rela *rel;
1377 Elf_Internal_Rela *relend;
1378
1379 if (info->relocatable)
1380 return TRUE;
1381
1382 dynobj = elf_hash_table (info)->dynobj;
1383 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1384 sym_hashes = elf_sym_hashes (input_bfd);
1385 local_got_offsets = elf_local_got_offsets (input_bfd);
1386
1387 sgot = NULL;
1388 splt = NULL;
1389 sreloc = NULL;
1390
1391 rel = relocs;
1392 relend = relocs + input_section->reloc_count;
1393 for (; rel < relend; rel++)
1394 {
1395 int r_type;
1396 reloc_howto_type *howto;
1397 unsigned long r_symndx;
1398 struct elf_link_hash_entry *h;
1399 Elf_Internal_Sym *sym;
1400 asection *sec;
1401 bfd_vma relocation;
1402 bfd_boolean unresolved_reloc;
1403 bfd_reloc_status_type r;
1404
1405 r_type = ELF32_R_TYPE (rel->r_info);
1406 if (r_type < 0 || r_type >= (int) R_68K_max)
1407 {
1408 bfd_set_error (bfd_error_bad_value);
1409 return FALSE;
1410 }
1411 howto = howto_table + r_type;
1412
1413 r_symndx = ELF32_R_SYM (rel->r_info);
1414
1415 h = NULL;
1416 sym = NULL;
1417 sec = NULL;
1418 unresolved_reloc = FALSE;
1419
1420 if (r_symndx < symtab_hdr->sh_info)
1421 {
1422 sym = local_syms + r_symndx;
1423 sec = local_sections[r_symndx];
1424 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1425 }
1426 else
1427 {
1428 bfd_boolean warned;
1429
1430 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1431 r_symndx, symtab_hdr, sym_hashes,
1432 h, sec, relocation,
1433 unresolved_reloc, warned);
1434 }
1435
1436 switch (r_type)
1437 {
1438 case R_68K_GOT8:
1439 case R_68K_GOT16:
1440 case R_68K_GOT32:
1441 /* Relocation is to the address of the entry for this symbol
1442 in the global offset table. */
1443 if (h != NULL
1444 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1445 break;
1446 /* Fall through. */
1447 case R_68K_GOT8O:
1448 case R_68K_GOT16O:
1449 case R_68K_GOT32O:
1450 /* Relocation is the offset of the entry for this symbol in
1451 the global offset table. */
1452
1453 {
1454 bfd_vma off;
1455
1456 if (sgot == NULL)
1457 {
1458 sgot = bfd_get_section_by_name (dynobj, ".got");
1459 BFD_ASSERT (sgot != NULL);
1460 }
1461
1462 if (h != NULL)
1463 {
1464 bfd_boolean dyn;
1465
1466 off = h->got.offset;
1467 BFD_ASSERT (off != (bfd_vma) -1);
1468
1469 dyn = elf_hash_table (info)->dynamic_sections_created;
1470 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1471 || (info->shared
1472 && (info->symbolic
1473 || h->dynindx == -1
1474 || h->forced_local)
1475 && h->def_regular))
1476 {
1477 /* This is actually a static link, or it is a
1478 -Bsymbolic link and the symbol is defined
1479 locally, or the symbol was forced to be local
1480 because of a version file.. We must initialize
1481 this entry in the global offset table. Since
1482 the offset must always be a multiple of 4, we
1483 use the least significant bit to record whether
1484 we have initialized it already.
1485
1486 When doing a dynamic link, we create a .rela.got
1487 relocation entry to initialize the value. This
1488 is done in the finish_dynamic_symbol routine. */
1489 if ((off & 1) != 0)
1490 off &= ~1;
1491 else
1492 {
1493 bfd_put_32 (output_bfd, relocation,
1494 sgot->contents + off);
1495 h->got.offset |= 1;
1496 }
1497 }
1498 else
1499 unresolved_reloc = FALSE;
1500 }
1501 else
1502 {
1503 BFD_ASSERT (local_got_offsets != NULL
1504 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1505
1506 off = local_got_offsets[r_symndx];
1507
1508 /* The offset must always be a multiple of 4. We use
1509 the least significant bit to record whether we have
1510 already generated the necessary reloc. */
1511 if ((off & 1) != 0)
1512 off &= ~1;
1513 else
1514 {
1515 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1516
1517 if (info->shared)
1518 {
1519 asection *s;
1520 Elf_Internal_Rela outrel;
1521 bfd_byte *loc;
1522
1523 s = bfd_get_section_by_name (dynobj, ".rela.got");
1524 BFD_ASSERT (s != NULL);
1525
1526 outrel.r_offset = (sgot->output_section->vma
1527 + sgot->output_offset
1528 + off);
1529 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1530 outrel.r_addend = relocation;
1531 loc = s->contents;
1532 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1533 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1534 }
1535
1536 local_got_offsets[r_symndx] |= 1;
1537 }
1538 }
1539
1540 relocation = sgot->output_offset + off;
1541 if (r_type == R_68K_GOT8O
1542 || r_type == R_68K_GOT16O
1543 || r_type == R_68K_GOT32O)
1544 {
1545 /* This relocation does not use the addend. */
1546 rel->r_addend = 0;
1547 }
1548 else
1549 relocation += sgot->output_section->vma;
1550 }
1551 break;
1552
1553 case R_68K_PLT8:
1554 case R_68K_PLT16:
1555 case R_68K_PLT32:
1556 /* Relocation is to the entry for this symbol in the
1557 procedure linkage table. */
1558
1559 /* Resolve a PLTxx reloc against a local symbol directly,
1560 without using the procedure linkage table. */
1561 if (h == NULL)
1562 break;
1563
1564 if (h->plt.offset == (bfd_vma) -1
1565 || !elf_hash_table (info)->dynamic_sections_created)
1566 {
1567 /* We didn't make a PLT entry for this symbol. This
1568 happens when statically linking PIC code, or when
1569 using -Bsymbolic. */
1570 break;
1571 }
1572
1573 if (splt == NULL)
1574 {
1575 splt = bfd_get_section_by_name (dynobj, ".plt");
1576 BFD_ASSERT (splt != NULL);
1577 }
1578
1579 relocation = (splt->output_section->vma
1580 + splt->output_offset
1581 + h->plt.offset);
1582 unresolved_reloc = FALSE;
1583 break;
1584
1585 case R_68K_PLT8O:
1586 case R_68K_PLT16O:
1587 case R_68K_PLT32O:
1588 /* Relocation is the offset of the entry for this symbol in
1589 the procedure linkage table. */
1590 BFD_ASSERT (h != NULL && h->plt.offset != (bfd_vma) -1);
1591
1592 if (splt == NULL)
1593 {
1594 splt = bfd_get_section_by_name (dynobj, ".plt");
1595 BFD_ASSERT (splt != NULL);
1596 }
1597
1598 relocation = h->plt.offset;
1599 unresolved_reloc = FALSE;
1600
1601 /* This relocation does not use the addend. */
1602 rel->r_addend = 0;
1603
1604 break;
1605
1606 case R_68K_PC8:
1607 case R_68K_PC16:
1608 case R_68K_PC32:
1609 if (h == NULL
1610 || (info->shared
1611 && h->forced_local))
1612 break;
1613 /* Fall through. */
1614 case R_68K_8:
1615 case R_68K_16:
1616 case R_68K_32:
1617 if (info->shared
1618 && r_symndx != 0
1619 && (input_section->flags & SEC_ALLOC) != 0
1620 && (h == NULL
1621 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1622 || h->root.type != bfd_link_hash_undefweak)
1623 && ((r_type != R_68K_PC8
1624 && r_type != R_68K_PC16
1625 && r_type != R_68K_PC32)
1626 || (h != NULL
1627 && h->dynindx != -1
1628 && (!info->symbolic
1629 || !h->def_regular))))
1630 {
1631 Elf_Internal_Rela outrel;
1632 bfd_byte *loc;
1633 bfd_boolean skip, relocate;
1634
1635 /* When generating a shared object, these relocations
1636 are copied into the output file to be resolved at run
1637 time. */
1638
1639 skip = FALSE;
1640 relocate = FALSE;
1641
1642 outrel.r_offset =
1643 _bfd_elf_section_offset (output_bfd, info, input_section,
1644 rel->r_offset);
1645 if (outrel.r_offset == (bfd_vma) -1)
1646 skip = TRUE;
1647 else if (outrel.r_offset == (bfd_vma) -2)
1648 skip = TRUE, relocate = TRUE;
1649 outrel.r_offset += (input_section->output_section->vma
1650 + input_section->output_offset);
1651
1652 if (skip)
1653 memset (&outrel, 0, sizeof outrel);
1654 else if (h != NULL
1655 && h->dynindx != -1
1656 && (r_type == R_68K_PC8
1657 || r_type == R_68K_PC16
1658 || r_type == R_68K_PC32
1659 || !info->shared
1660 || !info->symbolic
1661 || !h->def_regular))
1662 {
1663 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1664 outrel.r_addend = rel->r_addend;
1665 }
1666 else
1667 {
1668 /* This symbol is local, or marked to become local. */
1669 if (r_type == R_68K_32)
1670 {
1671 relocate = TRUE;
1672 outrel.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1673 outrel.r_addend = relocation + rel->r_addend;
1674 }
1675 else
1676 {
1677 long indx;
1678
1679 if (bfd_is_abs_section (sec))
1680 indx = 0;
1681 else if (sec == NULL || sec->owner == NULL)
1682 {
1683 bfd_set_error (bfd_error_bad_value);
1684 return FALSE;
1685 }
1686 else
1687 {
1688 asection *osec;
1689
1690 osec = sec->output_section;
1691 indx = elf_section_data (osec)->dynindx;
1692 BFD_ASSERT (indx > 0);
1693 }
1694
1695 outrel.r_info = ELF32_R_INFO (indx, r_type);
1696 outrel.r_addend = relocation + rel->r_addend;
1697 }
1698 }
1699
1700 sreloc = elf_section_data (input_section)->sreloc;
1701 if (sreloc == NULL)
1702 abort ();
1703
1704 loc = sreloc->contents;
1705 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1706 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1707
1708 /* This reloc will be computed at runtime, so there's no
1709 need to do anything now, except for R_68K_32
1710 relocations that have been turned into
1711 R_68K_RELATIVE. */
1712 if (!relocate)
1713 continue;
1714 }
1715
1716 break;
1717
1718 case R_68K_GNU_VTINHERIT:
1719 case R_68K_GNU_VTENTRY:
1720 /* These are no-ops in the end. */
1721 continue;
1722
1723 default:
1724 break;
1725 }
1726
1727 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1728 because such sections are not SEC_ALLOC and thus ld.so will
1729 not process them. */
1730 if (unresolved_reloc
1731 && !((input_section->flags & SEC_DEBUGGING) != 0
1732 && h->def_dynamic))
1733 {
1734 (*_bfd_error_handler)
1735 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1736 input_bfd,
1737 input_section,
1738 (long) rel->r_offset,
1739 howto->name,
1740 h->root.root.string);
1741 return FALSE;
1742 }
1743
1744 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1745 contents, rel->r_offset,
1746 relocation, rel->r_addend);
1747
1748 if (r != bfd_reloc_ok)
1749 {
1750 const char *name;
1751
1752 if (h != NULL)
1753 name = h->root.root.string;
1754 else
1755 {
1756 name = bfd_elf_string_from_elf_section (input_bfd,
1757 symtab_hdr->sh_link,
1758 sym->st_name);
1759 if (name == NULL)
1760 return FALSE;
1761 if (*name == '\0')
1762 name = bfd_section_name (input_bfd, sec);
1763 }
1764
1765 if (r == bfd_reloc_overflow)
1766 {
1767 if (!(info->callbacks->reloc_overflow
1768 (info, (h ? &h->root : NULL), name, howto->name,
1769 (bfd_vma) 0, input_bfd, input_section,
1770 rel->r_offset)))
1771 return FALSE;
1772 }
1773 else
1774 {
1775 (*_bfd_error_handler)
1776 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
1777 input_bfd, input_section,
1778 (long) rel->r_offset, name, (int) r);
1779 return FALSE;
1780 }
1781 }
1782 }
1783
1784 return TRUE;
1785 }
1786
1787 /* Finish up dynamic symbol handling. We set the contents of various
1788 dynamic sections here. */
1789
1790 static bfd_boolean
1791 elf_m68k_finish_dynamic_symbol (output_bfd, info, h, sym)
1792 bfd *output_bfd;
1793 struct bfd_link_info *info;
1794 struct elf_link_hash_entry *h;
1795 Elf_Internal_Sym *sym;
1796 {
1797 bfd *dynobj;
1798 int plt_off1, plt_off2, plt_off3;
1799
1800 dynobj = elf_hash_table (info)->dynobj;
1801
1802 if (h->plt.offset != (bfd_vma) -1)
1803 {
1804 asection *splt;
1805 asection *sgot;
1806 asection *srela;
1807 bfd_vma plt_index;
1808 bfd_vma got_offset;
1809 Elf_Internal_Rela rela;
1810 bfd_byte *loc;
1811
1812 /* This symbol has an entry in the procedure linkage table. Set
1813 it up. */
1814
1815 BFD_ASSERT (h->dynindx != -1);
1816
1817 splt = bfd_get_section_by_name (dynobj, ".plt");
1818 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1819 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1820 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1821
1822 /* Get the index in the procedure linkage table which
1823 corresponds to this symbol. This is the index of this symbol
1824 in all the symbols for which we are making plt entries. The
1825 first entry in the procedure linkage table is reserved. */
1826 if (CPU32_FLAG (output_bfd))
1827 plt_index = (h->plt.offset / PLT_CPU32_ENTRY_SIZE) - 1;
1828 else if (CFV4E_FLAG (output_bfd))
1829 plt_index = (h->plt.offset / CFV4E_PLT_ENTRY_SIZE) - 1;
1830 else
1831 plt_index = (h->plt.offset / PLT_ENTRY_SIZE) - 1;
1832
1833 /* Get the offset into the .got table of the entry that
1834 corresponds to this function. Each .got entry is 4 bytes.
1835 The first three are reserved. */
1836 got_offset = (plt_index + 3) * 4;
1837
1838 if (CPU32_FLAG (output_bfd))
1839 {
1840 /* Fill in the entry in the procedure linkage table. */
1841 memcpy (splt->contents + h->plt.offset, elf_cpu32_plt_entry,
1842 PLT_CPU32_ENTRY_SIZE);
1843 plt_off1 = 4;
1844 plt_off2 = 12;
1845 plt_off3 = 18;
1846 }
1847 else if (CFV4E_FLAG (output_bfd))
1848 {
1849 memcpy (splt->contents + h->plt.offset, elf_cfv4e_plt_entry,
1850 CFV4E_PLT_ENTRY_SIZE);
1851 plt_off1 = 2;
1852 plt_off2 = 14;
1853 plt_off3 = 20;
1854 }
1855 else
1856 {
1857 /* Fill in the entry in the procedure linkage table. */
1858 memcpy (splt->contents + h->plt.offset, elf_m68k_plt_entry,
1859 PLT_ENTRY_SIZE);
1860 plt_off1 = 4;
1861 plt_off2 = 10;
1862 plt_off3 = 16;
1863 }
1864
1865 /* The offset is relative to the first extension word. */
1866 bfd_put_32 (output_bfd,
1867 sgot->output_section->vma
1868 + sgot->output_offset
1869 + got_offset
1870 - (splt->output_section->vma
1871 + h->plt.offset
1872 + CFV4E_FLAG (output_bfd) ? 8 : 2),
1873 splt->contents + h->plt.offset + plt_off1);
1874
1875 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
1876 splt->contents + h->plt.offset + plt_off2);
1877 bfd_put_32 (output_bfd, - (h->plt.offset + plt_off3),
1878 splt->contents + h->plt.offset + plt_off3);
1879
1880 /* Fill in the entry in the global offset table. */
1881 bfd_put_32 (output_bfd,
1882 (splt->output_section->vma
1883 + splt->output_offset
1884 + h->plt.offset
1885 + CFV4E_FLAG (output_bfd) ? 12 : 8),
1886 sgot->contents + got_offset);
1887
1888 /* Fill in the entry in the .rela.plt section. */
1889 rela.r_offset = (sgot->output_section->vma
1890 + sgot->output_offset
1891 + got_offset);
1892 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_JMP_SLOT);
1893 rela.r_addend = 0;
1894 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
1895 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1896
1897 if (!h->def_regular)
1898 {
1899 /* Mark the symbol as undefined, rather than as defined in
1900 the .plt section. Leave the value alone. */
1901 sym->st_shndx = SHN_UNDEF;
1902 }
1903 }
1904
1905 if (h->got.offset != (bfd_vma) -1)
1906 {
1907 asection *sgot;
1908 asection *srela;
1909 Elf_Internal_Rela rela;
1910 bfd_byte *loc;
1911
1912 /* This symbol has an entry in the global offset table. Set it
1913 up. */
1914
1915 sgot = bfd_get_section_by_name (dynobj, ".got");
1916 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1917 BFD_ASSERT (sgot != NULL && srela != NULL);
1918
1919 rela.r_offset = (sgot->output_section->vma
1920 + sgot->output_offset
1921 + (h->got.offset &~ (bfd_vma) 1));
1922
1923 /* If this is a -Bsymbolic link, and the symbol is defined
1924 locally, we just want to emit a RELATIVE reloc. Likewise if
1925 the symbol was forced to be local because of a version file.
1926 The entry in the global offset table will already have been
1927 initialized in the relocate_section function. */
1928 if (info->shared
1929 && (info->symbolic
1930 || h->dynindx == -1
1931 || h->forced_local)
1932 && h->def_regular)
1933 {
1934 rela.r_info = ELF32_R_INFO (0, R_68K_RELATIVE);
1935 rela.r_addend = bfd_get_signed_32 (output_bfd,
1936 (sgot->contents
1937 + (h->got.offset &~ (bfd_vma) 1)));
1938 }
1939 else
1940 {
1941 bfd_put_32 (output_bfd, (bfd_vma) 0,
1942 sgot->contents + (h->got.offset &~ (bfd_vma) 1));
1943 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_GLOB_DAT);
1944 rela.r_addend = 0;
1945 }
1946
1947 loc = srela->contents;
1948 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
1949 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1950 }
1951
1952 if (h->needs_copy)
1953 {
1954 asection *s;
1955 Elf_Internal_Rela rela;
1956 bfd_byte *loc;
1957
1958 /* This symbol needs a copy reloc. Set it up. */
1959
1960 BFD_ASSERT (h->dynindx != -1
1961 && (h->root.type == bfd_link_hash_defined
1962 || h->root.type == bfd_link_hash_defweak));
1963
1964 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1965 ".rela.bss");
1966 BFD_ASSERT (s != NULL);
1967
1968 rela.r_offset = (h->root.u.def.value
1969 + h->root.u.def.section->output_section->vma
1970 + h->root.u.def.section->output_offset);
1971 rela.r_info = ELF32_R_INFO (h->dynindx, R_68K_COPY);
1972 rela.r_addend = 0;
1973 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
1974 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1975 }
1976
1977 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1978 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1979 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1980 sym->st_shndx = SHN_ABS;
1981
1982 return TRUE;
1983 }
1984
1985 /* Finish up the dynamic sections. */
1986
1987 static bfd_boolean
1988 elf_m68k_finish_dynamic_sections (output_bfd, info)
1989 bfd *output_bfd;
1990 struct bfd_link_info *info;
1991 {
1992 bfd *dynobj;
1993 asection *sgot;
1994 asection *sdyn;
1995
1996 dynobj = elf_hash_table (info)->dynobj;
1997
1998 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1999 BFD_ASSERT (sgot != NULL);
2000 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2001
2002 if (elf_hash_table (info)->dynamic_sections_created)
2003 {
2004 asection *splt;
2005 Elf32_External_Dyn *dyncon, *dynconend;
2006
2007 splt = bfd_get_section_by_name (dynobj, ".plt");
2008 BFD_ASSERT (splt != NULL && sdyn != NULL);
2009
2010 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2011 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2012 for (; dyncon < dynconend; dyncon++)
2013 {
2014 Elf_Internal_Dyn dyn;
2015 const char *name;
2016 asection *s;
2017
2018 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2019
2020 switch (dyn.d_tag)
2021 {
2022 default:
2023 break;
2024
2025 case DT_PLTGOT:
2026 name = ".got";
2027 goto get_vma;
2028 case DT_JMPREL:
2029 name = ".rela.plt";
2030 get_vma:
2031 s = bfd_get_section_by_name (output_bfd, name);
2032 BFD_ASSERT (s != NULL);
2033 dyn.d_un.d_ptr = s->vma;
2034 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2035 break;
2036
2037 case DT_PLTRELSZ:
2038 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2039 BFD_ASSERT (s != NULL);
2040 dyn.d_un.d_val = s->size;
2041 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2042 break;
2043
2044 case DT_RELASZ:
2045 /* The procedure linkage table relocs (DT_JMPREL) should
2046 not be included in the overall relocs (DT_RELA).
2047 Therefore, we override the DT_RELASZ entry here to
2048 make it not include the JMPREL relocs. Since the
2049 linker script arranges for .rela.plt to follow all
2050 other relocation sections, we don't have to worry
2051 about changing the DT_RELA entry. */
2052 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2053 if (s != NULL)
2054 dyn.d_un.d_val -= s->size;
2055 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2056 break;
2057 }
2058 }
2059
2060 /* Fill in the first entry in the procedure linkage table. */
2061 if (splt->size > 0)
2062 {
2063 if (CFV4E_FLAG (output_bfd))
2064 {
2065 memcpy (splt->contents, elf_cfv4e_plt0_entry, CFV4E_PLT_ENTRY_SIZE);
2066 bfd_put_32 (output_bfd,
2067 (sgot->output_section->vma
2068 + sgot->output_offset + 4
2069 - (splt->output_section->vma + 2)),
2070 splt->contents + 2);
2071 bfd_put_32 (output_bfd,
2072 (sgot->output_section->vma
2073 + sgot->output_offset + 8
2074 - (splt->output_section->vma + 10) - 8),
2075 splt->contents + 12);
2076 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2077 = CFV4E_PLT_ENTRY_SIZE;
2078 }
2079 else if (CPU32_FLAG (output_bfd))
2080 {
2081 memcpy (splt->contents, elf_cpu32_plt0_entry, PLT_CPU32_ENTRY_SIZE);
2082 bfd_put_32 (output_bfd,
2083 (sgot->output_section->vma
2084 + sgot->output_offset + 4
2085 - (splt->output_section->vma + 2)),
2086 splt->contents + 4);
2087 bfd_put_32 (output_bfd,
2088 (sgot->output_section->vma
2089 + sgot->output_offset + 8
2090 - (splt->output_section->vma + 10)),
2091 splt->contents + 12);
2092 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2093 = PLT_CPU32_ENTRY_SIZE;
2094 }
2095 else
2096 {
2097 memcpy (splt->contents, elf_m68k_plt0_entry, PLT_ENTRY_SIZE);
2098 bfd_put_32 (output_bfd,
2099 (sgot->output_section->vma
2100 + sgot->output_offset + 4
2101 - (splt->output_section->vma + 2)),
2102 splt->contents + 4);
2103 bfd_put_32 (output_bfd,
2104 (sgot->output_section->vma
2105 + sgot->output_offset + 8
2106 - (splt->output_section->vma + 10)),
2107 splt->contents + 12);
2108 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2109 = PLT_ENTRY_SIZE;
2110 }
2111 }
2112 }
2113
2114 /* Fill in the first three entries in the global offset table. */
2115 if (sgot->size > 0)
2116 {
2117 if (sdyn == NULL)
2118 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2119 else
2120 bfd_put_32 (output_bfd,
2121 sdyn->output_section->vma + sdyn->output_offset,
2122 sgot->contents);
2123 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2124 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2125 }
2126
2127 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2128
2129 return TRUE;
2130 }
2131
2132 /* Given a .data section and a .emreloc in-memory section, store
2133 relocation information into the .emreloc section which can be
2134 used at runtime to relocate the section. This is called by the
2135 linker when the --embedded-relocs switch is used. This is called
2136 after the add_symbols entry point has been called for all the
2137 objects, and before the final_link entry point is called. */
2138
2139 bfd_boolean
2140 bfd_m68k_elf32_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
2141 bfd *abfd;
2142 struct bfd_link_info *info;
2143 asection *datasec;
2144 asection *relsec;
2145 char **errmsg;
2146 {
2147 Elf_Internal_Shdr *symtab_hdr;
2148 Elf_Internal_Sym *isymbuf = NULL;
2149 Elf_Internal_Rela *internal_relocs = NULL;
2150 Elf_Internal_Rela *irel, *irelend;
2151 bfd_byte *p;
2152 bfd_size_type amt;
2153
2154 BFD_ASSERT (! info->relocatable);
2155
2156 *errmsg = NULL;
2157
2158 if (datasec->reloc_count == 0)
2159 return TRUE;
2160
2161 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2162
2163 /* Get a copy of the native relocations. */
2164 internal_relocs = (_bfd_elf_link_read_relocs
2165 (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2166 info->keep_memory));
2167 if (internal_relocs == NULL)
2168 goto error_return;
2169
2170 amt = (bfd_size_type) datasec->reloc_count * 12;
2171 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2172 if (relsec->contents == NULL)
2173 goto error_return;
2174
2175 p = relsec->contents;
2176
2177 irelend = internal_relocs + datasec->reloc_count;
2178 for (irel = internal_relocs; irel < irelend; irel++, p += 12)
2179 {
2180 asection *targetsec;
2181
2182 /* We are going to write a four byte longword into the runtime
2183 reloc section. The longword will be the address in the data
2184 section which must be relocated. It is followed by the name
2185 of the target section NUL-padded or truncated to 8
2186 characters. */
2187
2188 /* We can only relocate absolute longword relocs at run time. */
2189 if (ELF32_R_TYPE (irel->r_info) != (int) R_68K_32)
2190 {
2191 *errmsg = _("unsupported reloc type");
2192 bfd_set_error (bfd_error_bad_value);
2193 goto error_return;
2194 }
2195
2196 /* Get the target section referred to by the reloc. */
2197 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2198 {
2199 /* A local symbol. */
2200 Elf_Internal_Sym *isym;
2201
2202 /* Read this BFD's local symbols if we haven't done so already. */
2203 if (isymbuf == NULL)
2204 {
2205 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2206 if (isymbuf == NULL)
2207 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2208 symtab_hdr->sh_info, 0,
2209 NULL, NULL, NULL);
2210 if (isymbuf == NULL)
2211 goto error_return;
2212 }
2213
2214 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2215 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2216 }
2217 else
2218 {
2219 unsigned long indx;
2220 struct elf_link_hash_entry *h;
2221
2222 /* An external symbol. */
2223 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2224 h = elf_sym_hashes (abfd)[indx];
2225 BFD_ASSERT (h != NULL);
2226 if (h->root.type == bfd_link_hash_defined
2227 || h->root.type == bfd_link_hash_defweak)
2228 targetsec = h->root.u.def.section;
2229 else
2230 targetsec = NULL;
2231 }
2232
2233 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
2234 memset (p + 4, 0, 8);
2235 if (targetsec != NULL)
2236 strncpy ((char *) p + 4, targetsec->output_section->name, 8);
2237 }
2238
2239 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2240 free (isymbuf);
2241 if (internal_relocs != NULL
2242 && elf_section_data (datasec)->relocs != internal_relocs)
2243 free (internal_relocs);
2244 return TRUE;
2245
2246 error_return:
2247 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2248 free (isymbuf);
2249 if (internal_relocs != NULL
2250 && elf_section_data (datasec)->relocs != internal_relocs)
2251 free (internal_relocs);
2252 return FALSE;
2253 }
2254
2255 static enum elf_reloc_type_class
2256 elf32_m68k_reloc_type_class (rela)
2257 const Elf_Internal_Rela *rela;
2258 {
2259 switch ((int) ELF32_R_TYPE (rela->r_info))
2260 {
2261 case R_68K_RELATIVE:
2262 return reloc_class_relative;
2263 case R_68K_JMP_SLOT:
2264 return reloc_class_plt;
2265 case R_68K_COPY:
2266 return reloc_class_copy;
2267 default:
2268 return reloc_class_normal;
2269 }
2270 }
2271
2272 /* Return address for Ith PLT stub in section PLT, for relocation REL
2273 or (bfd_vma) -1 if it should not be included. */
2274
2275 static bfd_vma
2276 elf_m68k_plt_sym_val (bfd_vma i, const asection *plt,
2277 const arelent *rel ATTRIBUTE_UNUSED)
2278 {
2279 if (CPU32_FLAG (plt->owner))
2280 return plt->vma + (i + 1) * PLT_CPU32_ENTRY_SIZE;
2281 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
2282 }
2283
2284 #define TARGET_BIG_SYM bfd_elf32_m68k_vec
2285 #define TARGET_BIG_NAME "elf32-m68k"
2286 #define ELF_MACHINE_CODE EM_68K
2287 #define ELF_MAXPAGESIZE 0x2000
2288 #define elf_backend_create_dynamic_sections \
2289 _bfd_elf_create_dynamic_sections
2290 #define bfd_elf32_bfd_link_hash_table_create \
2291 elf_m68k_link_hash_table_create
2292 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
2293
2294 #define elf_backend_check_relocs elf_m68k_check_relocs
2295 #define elf_backend_adjust_dynamic_symbol \
2296 elf_m68k_adjust_dynamic_symbol
2297 #define elf_backend_size_dynamic_sections \
2298 elf_m68k_size_dynamic_sections
2299 #define elf_backend_relocate_section elf_m68k_relocate_section
2300 #define elf_backend_finish_dynamic_symbol \
2301 elf_m68k_finish_dynamic_symbol
2302 #define elf_backend_finish_dynamic_sections \
2303 elf_m68k_finish_dynamic_sections
2304 #define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook
2305 #define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook
2306 #define bfd_elf32_bfd_merge_private_bfd_data \
2307 elf32_m68k_merge_private_bfd_data
2308 #define bfd_elf32_bfd_set_private_flags \
2309 elf32_m68k_set_private_flags
2310 #define bfd_elf32_bfd_print_private_bfd_data \
2311 elf32_m68k_print_private_bfd_data
2312 #define elf_backend_reloc_type_class elf32_m68k_reloc_type_class
2313 #define elf_backend_plt_sym_val elf_m68k_plt_sym_val
2314
2315 #define elf_backend_can_gc_sections 1
2316 #define elf_backend_can_refcount 1
2317 #define elf_backend_want_got_plt 1
2318 #define elf_backend_plt_readonly 1
2319 #define elf_backend_want_plt_sym 0
2320 #define elf_backend_got_header_size 12
2321 #define elf_backend_rela_normal 1
2322
2323 #include "elf32-target.h"
git-cvsimport of binutils cvsroot