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