projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elf32-mips.c (gprel32_with_gp): Remove useless N64 ABI case.
[deliverable/binutils-gdb.git] / bfd / elf32-i386.c
CommitLineData
252b5132 1/* Intel 80386/80486-specific support for 32-bit ELF
571fe01f 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
638632bd 3 Free Software Foundation, Inc.
252b5132 4
571fe01f 5 This file is part of BFD, the Binary File Descriptor library.
252b5132 6
571fe01f
NC		 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.
252b5132 11
571fe01f
NC		 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.
252b5132 16
571fe01f
NC		 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. */
252b5132
RH		 20
21#include "bfd.h"
22#include "sysdep.h"
23#include "bfdlink.h"
24#include "libbfd.h"
25#include "elf-bfd.h"
26
27static reloc_howto_type *elf_i386_reloc_type_lookup
28 PARAMS ((bfd *, bfd_reloc_code_real_type));
252b5132 29static void elf_i386_info_to_howto_rel
947216bf 30 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
b34976b6 31static bfd_boolean elf_i386_is_local_label_name
ebe50bae 32 PARAMS ((bfd *, const char *));
b34976b6 33static bfd_boolean elf_i386_grok_prstatus
38701953 34 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
b34976b6 35static bfd_boolean elf_i386_grok_psinfo
38701953
AM		 36 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
37static struct bfd_hash_entry *link_hash_newfunc
252b5132
RH		 38 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
39static struct bfd_link_hash_table *elf_i386_link_hash_table_create
40 PARAMS ((bfd *));
b34976b6 41static bfd_boolean create_got_section
571fe01f 42 PARAMS ((bfd *, struct bfd_link_info *));
b34976b6 43static bfd_boolean elf_i386_create_dynamic_sections
571fe01f 44 PARAMS ((bfd *, struct bfd_link_info *));
51b64d56 45static void elf_i386_copy_indirect_symbol
b48fa14c
AM		 46 PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
47 struct elf_link_hash_entry *));
13ae64f3
JJ		 48static int elf_i386_tls_transition
49 PARAMS ((struct bfd_link_info *, int, int));
50
b34976b6 51static bfd_boolean elf_i386_mkobject
571fe01f 52 PARAMS ((bfd *));
b34976b6 53static bfd_boolean elf_i386_object_p
571fe01f 54 PARAMS ((bfd *));
b34976b6 55static bfd_boolean elf_i386_check_relocs
252b5132
RH		 56 PARAMS ((bfd *, struct bfd_link_info *, asection *,
57 const Elf_Internal_Rela *));
a7b97311 58static asection *elf_i386_gc_mark_hook
1e2f5b6e 59 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
a7b97311 60 struct elf_link_hash_entry *, Elf_Internal_Sym *));
b34976b6 61static bfd_boolean elf_i386_gc_sweep_hook
a7b97311
AM		 62 PARAMS ((bfd *, struct bfd_link_info *, asection *,
63 const Elf_Internal_Rela *));
b34976b6 64static bfd_boolean elf_i386_adjust_dynamic_symbol
252b5132 65 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
b34976b6 66static bfd_boolean allocate_dynrelocs
0c715baa 67 PARAMS ((struct elf_link_hash_entry *, PTR));
b34976b6 68static bfd_boolean readonly_dynrelocs
6725bdbf 69 PARAMS ((struct elf_link_hash_entry *, PTR));
b34976b6 70static bfd_boolean elf_i386_fake_sections
947216bf 71 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
b34976b6 72static bfd_boolean elf_i386_size_dynamic_sections
252b5132 73 PARAMS ((bfd *, struct bfd_link_info *));
13ae64f3
JJ		 74static bfd_vma dtpoff_base
75 PARAMS ((struct bfd_link_info *));
76static bfd_vma tpoff
77 PARAMS ((struct bfd_link_info *, bfd_vma));
b34976b6 78static bfd_boolean elf_i386_relocate_section
252b5132
RH		 79 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
80 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
b34976b6 81static bfd_boolean elf_i386_finish_dynamic_symbol
252b5132
RH		 82 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
83 Elf_Internal_Sym *));
f51e552e
AM		 84static enum elf_reloc_type_class elf_i386_reloc_type_class
85 PARAMS ((const Elf_Internal_Rela *));
b34976b6 86static bfd_boolean elf_i386_finish_dynamic_sections
38701953 87 PARAMS ((bfd *, struct bfd_link_info *));
252b5132 88
571fe01f 89#define USE_REL 1 /* 386 uses REL relocations instead of RELA. */
252b5132
RH		 90
91#include "elf/i386.h"
92
93static reloc_howto_type elf_howto_table[]=
94{
b34976b6 95 HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
1b452ec6 96 bfd_elf_generic_reloc, "R_386_NONE",
b34976b6
AM		 97 TRUE, 0x00000000, 0x00000000, FALSE),
98 HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 99 bfd_elf_generic_reloc, "R_386_32",
b34976b6
AM		 100 TRUE, 0xffffffff, 0xffffffff, FALSE),
101 HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 102 bfd_elf_generic_reloc, "R_386_PC32",
b34976b6
AM		 103 TRUE, 0xffffffff, 0xffffffff, TRUE),
104 HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 105 bfd_elf_generic_reloc, "R_386_GOT32",
b34976b6
AM		 106 TRUE, 0xffffffff, 0xffffffff, FALSE),
107 HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 108 bfd_elf_generic_reloc, "R_386_PLT32",
b34976b6
AM		 109 TRUE, 0xffffffff, 0xffffffff, TRUE),
110 HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 111 bfd_elf_generic_reloc, "R_386_COPY",
b34976b6
AM		 112 TRUE, 0xffffffff, 0xffffffff, FALSE),
113 HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 114 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
b34976b6
AM		 115 TRUE, 0xffffffff, 0xffffffff, FALSE),
116 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 117 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
b34976b6
AM		 118 TRUE, 0xffffffff, 0xffffffff, FALSE),
119 HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 120 bfd_elf_generic_reloc, "R_386_RELATIVE",
b34976b6
AM		 121 TRUE, 0xffffffff, 0xffffffff, FALSE),
122 HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 123 bfd_elf_generic_reloc, "R_386_GOTOFF",
b34976b6
AM		 124 TRUE, 0xffffffff, 0xffffffff, FALSE),
125 HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 126 bfd_elf_generic_reloc, "R_386_GOTPC",
b34976b6 127 TRUE, 0xffffffff, 0xffffffff, TRUE),
1b452ec6 128
dc47f327
AM		 129 /* We have a gap in the reloc numbers here.
130 R_386_standard counts the number up to this point, and
131 R_386_ext_offset is the value to subtract from a reloc type of
132 R_386_16 thru R_386_PC8 to form an index into this table. */
1b452ec6 133#define R_386_standard ((unsigned int) R_386_GOTPC + 1)
37e55690 134#define R_386_ext_offset ((unsigned int) R_386_TLS_TPOFF - R_386_standard)
1b452ec6 135
37e55690 136 /* These relocs are a GNU extension. */
b34976b6 137 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 138 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
b34976b6
AM		 139 TRUE, 0xffffffff, 0xffffffff, FALSE),
140 HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 141 bfd_elf_generic_reloc, "R_386_TLS_IE",
b34976b6
AM		 142 TRUE, 0xffffffff, 0xffffffff, FALSE),
143 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 144 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
b34976b6
AM		 145 TRUE, 0xffffffff, 0xffffffff, FALSE),
146 HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 147 bfd_elf_generic_reloc, "R_386_TLS_LE",
b34976b6
AM		 148 TRUE, 0xffffffff, 0xffffffff, FALSE),
149 HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 150 bfd_elf_generic_reloc, "R_386_TLS_GD",
b34976b6
AM		 151 TRUE, 0xffffffff, 0xffffffff, FALSE),
152 HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 153 bfd_elf_generic_reloc, "R_386_TLS_LDM",
b34976b6
AM		 154 TRUE, 0xffffffff, 0xffffffff, FALSE),
155 HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
1b452ec6 156 bfd_elf_generic_reloc, "R_386_16",
b34976b6
AM		 157 TRUE, 0xffff, 0xffff, FALSE),
158 HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
1b452ec6 159 bfd_elf_generic_reloc, "R_386_PC16",
b34976b6
AM		 160 TRUE, 0xffff, 0xffff, TRUE),
161 HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
1b452ec6 162 bfd_elf_generic_reloc, "R_386_8",
b34976b6
AM		 163 TRUE, 0xff, 0xff, FALSE),
164 HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
1b452ec6 165 bfd_elf_generic_reloc, "R_386_PC8",
b34976b6 166 TRUE, 0xff, 0xff, TRUE),
dc47f327 167
dc47f327 168#define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
13ae64f3
JJ		 169#define R_386_tls_offset ((unsigned int) R_386_TLS_LDO_32 - R_386_ext)
170 /* These are common with Solaris TLS implementation. */
b34976b6 171 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 172 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
b34976b6
AM		 173 TRUE, 0xffffffff, 0xffffffff, FALSE),
174 HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 175 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
b34976b6
AM		 176 TRUE, 0xffffffff, 0xffffffff, FALSE),
177 HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 178 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
b34976b6
AM		 179 TRUE, 0xffffffff, 0xffffffff, FALSE),
180 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 181 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
b34976b6
AM		 182 TRUE, 0xffffffff, 0xffffffff, FALSE),
183 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 184 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
b34976b6
AM		 185 TRUE, 0xffffffff, 0xffffffff, FALSE),
186 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 187 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
b34976b6 188 TRUE, 0xffffffff, 0xffffffff, FALSE),
13ae64f3
JJ		 189
190 /* Another gap. */
191#define R_386_tls ((unsigned int) R_386_TLS_TPOFF32 + 1 - R_386_tls_offset)
192#define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_tls)
252b5132
RH		 193
194/* GNU extension to record C++ vtable hierarchy. */
252b5132
RH		 195 HOWTO (R_386_GNU_VTINHERIT, /* type */
196 0, /* rightshift */
197 2, /* size (0 = byte, 1 = short, 2 = long) */
198 0, /* bitsize */
b34976b6 199 FALSE, /* pc_relative */
252b5132
RH		 200 0, /* bitpos */
201 complain_overflow_dont, /* complain_on_overflow */
202 NULL, /* special_function */
203 "R_386_GNU_VTINHERIT", /* name */
b34976b6 204 FALSE, /* partial_inplace */
252b5132
RH		 205 0, /* src_mask */
206 0, /* dst_mask */
b34976b6 207 FALSE), /* pcrel_offset */
252b5132
RH		 208
209/* GNU extension to record C++ vtable member usage. */
252b5132
RH		 210 HOWTO (R_386_GNU_VTENTRY, /* type */
211 0, /* rightshift */
212 2, /* size (0 = byte, 1 = short, 2 = long) */
213 0, /* bitsize */
b34976b6 214 FALSE, /* pc_relative */
252b5132
RH		 215 0, /* bitpos */
216 complain_overflow_dont, /* complain_on_overflow */
217 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
218 "R_386_GNU_VTENTRY", /* name */
b34976b6 219 FALSE, /* partial_inplace */
252b5132
RH		 220 0, /* src_mask */
221 0, /* dst_mask */
b34976b6 222 FALSE) /* pcrel_offset */
dc47f327
AM		 223
224#define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
225
226};
227
252b5132
RH		 228#ifdef DEBUG_GEN_RELOC
229#define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
230#else
231#define TRACE(str)
232#endif
233
234static reloc_howto_type *
235elf_i386_reloc_type_lookup (abfd, code)
7442e600 236 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 237 bfd_reloc_code_real_type code;
238{
239 switch (code)
240 {
241 case BFD_RELOC_NONE:
242 TRACE ("BFD_RELOC_NONE");
1b452ec6 243 return &elf_howto_table[(unsigned int) R_386_NONE ];
252b5132
RH		 244
245 case BFD_RELOC_32:
246 TRACE ("BFD_RELOC_32");
1b452ec6 247 return &elf_howto_table[(unsigned int) R_386_32 ];
252b5132
RH		 248
249 case BFD_RELOC_CTOR:
250 TRACE ("BFD_RELOC_CTOR");
1b452ec6 251 return &elf_howto_table[(unsigned int) R_386_32 ];
252b5132
RH		 252
253 case BFD_RELOC_32_PCREL:
254 TRACE ("BFD_RELOC_PC32");
1b452ec6 255 return &elf_howto_table[(unsigned int) R_386_PC32 ];
252b5132
RH		 256
257 case BFD_RELOC_386_GOT32:
258 TRACE ("BFD_RELOC_386_GOT32");
1b452ec6 259 return &elf_howto_table[(unsigned int) R_386_GOT32 ];
252b5132
RH		 260
261 case BFD_RELOC_386_PLT32:
262 TRACE ("BFD_RELOC_386_PLT32");
1b452ec6 263 return &elf_howto_table[(unsigned int) R_386_PLT32 ];
252b5132
RH		 264
265 case BFD_RELOC_386_COPY:
266 TRACE ("BFD_RELOC_386_COPY");
1b452ec6 267 return &elf_howto_table[(unsigned int) R_386_COPY ];
252b5132
RH		 268
269 case BFD_RELOC_386_GLOB_DAT:
270 TRACE ("BFD_RELOC_386_GLOB_DAT");
1b452ec6 271 return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
252b5132
RH		 272
273 case BFD_RELOC_386_JUMP_SLOT:
274 TRACE ("BFD_RELOC_386_JUMP_SLOT");
1b452ec6 275 return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
252b5132
RH		 276
277 case BFD_RELOC_386_RELATIVE:
278 TRACE ("BFD_RELOC_386_RELATIVE");
1b452ec6 279 return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
252b5132
RH		 280
281 case BFD_RELOC_386_GOTOFF:
282 TRACE ("BFD_RELOC_386_GOTOFF");
1b452ec6 283 return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
252b5132
RH		 284
285 case BFD_RELOC_386_GOTPC:
286 TRACE ("BFD_RELOC_386_GOTPC");
1b452ec6 287 return &elf_howto_table[(unsigned int) R_386_GOTPC ];
252b5132 288
37e55690
JJ		 289 /* These relocs are a GNU extension. */
290 case BFD_RELOC_386_TLS_TPOFF:
291 TRACE ("BFD_RELOC_386_TLS_TPOFF");
292 return &elf_howto_table[(unsigned int) R_386_TLS_TPOFF - R_386_ext_offset];
293
294 case BFD_RELOC_386_TLS_IE:
295 TRACE ("BFD_RELOC_386_TLS_IE");
296 return &elf_howto_table[(unsigned int) R_386_TLS_IE - R_386_ext_offset];
297
298 case BFD_RELOC_386_TLS_GOTIE:
299 TRACE ("BFD_RELOC_386_TLS_GOTIE");
300 return &elf_howto_table[(unsigned int) R_386_TLS_GOTIE - R_386_ext_offset];
301
13ae64f3
JJ		 302 case BFD_RELOC_386_TLS_LE:
303 TRACE ("BFD_RELOC_386_TLS_LE");
304 return &elf_howto_table[(unsigned int) R_386_TLS_LE - R_386_ext_offset];
305
306 case BFD_RELOC_386_TLS_GD:
307 TRACE ("BFD_RELOC_386_TLS_GD");
308 return &elf_howto_table[(unsigned int) R_386_TLS_GD - R_386_ext_offset];
309
310 case BFD_RELOC_386_TLS_LDM:
311 TRACE ("BFD_RELOC_386_TLS_LDM");
312 return &elf_howto_table[(unsigned int) R_386_TLS_LDM - R_386_ext_offset];
313
252b5132
RH		 314 case BFD_RELOC_16:
315 TRACE ("BFD_RELOC_16");
1b452ec6 316 return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
252b5132
RH		 317
318 case BFD_RELOC_16_PCREL:
319 TRACE ("BFD_RELOC_16_PCREL");
1b452ec6 320 return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
252b5132
RH		 321
322 case BFD_RELOC_8:
323 TRACE ("BFD_RELOC_8");
1b452ec6 324 return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
252b5132
RH		 325
326 case BFD_RELOC_8_PCREL:
327 TRACE ("BFD_RELOC_8_PCREL");
1b452ec6 328 return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
252b5132 329
13ae64f3
JJ		 330 /* Common with Sun TLS implementation. */
331 case BFD_RELOC_386_TLS_LDO_32:
332 TRACE ("BFD_RELOC_386_TLS_LDO_32");
333 return &elf_howto_table[(unsigned int) R_386_TLS_LDO_32 - R_386_tls_offset];
334
335 case BFD_RELOC_386_TLS_IE_32:
336 TRACE ("BFD_RELOC_386_TLS_IE_32");
337 return &elf_howto_table[(unsigned int) R_386_TLS_IE_32 - R_386_tls_offset];
338
339 case BFD_RELOC_386_TLS_LE_32:
340 TRACE ("BFD_RELOC_386_TLS_LE_32");
341 return &elf_howto_table[(unsigned int) R_386_TLS_LE_32 - R_386_tls_offset];
342
343 case BFD_RELOC_386_TLS_DTPMOD32:
344 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
345 return &elf_howto_table[(unsigned int) R_386_TLS_DTPMOD32 - R_386_tls_offset];
346
347 case BFD_RELOC_386_TLS_DTPOFF32:
348 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
349 return &elf_howto_table[(unsigned int) R_386_TLS_DTPOFF32 - R_386_tls_offset];
350
351 case BFD_RELOC_386_TLS_TPOFF32:
352 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
353 return &elf_howto_table[(unsigned int) R_386_TLS_TPOFF32 - R_386_tls_offset];
354
252b5132
RH		 355 case BFD_RELOC_VTABLE_INHERIT:
356 TRACE ("BFD_RELOC_VTABLE_INHERIT");
dc47f327
AM		 357 return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
358 - R_386_vt_offset];
252b5132
RH		 359
360 case BFD_RELOC_VTABLE_ENTRY:
361 TRACE ("BFD_RELOC_VTABLE_ENTRY");
dc47f327
AM		 362 return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
363 - R_386_vt_offset];
252b5132
RH		 364
365 default:
366 break;
367 }
368
369 TRACE ("Unknown");
370 return 0;
371}
372
252b5132
RH		 373static void
374elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
7442e600 375 bfd *abfd ATTRIBUTE_UNUSED;
252b5132 376 arelent *cache_ptr;
947216bf 377 Elf_Internal_Rela *dst;
252b5132 378{
dc47f327
AM		 379 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
380 unsigned int indx;
381
382 if ((indx = r_type) >= R_386_standard
383 && ((indx = r_type - R_386_ext_offset) - R_386_standard
384 >= R_386_ext - R_386_standard)
13ae64f3
JJ		 385 && ((indx = r_type - R_386_tls_offset) - R_386_ext
386 >= R_386_tls - R_386_ext)
387 && ((indx = r_type - R_386_vt_offset) - R_386_tls
388 >= R_386_vt - R_386_tls))
252b5132 389 {
dc47f327 390 (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
8f615d07 391 bfd_archive_filename (abfd), (int) r_type);
dc47f327 392 indx = (unsigned int) R_386_NONE;
252b5132 393 }
dc47f327 394 cache_ptr->howto = &elf_howto_table[indx];
252b5132
RH		 395}
396
397/* Return whether a symbol name implies a local label. The UnixWare
398 2.1 cc generates temporary symbols that start with .X, so we
399 recognize them here. FIXME: do other SVR4 compilers also use .X?.
400 If so, we should move the .X recognition into
401 _bfd_elf_is_local_label_name. */
402
b34976b6 403static bfd_boolean
252b5132
RH		 404elf_i386_is_local_label_name (abfd, name)
405 bfd *abfd;
406 const char *name;
407{
408 if (name[0] == '.' && name[1] == 'X')
b34976b6 409 return TRUE;
252b5132
RH		 410
411 return _bfd_elf_is_local_label_name (abfd, name);
412}
413\f
38701953 414/* Support for core dump NOTE sections. */
b34976b6 415static bfd_boolean
38701953
AM		 416elf_i386_grok_prstatus (abfd, note)
417 bfd *abfd;
418 Elf_Internal_Note *note;
419{
420 int offset;
421 size_t raw_size;
422
423 switch (note->descsz)
424 {
425 default:
b34976b6 426 return FALSE;
38701953
AM		 427
428 case 144: /* Linux/i386 */
429 /* pr_cursig */
430 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
431
432 /* pr_pid */
433 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
434
435 /* pr_reg */
436 offset = 72;
437 raw_size = 68;
438
439 break;
440 }
441
442 /* Make a ".reg/999" section. */
443 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
444 raw_size, note->descpos + offset);
445}
446
b34976b6 447static bfd_boolean
38701953
AM		 448elf_i386_grok_psinfo (abfd, note)
449 bfd *abfd;
450 Elf_Internal_Note *note;
451{
452 switch (note->descsz)
453 {
454 default:
b34976b6 455 return FALSE;
38701953 456
fd29389c 457 case 124: /* Linux/i386 elf_prpsinfo */
38701953
AM		 458 elf_tdata (abfd)->core_program
459 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
460 elf_tdata (abfd)->core_command
461 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
462 }
463
464 /* Note that for some reason, a spurious space is tacked
465 onto the end of the args in some (at least one anyway)
466 implementations, so strip it off if it exists. */
467
468 {
469 char *command = elf_tdata (abfd)->core_command;
470 int n = strlen (command);
471
472 if (0 < n && command[n - 1] == ' ')
473 command[n - 1] = '\0';
474 }
475
b34976b6 476 return TRUE;
38701953
AM		 477}
478\f
479/* Functions for the i386 ELF linker.
480
481 In order to gain some understanding of code in this file without
482 knowing all the intricate details of the linker, note the
483 following:
484
485 Functions named elf_i386_* are called by external routines, other
486 functions are only called locally. elf_i386_* functions appear
487 in this file more or less in the order in which they are called
488 from external routines. eg. elf_i386_check_relocs is called
489 early in the link process, elf_i386_finish_dynamic_sections is
490 one of the last functions. */
491
252b5132
RH		 492
493/* The name of the dynamic interpreter. This is put in the .interp
494 section. */
495
496#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
497
a23b6845
AM		 498/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
499 copying dynamic variables from a shared lib into an app's dynbss
500 section, and instead use a dynamic relocation to point into the
501 shared lib. */
502#define ELIMINATE_COPY_RELOCS 1
503
252b5132
RH		 504/* The size in bytes of an entry in the procedure linkage table. */
505
506#define PLT_ENTRY_SIZE 16
507
508/* The first entry in an absolute procedure linkage table looks like
509 this. See the SVR4 ABI i386 supplement to see how this works. */
510
511static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
512{
513 0xff, 0x35, /* pushl contents of address */
514 0, 0, 0, 0, /* replaced with address of .got + 4. */
515 0xff, 0x25, /* jmp indirect */
516 0, 0, 0, 0, /* replaced with address of .got + 8. */
517 0, 0, 0, 0 /* pad out to 16 bytes. */
518};
519
520/* Subsequent entries in an absolute procedure linkage table look like
521 this. */
522
523static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
524{
525 0xff, 0x25, /* jmp indirect */
526 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
527 0x68, /* pushl immediate */
528 0, 0, 0, 0, /* replaced with offset into relocation table. */
529 0xe9, /* jmp relative */
530 0, 0, 0, 0 /* replaced with offset to start of .plt. */
531};
532
533/* The first entry in a PIC procedure linkage table look like this. */
534
535static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
536{
537 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
538 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
539 0, 0, 0, 0 /* pad out to 16 bytes. */
540};
541
542/* Subsequent entries in a PIC procedure linkage table look like this. */
543
544static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
545{
546 0xff, 0xa3, /* jmp *offset(%ebx) */
547 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
548 0x68, /* pushl immediate */
549 0, 0, 0, 0, /* replaced with offset into relocation table. */
550 0xe9, /* jmp relative */
551 0, 0, 0, 0 /* replaced with offset to start of .plt. */
552};
553
554/* The i386 linker needs to keep track of the number of relocs that it
ffb2e45b
AM		 555 decides to copy as dynamic relocs in check_relocs for each symbol.
556 This is so that it can later discard them if they are found to be
557 unnecessary. We store the information in a field extending the
558 regular ELF linker hash table. */
252b5132 559
ffb2e45b 560struct elf_i386_dyn_relocs
252b5132 561{
ffb2e45b 562 struct elf_i386_dyn_relocs *next;
0c715baa
AM		 563
564 /* The input section of the reloc. */
565 asection *sec;
566
567 /* Total number of relocs copied for the input section. */
252b5132 568 bfd_size_type count;
0c715baa
AM		 569
570 /* Number of pc-relative relocs copied for the input section. */
571 bfd_size_type pc_count;
252b5132
RH		 572};
573
574/* i386 ELF linker hash entry. */
575
576struct elf_i386_link_hash_entry
577{
ebe50bae 578 struct elf_link_hash_entry elf;
252b5132 579
0c715baa 580 /* Track dynamic relocs copied for this symbol. */
ffb2e45b 581 struct elf_i386_dyn_relocs *dyn_relocs;
13ae64f3 582
37e55690
JJ		 583#define GOT_UNKNOWN 0
584#define GOT_NORMAL 1
585#define GOT_TLS_GD 2
586#define GOT_TLS_IE 4
587#define GOT_TLS_IE_POS 5
588#define GOT_TLS_IE_NEG 6
589#define GOT_TLS_IE_BOTH 7
590 unsigned char tls_type;
13ae64f3
JJ		 591};
592
593#define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
594
595struct elf_i386_obj_tdata
596{
597 struct elf_obj_tdata root;
598
599 /* tls_type for each local got entry. */
600 char *local_got_tls_type;
252b5132
RH		 601};
602
13ae64f3
JJ		 603#define elf_i386_tdata(abfd) \
604 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
605
606#define elf_i386_local_got_tls_type(abfd) \
607 (elf_i386_tdata (abfd)->local_got_tls_type)
608
b34976b6 609static bfd_boolean
13ae64f3
JJ		 610elf_i386_mkobject (abfd)
611 bfd *abfd;
612{
613 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
614 abfd->tdata.any = bfd_zalloc (abfd, amt);
615 if (abfd->tdata.any == NULL)
b34976b6
AM		 616 return FALSE;
617 return TRUE;
13ae64f3 618}
cedb70c5 619
b34976b6 620static bfd_boolean
13ae64f3
JJ		 621elf_i386_object_p (abfd)
622 bfd *abfd;
623{
624 /* Allocate our special target data. */
625 struct elf_i386_obj_tdata *new_tdata;
626 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
627 new_tdata = bfd_zalloc (abfd, amt);
628 if (new_tdata == NULL)
b34976b6 629 return FALSE;
13ae64f3
JJ		 630 new_tdata->root = *abfd->tdata.elf_obj_data;
631 abfd->tdata.any = new_tdata;
b34976b6 632 return TRUE;
13ae64f3
JJ		 633}
634
252b5132
RH		 635/* i386 ELF linker hash table. */
636
637struct elf_i386_link_hash_table
638{
ebe50bae 639 struct elf_link_hash_table elf;
252b5132 640
6725bdbf
AM		 641 /* Short-cuts to get to dynamic linker sections. */
642 asection *sgot;
643 asection *sgotplt;
644 asection *srelgot;
645 asection *splt;
646 asection *srelplt;
647 asection *sdynbss;
648 asection *srelbss;
ec338859 649
13ae64f3
JJ		 650 union {
651 bfd_signed_vma refcount;
652 bfd_vma offset;
653 } tls_ldm_got;
654
ec338859
AM		 655 /* Small local sym to section mapping cache. */
656 struct sym_sec_cache sym_sec;
6725bdbf 657};
252b5132
RH		 658
659/* Get the i386 ELF linker hash table from a link_info structure. */
660
661#define elf_i386_hash_table(p) \
662 ((struct elf_i386_link_hash_table *) ((p)->hash))
663
664/* Create an entry in an i386 ELF linker hash table. */
665
666static struct bfd_hash_entry *
38701953 667link_hash_newfunc (entry, table, string)
252b5132
RH		 668 struct bfd_hash_entry *entry;
669 struct bfd_hash_table *table;
670 const char *string;
671{
252b5132
RH		 672 /* Allocate the structure if it has not already been allocated by a
673 subclass. */
ebe50bae
AM		 674 if (entry == NULL)
675 {
676 entry = bfd_hash_allocate (table,
677 sizeof (struct elf_i386_link_hash_entry));
678 if (entry == NULL)
679 return entry;
680 }
252b5132
RH		 681
682 /* Call the allocation method of the superclass. */
ebe50bae
AM		 683 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
684 if (entry != NULL)
252b5132 685 {
ebe50bae
AM		 686 struct elf_i386_link_hash_entry *eh;
687
688 eh = (struct elf_i386_link_hash_entry *) entry;
689 eh->dyn_relocs = NULL;
13ae64f3 690 eh->tls_type = GOT_UNKNOWN;
252b5132
RH		 691 }
692
ebe50bae 693 return entry;
252b5132
RH		 694}
695
696/* Create an i386 ELF linker hash table. */
697
698static struct bfd_link_hash_table *
699elf_i386_link_hash_table_create (abfd)
700 bfd *abfd;
701{
702 struct elf_i386_link_hash_table *ret;
dc810e39 703 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
252b5132 704
e2d34d7d 705 ret = (struct elf_i386_link_hash_table *) bfd_malloc (amt);
ebe50bae 706 if (ret == NULL)
252b5132
RH		 707 return NULL;
708
ebe50bae 709 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
252b5132 710 {
e2d34d7d 711 free (ret);
252b5132
RH		 712 return NULL;
713 }
714
6725bdbf
AM		 715 ret->sgot = NULL;
716 ret->sgotplt = NULL;
717 ret->srelgot = NULL;
718 ret->splt = NULL;
719 ret->srelplt = NULL;
720 ret->sdynbss = NULL;
721 ret->srelbss = NULL;
7a624474 722 ret->tls_ldm_got.refcount = 0;
ec338859 723 ret->sym_sec.abfd = NULL;
6725bdbf 724
ebe50bae 725 return &ret->elf.root;
252b5132
RH		 726}
727
6725bdbf
AM		 728/* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
729 shortcuts to them in our hash table. */
730
b34976b6 731static bfd_boolean
6725bdbf
AM		 732create_got_section (dynobj, info)
733 bfd *dynobj;
734 struct bfd_link_info *info;
735{
736 struct elf_i386_link_hash_table *htab;
737
738 if (! _bfd_elf_create_got_section (dynobj, info))
b34976b6 739 return FALSE;
6725bdbf
AM		 740
741 htab = elf_i386_hash_table (info);
742 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
743 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
744 if (!htab->sgot || !htab->sgotplt)
745 abort ();
746
747 htab->srelgot = bfd_make_section (dynobj, ".rel.got");
748 if (htab->srelgot == NULL
749 || ! bfd_set_section_flags (dynobj, htab->srelgot,
750 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
751 | SEC_IN_MEMORY | SEC_LINKER_CREATED
752 | SEC_READONLY))
753 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
b34976b6
AM		 754 return FALSE;
755 return TRUE;
6725bdbf
AM		 756}
757
758/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
759 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
760 hash table. */
761
b34976b6 762static bfd_boolean
6725bdbf
AM		 763elf_i386_create_dynamic_sections (dynobj, info)
764 bfd *dynobj;
765 struct bfd_link_info *info;
766{
767 struct elf_i386_link_hash_table *htab;
768
769 htab = elf_i386_hash_table (info);
770 if (!htab->sgot && !create_got_section (dynobj, info))
b34976b6 771 return FALSE;
6725bdbf
AM		 772
773 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 774 return FALSE;
6725bdbf
AM		 775
776 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
777 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
778 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
779 if (!info->shared)
780 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
781
782 if (!htab->splt || !htab->srelplt || !htab->sdynbss
783 || (!info->shared && !htab->srelbss))
784 abort ();
785
b34976b6 786 return TRUE;
6725bdbf
AM		 787}
788
ebe50bae
AM		 789/* Copy the extra info we tack onto an elf_link_hash_entry. */
790
51b64d56 791static void
b48fa14c
AM		 792elf_i386_copy_indirect_symbol (bed, dir, ind)
793 struct elf_backend_data *bed;
ebe50bae
AM		 794 struct elf_link_hash_entry *dir, *ind;
795{
796 struct elf_i386_link_hash_entry *edir, *eind;
797
798 edir = (struct elf_i386_link_hash_entry *) dir;
799 eind = (struct elf_i386_link_hash_entry *) ind;
800
bbd7ec4a 801 if (eind->dyn_relocs != NULL)
ebe50bae 802 {
bbd7ec4a
AM		 803 if (edir->dyn_relocs != NULL)
804 {
805 struct elf_i386_dyn_relocs **pp;
806 struct elf_i386_dyn_relocs *p;
807
1e370bd2 808 if (ind->root.type == bfd_link_hash_indirect)
bbd7ec4a
AM		 809 abort ();
810
811 /* Add reloc counts against the weak sym to the strong sym
812 list. Merge any entries against the same section. */
813 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
814 {
815 struct elf_i386_dyn_relocs *q;
816
817 for (q = edir->dyn_relocs; q != NULL; q = q->next)
818 if (q->sec == p->sec)
819 {
820 q->pc_count += p->pc_count;
821 q->count += p->count;
822 *pp = p->next;
823 break;
824 }
825 if (q == NULL)
826 pp = &p->next;
827 }
828 *pp = edir->dyn_relocs;
829 }
830
ebe50bae
AM		 831 edir->dyn_relocs = eind->dyn_relocs;
832 eind->dyn_relocs = NULL;
833 }
ebe50bae 834
cd67d266
JJ		 835 if (ind->root.type == bfd_link_hash_indirect
836 && dir->got.refcount <= 0)
837 {
838 edir->tls_type = eind->tls_type;
839 eind->tls_type = GOT_UNKNOWN;
840 }
81848ca0
AM		 841
842 if (ELIMINATE_COPY_RELOCS
843 && ind->root.type != bfd_link_hash_indirect
844 && (dir->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
845 /* If called to transfer flags for a weakdef during processing
846 of elf_adjust_dynamic_symbol, don't copy ELF_LINK_NON_GOT_REF.
847 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
848 dir->elf_link_hash_flags |=
849 (ind->elf_link_hash_flags & (ELF_LINK_HASH_REF_DYNAMIC
850 | ELF_LINK_HASH_REF_REGULAR
851 | ELF_LINK_HASH_REF_REGULAR_NONWEAK));
852 else
853 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
ebe50bae
AM		 854}
855
13ae64f3
JJ		 856static int
857elf_i386_tls_transition (info, r_type, is_local)
858 struct bfd_link_info *info;
859 int r_type;
860 int is_local;
861{
862 if (info->shared)
863 return r_type;
864
865 switch (r_type)
866 {
867 case R_386_TLS_GD:
868 case R_386_TLS_IE_32:
869 if (is_local)
870 return R_386_TLS_LE_32;
871 return R_386_TLS_IE_32;
37e55690
JJ		 872 case R_386_TLS_IE:
873 case R_386_TLS_GOTIE:
874 if (is_local)
875 return R_386_TLS_LE_32;
876 return r_type;
13ae64f3
JJ		 877 case R_386_TLS_LDM:
878 return R_386_TLS_LE_32;
879 }
880
881 return r_type;
882}
883
252b5132 884/* Look through the relocs for a section during the first phase, and
0ac8d2ca
AM		 885 calculate needed space in the global offset table, procedure linkage
886 table, and dynamic reloc sections. */
252b5132 887
b34976b6 888static bfd_boolean
252b5132
RH		 889elf_i386_check_relocs (abfd, info, sec, relocs)
890 bfd *abfd;
891 struct bfd_link_info *info;
892 asection *sec;
893 const Elf_Internal_Rela *relocs;
894{
6725bdbf 895 struct elf_i386_link_hash_table *htab;
252b5132
RH		 896 Elf_Internal_Shdr *symtab_hdr;
897 struct elf_link_hash_entry **sym_hashes;
252b5132
RH		 898 const Elf_Internal_Rela *rel;
899 const Elf_Internal_Rela *rel_end;
252b5132
RH		 900 asection *sreloc;
901
902 if (info->relocateable)
b34976b6 903 return TRUE;
252b5132 904
6725bdbf 905 htab = elf_i386_hash_table (info);
252b5132
RH		 906 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
907 sym_hashes = elf_sym_hashes (abfd);
252b5132 908
252b5132
RH		 909 sreloc = NULL;
910
911 rel_end = relocs + sec->reloc_count;
912 for (rel = relocs; rel < rel_end; rel++)
913 {
13ae64f3 914 unsigned int r_type;
252b5132
RH		 915 unsigned long r_symndx;
916 struct elf_link_hash_entry *h;
917
918 r_symndx = ELF32_R_SYM (rel->r_info);
13ae64f3 919 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 920
d9bc7a44 921 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
f5f31454 922 {
8f615d07
AM		 923 (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
924 bfd_archive_filename (abfd),
925 r_symndx);
b34976b6 926 return FALSE;
f5f31454
L		 927 }
928
252b5132
RH		 929 if (r_symndx < symtab_hdr->sh_info)
930 h = NULL;
931 else
932 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
933
13ae64f3
JJ		 934 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
935
936 switch (r_type)
252b5132 937 {
37e55690
JJ		 938 case R_386_TLS_LDM:
939 htab->tls_ldm_got.refcount += 1;
940 goto create_got;
941
942 case R_386_PLT32:
943 /* This symbol requires a procedure linkage table entry. We
944 actually build the entry in adjust_dynamic_symbol,
945 because this might be a case of linking PIC code which is
946 never referenced by a dynamic object, in which case we
947 don't need to generate a procedure linkage table entry
948 after all. */
949
950 /* If this is a local symbol, we resolve it directly without
951 creating a procedure linkage table entry. */
952 if (h == NULL)
953 continue;
954
955 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
956 h->plt.refcount += 1;
957 break;
958
13ae64f3 959 case R_386_TLS_IE_32:
37e55690
JJ		 960 case R_386_TLS_IE:
961 case R_386_TLS_GOTIE:
13ae64f3
JJ		 962 if (info->shared)
963 info->flags |= DF_STATIC_TLS;
37e55690
JJ		 964 /* Fall through */
965
252b5132 966 case R_386_GOT32:
13ae64f3 967 case R_386_TLS_GD:
252b5132 968 /* This symbol requires a global offset table entry. */
13ae64f3
JJ		 969 {
970 int tls_type, old_tls_type;
971
972 switch (r_type)
973 {
974 default:
975 case R_386_GOT32: tls_type = GOT_NORMAL; break;
976 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
37e55690
JJ		 977 case R_386_TLS_IE_32:
978 if (ELF32_R_TYPE (rel->r_info) == r_type)
979 tls_type = GOT_TLS_IE_NEG;
980 else
981 /* If this is a GD->IE transition, we may use either of
982 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
983 tls_type = GOT_TLS_IE;
984 break;
985 case R_386_TLS_IE:
986 case R_386_TLS_GOTIE:
987 tls_type = GOT_TLS_IE_POS; break;
13ae64f3
JJ		 988 }
989
990 if (h != NULL)
991 {
992 h->got.refcount += 1;
993 old_tls_type = elf_i386_hash_entry(h)->tls_type;
994 }
995 else
996 {
997 bfd_signed_vma *local_got_refcounts;
998
999 /* This is a global offset table entry for a local symbol. */
1000 local_got_refcounts = elf_local_got_refcounts (abfd);
1001 if (local_got_refcounts == NULL)
1002 {
1003 bfd_size_type size;
1004
1005 size = symtab_hdr->sh_info;
1006 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1007 local_got_refcounts = ((bfd_signed_vma *)
1008 bfd_zalloc (abfd, size));
1009 if (local_got_refcounts == NULL)
b34976b6 1010 return FALSE;
13ae64f3
JJ		 1011 elf_local_got_refcounts (abfd) = local_got_refcounts;
1012 elf_i386_local_got_tls_type (abfd)
1013 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1014 }
1015 local_got_refcounts[r_symndx] += 1;
1016 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1017 }
1018
37e55690
JJ		 1019 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1020 tls_type |= old_tls_type;
13ae64f3
JJ		 1021 /* If a TLS symbol is accessed using IE at least once,
1022 there is no point to use dynamic model for it. */
37e55690
JJ		 1023 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1024 && (old_tls_type != GOT_TLS_GD
1025 || (tls_type & GOT_TLS_IE) == 0))
13ae64f3 1026 {
37e55690
JJ		 1027 if ((old_tls_type & GOT_TLS_IE) && tls_type == GOT_TLS_GD)
1028 tls_type = old_tls_type;
13ae64f3
JJ		 1029 else
1030 {
1031 (*_bfd_error_handler)
1032 (_("%s: `%s' accessed both as normal and thread local symbol"),
37e55690
JJ		 1033 bfd_archive_filename (abfd),
1034 h ? h->root.root.string : "<local>");
b34976b6 1035 return FALSE;
13ae64f3
JJ		 1036 }
1037 }
1038
1039 if (old_tls_type != tls_type)
1040 {
1041 if (h != NULL)
1042 elf_i386_hash_entry (h)->tls_type = tls_type;
1043 else
1044 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1045 }
1046 }
0ac8d2ca
AM		 1047 /* Fall through */
1048
1049 case R_386_GOTOFF:
1050 case R_386_GOTPC:
13ae64f3 1051 create_got:
0ac8d2ca
AM		 1052 if (htab->sgot == NULL)
1053 {
1054 if (htab->elf.dynobj == NULL)
1055 htab->elf.dynobj = abfd;
1056 if (!create_got_section (htab->elf.dynobj, info))
b34976b6 1057 return FALSE;
0ac8d2ca 1058 }
37e55690
JJ		 1059 if (r_type != R_386_TLS_IE)
1060 break;
1061 /* Fall through */
252b5132 1062
37e55690
JJ		 1063 case R_386_TLS_LE_32:
1064 case R_386_TLS_LE:
1065 if (!info->shared)
1066 break;
bffbf940 1067 info->flags |= DF_STATIC_TLS;
b34976b6 1068 /* Fall through */
252b5132
RH		 1069
1070 case R_386_32:
1071 case R_386_PC32:
12d0ee4a 1072 if (h != NULL && !info->shared)
6725bdbf 1073 {
12d0ee4a 1074 /* If this reloc is in a read-only section, we might
ebe50bae
AM		 1075 need a copy reloc. We can't check reliably at this
1076 stage whether the section is read-only, as input
1077 sections have not yet been mapped to output sections.
1078 Tentatively set the flag for now, and correct in
1079 adjust_dynamic_symbol. */
1080 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
12d0ee4a
AM		 1081
1082 /* We may need a .plt entry if the function this reloc
1083 refers to is in a shared lib. */
51b64d56 1084 h->plt.refcount += 1;
6725bdbf 1085 }
7843f00e 1086
252b5132 1087 /* If we are creating a shared library, and this is a reloc
f69da49f
AM		 1088 against a global symbol, or a non PC relative reloc
1089 against a local symbol, then we need to copy the reloc
1090 into the shared library. However, if we are linking with
1091 -Bsymbolic, we do not need to copy a reloc against a
1092 global symbol which is defined in an object we are
1093 including in the link (i.e., DEF_REGULAR is set). At
1094 this point we have not seen all the input files, so it is
1095 possible that DEF_REGULAR is not set now but will be set
1f655a09
L		 1096 later (it is never cleared). In case of a weak definition,
1097 DEF_REGULAR may be cleared later by a strong definition in
ebe50bae 1098 a shared library. We account for that possibility below by
1f655a09
L		 1099 storing information in the relocs_copied field of the hash
1100 table entry. A similar situation occurs when creating
1101 shared libraries and symbol visibility changes render the
12d0ee4a 1102 symbol local.
56882138 1103
12d0ee4a
AM		 1104 If on the other hand, we are creating an executable, we
1105 may need to keep relocations for symbols satisfied by a
1106 dynamic library if we manage to avoid copy relocs for the
1107 symbol. */
1108 if ((info->shared
1109 && (sec->flags & SEC_ALLOC) != 0
13ae64f3 1110 && (r_type != R_386_PC32
12d0ee4a
AM		 1111 || (h != NULL
1112 && (! info->symbolic
1113 || h->root.type == bfd_link_hash_defweak
1114 || (h->elf_link_hash_flags
1115 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
a23b6845
AM		 1116 || (ELIMINATE_COPY_RELOCS
1117 && !info->shared
12d0ee4a
AM		 1118 && (sec->flags & SEC_ALLOC) != 0
1119 && h != NULL
12d0ee4a
AM		 1120 && (h->root.type == bfd_link_hash_defweak
1121 || (h->elf_link_hash_flags
1122 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
252b5132 1123 {
ec338859
AM		 1124 struct elf_i386_dyn_relocs *p;
1125 struct elf_i386_dyn_relocs **head;
1126
12d0ee4a
AM		 1127 /* We must copy these reloc types into the output file.
1128 Create a reloc section in dynobj and make room for
1129 this reloc. */
252b5132
RH		 1130 if (sreloc == NULL)
1131 {
1132 const char *name;
0ac8d2ca 1133 bfd *dynobj;
e92d460e
AM		 1134 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1135 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
252b5132 1136
e92d460e 1137 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
252b5132 1138 if (name == NULL)
b34976b6 1139 return FALSE;
252b5132 1140
c8492176
L		 1141 if (strncmp (name, ".rel", 4) != 0
1142 || strcmp (bfd_get_section_name (abfd, sec),
1143 name + 4) != 0)
1144 {
0c715baa
AM		 1145 (*_bfd_error_handler)
1146 (_("%s: bad relocation section name `%s\'"),
1147 bfd_archive_filename (abfd), name);
f5f31454 1148 }
252b5132 1149
0ac8d2ca
AM		 1150 if (htab->elf.dynobj == NULL)
1151 htab->elf.dynobj = abfd;
1152
1153 dynobj = htab->elf.dynobj;
252b5132
RH		 1154 sreloc = bfd_get_section_by_name (dynobj, name);
1155 if (sreloc == NULL)
1156 {
1157 flagword flags;
1158
1159 sreloc = bfd_make_section (dynobj, name);
1160 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1161 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1162 if ((sec->flags & SEC_ALLOC) != 0)
1163 flags |= SEC_ALLOC | SEC_LOAD;
1164 if (sreloc == NULL
1165 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1166 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
b34976b6 1167 return FALSE;
252b5132 1168 }
0c715baa 1169 elf_section_data (sec)->sreloc = sreloc;
252b5132
RH		 1170 }
1171
0c715baa
AM		 1172 /* If this is a global symbol, we count the number of
1173 relocations we need for this symbol. */
1174 if (h != NULL)
252b5132 1175 {
ec338859 1176 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
0c715baa
AM		 1177 }
1178 else
1179 {
ec338859
AM		 1180 /* Track dynamic relocs needed for local syms too.
1181 We really need local syms available to do this
1182 easily. Oh well. */
1183
1184 asection *s;
1185 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1186 sec, r_symndx);
1187 if (s == NULL)
b34976b6 1188 return FALSE;
ec338859
AM		 1189
1190 head = ((struct elf_i386_dyn_relocs **)
1191 &elf_section_data (s)->local_dynrel);
1192 }
1193
1194 p = *head;
1195 if (p == NULL || p->sec != sec)
1196 {
1197 bfd_size_type amt = sizeof *p;
1198 p = ((struct elf_i386_dyn_relocs *)
1199 bfd_alloc (htab->elf.dynobj, amt));
1200 if (p == NULL)
b34976b6 1201 return FALSE;
ec338859
AM		 1202 p->next = *head;
1203 *head = p;
1204 p->sec = sec;
1205 p->count = 0;
1206 p->pc_count = 0;
252b5132 1207 }
ec338859
AM		 1208
1209 p->count += 1;
13ae64f3 1210 if (r_type == R_386_PC32)
ec338859 1211 p->pc_count += 1;
252b5132 1212 }
252b5132
RH		 1213 break;
1214
1215 /* This relocation describes the C++ object vtable hierarchy.
1216 Reconstruct it for later use during GC. */
1217 case R_386_GNU_VTINHERIT:
1218 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 1219 return FALSE;
252b5132
RH		 1220 break;
1221
1222 /* This relocation describes which C++ vtable entries are actually
1223 used. Record for later use during GC. */
1224 case R_386_GNU_VTENTRY:
1225 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
b34976b6 1226 return FALSE;
252b5132
RH		 1227 break;
1228
1229 default:
1230 break;
1231 }
1232 }
1233
b34976b6 1234 return TRUE;
252b5132
RH		 1235}
1236
1237/* Return the section that should be marked against GC for a given
1238 relocation. */
1239
1240static asection *
1e2f5b6e
AM		 1241elf_i386_gc_mark_hook (sec, info, rel, h, sym)
1242 asection *sec;
7442e600 1243 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 1244 Elf_Internal_Rela *rel;
1245 struct elf_link_hash_entry *h;
1246 Elf_Internal_Sym *sym;
1247{
1248 if (h != NULL)
1249 {
1250 switch (ELF32_R_TYPE (rel->r_info))
1251 {
1252 case R_386_GNU_VTINHERIT:
1253 case R_386_GNU_VTENTRY:
1254 break;
1255
1256 default:
1257 switch (h->root.type)
1258 {
1259 case bfd_link_hash_defined:
1260 case bfd_link_hash_defweak:
1261 return h->root.u.def.section;
1262
1263 case bfd_link_hash_common:
1264 return h->root.u.c.p->section;
1265
1266 default:
1267 break;
1268 }
1269 }
1270 }
1271 else
1e2f5b6e 1272 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
252b5132
RH		 1273
1274 return NULL;
1275}
1276
1277/* Update the got entry reference counts for the section being removed. */
1278
b34976b6 1279static bfd_boolean
252b5132 1280elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
dd5724d5 1281 bfd *abfd;
6725bdbf 1282 struct bfd_link_info *info;
dd5724d5
AM		 1283 asection *sec;
1284 const Elf_Internal_Rela *relocs;
252b5132 1285{
dd5724d5
AM		 1286 Elf_Internal_Shdr *symtab_hdr;
1287 struct elf_link_hash_entry **sym_hashes;
1288 bfd_signed_vma *local_got_refcounts;
1289 const Elf_Internal_Rela *rel, *relend;
dd5724d5 1290
ec338859 1291 elf_section_data (sec)->local_dynrel = NULL;
dd5724d5 1292
6725bdbf
AM		 1293 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1294 sym_hashes = elf_sym_hashes (abfd);
1295 local_got_refcounts = elf_local_got_refcounts (abfd);
dd5724d5
AM		 1296
1297 relend = relocs + sec->reloc_count;
1298 for (rel = relocs; rel < relend; rel++)
26e41594
AM		 1299 {
1300 unsigned long r_symndx;
1301 unsigned int r_type;
1302 struct elf_link_hash_entry *h = NULL;
37e55690 1303
26e41594
AM		 1304 r_symndx = ELF32_R_SYM (rel->r_info);
1305 if (r_symndx >= symtab_hdr->sh_info)
1306 {
1307 struct elf_i386_link_hash_entry *eh;
1308 struct elf_i386_dyn_relocs **pp;
1309 struct elf_i386_dyn_relocs *p;
dd5724d5 1310
26e41594
AM		 1311 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1312 eh = (struct elf_i386_link_hash_entry *) h;
0c715baa 1313
26e41594
AM		 1314 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1315 if (p->sec == sec)
1316 {
1317 /* Everything must go for SEC. */
1318 *pp = p->next;
1319 break;
1320 }
1321 }
0c715baa 1322
26e41594
AM		 1323 r_type = ELF32_R_TYPE (rel->r_info);
1324 r_type = elf_i386_tls_transition (info, r_type, h != NULL);
1325 switch (r_type)
1326 {
1327 case R_386_TLS_LDM:
1328 if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1329 elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1330 break;
0c715baa 1331
26e41594
AM		 1332 case R_386_TLS_GD:
1333 case R_386_TLS_IE_32:
1334 case R_386_TLS_IE:
1335 case R_386_TLS_GOTIE:
1336 case R_386_GOT32:
1337 if (h != NULL)
1338 {
1339 if (h->got.refcount > 0)
1340 h->got.refcount -= 1;
1341 }
1342 else if (local_got_refcounts != NULL)
1343 {
1344 if (local_got_refcounts[r_symndx] > 0)
1345 local_got_refcounts[r_symndx] -= 1;
1346 }
1347 break;
0c715baa 1348
26e41594
AM		 1349 case R_386_32:
1350 case R_386_PC32:
1351 if (info->shared)
1352 break;
1353 /* Fall through */
6725bdbf 1354
26e41594
AM		 1355 case R_386_PLT32:
1356 if (h != NULL)
1357 {
1358 if (h->plt.refcount > 0)
1359 h->plt.refcount -= 1;
1360 }
1361 break;
dd5724d5 1362
26e41594
AM		 1363 default:
1364 break;
1365 }
1366 }
252b5132 1367
b34976b6 1368 return TRUE;
252b5132
RH		 1369}
1370
1371/* Adjust a symbol defined by a dynamic object and referenced by a
1372 regular object. The current definition is in some section of the
1373 dynamic object, but we're not including those sections. We have to
1374 change the definition to something the rest of the link can
1375 understand. */
1376
b34976b6 1377static bfd_boolean
252b5132
RH		 1378elf_i386_adjust_dynamic_symbol (info, h)
1379 struct bfd_link_info *info;
1380 struct elf_link_hash_entry *h;
1381{
6725bdbf 1382 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1383 asection *s;
1384 unsigned int power_of_two;
1385
252b5132
RH		 1386 /* If this is a function, put it in the procedure linkage table. We
1387 will fill in the contents of the procedure linkage table later,
1388 when we know the address of the .got section. */
1389 if (h->type == STT_FUNC
1390 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1391 {
6725bdbf
AM		 1392 if (h->plt.refcount <= 0
1393 || (! info->shared
1394 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
f9cd9119
MS		 1395 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1396 && h->root.type != bfd_link_hash_undefweak
1397 && h->root.type != bfd_link_hash_undefined))
252b5132
RH		 1398 {
1399 /* This case can occur if we saw a PLT32 reloc in an input
dd5724d5
AM		 1400 file, but the symbol was never referred to by a dynamic
1401 object, or if all references were garbage collected. In
1402 such a case, we don't actually need to build a procedure
1403 linkage table, and we can just do a PC32 reloc instead. */
bbd7ec4a 1404 h->plt.offset = (bfd_vma) -1;
dd5724d5 1405 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
252b5132
RH		 1406 }
1407
b34976b6 1408 return TRUE;
252b5132 1409 }
6725bdbf
AM		 1410 else
1411 /* It's possible that we incorrectly decided a .plt reloc was
1412 needed for an R_386_PC32 reloc to a non-function sym in
1413 check_relocs. We can't decide accurately between function and
1414 non-function syms in check-relocs; Objects loaded later in
1415 the link may change h->type. So fix it now. */
bbd7ec4a 1416 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 1417
1418 /* If this is a weak symbol, and there is a real definition, the
1419 processor independent code will have arranged for us to see the
1420 real definition first, and we can just use the same value. */
1421 if (h->weakdef != NULL)
1422 {
1423 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1424 || h->weakdef->root.type == bfd_link_hash_defweak);
1425 h->root.u.def.section = h->weakdef->root.u.def.section;
1426 h->root.u.def.value = h->weakdef->root.u.def.value;
a23b6845
AM		 1427 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1428 h->elf_link_hash_flags
1429 = ((h->elf_link_hash_flags & ~ELF_LINK_NON_GOT_REF)
1430 | (h->weakdef->elf_link_hash_flags & ELF_LINK_NON_GOT_REF));
b34976b6 1431 return TRUE;
252b5132
RH		 1432 }
1433
1434 /* This is a reference to a symbol defined by a dynamic object which
1435 is not a function. */
1436
1437 /* If we are creating a shared library, we must presume that the
1438 only references to the symbol are via the global offset table.
1439 For such cases we need not do anything here; the relocations will
1440 be handled correctly by relocate_section. */
1441 if (info->shared)
b34976b6 1442 return TRUE;
252b5132 1443
7843f00e
ILT		 1444 /* If there are no references to this symbol that do not use the
1445 GOT, we don't need to generate a copy reloc. */
1446 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
b34976b6 1447 return TRUE;
7843f00e 1448
8bd621d8
AM		 1449 /* If -z nocopyreloc was given, we won't generate them either. */
1450 if (info->nocopyreloc)
1451 {
1452 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
b34976b6 1453 return TRUE;
8bd621d8
AM		 1454 }
1455
a23b6845 1456 if (ELIMINATE_COPY_RELOCS)
ebe50bae 1457 {
a23b6845
AM		 1458 struct elf_i386_link_hash_entry * eh;
1459 struct elf_i386_dyn_relocs *p;
ebe50bae 1460
a23b6845
AM		 1461 eh = (struct elf_i386_link_hash_entry *) h;
1462 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1463 {
1464 s = p->sec->output_section;
1465 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1466 break;
1467 }
1468
1469 /* If we didn't find any dynamic relocs in read-only sections, then
1470 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1471 if (p == NULL)
1472 {
1473 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1474 return TRUE;
1475 }
ebe50bae
AM		 1476 }
1477
252b5132
RH		 1478 /* We must allocate the symbol in our .dynbss section, which will
1479 become part of the .bss section of the executable. There will be
1480 an entry for this symbol in the .dynsym section. The dynamic
1481 object will contain position independent code, so all references
1482 from the dynamic object to this symbol will go through the global
1483 offset table. The dynamic linker will use the .dynsym entry to
1484 determine the address it must put in the global offset table, so
1485 both the dynamic object and the regular object will refer to the
1486 same memory location for the variable. */
1487
0ac8d2ca 1488 htab = elf_i386_hash_table (info);
252b5132
RH		 1489
1490 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1491 copy the initial value out of the dynamic object and into the
0ac8d2ca 1492 runtime process image. */
252b5132
RH		 1493 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1494 {
0ac8d2ca 1495 htab->srelbss->_raw_size += sizeof (Elf32_External_Rel);
252b5132
RH		 1496 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1497 }
1498
1499 /* We need to figure out the alignment required for this symbol. I
1500 have no idea how ELF linkers handle this. */
1501 power_of_two = bfd_log2 (h->size);
1502 if (power_of_two > 3)
1503 power_of_two = 3;
1504
1505 /* Apply the required alignment. */
0ac8d2ca
AM		 1506 s = htab->sdynbss;
1507 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1508 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
252b5132 1509 {
0ac8d2ca 1510 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
b34976b6 1511 return FALSE;
252b5132
RH		 1512 }
1513
1514 /* Define the symbol as being at this point in the section. */
1515 h->root.u.def.section = s;
1516 h->root.u.def.value = s->_raw_size;
1517
1518 /* Increment the section size to make room for the symbol. */
1519 s->_raw_size += h->size;
1520
b34976b6 1521 return TRUE;
252b5132
RH		 1522}
1523
6725bdbf
AM		 1524/* This is the condition under which elf_i386_finish_dynamic_symbol
1525 will be called from elflink.h. If elflink.h doesn't call our
1526 finish_dynamic_symbol routine, we'll need to do something about
1527 initializing any .plt and .got entries in elf_i386_relocate_section. */
26e41594 1528#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
6725bdbf 1529 ((DYN) \
26e41594 1530 && ((SHARED) \
6725bdbf
AM		 1531 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1532 && ((H)->dynindx != -1 \
1533 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1534
1535/* Allocate space in .plt, .got and associated reloc sections for
0c715baa 1536 dynamic relocs. */
6725bdbf 1537
b34976b6 1538static bfd_boolean
0c715baa 1539allocate_dynrelocs (h, inf)
6725bdbf
AM		 1540 struct elf_link_hash_entry *h;
1541 PTR inf;
1542{
1543 struct bfd_link_info *info;
1544 struct elf_i386_link_hash_table *htab;
5a15f56f 1545 struct elf_i386_link_hash_entry *eh;
0c715baa 1546 struct elf_i386_dyn_relocs *p;
6725bdbf 1547
e92d460e 1548 if (h->root.type == bfd_link_hash_indirect)
b34976b6 1549 return TRUE;
6725bdbf 1550
e92d460e
AM		 1551 if (h->root.type == bfd_link_hash_warning)
1552 /* When warning symbols are created, they **replace** the "real"
1553 entry in the hash table, thus we never get to see the real
1554 symbol in a hash traversal. So look at it now. */
1555 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1556
6725bdbf
AM		 1557 info = (struct bfd_link_info *) inf;
1558 htab = elf_i386_hash_table (info);
1559
ebe50bae 1560 if (htab->elf.dynamic_sections_created
4e795f50
AM		 1561 && h->plt.refcount > 0
1562 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1563 || h->root.type != bfd_link_hash_undefweak))
6725bdbf 1564 {
5a15f56f
AM		 1565 /* Make sure this symbol is output as a dynamic symbol.
1566 Undefined weak syms won't yet be marked as dynamic. */
1567 if (h->dynindx == -1
1568 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1569 {
1570 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 1571 return FALSE;
5a15f56f
AM		 1572 }
1573
4e795f50
AM		 1574 if (info->shared
1575 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
ced53ee5 1576 {
0ac8d2ca 1577 asection *s = htab->splt;
6725bdbf 1578
ced53ee5
AM		 1579 /* If this is the first .plt entry, make room for the special
1580 first entry. */
1581 if (s->_raw_size == 0)
1582 s->_raw_size += PLT_ENTRY_SIZE;
6725bdbf 1583
ced53ee5 1584 h->plt.offset = s->_raw_size;
6725bdbf 1585
ced53ee5
AM		 1586 /* If this symbol is not defined in a regular file, and we are
1587 not generating a shared library, then set the symbol to this
1588 location in the .plt. This is required to make function
1589 pointers compare as equal between the normal executable and
1590 the shared library. */
1591 if (! info->shared
1592 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1593 {
1594 h->root.u.def.section = s;
1595 h->root.u.def.value = h->plt.offset;
1596 }
6725bdbf 1597
ced53ee5
AM		 1598 /* Make room for this entry. */
1599 s->_raw_size += PLT_ENTRY_SIZE;
6725bdbf 1600
ced53ee5
AM		 1601 /* We also need to make an entry in the .got.plt section, which
1602 will be placed in the .got section by the linker script. */
0ac8d2ca 1603 htab->sgotplt->_raw_size += 4;
6725bdbf 1604
6725bdbf 1605 /* We also need to make an entry in the .rel.plt section. */
0ac8d2ca 1606 htab->srelplt->_raw_size += sizeof (Elf32_External_Rel);
6725bdbf 1607 }
ced53ee5
AM		 1608 else
1609 {
51b64d56 1610 h->plt.offset = (bfd_vma) -1;
ced53ee5
AM		 1611 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1612 }
6725bdbf
AM		 1613 }
1614 else
1615 {
51b64d56 1616 h->plt.offset = (bfd_vma) -1;
6725bdbf
AM		 1617 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1618 }
1619
37e55690 1620 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
13ae64f3
JJ		 1621 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1622 if (h->got.refcount > 0
1623 && !info->shared
1624 && h->dynindx == -1
37e55690 1625 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
cedb70c5 1626 h->got.offset = (bfd_vma) -1;
13ae64f3 1627 else if (h->got.refcount > 0)
6725bdbf 1628 {
0ac8d2ca 1629 asection *s;
b34976b6 1630 bfd_boolean dyn;
13ae64f3 1631 int tls_type = elf_i386_hash_entry(h)->tls_type;
6725bdbf 1632
5a15f56f
AM		 1633 /* Make sure this symbol is output as a dynamic symbol.
1634 Undefined weak syms won't yet be marked as dynamic. */
1635 if (h->dynindx == -1
1636 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1637 {
1638 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 1639 return FALSE;
5a15f56f
AM		 1640 }
1641
6725bdbf
AM		 1642 s = htab->sgot;
1643 h->got.offset = s->_raw_size;
1644 s->_raw_size += 4;
13ae64f3 1645 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
37e55690 1646 if (tls_type == GOT_TLS_GD || tls_type == GOT_TLS_IE_BOTH)
13ae64f3 1647 s->_raw_size += 4;
ebe50bae 1648 dyn = htab->elf.dynamic_sections_created;
13ae64f3 1649 /* R_386_TLS_IE_32 needs one dynamic relocation,
37e55690
JJ		 1650 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1651 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1652 need two), R_386_TLS_GD needs one if local symbol and two if
1653 global. */
1654 if (tls_type == GOT_TLS_IE_BOTH)
1655 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rel);
1656 else if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1657 || (tls_type & GOT_TLS_IE))
13ae64f3
JJ		 1658 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1659 else if (tls_type == GOT_TLS_GD)
1660 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rel);
ef5aade5
L		 1661 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1662 || h->root.type != bfd_link_hash_undefweak)
1663 && (info->shared
1664 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
6725bdbf
AM		 1665 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1666 }
1667 else
51b64d56 1668 h->got.offset = (bfd_vma) -1;
6725bdbf 1669
5a15f56f
AM		 1670 eh = (struct elf_i386_link_hash_entry *) h;
1671 if (eh->dyn_relocs == NULL)
b34976b6 1672 return TRUE;
5a15f56f 1673
0c715baa
AM		 1674 /* In the shared -Bsymbolic case, discard space allocated for
1675 dynamic pc-relative relocs against symbols which turn out to be
1676 defined in regular objects. For the normal shared case, discard
0ac8d2ca
AM		 1677 space for pc-relative relocs that have become local due to symbol
1678 visibility changes. */
0c715baa
AM		 1679
1680 if (info->shared)
5a15f56f 1681 {
586119b3 1682 if (SYMBOL_REFERENCES_LOCAL (info, h))
5a15f56f 1683 {
0c715baa
AM		 1684 struct elf_i386_dyn_relocs **pp;
1685
1686 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1687 {
1688 p->count -= p->pc_count;
1689 p->pc_count = 0;
1690 if (p->count == 0)
1691 *pp = p->next;
1692 else
1693 pp = &p->next;
1694 }
5a15f56f 1695 }
4e795f50
AM		 1696
1697 /* Also discard relocs on undefined weak syms with non-default
1698 visibility. */
1699 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1700 && h->root.type == bfd_link_hash_undefweak)
1701 eh->dyn_relocs = NULL;
0c715baa 1702 }
a23b6845 1703 else if (ELIMINATE_COPY_RELOCS)
0c715baa
AM		 1704 {
1705 /* For the non-shared case, discard space for relocs against
1706 symbols which turn out to need copy relocs or are not
1707 dynamic. */
1708
1709 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1710 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1711 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
ebe50bae 1712 || (htab->elf.dynamic_sections_created
0c715baa
AM		 1713 && (h->root.type == bfd_link_hash_undefweak
1714 || h->root.type == bfd_link_hash_undefined))))
1715 {
1716 /* Make sure this symbol is output as a dynamic symbol.
1717 Undefined weak syms won't yet be marked as dynamic. */
1718 if (h->dynindx == -1
1719 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1720 {
1721 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 1722 return FALSE;
0c715baa 1723 }
5a15f56f 1724
0c715baa
AM		 1725 /* If that succeeded, we know we'll be keeping all the
1726 relocs. */
1727 if (h->dynindx != -1)
1728 goto keep;
1729 }
1730
1731 eh->dyn_relocs = NULL;
1732
ec338859 1733 keep: ;
5a15f56f
AM		 1734 }
1735
0c715baa
AM		 1736 /* Finally, allocate space. */
1737 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12d0ee4a 1738 {
0c715baa
AM		 1739 asection *sreloc = elf_section_data (p->sec)->sreloc;
1740 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
12d0ee4a
AM		 1741 }
1742
b34976b6 1743 return TRUE;
6725bdbf
AM		 1744}
1745
0c715baa
AM		 1746/* Find any dynamic relocs that apply to read-only sections. */
1747
b34976b6 1748static bfd_boolean
0c715baa
AM		 1749readonly_dynrelocs (h, inf)
1750 struct elf_link_hash_entry *h;
1751 PTR inf;
1752{
1753 struct elf_i386_link_hash_entry *eh;
1754 struct elf_i386_dyn_relocs *p;
1755
e92d460e
AM		 1756 if (h->root.type == bfd_link_hash_warning)
1757 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1758
0c715baa
AM		 1759 eh = (struct elf_i386_link_hash_entry *) h;
1760 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1761 {
1762 asection *s = p->sec->output_section;
1763
1764 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1765 {
1766 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1767
1768 info->flags |= DF_TEXTREL;
1769
1770 /* Not an error, just cut short the traversal. */
b34976b6 1771 return FALSE;
0c715baa
AM		 1772 }
1773 }
b34976b6 1774 return TRUE;
0c715baa
AM		 1775}
1776
252b5132
RH		 1777/* Set the sizes of the dynamic sections. */
1778
b34976b6 1779static bfd_boolean
252b5132 1780elf_i386_size_dynamic_sections (output_bfd, info)
db6751f2 1781 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 1782 struct bfd_link_info *info;
1783{
6725bdbf 1784 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1785 bfd *dynobj;
1786 asection *s;
b34976b6 1787 bfd_boolean relocs;
0c715baa 1788 bfd *ibfd;
252b5132 1789
6725bdbf 1790 htab = elf_i386_hash_table (info);
ebe50bae 1791 dynobj = htab->elf.dynobj;
ffb2e45b
AM		 1792 if (dynobj == NULL)
1793 abort ();
252b5132 1794
ebe50bae 1795 if (htab->elf.dynamic_sections_created)
252b5132
RH		 1796 {
1797 /* Set the contents of the .interp section to the interpreter. */
1798 if (! info->shared)
1799 {
1800 s = bfd_get_section_by_name (dynobj, ".interp");
ffb2e45b
AM		 1801 if (s == NULL)
1802 abort ();
252b5132
RH		 1803 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1804 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1805 }
161d71a6 1806 }
6725bdbf 1807
0c715baa
AM		 1808 /* Set up .got offsets for local syms, and space for local dynamic
1809 relocs. */
1810 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
161d71a6
L		 1811 {
1812 bfd_signed_vma *local_got;
1813 bfd_signed_vma *end_local_got;
13ae64f3 1814 char *local_tls_type;
161d71a6
L		 1815 bfd_size_type locsymcount;
1816 Elf_Internal_Shdr *symtab_hdr;
1817 asection *srel;
6725bdbf 1818
0c715baa 1819 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
161d71a6 1820 continue;
6725bdbf 1821
0c715baa
AM		 1822 for (s = ibfd->sections; s != NULL; s = s->next)
1823 {
ec338859 1824 struct elf_i386_dyn_relocs *p;
0c715baa 1825
ec338859
AM		 1826 for (p = *((struct elf_i386_dyn_relocs **)
1827 &elf_section_data (s)->local_dynrel);
1828 p != NULL;
1829 p = p->next)
0c715baa 1830 {
ec338859
AM		 1831 if (!bfd_is_abs_section (p->sec)
1832 && bfd_is_abs_section (p->sec->output_section))
1833 {
1834 /* Input section has been discarded, either because
1835 it is a copy of a linkonce section or due to
1836 linker script /DISCARD/, so we'll be discarding
1837 the relocs too. */
1838 }
248866a8 1839 else if (p->count != 0)
ec338859
AM		 1840 {
1841 srel = elf_section_data (p->sec)->sreloc;
1842 srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
248866a8
AM		 1843 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1844 info->flags |= DF_TEXTREL;
ec338859 1845 }
0c715baa
AM		 1846 }
1847 }
1848
1849 local_got = elf_local_got_refcounts (ibfd);
161d71a6
L		 1850 if (!local_got)
1851 continue;
6725bdbf 1852
0c715baa 1853 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
161d71a6
L		 1854 locsymcount = symtab_hdr->sh_info;
1855 end_local_got = local_got + locsymcount;
13ae64f3 1856 local_tls_type = elf_i386_local_got_tls_type (ibfd);
161d71a6
L		 1857 s = htab->sgot;
1858 srel = htab->srelgot;
13ae64f3 1859 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
161d71a6
L		 1860 {
1861 if (*local_got > 0)
6725bdbf 1862 {
161d71a6
L		 1863 *local_got = s->_raw_size;
1864 s->_raw_size += 4;
37e55690
JJ		 1865 if (*local_tls_type == GOT_TLS_GD
1866 || *local_tls_type == GOT_TLS_IE_BOTH)
13ae64f3
JJ		 1867 s->_raw_size += 4;
1868 if (info->shared
1869 || *local_tls_type == GOT_TLS_GD
37e55690
JJ		 1870 || (*local_tls_type & GOT_TLS_IE))
1871 {
1872 if (*local_tls_type == GOT_TLS_IE_BOTH)
1873 srel->_raw_size += 2 * sizeof (Elf32_External_Rel);
1874 else
1875 srel->_raw_size += sizeof (Elf32_External_Rel);
1876 }
6725bdbf 1877 }
161d71a6
L		 1878 else
1879 *local_got = (bfd_vma) -1;
6725bdbf 1880 }
252b5132 1881 }
6725bdbf 1882
13ae64f3
JJ		 1883 if (htab->tls_ldm_got.refcount > 0)
1884 {
1885 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1886 relocs. */
1887 htab->tls_ldm_got.offset = htab->sgot->_raw_size;
1888 htab->sgot->_raw_size += 8;
1889 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1890 }
1891 else
1892 htab->tls_ldm_got.offset = -1;
1893
0c715baa
AM		 1894 /* Allocate global sym .plt and .got entries, and space for global
1895 sym dynamic relocs. */
ebe50bae 1896 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
252b5132 1897
5a15f56f
AM		 1898 /* We now have determined the sizes of the various dynamic sections.
1899 Allocate memory for them. */
b34976b6 1900 relocs = FALSE;
252b5132
RH		 1901 for (s = dynobj->sections; s != NULL; s = s->next)
1902 {
252b5132
RH		 1903 if ((s->flags & SEC_LINKER_CREATED) == 0)
1904 continue;
1905
6725bdbf
AM		 1906 if (s == htab->splt
1907 || s == htab->sgot
1908 || s == htab->sgotplt)
252b5132 1909 {
6725bdbf
AM		 1910 /* Strip this section if we don't need it; see the
1911 comment below. */
252b5132 1912 }
6725bdbf 1913 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
252b5132 1914 {
0ac8d2ca 1915 if (s->_raw_size != 0 && s != htab->srelplt)
b34976b6 1916 relocs = TRUE;
252b5132 1917
0ac8d2ca
AM		 1918 /* We use the reloc_count field as a counter if we need
1919 to copy relocs into the output file. */
1920 s->reloc_count = 0;
252b5132 1921 }
6725bdbf 1922 else
252b5132
RH		 1923 {
1924 /* It's not one of our sections, so don't allocate space. */
1925 continue;
1926 }
1927
6725bdbf 1928 if (s->_raw_size == 0)
252b5132 1929 {
0ac8d2ca
AM		 1930 /* If we don't need this section, strip it from the
1931 output file. This is mostly to handle .rel.bss and
1932 .rel.plt. We must create both sections in
1933 create_dynamic_sections, because they must be created
1934 before the linker maps input sections to output
1935 sections. The linker does that before
1936 adjust_dynamic_symbol is called, and it is that
1937 function which decides whether anything needs to go
1938 into these sections. */
1939
7f8d5fc9 1940 _bfd_strip_section_from_output (info, s);
252b5132
RH		 1941 continue;
1942 }
1943
f69da49f
AM		 1944 /* Allocate memory for the section contents. We use bfd_zalloc
1945 here in case unused entries are not reclaimed before the
1946 section's contents are written out. This should not happen,
1947 but this way if it does, we get a R_386_NONE reloc instead
1948 of garbage. */
7a9af8c4 1949 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
6725bdbf 1950 if (s->contents == NULL)
b34976b6 1951 return FALSE;
252b5132
RH		 1952 }
1953
ebe50bae 1954 if (htab->elf.dynamic_sections_created)
252b5132
RH		 1955 {
1956 /* Add some entries to the .dynamic section. We fill in the
1957 values later, in elf_i386_finish_dynamic_sections, but we
1958 must add the entries now so that we get the correct size for
1959 the .dynamic section. The DT_DEBUG entry is filled in by the
1960 dynamic linker and used by the debugger. */
dc810e39
AM		 1961#define add_dynamic_entry(TAG, VAL) \
1962 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1963
252b5132
RH		 1964 if (! info->shared)
1965 {
dc810e39 1966 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 1967 return FALSE;
252b5132
RH		 1968 }
1969
6725bdbf 1970 if (htab->splt->_raw_size != 0)
252b5132 1971 {
dc810e39
AM		 1972 if (!add_dynamic_entry (DT_PLTGOT, 0)
1973 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1974 || !add_dynamic_entry (DT_PLTREL, DT_REL)
1975 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 1976 return FALSE;
252b5132
RH		 1977 }
1978
1979 if (relocs)
1980 {
dc810e39
AM		 1981 if (!add_dynamic_entry (DT_REL, 0)
1982 || !add_dynamic_entry (DT_RELSZ, 0)
1983 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
b34976b6 1984 return FALSE;
252b5132 1985
0c715baa
AM		 1986 /* If any dynamic relocs apply to a read-only section,
1987 then we need a DT_TEXTREL entry. */
248866a8
AM		 1988 if ((info->flags & DF_TEXTREL) == 0)
1989 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1990 (PTR) info);
0c715baa
AM		 1991
1992 if ((info->flags & DF_TEXTREL) != 0)
1993 {
1994 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 1995 return FALSE;
0c715baa 1996 }
252b5132
RH		 1997 }
1998 }
dc810e39 1999#undef add_dynamic_entry
252b5132 2000
b34976b6 2001 return TRUE;
252b5132
RH		 2002}
2003
38701953
AM		 2004/* Set the correct type for an x86 ELF section. We do this by the
2005 section name, which is a hack, but ought to work. */
2006
b34976b6 2007static bfd_boolean
38701953
AM		 2008elf_i386_fake_sections (abfd, hdr, sec)
2009 bfd *abfd ATTRIBUTE_UNUSED;
947216bf 2010 Elf_Internal_Shdr *hdr;
38701953
AM		 2011 asection *sec;
2012{
2013 register const char *name;
2014
2015 name = bfd_get_section_name (abfd, sec);
2016
2017 /* This is an ugly, but unfortunately necessary hack that is
2018 needed when producing EFI binaries on x86. It tells
2019 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2020 containing ELF relocation info. We need this hack in order to
2021 be able to generate ELF binaries that can be translated into
2022 EFI applications (which are essentially COFF objects). Those
2023 files contain a COFF ".reloc" section inside an ELFNN object,
2024 which would normally cause BFD to segfault because it would
2025 attempt to interpret this section as containing relocation
2026 entries for section "oc". With this hack enabled, ".reloc"
2027 will be treated as a normal data section, which will avoid the
2028 segfault. However, you won't be able to create an ELFNN binary
2029 with a section named "oc" that needs relocations, but that's
2030 the kind of ugly side-effects you get when detecting section
2031 types based on their names... In practice, this limitation is
2032 unlikely to bite. */
2033 if (strcmp (name, ".reloc") == 0)
2034 hdr->sh_type = SHT_PROGBITS;
2035
b34976b6 2036 return TRUE;
38701953
AM		 2037}
2038
13ae64f3
JJ		 2039/* Return the base VMA address which should be subtracted from real addresses
2040 when resolving @dtpoff relocation.
2041 This is PT_TLS segment p_vaddr. */
2042
2043static bfd_vma
2044dtpoff_base (info)
2045 struct bfd_link_info *info;
2046{
6a30718d
JJ		 2047 /* If tls_segment is NULL, we should have signalled an error already. */
2048 if (elf_hash_table (info)->tls_segment == NULL)
2049 return 0;
13ae64f3
JJ		 2050 return elf_hash_table (info)->tls_segment->start;
2051}
2052
2053/* Return the relocation value for @tpoff relocation
2054 if STT_TLS virtual address is ADDRESS. */
2055
2056static bfd_vma
2057tpoff (info, address)
2058 struct bfd_link_info *info;
2059 bfd_vma address;
2060{
2061 struct elf_link_tls_segment *tls_segment
2062 = elf_hash_table (info)->tls_segment;
2063
6a30718d
JJ		 2064 /* If tls_segment is NULL, we should have signalled an error already. */
2065 if (tls_segment == NULL)
2066 return 0;
13ae64f3
JJ		 2067 return (align_power (tls_segment->size, tls_segment->align)
2068 + tls_segment->start - address);
2069}
2070
252b5132
RH		 2071/* Relocate an i386 ELF section. */
2072
b34976b6 2073static bfd_boolean
252b5132
RH		 2074elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
2075 contents, relocs, local_syms, local_sections)
2076 bfd *output_bfd;
2077 struct bfd_link_info *info;
2078 bfd *input_bfd;
2079 asection *input_section;
2080 bfd_byte *contents;
2081 Elf_Internal_Rela *relocs;
2082 Elf_Internal_Sym *local_syms;
2083 asection **local_sections;
2084{
6725bdbf 2085 struct elf_i386_link_hash_table *htab;
252b5132
RH		 2086 Elf_Internal_Shdr *symtab_hdr;
2087 struct elf_link_hash_entry **sym_hashes;
2088 bfd_vma *local_got_offsets;
252b5132
RH		 2089 Elf_Internal_Rela *rel;
2090 Elf_Internal_Rela *relend;
2091
6725bdbf 2092 htab = elf_i386_hash_table (info);
252b5132
RH		 2093 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2094 sym_hashes = elf_sym_hashes (input_bfd);
2095 local_got_offsets = elf_local_got_offsets (input_bfd);
2096
252b5132
RH		 2097 rel = relocs;
2098 relend = relocs + input_section->reloc_count;
2099 for (; rel < relend; rel++)
2100 {
13ae64f3 2101 unsigned int r_type;
252b5132
RH		 2102 reloc_howto_type *howto;
2103 unsigned long r_symndx;
2104 struct elf_link_hash_entry *h;
2105 Elf_Internal_Sym *sym;
2106 asection *sec;
ffb2e45b 2107 bfd_vma off;
252b5132 2108 bfd_vma relocation;
b34976b6 2109 bfd_boolean unresolved_reloc;
252b5132 2110 bfd_reloc_status_type r;
1b452ec6 2111 unsigned int indx;
13ae64f3 2112 int tls_type;
252b5132
RH		 2113
2114 r_type = ELF32_R_TYPE (rel->r_info);
dc47f327
AM		 2115 if (r_type == (int) R_386_GNU_VTINHERIT
2116 || r_type == (int) R_386_GNU_VTENTRY)
252b5132 2117 continue;
dc47f327 2118
1b452ec6 2119 if ((indx = (unsigned) r_type) >= R_386_standard
13ae64f3
JJ		 2120 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2121 >= R_386_ext - R_386_standard)
2122 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2123 >= R_386_tls - R_386_ext))
252b5132
RH		 2124 {
2125 bfd_set_error (bfd_error_bad_value);
b34976b6 2126 return FALSE;
252b5132 2127 }
1b452ec6 2128 howto = elf_howto_table + indx;
252b5132
RH		 2129
2130 r_symndx = ELF32_R_SYM (rel->r_info);
2131
2132 if (info->relocateable)
2133 {
4a335f3d 2134 bfd_vma val;
4a335f3d
AM		 2135 bfd_byte *where;
2136
0ac8d2ca 2137 /* This is a relocatable link. We don't have to change
252b5132
RH		 2138 anything, unless the reloc is against a section symbol,
2139 in which case we have to adjust according to where the
2140 section symbol winds up in the output section. */
4a335f3d
AM		 2141 if (r_symndx >= symtab_hdr->sh_info)
2142 continue;
2143
2144 sym = local_syms + r_symndx;
2145 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2146 continue;
2147
2148 sec = local_sections[r_symndx];
2149 val = sec->output_offset;
2150 if (val == 0)
2151 continue;
2152
2153 where = contents + rel->r_offset;
2154 switch (howto->size)
252b5132 2155 {
16a10388 2156 /* FIXME: overflow checks. */
4a335f3d 2157 case 0:
16a10388 2158 val += bfd_get_8 (input_bfd, where);
4a335f3d 2159 bfd_put_8 (input_bfd, val, where);
4a335f3d
AM		 2160 break;
2161 case 1:
16a10388 2162 val += bfd_get_16 (input_bfd, where);
4a335f3d 2163 bfd_put_16 (input_bfd, val, where);
4a335f3d
AM		 2164 break;
2165 case 2:
2166 val += bfd_get_32 (input_bfd, where);
2167 bfd_put_32 (input_bfd, val, where);
2168 break;
2169 default:
2170 abort ();
252b5132 2171 }
252b5132
RH		 2172 continue;
2173 }
2174
2175 /* This is a final link. */
2176 h = NULL;
2177 sym = NULL;
2178 sec = NULL;
b34976b6 2179 unresolved_reloc = FALSE;
252b5132
RH		 2180 if (r_symndx < symtab_hdr->sh_info)
2181 {
2182 sym = local_syms + r_symndx;
2183 sec = local_sections[r_symndx];
2184 relocation = (sec->output_section->vma
2185 + sec->output_offset
2186 + sym->st_value);
f8df10f4
JJ		 2187 if ((sec->flags & SEC_MERGE)
2188 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2189 {
2190 asection *msec;
2191 bfd_vma addend;
4a335f3d 2192 bfd_byte *where = contents + rel->r_offset;
f8df10f4 2193
4a335f3d 2194 switch (howto->size)
f8df10f4 2195 {
4a335f3d
AM		 2196 case 0:
2197 addend = bfd_get_8 (input_bfd, where);
2198 if (howto->pc_relative)
2199 {
2200 addend = (addend ^ 0x80) - 0x80;
2201 addend += 1;
2202 }
2203 break;
2204 case 1:
2205 addend = bfd_get_16 (input_bfd, where);
2206 if (howto->pc_relative)
2207 {
2208 addend = (addend ^ 0x8000) - 0x8000;
2209 addend += 2;
2210 }
2211 break;
2212 case 2:
2213 addend = bfd_get_32 (input_bfd, where);
2214 if (howto->pc_relative)
2215 {
2216 addend = (addend ^ 0x80000000) - 0x80000000;
2217 addend += 4;
2218 }
2219 break;
2220 default:
2221 abort ();
f8df10f4
JJ		 2222 }
2223
f8df10f4 2224 msec = sec;
4a335f3d
AM		 2225 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2226 addend -= relocation;
f8df10f4 2227 addend += msec->output_section->vma + msec->output_offset;
4a335f3d
AM		 2228
2229 switch (howto->size)
2230 {
2231 case 0:
16a10388 2232 /* FIXME: overflow checks. */
4a335f3d
AM		 2233 if (howto->pc_relative)
2234 addend -= 1;
2235 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 2236 break;
2237 case 1:
2238 if (howto->pc_relative)
2239 addend -= 2;
2240 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 2241 break;
2242 case 2:
2243 if (howto->pc_relative)
2244 addend -= 4;
2245 bfd_put_32 (input_bfd, addend, where);
2246 break;
2247 }
f8df10f4 2248 }
252b5132
RH		 2249 }
2250 else
2251 {
2252 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2253 while (h->root.type == bfd_link_hash_indirect
2254 || h->root.type == bfd_link_hash_warning)
2255 h = (struct elf_link_hash_entry *) h->root.u.i.link;
ffb2e45b 2256
6725bdbf 2257 relocation = 0;
252b5132
RH		 2258 if (h->root.type == bfd_link_hash_defined
2259 || h->root.type == bfd_link_hash_defweak)
2260 {
2261 sec = h->root.u.def.section;
83be169b
AM		 2262 if (sec->output_section == NULL)
2263 /* Set a flag that will be cleared later if we find a
2264 relocation value for this symbol. output_section
2265 is typically NULL for symbols satisfied by a shared
2266 library. */
b34976b6 2267 unresolved_reloc = TRUE;
252b5132
RH		 2268 else
2269 relocation = (h->root.u.def.value
2270 + sec->output_section->vma
2271 + sec->output_offset);
2272 }
2273 else if (h->root.type == bfd_link_hash_undefweak)
6725bdbf 2274 ;
671bae9c 2275 else if (info->shared
3a27a730
L		 2276 && !info->no_undefined
2277 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
6725bdbf 2278 ;
252b5132
RH		 2279 else
2280 {
2281 if (! ((*info->callbacks->undefined_symbol)
2282 (info, h->root.root.string, input_bfd,
5cc7c785 2283 input_section, rel->r_offset,
3a27a730
L		 2284 (!info->shared || info->no_undefined
2285 || ELF_ST_VISIBILITY (h->other)))))
b34976b6 2286 return FALSE;
252b5132
RH		 2287 }
2288 }
2289
2290 switch (r_type)
2291 {
2292 case R_386_GOT32:
2293 /* Relocation is to the entry for this symbol in the global
2294 offset table. */
ffb2e45b
AM		 2295 if (htab->sgot == NULL)
2296 abort ();
252b5132
RH		 2297
2298 if (h != NULL)
2299 {
b34976b6 2300 bfd_boolean dyn;
252b5132
RH		 2301
2302 off = h->got.offset;
ebe50bae 2303 dyn = htab->elf.dynamic_sections_created;
26e41594 2304 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
252b5132 2305 || (info->shared
586119b3 2306 && SYMBOL_REFERENCES_LOCAL (info, h))
ef5aade5
L		 2307 || (ELF_ST_VISIBILITY (h->other)
2308 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 2309 {
2310 /* This is actually a static link, or it is a
2311 -Bsymbolic link and the symbol is defined
2312 locally, or the symbol was forced to be local
2313 because of a version file. We must initialize
2314 this entry in the global offset table. Since the
2315 offset must always be a multiple of 4, we use the
2316 least significant bit to record whether we have
2317 initialized it already.
2318
2319 When doing a dynamic link, we create a .rel.got
2320 relocation entry to initialize the value. This
2321 is done in the finish_dynamic_symbol routine. */
2322 if ((off & 1) != 0)
2323 off &= ~1;
2324 else
2325 {
2326 bfd_put_32 (output_bfd, relocation,
6725bdbf 2327 htab->sgot->contents + off);
252b5132
RH		 2328 h->got.offset |= 1;
2329 }
2330 }
8c694914 2331 else
b34976b6 2332 unresolved_reloc = FALSE;
252b5132
RH		 2333 }
2334 else
2335 {
ffb2e45b
AM		 2336 if (local_got_offsets == NULL)
2337 abort ();
252b5132
RH		 2338
2339 off = local_got_offsets[r_symndx];
2340
2341 /* The offset must always be a multiple of 4. We use
83be169b
AM		 2342 the least significant bit to record whether we have
2343 already generated the necessary reloc. */
252b5132
RH		 2344 if ((off & 1) != 0)
2345 off &= ~1;
2346 else
2347 {
6725bdbf
AM		 2348 bfd_put_32 (output_bfd, relocation,
2349 htab->sgot->contents + off);
252b5132
RH		 2350
2351 if (info->shared)
2352 {
947216bf
AM		 2353 asection *s;
2354 Elf_Internal_Rela outrel;
2355 bfd_byte *loc;
252b5132 2356
947216bf
AM		 2357 s = htab->srelgot;
2358 if (s == NULL)
ffb2e45b 2359 abort ();
252b5132 2360
6725bdbf
AM		 2361 outrel.r_offset = (htab->sgot->output_section->vma
2362 + htab->sgot->output_offset
252b5132
RH		 2363 + off);
2364 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
947216bf
AM		 2365 loc = s->contents;
2366 loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 2367 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2368 }
2369
2370 local_got_offsets[r_symndx] |= 1;
2371 }
252b5132
RH		 2372 }
2373
ffb2e45b
AM		 2374 if (off >= (bfd_vma) -2)
2375 abort ();
2376
2377 relocation = htab->sgot->output_offset + off;
252b5132
RH		 2378 break;
2379
2380 case R_386_GOTOFF:
2381 /* Relocation is relative to the start of the global offset
2382 table. */
2383
252b5132
RH		 2384 /* Note that sgot->output_offset is not involved in this
2385 calculation. We always want the start of .got. If we
2386 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2387 permitted by the ABI, we might have to change this
2388 calculation. */
6725bdbf 2389 relocation -= htab->sgot->output_section->vma;
252b5132
RH		 2390 break;
2391
2392 case R_386_GOTPC:
2393 /* Use global offset table as symbol value. */
6725bdbf 2394 relocation = htab->sgot->output_section->vma;
b34976b6 2395 unresolved_reloc = FALSE;
252b5132
RH		 2396 break;
2397
2398 case R_386_PLT32:
2399 /* Relocation is to the entry for this symbol in the
2400 procedure linkage table. */
2401
dd5724d5 2402 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 2403 without using the procedure linkage table. */
252b5132
RH		 2404 if (h == NULL)
2405 break;
2406
dd5724d5 2407 if (h->plt.offset == (bfd_vma) -1
6725bdbf 2408 || htab->splt == NULL)
252b5132
RH		 2409 {
2410 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 2411 happens when statically linking PIC code, or when
2412 using -Bsymbolic. */
252b5132
RH		 2413 break;
2414 }
2415
6725bdbf
AM		 2416 relocation = (htab->splt->output_section->vma
2417 + htab->splt->output_offset
252b5132 2418 + h->plt.offset);
b34976b6 2419 unresolved_reloc = FALSE;
252b5132
RH		 2420 break;
2421
2422 case R_386_32:
2423 case R_386_PC32:
ec338859
AM		 2424 /* r_symndx will be zero only for relocs against symbols
2425 from removed linkonce sections, or sections discarded by
2426 a linker script. */
2427 if (r_symndx == 0
2428 || (input_section->flags & SEC_ALLOC) == 0)
2429 break;
2430
12d0ee4a 2431 if ((info->shared
ef5aade5
L		 2432 && (h == NULL
2433 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2434 || h->root.type != bfd_link_hash_undefweak)
12d0ee4a
AM		 2435 && (r_type != R_386_PC32
2436 || (h != NULL
586119b3 2437 && !SYMBOL_REFERENCES_LOCAL (info, h))))
a23b6845
AM		 2438 || (ELIMINATE_COPY_RELOCS
2439 && !info->shared
12d0ee4a
AM		 2440 && h != NULL
2441 && h->dynindx != -1
2442 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
56882138
AM		 2443 && (((h->elf_link_hash_flags
2444 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2445 && (h->elf_link_hash_flags
2446 & ELF_LINK_HASH_DEF_REGULAR) == 0)
28d0b90e
AM		 2447 || h->root.type == bfd_link_hash_undefweak
2448 || h->root.type == bfd_link_hash_undefined)))
252b5132 2449 {
947216bf
AM		 2450 Elf_Internal_Rela outrel;
2451 bfd_byte *loc;
b34976b6 2452 bfd_boolean skip, relocate;
0c715baa 2453 asection *sreloc;
252b5132
RH		 2454
2455 /* When generating a shared object, these relocations
2456 are copied into the output file to be resolved at run
2457 time. */
2458
b34976b6
AM		 2459 skip = FALSE;
2460 relocate = FALSE;
252b5132 2461
c629eae0
JJ		 2462 outrel.r_offset =
2463 _bfd_elf_section_offset (output_bfd, info, input_section,
2464 rel->r_offset);
2465 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 2466 skip = TRUE;
0bb2d96a 2467 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 2468 skip = TRUE, relocate = TRUE;
252b5132
RH		 2469 outrel.r_offset += (input_section->output_section->vma
2470 + input_section->output_offset);
2471
2472 if (skip)
0bb2d96a 2473 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 2474 else if (h != NULL
2475 && h->dynindx != -1
2476 && (r_type == R_386_PC32
2477 || !info->shared
2478 || !info->symbolic
2479 || (h->elf_link_hash_flags
2480 & ELF_LINK_HASH_DEF_REGULAR) == 0))
0bb2d96a 2481 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 2482 else
2483 {
5a15f56f 2484 /* This symbol is local, or marked to become local. */
b34976b6 2485 relocate = TRUE;
5a15f56f 2486 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 2487 }
2488
0c715baa
AM		 2489 sreloc = elf_section_data (input_section)->sreloc;
2490 if (sreloc == NULL)
2491 abort ();
2492
947216bf
AM		 2493 loc = sreloc->contents;
2494 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
0c715baa 2495 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2496
2497 /* If this reloc is against an external symbol, we do
2498 not want to fiddle with the addend. Otherwise, we
2499 need to include the symbol value so that it becomes
2500 an addend for the dynamic reloc. */
2501 if (! relocate)
2502 continue;
2503 }
252b5132
RH		 2504 break;
2505
37e55690
JJ		 2506 case R_386_TLS_IE:
2507 if (info->shared)
2508 {
947216bf
AM		 2509 Elf_Internal_Rela outrel;
2510 bfd_byte *loc;
37e55690 2511 asection *sreloc;
37e55690
JJ		 2512
2513 outrel.r_offset = rel->r_offset
2514 + input_section->output_section->vma
2515 + input_section->output_offset;
2516 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2517 sreloc = elf_section_data (input_section)->sreloc;
2518 if (sreloc == NULL)
2519 abort ();
947216bf
AM		 2520 loc = sreloc->contents;
2521 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
37e55690
JJ		 2522 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2523 }
2524 /* Fall through */
2525
13ae64f3
JJ		 2526 case R_386_TLS_GD:
2527 case R_386_TLS_IE_32:
37e55690 2528 case R_386_TLS_GOTIE:
13ae64f3
JJ		 2529 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2530 tls_type = GOT_UNKNOWN;
2531 if (h == NULL && local_got_offsets)
2532 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2533 else if (h != NULL)
2534 {
2535 tls_type = elf_i386_hash_entry(h)->tls_type;
37e55690 2536 if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
13ae64f3
JJ		 2537 r_type = R_386_TLS_LE_32;
2538 }
37e55690
JJ		 2539 if (tls_type == GOT_TLS_IE)
2540 tls_type = GOT_TLS_IE_NEG;
2541 if (r_type == R_386_TLS_GD)
2542 {
2543 if (tls_type == GOT_TLS_IE_POS)
2544 r_type = R_386_TLS_GOTIE;
2545 else if (tls_type & GOT_TLS_IE)
2546 r_type = R_386_TLS_IE_32;
2547 }
13ae64f3
JJ		 2548
2549 if (r_type == R_386_TLS_LE_32)
2550 {
82e51918 2551 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2552 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2553 {
2554 unsigned int val, type;
2555 bfd_vma roff;
2556
2557 /* GD->LE transition. */
2558 BFD_ASSERT (rel->r_offset >= 2);
2559 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2560 BFD_ASSERT (type == 0x8d || type == 0x04);
2561 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2562 BFD_ASSERT (bfd_get_8 (input_bfd,
2563 contents + rel->r_offset + 4)
2564 == 0xe8);
2565 BFD_ASSERT (rel + 1 < relend);
2566 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2567 roff = rel->r_offset + 5;
2568 val = bfd_get_8 (input_bfd,
2569 contents + rel->r_offset - 1);
2570 if (type == 0x04)
2571 {
2572 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2573 Change it into:
2574 movl %gs:0, %eax; subl $foo@tpoff, %eax
2575 (6 byte form of subl). */
2576 BFD_ASSERT (rel->r_offset >= 3);
2577 BFD_ASSERT (bfd_get_8 (input_bfd,
2578 contents + rel->r_offset - 3)
2579 == 0x8d);
2580 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2581 memcpy (contents + rel->r_offset - 3,
2582 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2583 }
2584 else
2585 {
2586 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2587 if (rel->r_offset + 10 <= input_section->_raw_size
2588 && bfd_get_8 (input_bfd,
2589 contents + rel->r_offset + 9) == 0x90)
2590 {
2591 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2592 Change it into:
2593 movl %gs:0, %eax; subl $foo@tpoff, %eax
2594 (6 byte form of subl). */
2595 memcpy (contents + rel->r_offset - 2,
2596 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2597 roff = rel->r_offset + 6;
2598 }
2599 else
2600 {
2601 /* leal foo(%reg), %eax; call ___tls_get_addr
2602 Change it into:
2603 movl %gs:0, %eax; subl $foo@tpoff, %eax
2604 (5 byte form of subl). */
2605 memcpy (contents + rel->r_offset - 2,
2606 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2607 }
2608 }
2609 bfd_put_32 (output_bfd, tpoff (info, relocation),
2610 contents + roff);
2611 /* Skip R_386_PLT32. */
2612 rel++;
2613 continue;
2614 }
37e55690 2615 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
13ae64f3
JJ		 2616 {
2617 unsigned int val, type;
2618
2619 /* IE->LE transition:
37e55690
JJ		 2620 Originally it can be one of:
2621 movl foo, %eax
2622 movl foo, %reg
2623 addl foo, %reg
2624 We change it into:
2625 movl $foo, %eax
2626 movl $foo, %reg
2627 addl $foo, %reg. */
2628 BFD_ASSERT (rel->r_offset >= 1);
2629 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2630 BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
37e55690
JJ		 2631 if (val == 0xa1)
2632 {
2633 /* movl foo, %eax. */
7c445aa3 2634 bfd_put_8 (output_bfd, 0xb8, contents + rel->r_offset - 1);
37e55690 2635 }
299bf759 2636 else
37e55690 2637 {
299bf759
L		 2638 BFD_ASSERT (rel->r_offset >= 2);
2639 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2640 switch (type)
26e41594 2641 {
299bf759
L		 2642 case 0x8b:
2643 /* movl */
2644 BFD_ASSERT ((val & 0xc7) == 0x05);
2645 bfd_put_8 (output_bfd, 0xc7,
2646 contents + rel->r_offset - 2);
2647 bfd_put_8 (output_bfd,
2648 0xc0 | ((val >> 3) & 7),
2649 contents + rel->r_offset - 1);
2650 break;
2651 case 0x03:
2652 /* addl */
2653 BFD_ASSERT ((val & 0xc7) == 0x05);
2654 bfd_put_8 (output_bfd, 0x81,
2655 contents + rel->r_offset - 2);
2656 bfd_put_8 (output_bfd,
2657 0xc0 | ((val >> 3) & 7),
2658 contents + rel->r_offset - 1);
2659 break;
2660 default:
2661 BFD_FAIL ();
2662 break;
26e41594 2663 }
37e55690 2664 }
37e55690
JJ		 2665 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2666 contents + rel->r_offset);
2667 continue;
2668 }
2669 else
2670 {
2671 unsigned int val, type;
2672
2673 /* {IE_32,GOTIE}->LE transition:
2674 Originally it can be one of:
13ae64f3 2675 subl foo(%reg1), %reg2
13ae64f3 2676 movl foo(%reg1), %reg2
37e55690 2677 addl foo(%reg1), %reg2
13ae64f3
JJ		 2678 We change it into:
2679 subl $foo, %reg2
37e55690
JJ		 2680 movl $foo, %reg2 (6 byte form)
2681 addl $foo, %reg2. */
13ae64f3
JJ		 2682 BFD_ASSERT (rel->r_offset >= 2);
2683 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2684 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2685 BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
37e55690 2686 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
13ae64f3
JJ		 2687 if (type == 0x8b)
2688 {
2689 /* movl */
13ae64f3
JJ		 2690 bfd_put_8 (output_bfd, 0xc7,
2691 contents + rel->r_offset - 2);
2692 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2693 contents + rel->r_offset - 1);
2694 }
2695 else if (type == 0x2b)
2696 {
2697 /* subl */
13ae64f3
JJ		 2698 bfd_put_8 (output_bfd, 0x81,
2699 contents + rel->r_offset - 2);
2700 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2701 contents + rel->r_offset - 1);
2702 }
37e55690
JJ		 2703 else if (type == 0x03)
2704 {
2705 /* addl */
2706 bfd_put_8 (output_bfd, 0x81,
2707 contents + rel->r_offset - 2);
2708 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2709 contents + rel->r_offset - 1);
2710 }
13ae64f3
JJ		 2711 else
2712 BFD_FAIL ();
37e55690
JJ		 2713 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2714 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2715 contents + rel->r_offset);
2716 else
2717 bfd_put_32 (output_bfd, tpoff (info, relocation),
2718 contents + rel->r_offset);
13ae64f3
JJ		 2719 continue;
2720 }
2721 }
2722
2723 if (htab->sgot == NULL)
2724 abort ();
2725
2726 if (h != NULL)
2727 off = h->got.offset;
2728 else
2729 {
2730 if (local_got_offsets == NULL)
2731 abort ();
2732
2733 off = local_got_offsets[r_symndx];
2734 }
2735
2736 if ((off & 1) != 0)
2737 off &= ~1;
26e41594 2738 else
13ae64f3 2739 {
947216bf
AM		 2740 Elf_Internal_Rela outrel;
2741 bfd_byte *loc;
13ae64f3
JJ		 2742 int dr_type, indx;
2743
2744 if (htab->srelgot == NULL)
2745 abort ();
2746
2747 outrel.r_offset = (htab->sgot->output_section->vma
2748 + htab->sgot->output_offset + off);
2749
13ae64f3
JJ		 2750 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2751 if (r_type == R_386_TLS_GD)
2752 dr_type = R_386_TLS_DTPMOD32;
37e55690
JJ		 2753 else if (tls_type == GOT_TLS_IE_POS)
2754 dr_type = R_386_TLS_TPOFF;
13ae64f3
JJ		 2755 else
2756 dr_type = R_386_TLS_TPOFF32;
37e55690
JJ		 2757 if (dr_type == R_386_TLS_TPOFF && indx == 0)
2758 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2759 htab->sgot->contents + off);
2760 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
c5c1f40c 2761 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
c366c25e
JJ		 2762 htab->sgot->contents + off);
2763 else
2764 bfd_put_32 (output_bfd, 0,
2765 htab->sgot->contents + off);
13ae64f3 2766 outrel.r_info = ELF32_R_INFO (indx, dr_type);
947216bf
AM		 2767 loc = htab->srelgot->contents;
2768 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
13ae64f3
JJ		 2769 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2770
2771 if (r_type == R_386_TLS_GD)
2772 {
2773 if (indx == 0)
2774 {
82e51918 2775 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2776 bfd_put_32 (output_bfd,
2777 relocation - dtpoff_base (info),
2778 htab->sgot->contents + off + 4);
2779 }
2780 else
2781 {
2782 bfd_put_32 (output_bfd, 0,
2783 htab->sgot->contents + off + 4);
2784 outrel.r_info = ELF32_R_INFO (indx,
2785 R_386_TLS_DTPOFF32);
2786 outrel.r_offset += 4;
2787 htab->srelgot->reloc_count++;
947216bf
AM		 2788 loc += sizeof (Elf32_External_Rel);
2789 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
13ae64f3
JJ		 2790 }
2791 }
37e55690
JJ		 2792 else if (tls_type == GOT_TLS_IE_BOTH)
2793 {
2794 bfd_put_32 (output_bfd,
2795 indx == 0 ? relocation - dtpoff_base (info) : 0,
2796 htab->sgot->contents + off + 4);
2797 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2798 outrel.r_offset += 4;
2799 htab->srelgot->reloc_count++;
947216bf 2800 loc += sizeof (Elf32_External_Rel);
37e55690
JJ		 2801 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2802 }
13ae64f3
JJ		 2803
2804 if (h != NULL)
2805 h->got.offset |= 1;
2806 else
2807 local_got_offsets[r_symndx] |= 1;
2808 }
2809
2810 if (off >= (bfd_vma) -2)
2811 abort ();
2812 if (r_type == ELF32_R_TYPE (rel->r_info))
2813 {
2814 relocation = htab->sgot->output_offset + off;
37e55690
JJ		 2815 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
2816 && tls_type == GOT_TLS_IE_BOTH)
2817 relocation += 4;
2818 if (r_type == R_386_TLS_IE)
2819 relocation += htab->sgot->output_section->vma;
b34976b6 2820 unresolved_reloc = FALSE;
13ae64f3
JJ		 2821 }
2822 else
2823 {
2824 unsigned int val, type;
2825 bfd_vma roff;
2826
2827 /* GD->IE transition. */
2828 BFD_ASSERT (rel->r_offset >= 2);
2829 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2830 BFD_ASSERT (type == 0x8d || type == 0x04);
2831 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2832 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2833 == 0xe8);
2834 BFD_ASSERT (rel + 1 < relend);
2835 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2836 roff = rel->r_offset - 3;
2837 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2838 if (type == 0x04)
2839 {
2840 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2841 Change it into:
2842 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2843 BFD_ASSERT (rel->r_offset >= 3);
2844 BFD_ASSERT (bfd_get_8 (input_bfd,
2845 contents + rel->r_offset - 3)
2846 == 0x8d);
2847 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2848 val >>= 3;
2849 }
2850 else
2851 {
2852 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2853 Change it into:
2854 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2855 BFD_ASSERT (rel->r_offset + 10 <= input_section->_raw_size);
2856 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2857 BFD_ASSERT (bfd_get_8 (input_bfd,
2858 contents + rel->r_offset + 9)
2859 == 0x90);
2860 roff = rel->r_offset - 2;
2861 }
2862 memcpy (contents + roff,
2863 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2864 contents[roff + 7] = 0x80 | (val & 7);
37e55690
JJ		 2865 /* If foo is used only with foo@gotntpoff(%reg) and
2866 foo@indntpoff, but not with foo@gottpoff(%reg), change
2867 subl $foo@gottpoff(%reg), %eax
2868 into:
2869 addl $foo@gotntpoff(%reg), %eax. */
2870 if (r_type == R_386_TLS_GOTIE)
2871 {
2872 contents[roff + 6] = 0x03;
2873 if (tls_type == GOT_TLS_IE_BOTH)
2874 off += 4;
2875 }
13ae64f3
JJ		 2876 bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2877 contents + roff + 8);
2878 /* Skip R_386_PLT32. */
2879 rel++;
2880 continue;
2881 }
2882 break;
2883
2884 case R_386_TLS_LDM:
2885 if (! info->shared)
2886 {
2887 unsigned int val;
2888
2889 /* LD->LE transition:
2890 Ensure it is:
2891 leal foo(%reg), %eax; call ___tls_get_addr.
2892 We change it into:
2893 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
2894 BFD_ASSERT (rel->r_offset >= 2);
2895 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2896 == 0x8d);
2897 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2898 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2899 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2900 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2901 == 0xe8);
2902 BFD_ASSERT (rel + 1 < relend);
2903 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2904 memcpy (contents + rel->r_offset - 2,
2905 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2906 /* Skip R_386_PLT32. */
2907 rel++;
2908 continue;
2909 }
2910
2911 if (htab->sgot == NULL)
2912 abort ();
2913
2914 off = htab->tls_ldm_got.offset;
2915 if (off & 1)
2916 off &= ~1;
2917 else
2918 {
947216bf
AM		 2919 Elf_Internal_Rela outrel;
2920 bfd_byte *loc;
13ae64f3
JJ		 2921
2922 if (htab->srelgot == NULL)
2923 abort ();
2924
2925 outrel.r_offset = (htab->sgot->output_section->vma
2926 + htab->sgot->output_offset + off);
2927
2928 bfd_put_32 (output_bfd, 0,
2929 htab->sgot->contents + off);
2930 bfd_put_32 (output_bfd, 0,
2931 htab->sgot->contents + off + 4);
2932 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
947216bf
AM		 2933 loc = htab->srelgot->contents;
2934 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
13ae64f3
JJ		 2935 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2936 htab->tls_ldm_got.offset |= 1;
2937 }
2938 relocation = htab->sgot->output_offset + off;
b34976b6 2939 unresolved_reloc = FALSE;
13ae64f3
JJ		 2940 break;
2941
2942 case R_386_TLS_LDO_32:
a45bb67d 2943 if (info->shared || (input_section->flags & SEC_CODE) == 0)
13ae64f3
JJ		 2944 relocation -= dtpoff_base (info);
2945 else
2946 /* When converting LDO to LE, we must negate. */
2947 relocation = -tpoff (info, relocation);
2948 break;
2949
2950 case R_386_TLS_LE_32:
13ae64f3 2951 case R_386_TLS_LE:
37e55690
JJ		 2952 if (info->shared)
2953 {
947216bf 2954 Elf_Internal_Rela outrel;
37e55690 2955 asection *sreloc;
947216bf 2956 bfd_byte *loc;
37e55690
JJ		 2957 int indx;
2958
2959 outrel.r_offset = rel->r_offset
2960 + input_section->output_section->vma
2961 + input_section->output_offset;
2962 if (h != NULL && h->dynindx != -1)
2963 indx = h->dynindx;
2964 else
2965 indx = 0;
2966 if (r_type == R_386_TLS_LE_32)
2967 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
2968 else
2969 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2970 sreloc = elf_section_data (input_section)->sreloc;
2971 if (sreloc == NULL)
2972 abort ();
947216bf
AM		 2973 loc = sreloc->contents;
2974 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
37e55690
JJ		 2975 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2976 if (indx)
2977 continue;
2978 else if (r_type == R_386_TLS_LE_32)
2979 relocation = dtpoff_base (info) - relocation;
2980 else
2981 relocation -= dtpoff_base (info);
2982 }
2983 else if (r_type == R_386_TLS_LE_32)
2984 relocation = tpoff (info, relocation);
2985 else
2986 relocation = -tpoff (info, relocation);
13ae64f3
JJ		 2987 break;
2988
252b5132
RH		 2989 default:
2990 break;
2991 }
2992
239e1f3a
AM		 2993 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2994 because such sections are not SEC_ALLOC and thus ld.so will
2995 not process them. */
8c694914 2996 if (unresolved_reloc
239e1f3a 2997 && !((input_section->flags & SEC_DEBUGGING) != 0
8c694914 2998 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
6a30718d
JJ		 2999 {
3000 (*_bfd_error_handler)
3001 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
3002 bfd_archive_filename (input_bfd),
3003 bfd_get_section_name (input_bfd, input_section),
3004 (long) rel->r_offset,
3005 h->root.root.string);
b34976b6 3006 return FALSE;
6a30718d 3007 }
83be169b 3008
252b5132
RH		 3009 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3010 contents, rel->r_offset,
3011 relocation, (bfd_vma) 0);
3012
cf5c0c5b 3013 if (r != bfd_reloc_ok)
252b5132 3014 {
cf5c0c5b 3015 const char *name;
ffb2e45b 3016
cf5c0c5b
AM		 3017 if (h != NULL)
3018 name = h->root.root.string;
3019 else
3020 {
3021 name = bfd_elf_string_from_elf_section (input_bfd,
3022 symtab_hdr->sh_link,
3023 sym->st_name);
3024 if (name == NULL)
b34976b6 3025 return FALSE;
cf5c0c5b
AM		 3026 if (*name == '\0')
3027 name = bfd_section_name (input_bfd, sec);
3028 }
ffb2e45b 3029
cf5c0c5b
AM		 3030 if (r == bfd_reloc_overflow)
3031 {
cf5c0c5b
AM		 3032 if (! ((*info->callbacks->reloc_overflow)
3033 (info, name, howto->name, (bfd_vma) 0,
3034 input_bfd, input_section, rel->r_offset)))
b34976b6 3035 return FALSE;
cf5c0c5b
AM		 3036 }
3037 else
3038 {
3039 (*_bfd_error_handler)
3040 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
3041 bfd_archive_filename (input_bfd),
3042 bfd_get_section_name (input_bfd, input_section),
3043 (long) rel->r_offset, name, (int) r);
b34976b6 3044 return FALSE;
cf5c0c5b 3045 }
252b5132
RH		 3046 }
3047 }
3048
b34976b6 3049 return TRUE;
252b5132
RH		 3050}
3051
3052/* Finish up dynamic symbol handling. We set the contents of various
3053 dynamic sections here. */
3054
b34976b6 3055static bfd_boolean
252b5132
RH		 3056elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
3057 bfd *output_bfd;
3058 struct bfd_link_info *info;
3059 struct elf_link_hash_entry *h;
3060 Elf_Internal_Sym *sym;
3061{
6725bdbf 3062 struct elf_i386_link_hash_table *htab;
252b5132 3063
6725bdbf 3064 htab = elf_i386_hash_table (info);
252b5132
RH		 3065
3066 if (h->plt.offset != (bfd_vma) -1)
3067 {
252b5132
RH		 3068 bfd_vma plt_index;
3069 bfd_vma got_offset;
947216bf
AM		 3070 Elf_Internal_Rela rel;
3071 bfd_byte *loc;
252b5132
RH		 3072
3073 /* This symbol has an entry in the procedure linkage table. Set
3074 it up. */
3075
ffb2e45b
AM		 3076 if (h->dynindx == -1
3077 || htab->splt == NULL
3078 || htab->sgotplt == NULL
3079 || htab->srelplt == NULL)
3080 abort ();
252b5132
RH		 3081
3082 /* Get the index in the procedure linkage table which
3083 corresponds to this symbol. This is the index of this symbol
3084 in all the symbols for which we are making plt entries. The
3085 first entry in the procedure linkage table is reserved. */
3086 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3087
3088 /* Get the offset into the .got table of the entry that
3089 corresponds to this function. Each .got entry is 4 bytes.
3090 The first three are reserved. */
3091 got_offset = (plt_index + 3) * 4;
3092
3093 /* Fill in the entry in the procedure linkage table. */
3094 if (! info->shared)
3095 {
6725bdbf 3096 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
252b5132
RH		 3097 PLT_ENTRY_SIZE);
3098 bfd_put_32 (output_bfd,
6725bdbf
AM		 3099 (htab->sgotplt->output_section->vma
3100 + htab->sgotplt->output_offset
252b5132 3101 + got_offset),
6725bdbf 3102 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 3103 }
3104 else
3105 {
6725bdbf 3106 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
252b5132
RH		 3107 PLT_ENTRY_SIZE);
3108 bfd_put_32 (output_bfd, got_offset,
6725bdbf 3109 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 3110 }
3111
3112 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
6725bdbf 3113 htab->splt->contents + h->plt.offset + 7);
252b5132 3114 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
6725bdbf 3115 htab->splt->contents + h->plt.offset + 12);
252b5132
RH		 3116
3117 /* Fill in the entry in the global offset table. */
3118 bfd_put_32 (output_bfd,
6725bdbf
AM		 3119 (htab->splt->output_section->vma
3120 + htab->splt->output_offset
252b5132
RH		 3121 + h->plt.offset
3122 + 6),
6725bdbf 3123 htab->sgotplt->contents + got_offset);
252b5132
RH		 3124
3125 /* Fill in the entry in the .rel.plt section. */
6725bdbf
AM		 3126 rel.r_offset = (htab->sgotplt->output_section->vma
3127 + htab->sgotplt->output_offset
252b5132
RH		 3128 + got_offset);
3129 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
947216bf 3130 loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
0ac8d2ca 3131 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3132
3133 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3134 {
3135 /* Mark the symbol as undefined, rather than as defined in
51b64d56
AM		 3136 the .plt section. Leave the value alone. This is a clue
3137 for the dynamic linker, to make function pointer
3138 comparisons work between an application and shared
cedb70c5 3139 library. */
252b5132
RH		 3140 sym->st_shndx = SHN_UNDEF;
3141 }
3142 }
3143
13ae64f3
JJ		 3144 if (h->got.offset != (bfd_vma) -1
3145 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
37e55690 3146 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
252b5132 3147 {
947216bf
AM		 3148 Elf_Internal_Rela rel;
3149 bfd_byte *loc;
252b5132
RH		 3150
3151 /* This symbol has an entry in the global offset table. Set it
3152 up. */
3153
ffb2e45b
AM		 3154 if (htab->sgot == NULL || htab->srelgot == NULL)
3155 abort ();
252b5132 3156
6725bdbf
AM		 3157 rel.r_offset = (htab->sgot->output_section->vma
3158 + htab->sgot->output_offset
dc810e39 3159 + (h->got.offset & ~(bfd_vma) 1));
252b5132 3160
dd5724d5
AM		 3161 /* If this is a static link, or it is a -Bsymbolic link and the
3162 symbol is defined locally or was forced to be local because
3163 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 3164 The entry in the global offset table will already have been
3165 initialized in the relocate_section function. */
6725bdbf 3166 if (info->shared
586119b3 3167 && SYMBOL_REFERENCES_LOCAL (info, h))
dd5724d5 3168 {
6725bdbf 3169 BFD_ASSERT((h->got.offset & 1) != 0);
dd5724d5
AM		 3170 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3171 }
252b5132
RH		 3172 else
3173 {
dd5724d5 3174 BFD_ASSERT((h->got.offset & 1) == 0);
6725bdbf
AM		 3175 bfd_put_32 (output_bfd, (bfd_vma) 0,
3176 htab->sgot->contents + h->got.offset);
252b5132
RH		 3177 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3178 }
3179
947216bf
AM		 3180 loc = htab->srelgot->contents;
3181 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 3182 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3183 }
3184
791987af 3185 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
252b5132 3186 {
947216bf
AM		 3187 Elf_Internal_Rela rel;
3188 bfd_byte *loc;
252b5132
RH		 3189
3190 /* This symbol needs a copy reloc. Set it up. */
3191
ffb2e45b
AM		 3192 if (h->dynindx == -1
3193 || (h->root.type != bfd_link_hash_defined
3194 && h->root.type != bfd_link_hash_defweak)
3195 || htab->srelbss == NULL)
3196 abort ();
252b5132
RH		 3197
3198 rel.r_offset = (h->root.u.def.value
3199 + h->root.u.def.section->output_section->vma
3200 + h->root.u.def.section->output_offset);
3201 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
947216bf
AM		 3202 loc = htab->srelbss->contents;
3203 loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 3204 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3205 }
3206
3207 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3208 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3209 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3210 sym->st_shndx = SHN_ABS;
3211
b34976b6 3212 return TRUE;
252b5132
RH		 3213}
3214
38701953
AM		 3215/* Used to decide how to sort relocs in an optimal manner for the
3216 dynamic linker, before writing them out. */
3217
3218static enum elf_reloc_type_class
3219elf_i386_reloc_type_class (rela)
3220 const Elf_Internal_Rela *rela;
3221{
3222 switch ((int) ELF32_R_TYPE (rela->r_info))
3223 {
3224 case R_386_RELATIVE:
3225 return reloc_class_relative;
3226 case R_386_JUMP_SLOT:
3227 return reloc_class_plt;
3228 case R_386_COPY:
3229 return reloc_class_copy;
3230 default:
3231 return reloc_class_normal;
3232 }
3233}
3234
252b5132
RH		 3235/* Finish up the dynamic sections. */
3236
b34976b6 3237static bfd_boolean
252b5132
RH		 3238elf_i386_finish_dynamic_sections (output_bfd, info)
3239 bfd *output_bfd;
3240 struct bfd_link_info *info;
3241{
6725bdbf 3242 struct elf_i386_link_hash_table *htab;
252b5132 3243 bfd *dynobj;
252b5132
RH		 3244 asection *sdyn;
3245
6725bdbf 3246 htab = elf_i386_hash_table (info);
ebe50bae 3247 dynobj = htab->elf.dynobj;
252b5132
RH		 3248 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3249
ebe50bae 3250 if (htab->elf.dynamic_sections_created)
252b5132 3251 {
252b5132
RH		 3252 Elf32_External_Dyn *dyncon, *dynconend;
3253
ffb2e45b
AM		 3254 if (sdyn == NULL || htab->sgot == NULL)
3255 abort ();
252b5132
RH		 3256
3257 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3258 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3259 for (; dyncon < dynconend; dyncon++)
3260 {
3261 Elf_Internal_Dyn dyn;
51b64d56 3262 asection *s;
252b5132
RH		 3263
3264 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3265
3266 switch (dyn.d_tag)
3267 {
3268 default:
0ac8d2ca 3269 continue;
252b5132
RH		 3270
3271 case DT_PLTGOT:
6725bdbf 3272 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
6725bdbf
AM		 3273 break;
3274
252b5132 3275 case DT_JMPREL:
6348e046
AM		 3276 s = htab->srelplt;
3277 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
252b5132
RH		 3278 break;
3279
3280 case DT_PLTRELSZ:
6348e046
AM		 3281 s = htab->srelplt;
3282 dyn.d_un.d_val = s->_raw_size;
252b5132
RH		 3283 break;
3284
3285 case DT_RELSZ:
3286 /* My reading of the SVR4 ABI indicates that the
3287 procedure linkage table relocs (DT_JMPREL) should be
3288 included in the overall relocs (DT_REL). This is
3289 what Solaris does. However, UnixWare can not handle
3290 that case. Therefore, we override the DT_RELSZ entry
6348e046
AM		 3291 here to make it not include the JMPREL relocs. */
3292 s = htab->srelplt;
3293 if (s == NULL)
3294 continue;
3295 dyn.d_un.d_val -= s->_raw_size;
3296 break;
3297
3298 case DT_REL:
3299 /* We may not be using the standard ELF linker script.
3300 If .rel.plt is the first .rel section, we adjust
3301 DT_REL to not include it. */
3302 s = htab->srelplt;
3303 if (s == NULL)
3304 continue;
3305 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3306 continue;
3307 dyn.d_un.d_ptr += s->_raw_size;
252b5132
RH		 3308 break;
3309 }
0ac8d2ca
AM		 3310
3311 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
252b5132
RH		 3312 }
3313
3314 /* Fill in the first entry in the procedure linkage table. */
6725bdbf 3315 if (htab->splt && htab->splt->_raw_size > 0)
252b5132
RH		 3316 {
3317 if (info->shared)
6725bdbf
AM		 3318 memcpy (htab->splt->contents,
3319 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
252b5132
RH		 3320 else
3321 {
6725bdbf
AM		 3322 memcpy (htab->splt->contents,
3323 elf_i386_plt0_entry, PLT_ENTRY_SIZE);
252b5132 3324 bfd_put_32 (output_bfd,
6725bdbf
AM		 3325 (htab->sgotplt->output_section->vma
3326 + htab->sgotplt->output_offset
3327 + 4),
3328 htab->splt->contents + 2);
252b5132 3329 bfd_put_32 (output_bfd,
6725bdbf
AM		 3330 (htab->sgotplt->output_section->vma
3331 + htab->sgotplt->output_offset
3332 + 8),
3333 htab->splt->contents + 8);
252b5132
RH		 3334 }
3335
3336 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3337 really seem like the right value. */
6725bdbf
AM		 3338 elf_section_data (htab->splt->output_section)
3339 ->this_hdr.sh_entsize = 4;
252b5132
RH		 3340 }
3341 }
3342
12d0ee4a 3343 if (htab->sgotplt)
252b5132 3344 {
12d0ee4a
AM		 3345 /* Fill in the first three entries in the global offset table. */
3346 if (htab->sgotplt->_raw_size > 0)
3347 {
3348 bfd_put_32 (output_bfd,
3349 (sdyn == NULL ? (bfd_vma) 0
3350 : sdyn->output_section->vma + sdyn->output_offset),
3351 htab->sgotplt->contents);
3352 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
3353 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3354 }
252b5132 3355
12d0ee4a
AM		 3356 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3357 }
b34976b6 3358 return TRUE;
252b5132
RH		 3359}
3360
3361#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3362#define TARGET_LITTLE_NAME "elf32-i386"
3363#define ELF_ARCH bfd_arch_i386
3364#define ELF_MACHINE_CODE EM_386
3365#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 3366
3367#define elf_backend_can_gc_sections 1
51b64d56 3368#define elf_backend_can_refcount 1
252b5132
RH		 3369#define elf_backend_want_got_plt 1
3370#define elf_backend_plt_readonly 1
3371#define elf_backend_want_plt_sym 0
3372#define elf_backend_got_header_size 12
3373#define elf_backend_plt_header_size PLT_ENTRY_SIZE
3374
8c29f035
AM		 3375/* Support RELA for objdump of prelink objects. */
3376#define elf_info_to_howto elf_i386_info_to_howto_rel
dd5724d5
AM		 3377#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3378
13ae64f3
JJ		 3379#define bfd_elf32_mkobject elf_i386_mkobject
3380#define elf_backend_object_p elf_i386_object_p
3381
dd5724d5
AM		 3382#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3383#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3384#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3385
3386#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3387#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 3388#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 3389#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 3390#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 3391#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3392#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3393#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3394#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
c5fccbec
DJ		 3395#define elf_backend_grok_prstatus elf_i386_grok_prstatus
3396#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 3397#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 3398#define elf_backend_relocate_section elf_i386_relocate_section
3399#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
dd5724d5 3400
252b5132 3401#include "elf32-target.h"
2bc3c89a
AM		 3402
3403/* FreeBSD support. */
3404
3405#undef TARGET_LITTLE_SYM
3406#define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
3407#undef TARGET_LITTLE_NAME
3408#define TARGET_LITTLE_NAME "elf32-i386-freebsd"
3409
3410/* The kernel recognizes executables as valid only if they carry a
3411 "FreeBSD" label in the ELF header. So we put this label on all
3412 executables and (for simplicity) also all other object files. */
3413
3414static void elf_i386_post_process_headers
3415 PARAMS ((bfd *, struct bfd_link_info *));
3416
3417static void
3418elf_i386_post_process_headers (abfd, link_info)
3419 bfd *abfd;
3420 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3421{
3422 Elf_Internal_Ehdr *i_ehdrp;
3423
3424 i_ehdrp = elf_elfheader (abfd);
3425
3426 /* Put an ABI label supported by FreeBSD >= 4.1. */
3427 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3428#ifdef OLD_FREEBSD_ABI_LABEL
3429 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
3430 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
caf47ea6 3431#endif
2bc3c89a
AM		 3432}
3433
3434#undef elf_backend_post_process_headers
571fe01f
NC		 3435#define elf_backend_post_process_headers elf_i386_post_process_headers
3436#undef elf32_bed
3437#define elf32_bed elf32_i386_fbsd_bed
2bc3c89a
AM		 3438
3439#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.397404 seconds and 4 git commands to generate.