1 /* Motorola 68k series support for 32-bit ELF
2 Copyright 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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
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_relocate_section
50 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
51 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
52 static bfd_boolean elf_m68k_finish_dynamic_symbol
53 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
55 static bfd_boolean elf_m68k_finish_dynamic_sections
56 PARAMS ((bfd
*, struct bfd_link_info
*));
58 static bfd_boolean elf32_m68k_set_private_flags
59 PARAMS ((bfd
*, flagword
));
60 static bfd_boolean elf32_m68k_merge_private_bfd_data
61 PARAMS ((bfd
*, bfd
*));
62 static bfd_boolean elf32_m68k_print_private_bfd_data
63 PARAMS ((bfd
*, PTR
));
64 static enum elf_reloc_type_class elf32_m68k_reloc_type_class
65 PARAMS ((const Elf_Internal_Rela
*));
67 static reloc_howto_type howto_table
[] = {
68 HOWTO(R_68K_NONE
, 0, 0, 0, FALSE
,0, complain_overflow_dont
, bfd_elf_generic_reloc
, "R_68K_NONE", FALSE
, 0, 0x00000000,FALSE
),
69 HOWTO(R_68K_32
, 0, 2,32, FALSE
,0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_68K_32", FALSE
, 0, 0xffffffff,FALSE
),
70 HOWTO(R_68K_16
, 0, 1,16, FALSE
,0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_68K_16", FALSE
, 0, 0x0000ffff,FALSE
),
71 HOWTO(R_68K_8
, 0, 0, 8, FALSE
,0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_68K_8", FALSE
, 0, 0x000000ff,FALSE
),
72 HOWTO(R_68K_PC32
, 0, 2,32, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_68K_PC32", FALSE
, 0, 0xffffffff,TRUE
),
73 HOWTO(R_68K_PC16
, 0, 1,16, TRUE
, 0, complain_overflow_signed
, bfd_elf_generic_reloc
, "R_68K_PC16", FALSE
, 0, 0x0000ffff,TRUE
),
74 HOWTO(R_68K_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
, bfd_elf_generic_reloc
, "R_68K_PC8", FALSE
, 0, 0x000000ff,TRUE
),
75 HOWTO(R_68K_GOT32
, 0, 2,32, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_68K_GOT32", FALSE
, 0, 0xffffffff,TRUE
),
76 HOWTO(R_68K_GOT16
, 0, 1,16, TRUE
, 0, complain_overflow_signed
, bfd_elf_generic_reloc
, "R_68K_GOT16", FALSE
, 0, 0x0000ffff,TRUE
),
77 HOWTO(R_68K_GOT8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
, bfd_elf_generic_reloc
, "R_68K_GOT8", FALSE
, 0, 0x000000ff,TRUE
),
78 HOWTO(R_68K_GOT32O
, 0, 2,32, FALSE
,0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_68K_GOT32O", FALSE
, 0, 0xffffffff,FALSE
),
79 HOWTO(R_68K_GOT16O
, 0, 1,16, FALSE
,0, complain_overflow_signed
, bfd_elf_generic_reloc
, "R_68K_GOT16O", FALSE
, 0, 0x0000ffff,FALSE
),
80 HOWTO(R_68K_GOT8O
, 0, 0, 8, FALSE
,0, complain_overflow_signed
, bfd_elf_generic_reloc
, "R_68K_GOT8O", FALSE
, 0, 0x000000ff,FALSE
),
81 HOWTO(R_68K_PLT32
, 0, 2,32, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_68K_PLT32", FALSE
, 0, 0xffffffff,TRUE
),
82 HOWTO(R_68K_PLT16
, 0, 1,16, TRUE
, 0, complain_overflow_signed
, bfd_elf_generic_reloc
, "R_68K_PLT16", FALSE
, 0, 0x0000ffff,TRUE
),
83 HOWTO(R_68K_PLT8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
, bfd_elf_generic_reloc
, "R_68K_PLT8", FALSE
, 0, 0x000000ff,TRUE
),
84 HOWTO(R_68K_PLT32O
, 0, 2,32, FALSE
,0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_68K_PLT32O", FALSE
, 0, 0xffffffff,FALSE
),
85 HOWTO(R_68K_PLT16O
, 0, 1,16, FALSE
,0, complain_overflow_signed
, bfd_elf_generic_reloc
, "R_68K_PLT16O", FALSE
, 0, 0x0000ffff,FALSE
),
86 HOWTO(R_68K_PLT8O
, 0, 0, 8, FALSE
,0, complain_overflow_signed
, bfd_elf_generic_reloc
, "R_68K_PLT8O", FALSE
, 0, 0x000000ff,FALSE
),
87 HOWTO(R_68K_COPY
, 0, 0, 0, FALSE
,0, complain_overflow_dont
, bfd_elf_generic_reloc
, "R_68K_COPY", FALSE
, 0, 0xffffffff,FALSE
),
88 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
),
89 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
),
90 HOWTO(R_68K_RELATIVE
, 0, 2,32, FALSE
,0, complain_overflow_dont
, bfd_elf_generic_reloc
, "R_68K_RELATIVE", FALSE
, 0, 0xffffffff,FALSE
),
91 /* GNU extension to record C++ vtable hierarchy */
92 HOWTO (R_68K_GNU_VTINHERIT
, /* type */
94 2, /* size (0 = byte, 1 = short, 2 = long) */
96 FALSE
, /* pc_relative */
98 complain_overflow_dont
, /* complain_on_overflow */
99 NULL
, /* special_function */
100 "R_68K_GNU_VTINHERIT", /* name */
101 FALSE
, /* partial_inplace */
105 /* GNU extension to record C++ vtable member usage */
106 HOWTO (R_68K_GNU_VTENTRY
, /* type */
108 2, /* size (0 = byte, 1 = short, 2 = long) */
110 FALSE
, /* pc_relative */
112 complain_overflow_dont
, /* complain_on_overflow */
113 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
114 "R_68K_GNU_VTENTRY", /* name */
115 FALSE
, /* partial_inplace */
122 rtype_to_howto (abfd
, cache_ptr
, dst
)
123 bfd
*abfd ATTRIBUTE_UNUSED
;
125 Elf_Internal_Rela
*dst
;
127 BFD_ASSERT (ELF32_R_TYPE(dst
->r_info
) < (unsigned int) R_68K_max
);
128 cache_ptr
->howto
= &howto_table
[ELF32_R_TYPE(dst
->r_info
)];
131 #define elf_info_to_howto rtype_to_howto
135 bfd_reloc_code_real_type bfd_val
;
138 { BFD_RELOC_NONE
, R_68K_NONE
},
139 { BFD_RELOC_32
, R_68K_32
},
140 { BFD_RELOC_16
, R_68K_16
},
141 { BFD_RELOC_8
, R_68K_8
},
142 { BFD_RELOC_32_PCREL
, R_68K_PC32
},
143 { BFD_RELOC_16_PCREL
, R_68K_PC16
},
144 { BFD_RELOC_8_PCREL
, R_68K_PC8
},
145 { BFD_RELOC_32_GOT_PCREL
, R_68K_GOT32
},
146 { BFD_RELOC_16_GOT_PCREL
, R_68K_GOT16
},
147 { BFD_RELOC_8_GOT_PCREL
, R_68K_GOT8
},
148 { BFD_RELOC_32_GOTOFF
, R_68K_GOT32O
},
149 { BFD_RELOC_16_GOTOFF
, R_68K_GOT16O
},
150 { BFD_RELOC_8_GOTOFF
, R_68K_GOT8O
},
151 { BFD_RELOC_32_PLT_PCREL
, R_68K_PLT32
},
152 { BFD_RELOC_16_PLT_PCREL
, R_68K_PLT16
},
153 { BFD_RELOC_8_PLT_PCREL
, R_68K_PLT8
},
154 { BFD_RELOC_32_PLTOFF
, R_68K_PLT32O
},
155 { BFD_RELOC_16_PLTOFF
, R_68K_PLT16O
},
156 { BFD_RELOC_8_PLTOFF
, R_68K_PLT8O
},
157 { BFD_RELOC_NONE
, R_68K_COPY
},
158 { BFD_RELOC_68K_GLOB_DAT
, R_68K_GLOB_DAT
},
159 { BFD_RELOC_68K_JMP_SLOT
, R_68K_JMP_SLOT
},
160 { BFD_RELOC_68K_RELATIVE
, R_68K_RELATIVE
},
161 { BFD_RELOC_CTOR
, R_68K_32
},
162 { BFD_RELOC_VTABLE_INHERIT
, R_68K_GNU_VTINHERIT
},
163 { BFD_RELOC_VTABLE_ENTRY
, R_68K_GNU_VTENTRY
},
166 static reloc_howto_type
*
167 reloc_type_lookup (abfd
, code
)
168 bfd
*abfd ATTRIBUTE_UNUSED
;
169 bfd_reloc_code_real_type code
;
172 for (i
= 0; i
< sizeof (reloc_map
) / sizeof (reloc_map
[0]); i
++)
174 if (reloc_map
[i
].bfd_val
== code
)
175 return &howto_table
[reloc_map
[i
].elf_val
];
180 #define bfd_elf32_bfd_reloc_type_lookup reloc_type_lookup
181 #define ELF_ARCH bfd_arch_m68k
182 /* end code generated by elf.el */
184 /* Functions for the m68k ELF linker. */
186 /* The name of the dynamic interpreter. This is put in the .interp
189 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
191 /* The size in bytes of an entry in the procedure linkage table. */
193 #define PLT_ENTRY_SIZE 20
195 /* The first entry in a procedure linkage table looks like this. See
196 the SVR4 ABI m68k supplement to see how this works. */
198 static const bfd_byte elf_m68k_plt0_entry
[PLT_ENTRY_SIZE
] =
200 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
201 0, 0, 0, 0, /* replaced with offset to .got + 4. */
202 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,addr]) */
203 0, 0, 0, 0, /* replaced with offset to .got + 8. */
204 0, 0, 0, 0 /* pad out to 20 bytes. */
207 /* Subsequent entries in a procedure linkage table look like this. */
209 static const bfd_byte elf_m68k_plt_entry
[PLT_ENTRY_SIZE
] =
211 0x4e, 0xfb, 0x01, 0x71, /* jmp ([%pc,symbol@GOTPC]) */
212 0, 0, 0, 0, /* replaced with offset to symbol's .got entry. */
213 0x2f, 0x3c, /* move.l #offset,-(%sp) */
214 0, 0, 0, 0, /* replaced with offset into relocation table. */
215 0x60, 0xff, /* bra.l .plt */
216 0, 0, 0, 0 /* replaced with offset to start of .plt. */
219 #define CPU32_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_CPU32)
221 #define PLT_CPU32_ENTRY_SIZE 24
222 /* Procedure linkage table entries for the cpu32 */
223 static const bfd_byte elf_cpu32_plt0_entry
[PLT_CPU32_ENTRY_SIZE
] =
225 0x2f, 0x3b, 0x01, 0x70, /* move.l (%pc,addr),-(%sp) */
226 0, 0, 0, 0, /* replaced with offset to .got + 4. */
227 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
228 0, 0, 0, 0, /* replace with offset to .got +8. */
229 0x4e, 0xd1, /* jmp %a1@ */
230 0, 0, 0, 0, /* pad out to 24 bytes. */
234 static const bfd_byte elf_cpu32_plt_entry
[PLT_CPU32_ENTRY_SIZE
] =
236 0x22, 0x7b, 0x01, 0x70, /* moveal %pc@(0xc), %a1 */
237 0, 0, 0, 0, /* replaced with offset to symbol's .got entry. */
238 0x4e, 0xd1, /* jmp %a1@ */
239 0x2f, 0x3c, /* move.l #offset,-(%sp) */
240 0, 0, 0, 0, /* replaced with offset into relocation table. */
241 0x60, 0xff, /* bra.l .plt */
242 0, 0, 0, 0, /* replaced with offset to start of .plt. */
246 /* The m68k linker needs to keep track of the number of relocs that it
247 decides to copy in check_relocs for each symbol. This is so that it
248 can discard PC relative relocs if it doesn't need them when linking
249 with -Bsymbolic. We store the information in a field extending the
250 regular ELF linker hash table. */
252 /* This structure keeps track of the number of PC relative relocs we have
253 copied for a given symbol. */
255 struct elf_m68k_pcrel_relocs_copied
258 struct elf_m68k_pcrel_relocs_copied
*next
;
259 /* A section in dynobj. */
261 /* Number of relocs copied in this section. */
265 /* m68k ELF linker hash entry. */
267 struct elf_m68k_link_hash_entry
269 struct elf_link_hash_entry root
;
271 /* Number of PC relative relocs copied for this symbol. */
272 struct elf_m68k_pcrel_relocs_copied
*pcrel_relocs_copied
;
275 /* m68k ELF linker hash table. */
277 struct elf_m68k_link_hash_table
279 struct elf_link_hash_table root
;
281 /* Small local sym to section mapping cache. */
282 struct sym_sec_cache sym_sec
;
285 /* Declare this now that the above structures are defined. */
287 static bfd_boolean elf_m68k_discard_copies
288 PARAMS ((struct elf_m68k_link_hash_entry
*, PTR
));
290 /* Traverse an m68k ELF linker hash table. */
292 #define elf_m68k_link_hash_traverse(table, func, info) \
293 (elf_link_hash_traverse \
295 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
298 /* Get the m68k ELF linker hash table from a link_info structure. */
300 #define elf_m68k_hash_table(p) \
301 ((struct elf_m68k_link_hash_table *) (p)->hash)
303 /* Create an entry in an m68k ELF linker hash table. */
305 static struct bfd_hash_entry
*
306 elf_m68k_link_hash_newfunc (entry
, table
, string
)
307 struct bfd_hash_entry
*entry
;
308 struct bfd_hash_table
*table
;
311 struct elf_m68k_link_hash_entry
*ret
=
312 (struct elf_m68k_link_hash_entry
*) entry
;
314 /* Allocate the structure if it has not already been allocated by a
316 if (ret
== (struct elf_m68k_link_hash_entry
*) NULL
)
317 ret
= ((struct elf_m68k_link_hash_entry
*)
318 bfd_hash_allocate (table
,
319 sizeof (struct elf_m68k_link_hash_entry
)));
320 if (ret
== (struct elf_m68k_link_hash_entry
*) NULL
)
321 return (struct bfd_hash_entry
*) ret
;
323 /* Call the allocation method of the superclass. */
324 ret
= ((struct elf_m68k_link_hash_entry
*)
325 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
327 if (ret
!= (struct elf_m68k_link_hash_entry
*) NULL
)
329 ret
->pcrel_relocs_copied
= NULL
;
332 return (struct bfd_hash_entry
*) ret
;
335 /* Create an m68k ELF linker hash table. */
337 static struct bfd_link_hash_table
*
338 elf_m68k_link_hash_table_create (abfd
)
341 struct elf_m68k_link_hash_table
*ret
;
342 bfd_size_type amt
= sizeof (struct elf_m68k_link_hash_table
);
344 ret
= (struct elf_m68k_link_hash_table
*) bfd_malloc (amt
);
345 if (ret
== (struct elf_m68k_link_hash_table
*) NULL
)
348 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
349 elf_m68k_link_hash_newfunc
))
355 ret
->sym_sec
.abfd
= NULL
;
357 return &ret
->root
.root
;
360 /* Keep m68k-specific flags in the ELF header */
362 elf32_m68k_set_private_flags (abfd
, flags
)
366 elf_elfheader (abfd
)->e_flags
= flags
;
367 elf_flags_init (abfd
) = TRUE
;
371 /* Merge backend specific data from an object file to the output
372 object file when linking. */
374 elf32_m68k_merge_private_bfd_data (ibfd
, obfd
)
381 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
382 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
385 in_flags
= elf_elfheader (ibfd
)->e_flags
;
386 out_flags
= elf_elfheader (obfd
)->e_flags
;
388 if (!elf_flags_init (obfd
))
390 elf_flags_init (obfd
) = TRUE
;
391 elf_elfheader (obfd
)->e_flags
= in_flags
;
397 /* Display the flags field */
399 elf32_m68k_print_private_bfd_data (abfd
, ptr
)
403 FILE *file
= (FILE *) ptr
;
405 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
407 /* Print normal ELF private data. */
408 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
410 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
412 /* xgettext:c-format */
413 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
415 if (elf_elfheader (abfd
)->e_flags
& EF_CPU32
)
416 fprintf (file
, _(" [cpu32]"));
418 if (elf_elfheader (abfd
)->e_flags
& EF_M68000
)
419 fprintf (file
, _(" [m68000]"));
425 /* Look through the relocs for a section during the first phase, and
426 allocate space in the global offset table or procedure linkage
430 elf_m68k_check_relocs (abfd
, info
, sec
, relocs
)
432 struct bfd_link_info
*info
;
434 const Elf_Internal_Rela
*relocs
;
437 Elf_Internal_Shdr
*symtab_hdr
;
438 struct elf_link_hash_entry
**sym_hashes
;
439 bfd_signed_vma
*local_got_refcounts
;
440 const Elf_Internal_Rela
*rel
;
441 const Elf_Internal_Rela
*rel_end
;
446 if (info
->relocateable
)
449 dynobj
= elf_hash_table (info
)->dynobj
;
450 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
451 sym_hashes
= elf_sym_hashes (abfd
);
452 local_got_refcounts
= elf_local_got_refcounts (abfd
);
458 rel_end
= relocs
+ sec
->reloc_count
;
459 for (rel
= relocs
; rel
< rel_end
; rel
++)
461 unsigned long r_symndx
;
462 struct elf_link_hash_entry
*h
;
464 r_symndx
= ELF32_R_SYM (rel
->r_info
);
466 if (r_symndx
< symtab_hdr
->sh_info
)
469 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
471 switch (ELF32_R_TYPE (rel
->r_info
))
477 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
483 /* This symbol requires a global offset table entry. */
487 /* Create the .got section. */
488 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
489 if (!_bfd_elf_create_got_section (dynobj
, info
))
495 sgot
= bfd_get_section_by_name (dynobj
, ".got");
496 BFD_ASSERT (sgot
!= NULL
);
500 && (h
!= NULL
|| info
->shared
))
502 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
505 srelgot
= bfd_make_section (dynobj
, ".rela.got");
507 || !bfd_set_section_flags (dynobj
, srelgot
,
514 || !bfd_set_section_alignment (dynobj
, srelgot
, 2))
521 if (h
->got
.refcount
== 0)
523 /* Make sure this symbol is output as a dynamic symbol. */
525 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
527 if (!bfd_elf32_link_record_dynamic_symbol (info
, h
))
531 /* Allocate space in the .got section. */
532 sgot
->_raw_size
+= 4;
533 /* Allocate relocation space. */
534 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
540 /* This is a global offset table entry for a local symbol. */
541 if (local_got_refcounts
== NULL
)
545 size
= symtab_hdr
->sh_info
;
546 size
*= sizeof (bfd_signed_vma
);
547 local_got_refcounts
= ((bfd_signed_vma
*)
548 bfd_zalloc (abfd
, size
));
549 if (local_got_refcounts
== NULL
)
551 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
553 if (local_got_refcounts
[r_symndx
] == 0)
555 sgot
->_raw_size
+= 4;
558 /* If we are generating a shared object, we need to
559 output a R_68K_RELATIVE reloc so that the dynamic
560 linker can adjust this GOT entry. */
561 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
564 local_got_refcounts
[r_symndx
]++;
571 /* This symbol requires a procedure linkage table entry. We
572 actually build the entry in adjust_dynamic_symbol,
573 because this might be a case of linking PIC code which is
574 never referenced by a dynamic object, in which case we
575 don't need to generate a procedure linkage table entry
578 /* If this is a local symbol, we resolve it directly without
579 creating a procedure linkage table entry. */
583 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
590 /* This symbol requires a procedure linkage table entry. */
594 /* It does not make sense to have this relocation for a
595 local symbol. FIXME: does it? How to handle it if
596 it does make sense? */
597 bfd_set_error (bfd_error_bad_value
);
601 /* Make sure this symbol is output as a dynamic symbol. */
603 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
605 if (!bfd_elf32_link_record_dynamic_symbol (info
, h
))
609 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
616 /* If we are creating a shared library and this is not a local
617 symbol, we need to copy the reloc into the shared library.
618 However when linking with -Bsymbolic and this is a global
619 symbol which is defined in an object we are including in the
620 link (i.e., DEF_REGULAR is set), then we can resolve the
621 reloc directly. At this point we have not seen all the input
622 files, so it is possible that DEF_REGULAR is not set now but
623 will be set later (it is never cleared). We account for that
624 possibility below by storing information in the
625 pcrel_relocs_copied field of the hash table entry. */
627 && (sec
->flags
& SEC_ALLOC
) != 0
630 || h
->root
.type
== bfd_link_hash_defweak
631 || (h
->elf_link_hash_flags
632 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
636 /* Make sure a plt entry is created for this symbol if
637 it turns out to be a function defined by a dynamic
649 /* Make sure a plt entry is created for this symbol if it
650 turns out to be a function defined by a dynamic object. */
654 /* If we are creating a shared library, we need to copy the
655 reloc into the shared library. */
657 && (sec
->flags
& SEC_ALLOC
) != 0)
659 /* When creating a shared object, we must copy these
660 reloc types into the output file. We create a reloc
661 section in dynobj and make room for this reloc. */
666 name
= (bfd_elf_string_from_elf_section
668 elf_elfheader (abfd
)->e_shstrndx
,
669 elf_section_data (sec
)->rel_hdr
.sh_name
));
673 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
674 && strcmp (bfd_get_section_name (abfd
, sec
),
677 sreloc
= bfd_get_section_by_name (dynobj
, name
);
680 sreloc
= bfd_make_section (dynobj
, name
);
682 || !bfd_set_section_flags (dynobj
, sreloc
,
689 || !bfd_set_section_alignment (dynobj
, sreloc
, 2))
694 if (sec
->flags
& SEC_READONLY
695 /* Don't set DF_TEXTREL yet for PC relative
696 relocations, they might be discarded later. */
697 && !(ELF32_R_TYPE (rel
->r_info
) == R_68K_PC8
698 || ELF32_R_TYPE (rel
->r_info
) == R_68K_PC16
699 || ELF32_R_TYPE (rel
->r_info
) == R_68K_PC32
))
700 info
->flags
|= DF_TEXTREL
;
702 sreloc
->_raw_size
+= sizeof (Elf32_External_Rela
);
704 /* We count the number of PC relative relocations we have
705 entered for this symbol, so that we can discard them
706 again if, in the -Bsymbolic case, the symbol is later
707 defined by a regular object, or, in the normal shared
708 case, the symbol is forced to be local. Note that this
709 function is only called if we are using an m68kelf linker
710 hash table, which means that h is really a pointer to an
711 elf_m68k_link_hash_entry. */
712 if (ELF32_R_TYPE (rel
->r_info
) == R_68K_PC8
713 || ELF32_R_TYPE (rel
->r_info
) == R_68K_PC16
714 || ELF32_R_TYPE (rel
->r_info
) == R_68K_PC32
)
716 struct elf_m68k_pcrel_relocs_copied
*p
;
717 struct elf_m68k_pcrel_relocs_copied
**head
;
721 struct elf_m68k_link_hash_entry
*eh
722 = (struct elf_m68k_link_hash_entry
*) h
;
723 head
= &eh
->pcrel_relocs_copied
;
728 s
= (bfd_section_from_r_symndx
729 (abfd
, &elf_m68k_hash_table (info
)->sym_sec
,
734 head
= ((struct elf_m68k_pcrel_relocs_copied
**)
735 &elf_section_data (s
)->local_dynrel
);
738 for (p
= *head
; p
!= NULL
; p
= p
->next
)
739 if (p
->section
== sreloc
)
744 p
= ((struct elf_m68k_pcrel_relocs_copied
*)
745 bfd_alloc (dynobj
, (bfd_size_type
) sizeof *p
));
760 /* This relocation describes the C++ object vtable hierarchy.
761 Reconstruct it for later use during GC. */
762 case R_68K_GNU_VTINHERIT
:
763 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
767 /* This relocation describes which C++ vtable entries are actually
768 used. Record for later use during GC. */
769 case R_68K_GNU_VTENTRY
:
770 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
782 /* Return the section that should be marked against GC for a given
786 elf_m68k_gc_mark_hook (sec
, info
, rel
, h
, sym
)
788 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
789 Elf_Internal_Rela
*rel
;
790 struct elf_link_hash_entry
*h
;
791 Elf_Internal_Sym
*sym
;
795 switch (ELF32_R_TYPE (rel
->r_info
))
797 case R_68K_GNU_VTINHERIT
:
798 case R_68K_GNU_VTENTRY
:
802 switch (h
->root
.type
)
807 case bfd_link_hash_defined
:
808 case bfd_link_hash_defweak
:
809 return h
->root
.u
.def
.section
;
811 case bfd_link_hash_common
:
812 return h
->root
.u
.c
.p
->section
;
817 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
822 /* Update the got entry reference counts for the section being removed. */
825 elf_m68k_gc_sweep_hook (abfd
, info
, sec
, relocs
)
827 struct bfd_link_info
*info
;
829 const Elf_Internal_Rela
*relocs
;
831 Elf_Internal_Shdr
*symtab_hdr
;
832 struct elf_link_hash_entry
**sym_hashes
;
833 bfd_signed_vma
*local_got_refcounts
;
834 const Elf_Internal_Rela
*rel
, *relend
;
835 unsigned long r_symndx
;
836 struct elf_link_hash_entry
*h
;
841 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
842 sym_hashes
= elf_sym_hashes (abfd
);
843 local_got_refcounts
= elf_local_got_refcounts (abfd
);
845 dynobj
= elf_hash_table (info
)->dynobj
;
849 sgot
= bfd_get_section_by_name (dynobj
, ".got");
850 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
852 relend
= relocs
+ sec
->reloc_count
;
853 for (rel
= relocs
; rel
< relend
; rel
++)
855 switch (ELF32_R_TYPE (rel
->r_info
))
863 r_symndx
= ELF32_R_SYM (rel
->r_info
);
864 if (r_symndx
>= symtab_hdr
->sh_info
)
866 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
867 if (h
->got
.refcount
> 0)
870 if (h
->got
.refcount
== 0)
872 /* We don't need the .got entry any more. */
873 sgot
->_raw_size
-= 4;
874 srelgot
->_raw_size
-= sizeof (Elf32_External_Rela
);
878 else if (local_got_refcounts
!= NULL
)
880 if (local_got_refcounts
[r_symndx
] > 0)
882 --local_got_refcounts
[r_symndx
];
883 if (local_got_refcounts
[r_symndx
] == 0)
885 /* We don't need the .got entry any more. */
886 sgot
->_raw_size
-= 4;
888 srelgot
->_raw_size
-= sizeof (Elf32_External_Rela
);
906 r_symndx
= ELF32_R_SYM (rel
->r_info
);
907 if (r_symndx
>= symtab_hdr
->sh_info
)
909 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
910 if (h
->plt
.refcount
> 0)
923 /* Adjust a symbol defined by a dynamic object and referenced by a
924 regular object. The current definition is in some section of the
925 dynamic object, but we're not including those sections. We have to
926 change the definition to something the rest of the link can
930 elf_m68k_adjust_dynamic_symbol (info
, h
)
931 struct bfd_link_info
*info
;
932 struct elf_link_hash_entry
*h
;
936 unsigned int power_of_two
;
938 dynobj
= elf_hash_table (info
)->dynobj
;
940 /* Make sure we know what is going on here. */
941 BFD_ASSERT (dynobj
!= NULL
942 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
943 || h
->weakdef
!= NULL
944 || ((h
->elf_link_hash_flags
945 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
946 && (h
->elf_link_hash_flags
947 & ELF_LINK_HASH_REF_REGULAR
) != 0
948 && (h
->elf_link_hash_flags
949 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
951 /* If this is a function, put it in the procedure linkage table. We
952 will fill in the contents of the procedure linkage table later,
953 when we know the address of the .got section. */
954 if (h
->type
== STT_FUNC
955 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
958 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
959 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0
960 /* We must always create the plt entry if it was referenced
961 by a PLTxxO relocation. In this case we already recorded
962 it as a dynamic symbol. */
965 /* This case can occur if we saw a PLTxx reloc in an input
966 file, but the symbol was never referred to by a dynamic
967 object. In such a case, we don't actually need to build
968 a procedure linkage table, and we can just do a PCxx
970 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
971 h
->plt
.offset
= (bfd_vma
) -1;
975 /* GC may have rendered this entry unused. */
976 if (h
->plt
.refcount
<= 0)
978 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
979 h
->plt
.offset
= (bfd_vma
) -1;
983 /* Make sure this symbol is output as a dynamic symbol. */
985 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
987 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
991 s
= bfd_get_section_by_name (dynobj
, ".plt");
992 BFD_ASSERT (s
!= NULL
);
994 /* If this is the first .plt entry, make room for the special
996 if (s
->_raw_size
== 0)
998 if (CPU32_FLAG (dynobj
))
999 s
->_raw_size
+= PLT_CPU32_ENTRY_SIZE
;
1001 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1004 /* If this symbol is not defined in a regular file, and we are
1005 not generating a shared library, then set the symbol to this
1006 location in the .plt. This is required to make function
1007 pointers compare as equal between the normal executable and
1008 the shared library. */
1010 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1012 h
->root
.u
.def
.section
= s
;
1013 h
->root
.u
.def
.value
= s
->_raw_size
;
1016 h
->plt
.offset
= s
->_raw_size
;
1018 /* Make room for this entry. */
1019 if (CPU32_FLAG (dynobj
))
1020 s
->_raw_size
+= PLT_CPU32_ENTRY_SIZE
;
1022 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1024 /* We also need to make an entry in the .got.plt section, which
1025 will be placed in the .got section by the linker script. */
1027 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
1028 BFD_ASSERT (s
!= NULL
);
1031 /* We also need to make an entry in the .rela.plt section. */
1033 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1034 BFD_ASSERT (s
!= NULL
);
1035 s
->_raw_size
+= sizeof (Elf32_External_Rela
);
1040 /* Reinitialize the plt offset now that it is not used as a reference
1042 h
->plt
.offset
= (bfd_vma
) -1;
1044 /* If this is a weak symbol, and there is a real definition, the
1045 processor independent code will have arranged for us to see the
1046 real definition first, and we can just use the same value. */
1047 if (h
->weakdef
!= NULL
)
1049 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1050 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1051 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1052 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1056 /* This is a reference to a symbol defined by a dynamic object which
1057 is not a function. */
1059 /* If we are creating a shared library, we must presume that the
1060 only references to the symbol are via the global offset table.
1061 For such cases we need not do anything here; the relocations will
1062 be handled correctly by relocate_section. */
1066 /* We must allocate the symbol in our .dynbss section, which will
1067 become part of the .bss section of the executable. There will be
1068 an entry for this symbol in the .dynsym section. The dynamic
1069 object will contain position independent code, so all references
1070 from the dynamic object to this symbol will go through the global
1071 offset table. The dynamic linker will use the .dynsym entry to
1072 determine the address it must put in the global offset table, so
1073 both the dynamic object and the regular object will refer to the
1074 same memory location for the variable. */
1076 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
1077 BFD_ASSERT (s
!= NULL
);
1079 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
1080 copy the initial value out of the dynamic object and into the
1081 runtime process image. We need to remember the offset into the
1082 .rela.bss section we are going to use. */
1083 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1087 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
1088 BFD_ASSERT (srel
!= NULL
);
1089 srel
->_raw_size
+= sizeof (Elf32_External_Rela
);
1090 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1093 /* We need to figure out the alignment required for this symbol. I
1094 have no idea how ELF linkers handle this. */
1095 power_of_two
= bfd_log2 (h
->size
);
1096 if (power_of_two
> 3)
1099 /* Apply the required alignment. */
1100 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1101 (bfd_size_type
) (1 << power_of_two
));
1102 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1104 if (!bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1108 /* Define the symbol as being at this point in the section. */
1109 h
->root
.u
.def
.section
= s
;
1110 h
->root
.u
.def
.value
= s
->_raw_size
;
1112 /* Increment the section size to make room for the symbol. */
1113 s
->_raw_size
+= h
->size
;
1118 /* Set the sizes of the dynamic sections. */
1121 elf_m68k_size_dynamic_sections (output_bfd
, info
)
1122 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1123 struct bfd_link_info
*info
;
1130 dynobj
= elf_hash_table (info
)->dynobj
;
1131 BFD_ASSERT (dynobj
!= NULL
);
1133 if (elf_hash_table (info
)->dynamic_sections_created
)
1135 /* Set the contents of the .interp section to the interpreter. */
1138 s
= bfd_get_section_by_name (dynobj
, ".interp");
1139 BFD_ASSERT (s
!= NULL
);
1140 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1141 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1146 /* We may have created entries in the .rela.got section.
1147 However, if we are not creating the dynamic sections, we will
1148 not actually use these entries. Reset the size of .rela.got,
1149 which will cause it to get stripped from the output file
1151 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
1156 /* If this is a -Bsymbolic shared link, then we need to discard all
1157 PC relative relocs against symbols defined in a regular object.
1158 For the normal shared case we discard the PC relative relocs
1159 against symbols that have become local due to visibility changes.
1160 We allocated space for them in the check_relocs routine, but we
1161 will not fill them in in the relocate_section routine. */
1163 elf_m68k_link_hash_traverse (elf_m68k_hash_table (info
),
1164 elf_m68k_discard_copies
,
1167 /* The check_relocs and adjust_dynamic_symbol entry points have
1168 determined the sizes of the various dynamic sections. Allocate
1172 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1177 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1180 /* It's OK to base decisions on the section name, because none
1181 of the dynobj section names depend upon the input files. */
1182 name
= bfd_get_section_name (dynobj
, s
);
1186 if (strcmp (name
, ".plt") == 0)
1188 if (s
->_raw_size
== 0)
1190 /* Strip this section if we don't need it; see the
1196 /* Remember whether there is a PLT. */
1200 else if (strncmp (name
, ".rela", 5) == 0)
1202 if (s
->_raw_size
== 0)
1204 /* If we don't need this section, strip it from the
1205 output file. This is mostly to handle .rela.bss and
1206 .rela.plt. We must create both sections in
1207 create_dynamic_sections, because they must be created
1208 before the linker maps input sections to output
1209 sections. The linker does that before
1210 adjust_dynamic_symbol is called, and it is that
1211 function which decides whether anything needs to go
1212 into these sections. */
1219 /* We use the reloc_count field as a counter if we need
1220 to copy relocs into the output file. */
1224 else if (strncmp (name
, ".got", 4) != 0)
1226 /* It's not one of our sections, so don't allocate space. */
1232 _bfd_strip_section_from_output (info
, s
);
1236 /* Allocate memory for the section contents. */
1237 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1238 Unused entries should be reclaimed before the section's contents
1239 are written out, but at the moment this does not happen. Thus in
1240 order to prevent writing out garbage, we initialise the section's
1241 contents to zero. */
1242 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1243 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1247 if (elf_hash_table (info
)->dynamic_sections_created
)
1249 /* Add some entries to the .dynamic section. We fill in the
1250 values later, in elf_m68k_finish_dynamic_sections, but we
1251 must add the entries now so that we get the correct size for
1252 the .dynamic section. The DT_DEBUG entry is filled in by the
1253 dynamic linker and used by the debugger. */
1254 #define add_dynamic_entry(TAG, VAL) \
1255 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1259 if (!add_dynamic_entry (DT_DEBUG
, 0))
1265 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1266 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1267 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1268 || !add_dynamic_entry (DT_JMPREL
, 0))
1274 if (!add_dynamic_entry (DT_RELA
, 0)
1275 || !add_dynamic_entry (DT_RELASZ
, 0)
1276 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1280 if ((info
->flags
& DF_TEXTREL
) != 0)
1282 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1286 #undef add_dynamic_entry
1291 /* This function is called via elf_m68k_link_hash_traverse if we are
1292 creating a shared object. In the -Bsymbolic case it discards the
1293 space allocated to copy PC relative relocs against symbols which
1294 are defined in regular objects. For the normal shared case, it
1295 discards space for pc-relative relocs that have become local due to
1296 symbol visibility changes. We allocated space for them in the
1297 check_relocs routine, but we won't fill them in in the
1298 relocate_section routine.
1300 We also check whether any of the remaining relocations apply
1301 against a readonly section, and set the DF_TEXTREL flag in this
1305 elf_m68k_discard_copies (h
, inf
)
1306 struct elf_m68k_link_hash_entry
*h
;
1309 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1310 struct elf_m68k_pcrel_relocs_copied
*s
;
1312 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1313 h
= (struct elf_m68k_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1315 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1317 && (h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0))
1319 if ((info
->flags
& DF_TEXTREL
) == 0)
1321 /* Look for relocations against read-only sections. */
1322 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
1323 if ((s
->section
->flags
& SEC_READONLY
) != 0)
1325 info
->flags
|= DF_TEXTREL
;
1332 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
1333 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rela
);
1338 /* Relocate an M68K ELF section. */
1341 elf_m68k_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1342 contents
, relocs
, local_syms
, local_sections
)
1344 struct bfd_link_info
*info
;
1346 asection
*input_section
;
1348 Elf_Internal_Rela
*relocs
;
1349 Elf_Internal_Sym
*local_syms
;
1350 asection
**local_sections
;
1353 Elf_Internal_Shdr
*symtab_hdr
;
1354 struct elf_link_hash_entry
**sym_hashes
;
1355 bfd_vma
*local_got_offsets
;
1359 Elf_Internal_Rela
*rel
;
1360 Elf_Internal_Rela
*relend
;
1362 if (info
->relocateable
)
1365 dynobj
= elf_hash_table (info
)->dynobj
;
1366 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1367 sym_hashes
= elf_sym_hashes (input_bfd
);
1368 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1375 relend
= relocs
+ input_section
->reloc_count
;
1376 for (; rel
< relend
; rel
++)
1379 reloc_howto_type
*howto
;
1380 unsigned long r_symndx
;
1381 struct elf_link_hash_entry
*h
;
1382 Elf_Internal_Sym
*sym
;
1385 bfd_reloc_status_type r
;
1387 r_type
= ELF32_R_TYPE (rel
->r_info
);
1388 if (r_type
< 0 || r_type
>= (int) R_68K_max
)
1390 bfd_set_error (bfd_error_bad_value
);
1393 howto
= howto_table
+ r_type
;
1395 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1400 if (r_symndx
< symtab_hdr
->sh_info
)
1402 sym
= local_syms
+ r_symndx
;
1403 sec
= local_sections
[r_symndx
];
1404 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
1408 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1409 while (h
->root
.type
== bfd_link_hash_indirect
1410 || h
->root
.type
== bfd_link_hash_warning
)
1411 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1412 if (h
->root
.type
== bfd_link_hash_defined
1413 || h
->root
.type
== bfd_link_hash_defweak
)
1415 sec
= h
->root
.u
.def
.section
;
1416 if (((r_type
== R_68K_PLT8
1417 || r_type
== R_68K_PLT16
1418 || r_type
== R_68K_PLT32
1419 || r_type
== R_68K_PLT8O
1420 || r_type
== R_68K_PLT16O
1421 || r_type
== R_68K_PLT32O
)
1422 && h
->plt
.offset
!= (bfd_vma
) -1
1423 && elf_hash_table (info
)->dynamic_sections_created
)
1424 || ((r_type
== R_68K_GOT8O
1425 || r_type
== R_68K_GOT16O
1426 || r_type
== R_68K_GOT32O
1427 || ((r_type
== R_68K_GOT8
1428 || r_type
== R_68K_GOT16
1429 || r_type
== R_68K_GOT32
)
1430 && strcmp (h
->root
.root
.string
,
1431 "_GLOBAL_OFFSET_TABLE_") != 0))
1432 && elf_hash_table (info
)->dynamic_sections_created
1434 || (! info
->symbolic
&& h
->dynindx
!= -1)
1435 || (h
->elf_link_hash_flags
1436 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1438 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1439 || (h
->elf_link_hash_flags
1440 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1441 && ((input_section
->flags
& SEC_ALLOC
) != 0
1442 /* DWARF will emit R_68K_32 relocations in its
1443 sections against symbols defined externally
1444 in shared libraries. We can't do anything
1446 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1447 && (h
->elf_link_hash_flags
1448 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1449 && (r_type
== R_68K_8
1450 || r_type
== R_68K_16
1451 || r_type
== R_68K_32
1452 || r_type
== R_68K_PC8
1453 || r_type
== R_68K_PC16
1454 || r_type
== R_68K_PC32
)))
1456 /* In these cases, we don't need the relocation
1457 value. We check specially because in some
1458 obscure cases sec->output_section will be NULL. */
1462 relocation
= (h
->root
.u
.def
.value
1463 + sec
->output_section
->vma
1464 + sec
->output_offset
);
1466 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1468 else if (info
->shared
1469 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1470 && !info
->no_undefined
1471 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1475 if (!(info
->callbacks
->undefined_symbol
1476 (info
, h
->root
.root
.string
, input_bfd
,
1477 input_section
, rel
->r_offset
,
1478 (!info
->shared
|| info
->no_undefined
1479 || ELF_ST_VISIBILITY (h
->other
)))))
1490 /* Relocation is to the address of the entry for this symbol
1491 in the global offset table. */
1493 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1499 /* Relocation is the offset of the entry for this symbol in
1500 the global offset table. */
1507 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1508 BFD_ASSERT (sgot
!= NULL
);
1513 off
= h
->got
.offset
;
1514 BFD_ASSERT (off
!= (bfd_vma
) -1);
1516 if (!elf_hash_table (info
)->dynamic_sections_created
1518 && (info
->symbolic
|| h
->dynindx
== -1)
1519 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1521 /* This is actually a static link, or it is a
1522 -Bsymbolic link and the symbol is defined
1523 locally, or the symbol was forced to be local
1524 because of a version file.. We must initialize
1525 this entry in the global offset table. Since
1526 the offset must always be a multiple of 4, we
1527 use the least significant bit to record whether
1528 we have initialized it already.
1530 When doing a dynamic link, we create a .rela.got
1531 relocation entry to initialize the value. This
1532 is done in the finish_dynamic_symbol routine. */
1537 bfd_put_32 (output_bfd
, relocation
,
1538 sgot
->contents
+ off
);
1545 BFD_ASSERT (local_got_offsets
!= NULL
1546 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1548 off
= local_got_offsets
[r_symndx
];
1550 /* The offset must always be a multiple of 4. We use
1551 the least significant bit to record whether we have
1552 already generated the necessary reloc. */
1557 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1562 Elf_Internal_Rela outrel
;
1565 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
1566 BFD_ASSERT (s
!= NULL
);
1568 outrel
.r_offset
= (sgot
->output_section
->vma
1569 + sgot
->output_offset
1571 outrel
.r_info
= ELF32_R_INFO (0, R_68K_RELATIVE
);
1572 outrel
.r_addend
= relocation
;
1574 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1575 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1578 local_got_offsets
[r_symndx
] |= 1;
1582 relocation
= sgot
->output_offset
+ off
;
1583 if (r_type
== R_68K_GOT8O
1584 || r_type
== R_68K_GOT16O
1585 || r_type
== R_68K_GOT32O
)
1587 /* This relocation does not use the addend. */
1591 relocation
+= sgot
->output_section
->vma
;
1598 /* Relocation is to the entry for this symbol in the
1599 procedure linkage table. */
1601 /* Resolve a PLTxx reloc against a local symbol directly,
1602 without using the procedure linkage table. */
1606 if (h
->plt
.offset
== (bfd_vma
) -1
1607 || !elf_hash_table (info
)->dynamic_sections_created
)
1609 /* We didn't make a PLT entry for this symbol. This
1610 happens when statically linking PIC code, or when
1611 using -Bsymbolic. */
1617 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1618 BFD_ASSERT (splt
!= NULL
);
1621 relocation
= (splt
->output_section
->vma
1622 + splt
->output_offset
1629 /* Relocation is the offset of the entry for this symbol in
1630 the procedure linkage table. */
1631 BFD_ASSERT (h
!= NULL
&& h
->plt
.offset
!= (bfd_vma
) -1);
1635 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1636 BFD_ASSERT (splt
!= NULL
);
1639 relocation
= h
->plt
.offset
;
1641 /* This relocation does not use the addend. */
1651 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0))
1659 && (input_section
->flags
& SEC_ALLOC
) != 0
1660 && ((r_type
!= R_68K_PC8
1661 && r_type
!= R_68K_PC16
1662 && r_type
!= R_68K_PC32
)
1664 || (h
->elf_link_hash_flags
1665 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
1667 Elf_Internal_Rela outrel
;
1669 bfd_boolean skip
, relocate
;
1671 /* When generating a shared object, these relocations
1672 are copied into the output file to be resolved at run
1679 name
= (bfd_elf_string_from_elf_section
1681 elf_elfheader (input_bfd
)->e_shstrndx
,
1682 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1686 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
1687 && strcmp (bfd_get_section_name (input_bfd
,
1691 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1692 BFD_ASSERT (sreloc
!= NULL
);
1699 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1701 if (outrel
.r_offset
== (bfd_vma
) -1)
1703 else if (outrel
.r_offset
== (bfd_vma
) -2)
1704 skip
= TRUE
, relocate
= TRUE
;
1705 outrel
.r_offset
+= (input_section
->output_section
->vma
1706 + input_section
->output_offset
);
1709 memset (&outrel
, 0, sizeof outrel
);
1710 /* h->dynindx may be -1 if the symbol was marked to
1713 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1714 || (h
->elf_link_hash_flags
1715 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1717 BFD_ASSERT (h
->dynindx
!= -1);
1718 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1719 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1723 if (r_type
== R_68K_32
)
1726 outrel
.r_info
= ELF32_R_INFO (0, R_68K_RELATIVE
);
1727 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1734 sec
= local_sections
[r_symndx
];
1737 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1739 == bfd_link_hash_defweak
));
1740 sec
= h
->root
.u
.def
.section
;
1742 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
1744 else if (sec
== NULL
|| sec
->owner
== NULL
)
1746 bfd_set_error (bfd_error_bad_value
);
1753 osec
= sec
->output_section
;
1754 indx
= elf_section_data (osec
)->dynindx
;
1755 BFD_ASSERT (indx
> 0);
1758 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
1759 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1763 loc
= sreloc
->contents
;
1764 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1765 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1767 /* This reloc will be computed at runtime, so there's no
1768 need to do anything now, except for R_68K_32
1769 relocations that have been turned into
1777 case R_68K_GNU_VTINHERIT
:
1778 case R_68K_GNU_VTENTRY
:
1779 /* These are no-ops in the end. */
1786 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1787 contents
, rel
->r_offset
,
1788 relocation
, rel
->r_addend
);
1790 if (r
!= bfd_reloc_ok
)
1795 case bfd_reloc_outofrange
:
1797 case bfd_reloc_overflow
:
1802 name
= h
->root
.root
.string
;
1805 name
= bfd_elf_string_from_elf_section (input_bfd
,
1806 symtab_hdr
->sh_link
,
1811 name
= bfd_section_name (input_bfd
, sec
);
1813 if (!(info
->callbacks
->reloc_overflow
1814 (info
, name
, howto
->name
, (bfd_vma
) 0,
1815 input_bfd
, input_section
, rel
->r_offset
)))
1826 /* Finish up dynamic symbol handling. We set the contents of various
1827 dynamic sections here. */
1830 elf_m68k_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1832 struct bfd_link_info
*info
;
1833 struct elf_link_hash_entry
*h
;
1834 Elf_Internal_Sym
*sym
;
1837 int plt_off1
, plt_off2
, plt_off3
;
1839 dynobj
= elf_hash_table (info
)->dynobj
;
1841 if (h
->plt
.offset
!= (bfd_vma
) -1)
1848 Elf_Internal_Rela rela
;
1851 /* This symbol has an entry in the procedure linkage table. Set
1854 BFD_ASSERT (h
->dynindx
!= -1);
1856 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1857 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
1858 srela
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1859 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srela
!= NULL
);
1861 /* Get the index in the procedure linkage table which
1862 corresponds to this symbol. This is the index of this symbol
1863 in all the symbols for which we are making plt entries. The
1864 first entry in the procedure linkage table is reserved. */
1865 if ( CPU32_FLAG (output_bfd
))
1866 plt_index
= h
->plt
.offset
/ PLT_CPU32_ENTRY_SIZE
- 1;
1868 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1870 /* Get the offset into the .got table of the entry that
1871 corresponds to this function. Each .got entry is 4 bytes.
1872 The first three are reserved. */
1873 got_offset
= (plt_index
+ 3) * 4;
1875 if ( CPU32_FLAG (output_bfd
))
1877 /* Fill in the entry in the procedure linkage table. */
1878 memcpy (splt
->contents
+ h
->plt
.offset
, elf_cpu32_plt_entry
,
1879 PLT_CPU32_ENTRY_SIZE
);
1886 /* Fill in the entry in the procedure linkage table. */
1887 memcpy (splt
->contents
+ h
->plt
.offset
, elf_m68k_plt_entry
,
1894 /* The offset is relative to the first extension word. */
1895 bfd_put_32 (output_bfd
,
1896 (sgot
->output_section
->vma
1897 + sgot
->output_offset
1899 - (splt
->output_section
->vma
1900 + h
->plt
.offset
+ 2)),
1901 splt
->contents
+ h
->plt
.offset
+ plt_off1
);
1903 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rela
),
1904 splt
->contents
+ h
->plt
.offset
+ plt_off2
);
1905 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ plt_off3
),
1906 splt
->contents
+ h
->plt
.offset
+ plt_off3
);
1908 /* Fill in the entry in the global offset table. */
1909 bfd_put_32 (output_bfd
,
1910 (splt
->output_section
->vma
1911 + splt
->output_offset
1914 sgot
->contents
+ got_offset
);
1916 /* Fill in the entry in the .rela.plt section. */
1917 rela
.r_offset
= (sgot
->output_section
->vma
1918 + sgot
->output_offset
1920 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_68K_JMP_SLOT
);
1922 loc
= srela
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
1923 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1925 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1927 /* Mark the symbol as undefined, rather than as defined in
1928 the .plt section. Leave the value alone. */
1929 sym
->st_shndx
= SHN_UNDEF
;
1933 if (h
->got
.offset
!= (bfd_vma
) -1)
1937 Elf_Internal_Rela rela
;
1940 /* This symbol has an entry in the global offset table. Set it
1943 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1944 srela
= bfd_get_section_by_name (dynobj
, ".rela.got");
1945 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
1947 rela
.r_offset
= (sgot
->output_section
->vma
1948 + sgot
->output_offset
1949 + (h
->got
.offset
&~ (bfd_vma
) 1));
1951 /* If this is a -Bsymbolic link, and the symbol is defined
1952 locally, we just want to emit a RELATIVE reloc. Likewise if
1953 the symbol was forced to be local because of a version file.
1954 The entry in the global offset table will already have been
1955 initialized in the relocate_section function. */
1957 && (info
->symbolic
|| h
->dynindx
== -1)
1958 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
1960 rela
.r_info
= ELF32_R_INFO (0, R_68K_RELATIVE
);
1961 rela
.r_addend
= bfd_get_signed_32 (output_bfd
,
1963 + (h
->got
.offset
&~ (bfd_vma
) 1)));
1967 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
1968 sgot
->contents
+ (h
->got
.offset
&~ (bfd_vma
) 1));
1969 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_68K_GLOB_DAT
);
1973 loc
= srela
->contents
;
1974 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1975 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1978 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
1981 Elf_Internal_Rela rela
;
1984 /* This symbol needs a copy reloc. Set it up. */
1986 BFD_ASSERT (h
->dynindx
!= -1
1987 && (h
->root
.type
== bfd_link_hash_defined
1988 || h
->root
.type
== bfd_link_hash_defweak
));
1990 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
1992 BFD_ASSERT (s
!= NULL
);
1994 rela
.r_offset
= (h
->root
.u
.def
.value
1995 + h
->root
.u
.def
.section
->output_section
->vma
1996 + h
->root
.u
.def
.section
->output_offset
);
1997 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_68K_COPY
);
1999 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
2000 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2003 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2004 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2005 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2006 sym
->st_shndx
= SHN_ABS
;
2011 /* Finish up the dynamic sections. */
2014 elf_m68k_finish_dynamic_sections (output_bfd
, info
)
2016 struct bfd_link_info
*info
;
2022 dynobj
= elf_hash_table (info
)->dynobj
;
2024 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
2025 BFD_ASSERT (sgot
!= NULL
);
2026 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2028 if (elf_hash_table (info
)->dynamic_sections_created
)
2031 Elf32_External_Dyn
*dyncon
, *dynconend
;
2033 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2034 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
2036 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2037 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2038 for (; dyncon
< dynconend
; dyncon
++)
2040 Elf_Internal_Dyn dyn
;
2044 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2057 s
= bfd_get_section_by_name (output_bfd
, name
);
2058 BFD_ASSERT (s
!= NULL
);
2059 dyn
.d_un
.d_ptr
= s
->vma
;
2060 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2064 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2065 BFD_ASSERT (s
!= NULL
);
2066 if (s
->_cooked_size
!= 0)
2067 dyn
.d_un
.d_val
= s
->_cooked_size
;
2069 dyn
.d_un
.d_val
= s
->_raw_size
;
2070 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2074 /* The procedure linkage table relocs (DT_JMPREL) should
2075 not be included in the overall relocs (DT_RELA).
2076 Therefore, we override the DT_RELASZ entry here to
2077 make it not include the JMPREL relocs. Since the
2078 linker script arranges for .rela.plt to follow all
2079 other relocation sections, we don't have to worry
2080 about changing the DT_RELA entry. */
2081 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2084 if (s
->_cooked_size
!= 0)
2085 dyn
.d_un
.d_val
-= s
->_cooked_size
;
2087 dyn
.d_un
.d_val
-= s
->_raw_size
;
2089 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2094 /* Fill in the first entry in the procedure linkage table. */
2095 if (splt
->_raw_size
> 0)
2097 if (!CPU32_FLAG (output_bfd
))
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
2115 memcpy (splt
->contents
, elf_cpu32_plt0_entry
, PLT_CPU32_ENTRY_SIZE
);
2116 bfd_put_32 (output_bfd
,
2117 (sgot
->output_section
->vma
2118 + sgot
->output_offset
+ 4
2119 - (splt
->output_section
->vma
+ 2)),
2120 splt
->contents
+ 4);
2121 bfd_put_32 (output_bfd
,
2122 (sgot
->output_section
->vma
2123 + sgot
->output_offset
+ 8
2124 - (splt
->output_section
->vma
+ 10)),
2125 splt
->contents
+ 12);
2126 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
2127 = PLT_CPU32_ENTRY_SIZE
;
2132 /* Fill in the first three entries in the global offset table. */
2133 if (sgot
->_raw_size
> 0)
2136 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
2138 bfd_put_32 (output_bfd
,
2139 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2141 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
2142 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
2145 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
2150 /* Given a .data section and a .emreloc in-memory section, store
2151 relocation information into the .emreloc section which can be
2152 used at runtime to relocate the section. This is called by the
2153 linker when the --embedded-relocs switch is used. This is called
2154 after the add_symbols entry point has been called for all the
2155 objects, and before the final_link entry point is called. */
2158 bfd_m68k_elf32_create_embedded_relocs (abfd
, info
, datasec
, relsec
, errmsg
)
2160 struct bfd_link_info
*info
;
2165 Elf_Internal_Shdr
*symtab_hdr
;
2166 Elf_Internal_Sym
*isymbuf
= NULL
;
2167 Elf_Internal_Rela
*internal_relocs
= NULL
;
2168 Elf_Internal_Rela
*irel
, *irelend
;
2172 BFD_ASSERT (! info
->relocateable
);
2176 if (datasec
->reloc_count
== 0)
2179 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2181 /* Get a copy of the native relocations. */
2182 internal_relocs
= (_bfd_elf32_link_read_relocs
2183 (abfd
, datasec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
2184 info
->keep_memory
));
2185 if (internal_relocs
== NULL
)
2188 amt
= (bfd_size_type
) datasec
->reloc_count
* 12;
2189 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
2190 if (relsec
->contents
== NULL
)
2193 p
= relsec
->contents
;
2195 irelend
= internal_relocs
+ datasec
->reloc_count
;
2196 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 12)
2198 asection
*targetsec
;
2200 /* We are going to write a four byte longword into the runtime
2201 reloc section. The longword will be the address in the data
2202 section which must be relocated. It is followed by the name
2203 of the target section NUL-padded or truncated to 8
2206 /* We can only relocate absolute longword relocs at run time. */
2207 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_68K_32
)
2209 *errmsg
= _("unsupported reloc type");
2210 bfd_set_error (bfd_error_bad_value
);
2214 /* Get the target section referred to by the reloc. */
2215 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
2217 /* A local symbol. */
2218 Elf_Internal_Sym
*isym
;
2220 /* Read this BFD's local symbols if we haven't done so already. */
2221 if (isymbuf
== NULL
)
2223 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2224 if (isymbuf
== NULL
)
2225 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
2226 symtab_hdr
->sh_info
, 0,
2228 if (isymbuf
== NULL
)
2232 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
2233 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2238 struct elf_link_hash_entry
*h
;
2240 /* An external symbol. */
2241 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
2242 h
= elf_sym_hashes (abfd
)[indx
];
2243 BFD_ASSERT (h
!= NULL
);
2244 if (h
->root
.type
== bfd_link_hash_defined
2245 || h
->root
.type
== bfd_link_hash_defweak
)
2246 targetsec
= h
->root
.u
.def
.section
;
2251 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
2252 memset (p
+ 4, 0, 8);
2253 if (targetsec
!= NULL
)
2254 strncpy (p
+ 4, targetsec
->output_section
->name
, 8);
2257 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2259 if (internal_relocs
!= NULL
2260 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
2261 free (internal_relocs
);
2265 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2267 if (internal_relocs
!= NULL
2268 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
2269 free (internal_relocs
);
2273 static enum elf_reloc_type_class
2274 elf32_m68k_reloc_type_class (rela
)
2275 const Elf_Internal_Rela
*rela
;
2277 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2279 case R_68K_RELATIVE
:
2280 return reloc_class_relative
;
2281 case R_68K_JMP_SLOT
:
2282 return reloc_class_plt
;
2284 return reloc_class_copy
;
2286 return reloc_class_normal
;
2290 #define TARGET_BIG_SYM bfd_elf32_m68k_vec
2291 #define TARGET_BIG_NAME "elf32-m68k"
2292 #define ELF_MACHINE_CODE EM_68K
2293 #define ELF_MAXPAGESIZE 0x2000
2294 #define elf_backend_create_dynamic_sections \
2295 _bfd_elf_create_dynamic_sections
2296 #define bfd_elf32_bfd_link_hash_table_create \
2297 elf_m68k_link_hash_table_create
2298 #define bfd_elf32_bfd_final_link _bfd_elf32_gc_common_final_link
2300 #define elf_backend_check_relocs elf_m68k_check_relocs
2301 #define elf_backend_adjust_dynamic_symbol \
2302 elf_m68k_adjust_dynamic_symbol
2303 #define elf_backend_size_dynamic_sections \
2304 elf_m68k_size_dynamic_sections
2305 #define elf_backend_relocate_section elf_m68k_relocate_section
2306 #define elf_backend_finish_dynamic_symbol \
2307 elf_m68k_finish_dynamic_symbol
2308 #define elf_backend_finish_dynamic_sections \
2309 elf_m68k_finish_dynamic_sections
2310 #define elf_backend_gc_mark_hook elf_m68k_gc_mark_hook
2311 #define elf_backend_gc_sweep_hook elf_m68k_gc_sweep_hook
2312 #define bfd_elf32_bfd_merge_private_bfd_data \
2313 elf32_m68k_merge_private_bfd_data
2314 #define bfd_elf32_bfd_set_private_flags \
2315 elf32_m68k_set_private_flags
2316 #define bfd_elf32_bfd_print_private_bfd_data \
2317 elf32_m68k_print_private_bfd_data
2318 #define elf_backend_reloc_type_class elf32_m68k_reloc_type_class
2320 #define elf_backend_can_gc_sections 1
2321 #define elf_backend_can_refcount 1
2322 #define elf_backend_want_got_plt 1
2323 #define elf_backend_plt_readonly 1
2324 #define elf_backend_want_plt_sym 0
2325 #define elf_backend_got_header_size 12
2326 #define elf_backend_rela_normal 1
2328 #include "elf32-target.h"