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