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