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