]> Git Repo - binutils.git/blame - bfd/elf32-i386.c
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2003-05-15 H.J. Lu <[email protected]>
[binutils.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 {
09695f56
AM		 1682 /* The only reloc that uses pc_count is R_386_PC32, which will
1683 appear on a call or on something like ".long foo - .". We
1684 want calls to protected symbols to resolve directly to the
1685 function rather than going via the plt. If people want
1686 function pointer comparisons to work as expected then they
1687 should avoid writing assembly like ".long foo - .". */
1688 if (SYMBOL_CALLS_LOCAL (info, h))
5a15f56f 1689 {
0c715baa
AM		 1690 struct elf_i386_dyn_relocs **pp;
1691
1692 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1693 {
1694 p->count -= p->pc_count;
1695 p->pc_count = 0;
1696 if (p->count == 0)
1697 *pp = p->next;
1698 else
1699 pp = &p->next;
1700 }
5a15f56f 1701 }
4e795f50
AM		 1702
1703 /* Also discard relocs on undefined weak syms with non-default
1704 visibility. */
1705 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1706 && h->root.type == bfd_link_hash_undefweak)
1707 eh->dyn_relocs = NULL;
0c715baa 1708 }
a23b6845 1709 else if (ELIMINATE_COPY_RELOCS)
0c715baa
AM		 1710 {
1711 /* For the non-shared case, discard space for relocs against
1712 symbols which turn out to need copy relocs or are not
1713 dynamic. */
1714
1715 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1716 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1717 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
ebe50bae 1718 || (htab->elf.dynamic_sections_created
0c715baa
AM		 1719 && (h->root.type == bfd_link_hash_undefweak
1720 || h->root.type == bfd_link_hash_undefined))))
1721 {
1722 /* Make sure this symbol is output as a dynamic symbol.
1723 Undefined weak syms won't yet be marked as dynamic. */
1724 if (h->dynindx == -1
1725 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1726 {
1727 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 1728 return FALSE;
0c715baa 1729 }
5a15f56f 1730
0c715baa
AM		 1731 /* If that succeeded, we know we'll be keeping all the
1732 relocs. */
1733 if (h->dynindx != -1)
1734 goto keep;
1735 }
1736
1737 eh->dyn_relocs = NULL;
1738
ec338859 1739 keep: ;
5a15f56f
AM		 1740 }
1741
0c715baa
AM		 1742 /* Finally, allocate space. */
1743 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12d0ee4a 1744 {
0c715baa
AM		 1745 asection *sreloc = elf_section_data (p->sec)->sreloc;
1746 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
12d0ee4a
AM		 1747 }
1748
b34976b6 1749 return TRUE;
6725bdbf
AM		 1750}
1751
0c715baa
AM		 1752/* Find any dynamic relocs that apply to read-only sections. */
1753
b34976b6 1754static bfd_boolean
0c715baa
AM		 1755readonly_dynrelocs (h, inf)
1756 struct elf_link_hash_entry *h;
1757 PTR inf;
1758{
1759 struct elf_i386_link_hash_entry *eh;
1760 struct elf_i386_dyn_relocs *p;
1761
e92d460e
AM		 1762 if (h->root.type == bfd_link_hash_warning)
1763 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1764
0c715baa
AM		 1765 eh = (struct elf_i386_link_hash_entry *) h;
1766 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1767 {
1768 asection *s = p->sec->output_section;
1769
1770 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1771 {
1772 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1773
1774 info->flags |= DF_TEXTREL;
1775
1776 /* Not an error, just cut short the traversal. */
b34976b6 1777 return FALSE;
0c715baa
AM		 1778 }
1779 }
b34976b6 1780 return TRUE;
0c715baa
AM		 1781}
1782
252b5132
RH		 1783/* Set the sizes of the dynamic sections. */
1784
b34976b6 1785static bfd_boolean
252b5132 1786elf_i386_size_dynamic_sections (output_bfd, info)
db6751f2 1787 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 1788 struct bfd_link_info *info;
1789{
6725bdbf 1790 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1791 bfd *dynobj;
1792 asection *s;
b34976b6 1793 bfd_boolean relocs;
0c715baa 1794 bfd *ibfd;
252b5132 1795
6725bdbf 1796 htab = elf_i386_hash_table (info);
ebe50bae 1797 dynobj = htab->elf.dynobj;
ffb2e45b
AM		 1798 if (dynobj == NULL)
1799 abort ();
252b5132 1800
ebe50bae 1801 if (htab->elf.dynamic_sections_created)
252b5132
RH		 1802 {
1803 /* Set the contents of the .interp section to the interpreter. */
1804 if (! info->shared)
1805 {
1806 s = bfd_get_section_by_name (dynobj, ".interp");
ffb2e45b
AM		 1807 if (s == NULL)
1808 abort ();
252b5132
RH		 1809 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1810 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1811 }
161d71a6 1812 }
6725bdbf 1813
0c715baa
AM		 1814 /* Set up .got offsets for local syms, and space for local dynamic
1815 relocs. */
1816 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
161d71a6
L		 1817 {
1818 bfd_signed_vma *local_got;
1819 bfd_signed_vma *end_local_got;
13ae64f3 1820 char *local_tls_type;
161d71a6
L		 1821 bfd_size_type locsymcount;
1822 Elf_Internal_Shdr *symtab_hdr;
1823 asection *srel;
6725bdbf 1824
0c715baa 1825 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
161d71a6 1826 continue;
6725bdbf 1827
0c715baa
AM		 1828 for (s = ibfd->sections; s != NULL; s = s->next)
1829 {
ec338859 1830 struct elf_i386_dyn_relocs *p;
0c715baa 1831
ec338859
AM		 1832 for (p = *((struct elf_i386_dyn_relocs **)
1833 &elf_section_data (s)->local_dynrel);
1834 p != NULL;
1835 p = p->next)
0c715baa 1836 {
ec338859
AM		 1837 if (!bfd_is_abs_section (p->sec)
1838 && bfd_is_abs_section (p->sec->output_section))
1839 {
1840 /* Input section has been discarded, either because
1841 it is a copy of a linkonce section or due to
1842 linker script /DISCARD/, so we'll be discarding
1843 the relocs too. */
1844 }
248866a8 1845 else if (p->count != 0)
ec338859
AM		 1846 {
1847 srel = elf_section_data (p->sec)->sreloc;
1848 srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
248866a8
AM		 1849 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1850 info->flags |= DF_TEXTREL;
ec338859 1851 }
0c715baa
AM		 1852 }
1853 }
1854
1855 local_got = elf_local_got_refcounts (ibfd);
161d71a6
L		 1856 if (!local_got)
1857 continue;
6725bdbf 1858
0c715baa 1859 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
161d71a6
L		 1860 locsymcount = symtab_hdr->sh_info;
1861 end_local_got = local_got + locsymcount;
13ae64f3 1862 local_tls_type = elf_i386_local_got_tls_type (ibfd);
161d71a6
L		 1863 s = htab->sgot;
1864 srel = htab->srelgot;
13ae64f3 1865 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
161d71a6
L		 1866 {
1867 if (*local_got > 0)
6725bdbf 1868 {
161d71a6
L		 1869 *local_got = s->_raw_size;
1870 s->_raw_size += 4;
37e55690
JJ		 1871 if (*local_tls_type == GOT_TLS_GD
1872 || *local_tls_type == GOT_TLS_IE_BOTH)
13ae64f3
JJ		 1873 s->_raw_size += 4;
1874 if (info->shared
1875 || *local_tls_type == GOT_TLS_GD
37e55690
JJ		 1876 || (*local_tls_type & GOT_TLS_IE))
1877 {
1878 if (*local_tls_type == GOT_TLS_IE_BOTH)
1879 srel->_raw_size += 2 * sizeof (Elf32_External_Rel);
1880 else
1881 srel->_raw_size += sizeof (Elf32_External_Rel);
1882 }
6725bdbf 1883 }
161d71a6
L		 1884 else
1885 *local_got = (bfd_vma) -1;
6725bdbf 1886 }
252b5132 1887 }
6725bdbf 1888
13ae64f3
JJ		 1889 if (htab->tls_ldm_got.refcount > 0)
1890 {
1891 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1892 relocs. */
1893 htab->tls_ldm_got.offset = htab->sgot->_raw_size;
1894 htab->sgot->_raw_size += 8;
1895 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1896 }
1897 else
1898 htab->tls_ldm_got.offset = -1;
1899
0c715baa
AM		 1900 /* Allocate global sym .plt and .got entries, and space for global
1901 sym dynamic relocs. */
ebe50bae 1902 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
252b5132 1903
5a15f56f
AM		 1904 /* We now have determined the sizes of the various dynamic sections.
1905 Allocate memory for them. */
b34976b6 1906 relocs = FALSE;
252b5132
RH		 1907 for (s = dynobj->sections; s != NULL; s = s->next)
1908 {
252b5132
RH		 1909 if ((s->flags & SEC_LINKER_CREATED) == 0)
1910 continue;
1911
6725bdbf
AM		 1912 if (s == htab->splt
1913 || s == htab->sgot
1914 || s == htab->sgotplt)
252b5132 1915 {
6725bdbf
AM		 1916 /* Strip this section if we don't need it; see the
1917 comment below. */
252b5132 1918 }
6725bdbf 1919 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
252b5132 1920 {
0ac8d2ca 1921 if (s->_raw_size != 0 && s != htab->srelplt)
b34976b6 1922 relocs = TRUE;
252b5132 1923
0ac8d2ca
AM		 1924 /* We use the reloc_count field as a counter if we need
1925 to copy relocs into the output file. */
1926 s->reloc_count = 0;
252b5132 1927 }
6725bdbf 1928 else
252b5132
RH		 1929 {
1930 /* It's not one of our sections, so don't allocate space. */
1931 continue;
1932 }
1933
6725bdbf 1934 if (s->_raw_size == 0)
252b5132 1935 {
0ac8d2ca
AM		 1936 /* If we don't need this section, strip it from the
1937 output file. This is mostly to handle .rel.bss and
1938 .rel.plt. We must create both sections in
1939 create_dynamic_sections, because they must be created
1940 before the linker maps input sections to output
1941 sections. The linker does that before
1942 adjust_dynamic_symbol is called, and it is that
1943 function which decides whether anything needs to go
1944 into these sections. */
1945
7f8d5fc9 1946 _bfd_strip_section_from_output (info, s);
252b5132
RH		 1947 continue;
1948 }
1949
f69da49f
AM		 1950 /* Allocate memory for the section contents. We use bfd_zalloc
1951 here in case unused entries are not reclaimed before the
1952 section's contents are written out. This should not happen,
1953 but this way if it does, we get a R_386_NONE reloc instead
1954 of garbage. */
7a9af8c4 1955 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
6725bdbf 1956 if (s->contents == NULL)
b34976b6 1957 return FALSE;
252b5132
RH		 1958 }
1959
ebe50bae 1960 if (htab->elf.dynamic_sections_created)
252b5132
RH		 1961 {
1962 /* Add some entries to the .dynamic section. We fill in the
1963 values later, in elf_i386_finish_dynamic_sections, but we
1964 must add the entries now so that we get the correct size for
1965 the .dynamic section. The DT_DEBUG entry is filled in by the
1966 dynamic linker and used by the debugger. */
dc810e39
AM		 1967#define add_dynamic_entry(TAG, VAL) \
1968 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1969
252b5132
RH		 1970 if (! info->shared)
1971 {
dc810e39 1972 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 1973 return FALSE;
252b5132
RH		 1974 }
1975
6725bdbf 1976 if (htab->splt->_raw_size != 0)
252b5132 1977 {
dc810e39
AM		 1978 if (!add_dynamic_entry (DT_PLTGOT, 0)
1979 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1980 || !add_dynamic_entry (DT_PLTREL, DT_REL)
1981 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 1982 return FALSE;
252b5132
RH		 1983 }
1984
1985 if (relocs)
1986 {
dc810e39
AM		 1987 if (!add_dynamic_entry (DT_REL, 0)
1988 || !add_dynamic_entry (DT_RELSZ, 0)
1989 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
b34976b6 1990 return FALSE;
252b5132 1991
0c715baa
AM		 1992 /* If any dynamic relocs apply to a read-only section,
1993 then we need a DT_TEXTREL entry. */
248866a8
AM		 1994 if ((info->flags & DF_TEXTREL) == 0)
1995 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1996 (PTR) info);
0c715baa
AM		 1997
1998 if ((info->flags & DF_TEXTREL) != 0)
1999 {
2000 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 2001 return FALSE;
0c715baa 2002 }
252b5132
RH		 2003 }
2004 }
dc810e39 2005#undef add_dynamic_entry
252b5132 2006
b34976b6 2007 return TRUE;
252b5132
RH		 2008}
2009
38701953
AM		 2010/* Set the correct type for an x86 ELF section. We do this by the
2011 section name, which is a hack, but ought to work. */
2012
b34976b6 2013static bfd_boolean
38701953
AM		 2014elf_i386_fake_sections (abfd, hdr, sec)
2015 bfd *abfd ATTRIBUTE_UNUSED;
947216bf 2016 Elf_Internal_Shdr *hdr;
38701953
AM		 2017 asection *sec;
2018{
2019 register const char *name;
2020
2021 name = bfd_get_section_name (abfd, sec);
2022
2023 /* This is an ugly, but unfortunately necessary hack that is
2024 needed when producing EFI binaries on x86. It tells
2025 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2026 containing ELF relocation info. We need this hack in order to
2027 be able to generate ELF binaries that can be translated into
2028 EFI applications (which are essentially COFF objects). Those
2029 files contain a COFF ".reloc" section inside an ELFNN object,
2030 which would normally cause BFD to segfault because it would
2031 attempt to interpret this section as containing relocation
2032 entries for section "oc". With this hack enabled, ".reloc"
2033 will be treated as a normal data section, which will avoid the
2034 segfault. However, you won't be able to create an ELFNN binary
2035 with a section named "oc" that needs relocations, but that's
2036 the kind of ugly side-effects you get when detecting section
2037 types based on their names... In practice, this limitation is
2038 unlikely to bite. */
2039 if (strcmp (name, ".reloc") == 0)
2040 hdr->sh_type = SHT_PROGBITS;
2041
b34976b6 2042 return TRUE;
38701953
AM		 2043}
2044
13ae64f3
JJ		 2045/* Return the base VMA address which should be subtracted from real addresses
2046 when resolving @dtpoff relocation.
2047 This is PT_TLS segment p_vaddr. */
2048
2049static bfd_vma
2050dtpoff_base (info)
2051 struct bfd_link_info *info;
2052{
6a30718d
JJ		 2053 /* If tls_segment is NULL, we should have signalled an error already. */
2054 if (elf_hash_table (info)->tls_segment == NULL)
2055 return 0;
13ae64f3
JJ		 2056 return elf_hash_table (info)->tls_segment->start;
2057}
2058
2059/* Return the relocation value for @tpoff relocation
2060 if STT_TLS virtual address is ADDRESS. */
2061
2062static bfd_vma
2063tpoff (info, address)
2064 struct bfd_link_info *info;
2065 bfd_vma address;
2066{
2067 struct elf_link_tls_segment *tls_segment
2068 = elf_hash_table (info)->tls_segment;
2069
6a30718d
JJ		 2070 /* If tls_segment is NULL, we should have signalled an error already. */
2071 if (tls_segment == NULL)
2072 return 0;
13ae64f3
JJ		 2073 return (align_power (tls_segment->size, tls_segment->align)
2074 + tls_segment->start - address);
2075}
2076
252b5132
RH		 2077/* Relocate an i386 ELF section. */
2078
b34976b6 2079static bfd_boolean
252b5132
RH		 2080elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
2081 contents, relocs, local_syms, local_sections)
2082 bfd *output_bfd;
2083 struct bfd_link_info *info;
2084 bfd *input_bfd;
2085 asection *input_section;
2086 bfd_byte *contents;
2087 Elf_Internal_Rela *relocs;
2088 Elf_Internal_Sym *local_syms;
2089 asection **local_sections;
2090{
6725bdbf 2091 struct elf_i386_link_hash_table *htab;
252b5132
RH		 2092 Elf_Internal_Shdr *symtab_hdr;
2093 struct elf_link_hash_entry **sym_hashes;
2094 bfd_vma *local_got_offsets;
252b5132
RH		 2095 Elf_Internal_Rela *rel;
2096 Elf_Internal_Rela *relend;
2097
6725bdbf 2098 htab = elf_i386_hash_table (info);
252b5132
RH		 2099 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2100 sym_hashes = elf_sym_hashes (input_bfd);
2101 local_got_offsets = elf_local_got_offsets (input_bfd);
2102
252b5132
RH		 2103 rel = relocs;
2104 relend = relocs + input_section->reloc_count;
2105 for (; rel < relend; rel++)
2106 {
13ae64f3 2107 unsigned int r_type;
252b5132
RH		 2108 reloc_howto_type *howto;
2109 unsigned long r_symndx;
2110 struct elf_link_hash_entry *h;
2111 Elf_Internal_Sym *sym;
2112 asection *sec;
ffb2e45b 2113 bfd_vma off;
252b5132 2114 bfd_vma relocation;
b34976b6 2115 bfd_boolean unresolved_reloc;
252b5132 2116 bfd_reloc_status_type r;
1b452ec6 2117 unsigned int indx;
13ae64f3 2118 int tls_type;
252b5132
RH		 2119
2120 r_type = ELF32_R_TYPE (rel->r_info);
dc47f327
AM		 2121 if (r_type == (int) R_386_GNU_VTINHERIT
2122 || r_type == (int) R_386_GNU_VTENTRY)
252b5132 2123 continue;
dc47f327 2124
1b452ec6 2125 if ((indx = (unsigned) r_type) >= R_386_standard
13ae64f3
JJ		 2126 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2127 >= R_386_ext - R_386_standard)
2128 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2129 >= R_386_tls - R_386_ext))
252b5132
RH		 2130 {
2131 bfd_set_error (bfd_error_bad_value);
b34976b6 2132 return FALSE;
252b5132 2133 }
1b452ec6 2134 howto = elf_howto_table + indx;
252b5132
RH		 2135
2136 r_symndx = ELF32_R_SYM (rel->r_info);
2137
2138 if (info->relocateable)
2139 {
4a335f3d 2140 bfd_vma val;
4a335f3d
AM		 2141 bfd_byte *where;
2142
0ac8d2ca 2143 /* This is a relocatable link. We don't have to change
252b5132
RH		 2144 anything, unless the reloc is against a section symbol,
2145 in which case we have to adjust according to where the
2146 section symbol winds up in the output section. */
4a335f3d
AM		 2147 if (r_symndx >= symtab_hdr->sh_info)
2148 continue;
2149
2150 sym = local_syms + r_symndx;
2151 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2152 continue;
2153
2154 sec = local_sections[r_symndx];
2155 val = sec->output_offset;
2156 if (val == 0)
2157 continue;
2158
2159 where = contents + rel->r_offset;
2160 switch (howto->size)
252b5132 2161 {
16a10388 2162 /* FIXME: overflow checks. */
4a335f3d 2163 case 0:
16a10388 2164 val += bfd_get_8 (input_bfd, where);
4a335f3d 2165 bfd_put_8 (input_bfd, val, where);
4a335f3d
AM		 2166 break;
2167 case 1:
16a10388 2168 val += bfd_get_16 (input_bfd, where);
4a335f3d 2169 bfd_put_16 (input_bfd, val, where);
4a335f3d
AM		 2170 break;
2171 case 2:
2172 val += bfd_get_32 (input_bfd, where);
2173 bfd_put_32 (input_bfd, val, where);
2174 break;
2175 default:
2176 abort ();
252b5132 2177 }
252b5132
RH		 2178 continue;
2179 }
2180
2181 /* This is a final link. */
2182 h = NULL;
2183 sym = NULL;
2184 sec = NULL;
b34976b6 2185 unresolved_reloc = FALSE;
252b5132
RH		 2186 if (r_symndx < symtab_hdr->sh_info)
2187 {
2188 sym = local_syms + r_symndx;
2189 sec = local_sections[r_symndx];
2190 relocation = (sec->output_section->vma
2191 + sec->output_offset
2192 + sym->st_value);
f8df10f4
JJ		 2193 if ((sec->flags & SEC_MERGE)
2194 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2195 {
2196 asection *msec;
2197 bfd_vma addend;
4a335f3d 2198 bfd_byte *where = contents + rel->r_offset;
f8df10f4 2199
4a335f3d 2200 switch (howto->size)
f8df10f4 2201 {
4a335f3d
AM		 2202 case 0:
2203 addend = bfd_get_8 (input_bfd, where);
2204 if (howto->pc_relative)
2205 {
2206 addend = (addend ^ 0x80) - 0x80;
2207 addend += 1;
2208 }
2209 break;
2210 case 1:
2211 addend = bfd_get_16 (input_bfd, where);
2212 if (howto->pc_relative)
2213 {
2214 addend = (addend ^ 0x8000) - 0x8000;
2215 addend += 2;
2216 }
2217 break;
2218 case 2:
2219 addend = bfd_get_32 (input_bfd, where);
2220 if (howto->pc_relative)
2221 {
2222 addend = (addend ^ 0x80000000) - 0x80000000;
2223 addend += 4;
2224 }
2225 break;
2226 default:
2227 abort ();
f8df10f4
JJ		 2228 }
2229
f8df10f4 2230 msec = sec;
4a335f3d
AM		 2231 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2232 addend -= relocation;
f8df10f4 2233 addend += msec->output_section->vma + msec->output_offset;
4a335f3d
AM		 2234
2235 switch (howto->size)
2236 {
2237 case 0:
16a10388 2238 /* FIXME: overflow checks. */
4a335f3d
AM		 2239 if (howto->pc_relative)
2240 addend -= 1;
2241 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 2242 break;
2243 case 1:
2244 if (howto->pc_relative)
2245 addend -= 2;
2246 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 2247 break;
2248 case 2:
2249 if (howto->pc_relative)
2250 addend -= 4;
2251 bfd_put_32 (input_bfd, addend, where);
2252 break;
2253 }
f8df10f4 2254 }
252b5132
RH		 2255 }
2256 else
2257 {
2258 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2259 while (h->root.type == bfd_link_hash_indirect
2260 || h->root.type == bfd_link_hash_warning)
2261 h = (struct elf_link_hash_entry *) h->root.u.i.link;
ffb2e45b 2262
6725bdbf 2263 relocation = 0;
252b5132
RH		 2264 if (h->root.type == bfd_link_hash_defined
2265 || h->root.type == bfd_link_hash_defweak)
2266 {
2267 sec = h->root.u.def.section;
83be169b
AM		 2268 if (sec->output_section == NULL)
2269 /* Set a flag that will be cleared later if we find a
2270 relocation value for this symbol. output_section
2271 is typically NULL for symbols satisfied by a shared
2272 library. */
b34976b6 2273 unresolved_reloc = TRUE;
252b5132
RH		 2274 else
2275 relocation = (h->root.u.def.value
2276 + sec->output_section->vma
2277 + sec->output_offset);
2278 }
2279 else if (h->root.type == bfd_link_hash_undefweak)
6725bdbf 2280 ;
671bae9c 2281 else if (info->shared
3a27a730
L		 2282 && !info->no_undefined
2283 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
6725bdbf 2284 ;
252b5132
RH		 2285 else
2286 {
2287 if (! ((*info->callbacks->undefined_symbol)
2288 (info, h->root.root.string, input_bfd,
5cc7c785 2289 input_section, rel->r_offset,
3a27a730
L		 2290 (!info->shared || info->no_undefined
2291 || ELF_ST_VISIBILITY (h->other)))))
b34976b6 2292 return FALSE;
252b5132
RH		 2293 }
2294 }
2295
2296 switch (r_type)
2297 {
2298 case R_386_GOT32:
2299 /* Relocation is to the entry for this symbol in the global
2300 offset table. */
ffb2e45b
AM		 2301 if (htab->sgot == NULL)
2302 abort ();
252b5132
RH		 2303
2304 if (h != NULL)
2305 {
b34976b6 2306 bfd_boolean dyn;
252b5132
RH		 2307
2308 off = h->got.offset;
ebe50bae 2309 dyn = htab->elf.dynamic_sections_created;
26e41594 2310 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
252b5132 2311 || (info->shared
586119b3 2312 && SYMBOL_REFERENCES_LOCAL (info, h))
ef5aade5
L		 2313 || (ELF_ST_VISIBILITY (h->other)
2314 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 2315 {
2316 /* This is actually a static link, or it is a
2317 -Bsymbolic link and the symbol is defined
2318 locally, or the symbol was forced to be local
2319 because of a version file. We must initialize
2320 this entry in the global offset table. Since the
2321 offset must always be a multiple of 4, we use the
2322 least significant bit to record whether we have
2323 initialized it already.
2324
2325 When doing a dynamic link, we create a .rel.got
2326 relocation entry to initialize the value. This
2327 is done in the finish_dynamic_symbol routine. */
2328 if ((off & 1) != 0)
2329 off &= ~1;
2330 else
2331 {
2332 bfd_put_32 (output_bfd, relocation,
6725bdbf 2333 htab->sgot->contents + off);
252b5132
RH		 2334 h->got.offset |= 1;
2335 }
2336 }
8c694914 2337 else
b34976b6 2338 unresolved_reloc = FALSE;
252b5132
RH		 2339 }
2340 else
2341 {
ffb2e45b
AM		 2342 if (local_got_offsets == NULL)
2343 abort ();
252b5132
RH		 2344
2345 off = local_got_offsets[r_symndx];
2346
2347 /* The offset must always be a multiple of 4. We use
83be169b
AM		 2348 the least significant bit to record whether we have
2349 already generated the necessary reloc. */
252b5132
RH		 2350 if ((off & 1) != 0)
2351 off &= ~1;
2352 else
2353 {
6725bdbf
AM		 2354 bfd_put_32 (output_bfd, relocation,
2355 htab->sgot->contents + off);
252b5132
RH		 2356
2357 if (info->shared)
2358 {
947216bf
AM		 2359 asection *s;
2360 Elf_Internal_Rela outrel;
2361 bfd_byte *loc;
252b5132 2362
947216bf
AM		 2363 s = htab->srelgot;
2364 if (s == NULL)
ffb2e45b 2365 abort ();
252b5132 2366
6725bdbf
AM		 2367 outrel.r_offset = (htab->sgot->output_section->vma
2368 + htab->sgot->output_offset
252b5132
RH		 2369 + off);
2370 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
947216bf
AM		 2371 loc = s->contents;
2372 loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 2373 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2374 }
2375
2376 local_got_offsets[r_symndx] |= 1;
2377 }
252b5132
RH		 2378 }
2379
ffb2e45b
AM		 2380 if (off >= (bfd_vma) -2)
2381 abort ();
2382
2383 relocation = htab->sgot->output_offset + off;
252b5132
RH		 2384 break;
2385
2386 case R_386_GOTOFF:
2387 /* Relocation is relative to the start of the global offset
2388 table. */
2389
252b5132
RH		 2390 /* Note that sgot->output_offset is not involved in this
2391 calculation. We always want the start of .got. If we
2392 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2393 permitted by the ABI, we might have to change this
2394 calculation. */
6725bdbf 2395 relocation -= htab->sgot->output_section->vma;
252b5132
RH		 2396 break;
2397
2398 case R_386_GOTPC:
2399 /* Use global offset table as symbol value. */
6725bdbf 2400 relocation = htab->sgot->output_section->vma;
b34976b6 2401 unresolved_reloc = FALSE;
252b5132
RH		 2402 break;
2403
2404 case R_386_PLT32:
2405 /* Relocation is to the entry for this symbol in the
2406 procedure linkage table. */
2407
dd5724d5 2408 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 2409 without using the procedure linkage table. */
252b5132
RH		 2410 if (h == NULL)
2411 break;
2412
dd5724d5 2413 if (h->plt.offset == (bfd_vma) -1
6725bdbf 2414 || htab->splt == NULL)
252b5132
RH		 2415 {
2416 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 2417 happens when statically linking PIC code, or when
2418 using -Bsymbolic. */
252b5132
RH		 2419 break;
2420 }
2421
6725bdbf
AM		 2422 relocation = (htab->splt->output_section->vma
2423 + htab->splt->output_offset
252b5132 2424 + h->plt.offset);
b34976b6 2425 unresolved_reloc = FALSE;
252b5132
RH		 2426 break;
2427
2428 case R_386_32:
2429 case R_386_PC32:
ec338859
AM		 2430 /* r_symndx will be zero only for relocs against symbols
2431 from removed linkonce sections, or sections discarded by
2432 a linker script. */
2433 if (r_symndx == 0
2434 || (input_section->flags & SEC_ALLOC) == 0)
2435 break;
2436
12d0ee4a 2437 if ((info->shared
ef5aade5
L		 2438 && (h == NULL
2439 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2440 || h->root.type != bfd_link_hash_undefweak)
12d0ee4a
AM		 2441 && (r_type != R_386_PC32
2442 || (h != NULL
09695f56 2443 && !SYMBOL_CALLS_LOCAL (info, h))))
a23b6845
AM		 2444 || (ELIMINATE_COPY_RELOCS
2445 && !info->shared
12d0ee4a
AM		 2446 && h != NULL
2447 && h->dynindx != -1
2448 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
56882138
AM		 2449 && (((h->elf_link_hash_flags
2450 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2451 && (h->elf_link_hash_flags
2452 & ELF_LINK_HASH_DEF_REGULAR) == 0)
28d0b90e
AM		 2453 || h->root.type == bfd_link_hash_undefweak
2454 || h->root.type == bfd_link_hash_undefined)))
252b5132 2455 {
947216bf
AM		 2456 Elf_Internal_Rela outrel;
2457 bfd_byte *loc;
b34976b6 2458 bfd_boolean skip, relocate;
0c715baa 2459 asection *sreloc;
252b5132
RH		 2460
2461 /* When generating a shared object, these relocations
2462 are copied into the output file to be resolved at run
2463 time. */
2464
b34976b6
AM		 2465 skip = FALSE;
2466 relocate = FALSE;
252b5132 2467
c629eae0
JJ		 2468 outrel.r_offset =
2469 _bfd_elf_section_offset (output_bfd, info, input_section,
2470 rel->r_offset);
2471 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 2472 skip = TRUE;
0bb2d96a 2473 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 2474 skip = TRUE, relocate = TRUE;
252b5132
RH		 2475 outrel.r_offset += (input_section->output_section->vma
2476 + input_section->output_offset);
2477
2478 if (skip)
0bb2d96a 2479 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 2480 else if (h != NULL
2481 && h->dynindx != -1
2482 && (r_type == R_386_PC32
2483 || !info->shared
2484 || !info->symbolic
2485 || (h->elf_link_hash_flags
2486 & ELF_LINK_HASH_DEF_REGULAR) == 0))
0bb2d96a 2487 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 2488 else
2489 {
5a15f56f 2490 /* This symbol is local, or marked to become local. */
b34976b6 2491 relocate = TRUE;
5a15f56f 2492 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 2493 }
2494
0c715baa
AM		 2495 sreloc = elf_section_data (input_section)->sreloc;
2496 if (sreloc == NULL)
2497 abort ();
2498
947216bf
AM		 2499 loc = sreloc->contents;
2500 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
0c715baa 2501 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2502
2503 /* If this reloc is against an external symbol, we do
2504 not want to fiddle with the addend. Otherwise, we
2505 need to include the symbol value so that it becomes
2506 an addend for the dynamic reloc. */
2507 if (! relocate)
2508 continue;
2509 }
252b5132
RH		 2510 break;
2511
37e55690
JJ		 2512 case R_386_TLS_IE:
2513 if (info->shared)
2514 {
947216bf
AM		 2515 Elf_Internal_Rela outrel;
2516 bfd_byte *loc;
37e55690 2517 asection *sreloc;
37e55690
JJ		 2518
2519 outrel.r_offset = rel->r_offset
2520 + input_section->output_section->vma
2521 + input_section->output_offset;
2522 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2523 sreloc = elf_section_data (input_section)->sreloc;
2524 if (sreloc == NULL)
2525 abort ();
947216bf
AM		 2526 loc = sreloc->contents;
2527 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
37e55690
JJ		 2528 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2529 }
2530 /* Fall through */
2531
13ae64f3
JJ		 2532 case R_386_TLS_GD:
2533 case R_386_TLS_IE_32:
37e55690 2534 case R_386_TLS_GOTIE:
13ae64f3
JJ		 2535 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2536 tls_type = GOT_UNKNOWN;
2537 if (h == NULL && local_got_offsets)
2538 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2539 else if (h != NULL)
2540 {
2541 tls_type = elf_i386_hash_entry(h)->tls_type;
37e55690 2542 if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
13ae64f3
JJ		 2543 r_type = R_386_TLS_LE_32;
2544 }
37e55690
JJ		 2545 if (tls_type == GOT_TLS_IE)
2546 tls_type = GOT_TLS_IE_NEG;
2547 if (r_type == R_386_TLS_GD)
2548 {
2549 if (tls_type == GOT_TLS_IE_POS)
2550 r_type = R_386_TLS_GOTIE;
2551 else if (tls_type & GOT_TLS_IE)
2552 r_type = R_386_TLS_IE_32;
2553 }
13ae64f3
JJ		 2554
2555 if (r_type == R_386_TLS_LE_32)
2556 {
82e51918 2557 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2558 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2559 {
2560 unsigned int val, type;
2561 bfd_vma roff;
2562
2563 /* GD->LE transition. */
2564 BFD_ASSERT (rel->r_offset >= 2);
2565 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2566 BFD_ASSERT (type == 0x8d || type == 0x04);
2567 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2568 BFD_ASSERT (bfd_get_8 (input_bfd,
2569 contents + rel->r_offset + 4)
2570 == 0xe8);
2571 BFD_ASSERT (rel + 1 < relend);
2572 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2573 roff = rel->r_offset + 5;
2574 val = bfd_get_8 (input_bfd,
2575 contents + rel->r_offset - 1);
2576 if (type == 0x04)
2577 {
2578 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2579 Change it into:
2580 movl %gs:0, %eax; subl $foo@tpoff, %eax
2581 (6 byte form of subl). */
2582 BFD_ASSERT (rel->r_offset >= 3);
2583 BFD_ASSERT (bfd_get_8 (input_bfd,
2584 contents + rel->r_offset - 3)
2585 == 0x8d);
2586 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2587 memcpy (contents + rel->r_offset - 3,
2588 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2589 }
2590 else
2591 {
2592 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2593 if (rel->r_offset + 10 <= input_section->_raw_size
2594 && bfd_get_8 (input_bfd,
2595 contents + rel->r_offset + 9) == 0x90)
2596 {
2597 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2598 Change it into:
2599 movl %gs:0, %eax; subl $foo@tpoff, %eax
2600 (6 byte form of subl). */
2601 memcpy (contents + rel->r_offset - 2,
2602 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2603 roff = rel->r_offset + 6;
2604 }
2605 else
2606 {
2607 /* leal foo(%reg), %eax; call ___tls_get_addr
2608 Change it into:
2609 movl %gs:0, %eax; subl $foo@tpoff, %eax
2610 (5 byte form of subl). */
2611 memcpy (contents + rel->r_offset - 2,
2612 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2613 }
2614 }
2615 bfd_put_32 (output_bfd, tpoff (info, relocation),
2616 contents + roff);
2617 /* Skip R_386_PLT32. */
2618 rel++;
2619 continue;
2620 }
37e55690 2621 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
13ae64f3
JJ		 2622 {
2623 unsigned int val, type;
2624
2625 /* IE->LE transition:
37e55690
JJ		 2626 Originally it can be one of:
2627 movl foo, %eax
2628 movl foo, %reg
2629 addl foo, %reg
2630 We change it into:
2631 movl $foo, %eax
2632 movl $foo, %reg
2633 addl $foo, %reg. */
2634 BFD_ASSERT (rel->r_offset >= 1);
2635 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2636 BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
37e55690
JJ		 2637 if (val == 0xa1)
2638 {
2639 /* movl foo, %eax. */
7c445aa3 2640 bfd_put_8 (output_bfd, 0xb8, contents + rel->r_offset - 1);
37e55690 2641 }
299bf759 2642 else
37e55690 2643 {
299bf759
L		 2644 BFD_ASSERT (rel->r_offset >= 2);
2645 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2646 switch (type)
26e41594 2647 {
299bf759
L		 2648 case 0x8b:
2649 /* movl */
2650 BFD_ASSERT ((val & 0xc7) == 0x05);
2651 bfd_put_8 (output_bfd, 0xc7,
2652 contents + rel->r_offset - 2);
2653 bfd_put_8 (output_bfd,
2654 0xc0 | ((val >> 3) & 7),
2655 contents + rel->r_offset - 1);
2656 break;
2657 case 0x03:
2658 /* addl */
2659 BFD_ASSERT ((val & 0xc7) == 0x05);
2660 bfd_put_8 (output_bfd, 0x81,
2661 contents + rel->r_offset - 2);
2662 bfd_put_8 (output_bfd,
2663 0xc0 | ((val >> 3) & 7),
2664 contents + rel->r_offset - 1);
2665 break;
2666 default:
2667 BFD_FAIL ();
2668 break;
26e41594 2669 }
37e55690 2670 }
37e55690
JJ		 2671 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2672 contents + rel->r_offset);
2673 continue;
2674 }
2675 else
2676 {
2677 unsigned int val, type;
2678
2679 /* {IE_32,GOTIE}->LE transition:
2680 Originally it can be one of:
13ae64f3 2681 subl foo(%reg1), %reg2
13ae64f3 2682 movl foo(%reg1), %reg2
37e55690 2683 addl foo(%reg1), %reg2
13ae64f3
JJ		 2684 We change it into:
2685 subl $foo, %reg2
37e55690
JJ		 2686 movl $foo, %reg2 (6 byte form)
2687 addl $foo, %reg2. */
13ae64f3
JJ		 2688 BFD_ASSERT (rel->r_offset >= 2);
2689 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2690 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2691 BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
37e55690 2692 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
13ae64f3
JJ		 2693 if (type == 0x8b)
2694 {
2695 /* movl */
13ae64f3
JJ		 2696 bfd_put_8 (output_bfd, 0xc7,
2697 contents + rel->r_offset - 2);
2698 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2699 contents + rel->r_offset - 1);
2700 }
2701 else if (type == 0x2b)
2702 {
2703 /* subl */
13ae64f3
JJ		 2704 bfd_put_8 (output_bfd, 0x81,
2705 contents + rel->r_offset - 2);
2706 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2707 contents + rel->r_offset - 1);
2708 }
37e55690
JJ		 2709 else if (type == 0x03)
2710 {
2711 /* addl */
2712 bfd_put_8 (output_bfd, 0x81,
2713 contents + rel->r_offset - 2);
2714 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2715 contents + rel->r_offset - 1);
2716 }
13ae64f3
JJ		 2717 else
2718 BFD_FAIL ();
37e55690
JJ		 2719 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2720 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2721 contents + rel->r_offset);
2722 else
2723 bfd_put_32 (output_bfd, tpoff (info, relocation),
2724 contents + rel->r_offset);
13ae64f3
JJ		 2725 continue;
2726 }
2727 }
2728
2729 if (htab->sgot == NULL)
2730 abort ();
2731
2732 if (h != NULL)
2733 off = h->got.offset;
2734 else
2735 {
2736 if (local_got_offsets == NULL)
2737 abort ();
2738
2739 off = local_got_offsets[r_symndx];
2740 }
2741
2742 if ((off & 1) != 0)
2743 off &= ~1;
26e41594 2744 else
13ae64f3 2745 {
947216bf
AM		 2746 Elf_Internal_Rela outrel;
2747 bfd_byte *loc;
13ae64f3
JJ		 2748 int dr_type, indx;
2749
2750 if (htab->srelgot == NULL)
2751 abort ();
2752
2753 outrel.r_offset = (htab->sgot->output_section->vma
2754 + htab->sgot->output_offset + off);
2755
13ae64f3
JJ		 2756 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2757 if (r_type == R_386_TLS_GD)
2758 dr_type = R_386_TLS_DTPMOD32;
37e55690
JJ		 2759 else if (tls_type == GOT_TLS_IE_POS)
2760 dr_type = R_386_TLS_TPOFF;
13ae64f3
JJ		 2761 else
2762 dr_type = R_386_TLS_TPOFF32;
37e55690
JJ		 2763 if (dr_type == R_386_TLS_TPOFF && indx == 0)
2764 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2765 htab->sgot->contents + off);
2766 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
c5c1f40c 2767 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
c366c25e
JJ		 2768 htab->sgot->contents + off);
2769 else
2770 bfd_put_32 (output_bfd, 0,
2771 htab->sgot->contents + off);
13ae64f3 2772 outrel.r_info = ELF32_R_INFO (indx, dr_type);
947216bf
AM		 2773 loc = htab->srelgot->contents;
2774 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
13ae64f3
JJ		 2775 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2776
2777 if (r_type == R_386_TLS_GD)
2778 {
2779 if (indx == 0)
2780 {
82e51918 2781 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2782 bfd_put_32 (output_bfd,
2783 relocation - dtpoff_base (info),
2784 htab->sgot->contents + off + 4);
2785 }
2786 else
2787 {
2788 bfd_put_32 (output_bfd, 0,
2789 htab->sgot->contents + off + 4);
2790 outrel.r_info = ELF32_R_INFO (indx,
2791 R_386_TLS_DTPOFF32);
2792 outrel.r_offset += 4;
2793 htab->srelgot->reloc_count++;
947216bf
AM		 2794 loc += sizeof (Elf32_External_Rel);
2795 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
13ae64f3
JJ		 2796 }
2797 }
37e55690
JJ		 2798 else if (tls_type == GOT_TLS_IE_BOTH)
2799 {
2800 bfd_put_32 (output_bfd,
2801 indx == 0 ? relocation - dtpoff_base (info) : 0,
2802 htab->sgot->contents + off + 4);
2803 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2804 outrel.r_offset += 4;
2805 htab->srelgot->reloc_count++;
947216bf 2806 loc += sizeof (Elf32_External_Rel);
37e55690
JJ		 2807 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2808 }
13ae64f3
JJ		 2809
2810 if (h != NULL)
2811 h->got.offset |= 1;
2812 else
2813 local_got_offsets[r_symndx] |= 1;
2814 }
2815
2816 if (off >= (bfd_vma) -2)
2817 abort ();
2818 if (r_type == ELF32_R_TYPE (rel->r_info))
2819 {
2820 relocation = htab->sgot->output_offset + off;
37e55690
JJ		 2821 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
2822 && tls_type == GOT_TLS_IE_BOTH)
2823 relocation += 4;
2824 if (r_type == R_386_TLS_IE)
2825 relocation += htab->sgot->output_section->vma;
b34976b6 2826 unresolved_reloc = FALSE;
13ae64f3
JJ		 2827 }
2828 else
2829 {
2830 unsigned int val, type;
2831 bfd_vma roff;
2832
2833 /* GD->IE transition. */
2834 BFD_ASSERT (rel->r_offset >= 2);
2835 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2836 BFD_ASSERT (type == 0x8d || type == 0x04);
2837 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2838 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2839 == 0xe8);
2840 BFD_ASSERT (rel + 1 < relend);
2841 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2842 roff = rel->r_offset - 3;
2843 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2844 if (type == 0x04)
2845 {
2846 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2847 Change it into:
2848 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2849 BFD_ASSERT (rel->r_offset >= 3);
2850 BFD_ASSERT (bfd_get_8 (input_bfd,
2851 contents + rel->r_offset - 3)
2852 == 0x8d);
2853 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2854 val >>= 3;
2855 }
2856 else
2857 {
2858 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2859 Change it into:
2860 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2861 BFD_ASSERT (rel->r_offset + 10 <= input_section->_raw_size);
2862 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2863 BFD_ASSERT (bfd_get_8 (input_bfd,
2864 contents + rel->r_offset + 9)
2865 == 0x90);
2866 roff = rel->r_offset - 2;
2867 }
2868 memcpy (contents + roff,
2869 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2870 contents[roff + 7] = 0x80 | (val & 7);
37e55690
JJ		 2871 /* If foo is used only with foo@gotntpoff(%reg) and
2872 foo@indntpoff, but not with foo@gottpoff(%reg), change
2873 subl $foo@gottpoff(%reg), %eax
2874 into:
2875 addl $foo@gotntpoff(%reg), %eax. */
2876 if (r_type == R_386_TLS_GOTIE)
2877 {
2878 contents[roff + 6] = 0x03;
2879 if (tls_type == GOT_TLS_IE_BOTH)
2880 off += 4;
2881 }
13ae64f3
JJ		 2882 bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2883 contents + roff + 8);
2884 /* Skip R_386_PLT32. */
2885 rel++;
2886 continue;
2887 }
2888 break;
2889
2890 case R_386_TLS_LDM:
2891 if (! info->shared)
2892 {
2893 unsigned int val;
2894
2895 /* LD->LE transition:
2896 Ensure it is:
2897 leal foo(%reg), %eax; call ___tls_get_addr.
2898 We change it into:
2899 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
2900 BFD_ASSERT (rel->r_offset >= 2);
2901 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2902 == 0x8d);
2903 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2904 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2905 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2906 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2907 == 0xe8);
2908 BFD_ASSERT (rel + 1 < relend);
2909 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2910 memcpy (contents + rel->r_offset - 2,
2911 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2912 /* Skip R_386_PLT32. */
2913 rel++;
2914 continue;
2915 }
2916
2917 if (htab->sgot == NULL)
2918 abort ();
2919
2920 off = htab->tls_ldm_got.offset;
2921 if (off & 1)
2922 off &= ~1;
2923 else
2924 {
947216bf
AM		 2925 Elf_Internal_Rela outrel;
2926 bfd_byte *loc;
13ae64f3
JJ		 2927
2928 if (htab->srelgot == NULL)
2929 abort ();
2930
2931 outrel.r_offset = (htab->sgot->output_section->vma
2932 + htab->sgot->output_offset + off);
2933
2934 bfd_put_32 (output_bfd, 0,
2935 htab->sgot->contents + off);
2936 bfd_put_32 (output_bfd, 0,
2937 htab->sgot->contents + off + 4);
2938 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
947216bf
AM		 2939 loc = htab->srelgot->contents;
2940 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
13ae64f3
JJ		 2941 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2942 htab->tls_ldm_got.offset |= 1;
2943 }
2944 relocation = htab->sgot->output_offset + off;
b34976b6 2945 unresolved_reloc = FALSE;
13ae64f3
JJ		 2946 break;
2947
2948 case R_386_TLS_LDO_32:
a45bb67d 2949 if (info->shared || (input_section->flags & SEC_CODE) == 0)
13ae64f3
JJ		 2950 relocation -= dtpoff_base (info);
2951 else
2952 /* When converting LDO to LE, we must negate. */
2953 relocation = -tpoff (info, relocation);
2954 break;
2955
2956 case R_386_TLS_LE_32:
13ae64f3 2957 case R_386_TLS_LE:
37e55690
JJ		 2958 if (info->shared)
2959 {
947216bf 2960 Elf_Internal_Rela outrel;
37e55690 2961 asection *sreloc;
947216bf 2962 bfd_byte *loc;
37e55690
JJ		 2963 int indx;
2964
2965 outrel.r_offset = rel->r_offset
2966 + input_section->output_section->vma
2967 + input_section->output_offset;
2968 if (h != NULL && h->dynindx != -1)
2969 indx = h->dynindx;
2970 else
2971 indx = 0;
2972 if (r_type == R_386_TLS_LE_32)
2973 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
2974 else
2975 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2976 sreloc = elf_section_data (input_section)->sreloc;
2977 if (sreloc == NULL)
2978 abort ();
947216bf
AM		 2979 loc = sreloc->contents;
2980 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
37e55690
JJ		 2981 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2982 if (indx)
2983 continue;
2984 else if (r_type == R_386_TLS_LE_32)
2985 relocation = dtpoff_base (info) - relocation;
2986 else
2987 relocation -= dtpoff_base (info);
2988 }
2989 else if (r_type == R_386_TLS_LE_32)
2990 relocation = tpoff (info, relocation);
2991 else
2992 relocation = -tpoff (info, relocation);
13ae64f3
JJ		 2993 break;
2994
252b5132
RH		 2995 default:
2996 break;
2997 }
2998
239e1f3a
AM		 2999 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3000 because such sections are not SEC_ALLOC and thus ld.so will
3001 not process them. */
8c694914 3002 if (unresolved_reloc
239e1f3a 3003 && !((input_section->flags & SEC_DEBUGGING) != 0
8c694914 3004 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
6a30718d
JJ		 3005 {
3006 (*_bfd_error_handler)
3007 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
3008 bfd_archive_filename (input_bfd),
3009 bfd_get_section_name (input_bfd, input_section),
3010 (long) rel->r_offset,
3011 h->root.root.string);
b34976b6 3012 return FALSE;
6a30718d 3013 }
83be169b 3014
252b5132
RH		 3015 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3016 contents, rel->r_offset,
3017 relocation, (bfd_vma) 0);
3018
cf5c0c5b 3019 if (r != bfd_reloc_ok)
252b5132 3020 {
cf5c0c5b 3021 const char *name;
ffb2e45b 3022
cf5c0c5b
AM		 3023 if (h != NULL)
3024 name = h->root.root.string;
3025 else
3026 {
3027 name = bfd_elf_string_from_elf_section (input_bfd,
3028 symtab_hdr->sh_link,
3029 sym->st_name);
3030 if (name == NULL)
b34976b6 3031 return FALSE;
cf5c0c5b
AM		 3032 if (*name == '\0')
3033 name = bfd_section_name (input_bfd, sec);
3034 }
ffb2e45b 3035
cf5c0c5b
AM		 3036 if (r == bfd_reloc_overflow)
3037 {
cf5c0c5b
AM		 3038 if (! ((*info->callbacks->reloc_overflow)
3039 (info, name, howto->name, (bfd_vma) 0,
3040 input_bfd, input_section, rel->r_offset)))
b34976b6 3041 return FALSE;
cf5c0c5b
AM		 3042 }
3043 else
3044 {
3045 (*_bfd_error_handler)
3046 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
3047 bfd_archive_filename (input_bfd),
3048 bfd_get_section_name (input_bfd, input_section),
3049 (long) rel->r_offset, name, (int) r);
b34976b6 3050 return FALSE;
cf5c0c5b 3051 }
252b5132
RH		 3052 }
3053 }
3054
b34976b6 3055 return TRUE;
252b5132
RH		 3056}
3057
3058/* Finish up dynamic symbol handling. We set the contents of various
3059 dynamic sections here. */
3060
b34976b6 3061static bfd_boolean
252b5132
RH		 3062elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
3063 bfd *output_bfd;
3064 struct bfd_link_info *info;
3065 struct elf_link_hash_entry *h;
3066 Elf_Internal_Sym *sym;
3067{
6725bdbf 3068 struct elf_i386_link_hash_table *htab;
252b5132 3069
6725bdbf 3070 htab = elf_i386_hash_table (info);
252b5132
RH		 3071
3072 if (h->plt.offset != (bfd_vma) -1)
3073 {
252b5132
RH		 3074 bfd_vma plt_index;
3075 bfd_vma got_offset;
947216bf
AM		 3076 Elf_Internal_Rela rel;
3077 bfd_byte *loc;
252b5132
RH		 3078
3079 /* This symbol has an entry in the procedure linkage table. Set
3080 it up. */
3081
ffb2e45b
AM		 3082 if (h->dynindx == -1
3083 || htab->splt == NULL
3084 || htab->sgotplt == NULL
3085 || htab->srelplt == NULL)
3086 abort ();
252b5132
RH		 3087
3088 /* Get the index in the procedure linkage table which
3089 corresponds to this symbol. This is the index of this symbol
3090 in all the symbols for which we are making plt entries. The
3091 first entry in the procedure linkage table is reserved. */
3092 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3093
3094 /* Get the offset into the .got table of the entry that
3095 corresponds to this function. Each .got entry is 4 bytes.
3096 The first three are reserved. */
3097 got_offset = (plt_index + 3) * 4;
3098
3099 /* Fill in the entry in the procedure linkage table. */
3100 if (! info->shared)
3101 {
6725bdbf 3102 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
252b5132
RH		 3103 PLT_ENTRY_SIZE);
3104 bfd_put_32 (output_bfd,
6725bdbf
AM		 3105 (htab->sgotplt->output_section->vma
3106 + htab->sgotplt->output_offset
252b5132 3107 + got_offset),
6725bdbf 3108 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 3109 }
3110 else
3111 {
6725bdbf 3112 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
252b5132
RH		 3113 PLT_ENTRY_SIZE);
3114 bfd_put_32 (output_bfd, got_offset,
6725bdbf 3115 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 3116 }
3117
3118 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
6725bdbf 3119 htab->splt->contents + h->plt.offset + 7);
252b5132 3120 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
6725bdbf 3121 htab->splt->contents + h->plt.offset + 12);
252b5132
RH		 3122
3123 /* Fill in the entry in the global offset table. */
3124 bfd_put_32 (output_bfd,
6725bdbf
AM		 3125 (htab->splt->output_section->vma
3126 + htab->splt->output_offset
252b5132
RH		 3127 + h->plt.offset
3128 + 6),
6725bdbf 3129 htab->sgotplt->contents + got_offset);
252b5132
RH		 3130
3131 /* Fill in the entry in the .rel.plt section. */
6725bdbf
AM		 3132 rel.r_offset = (htab->sgotplt->output_section->vma
3133 + htab->sgotplt->output_offset
252b5132
RH		 3134 + got_offset);
3135 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
947216bf 3136 loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
0ac8d2ca 3137 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3138
3139 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3140 {
3141 /* Mark the symbol as undefined, rather than as defined in
51b64d56
AM		 3142 the .plt section. Leave the value alone. This is a clue
3143 for the dynamic linker, to make function pointer
3144 comparisons work between an application and shared
cedb70c5 3145 library. */
252b5132
RH		 3146 sym->st_shndx = SHN_UNDEF;
3147 }
3148 }
3149
13ae64f3
JJ		 3150 if (h->got.offset != (bfd_vma) -1
3151 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
37e55690 3152 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
252b5132 3153 {
947216bf
AM		 3154 Elf_Internal_Rela rel;
3155 bfd_byte *loc;
252b5132
RH		 3156
3157 /* This symbol has an entry in the global offset table. Set it
3158 up. */
3159
ffb2e45b
AM		 3160 if (htab->sgot == NULL || htab->srelgot == NULL)
3161 abort ();
252b5132 3162
6725bdbf
AM		 3163 rel.r_offset = (htab->sgot->output_section->vma
3164 + htab->sgot->output_offset
dc810e39 3165 + (h->got.offset & ~(bfd_vma) 1));
252b5132 3166
dd5724d5
AM		 3167 /* If this is a static link, or it is a -Bsymbolic link and the
3168 symbol is defined locally or was forced to be local because
3169 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 3170 The entry in the global offset table will already have been
3171 initialized in the relocate_section function. */
6725bdbf 3172 if (info->shared
586119b3 3173 && SYMBOL_REFERENCES_LOCAL (info, h))
dd5724d5 3174 {
6725bdbf 3175 BFD_ASSERT((h->got.offset & 1) != 0);
dd5724d5
AM		 3176 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3177 }
252b5132
RH		 3178 else
3179 {
dd5724d5 3180 BFD_ASSERT((h->got.offset & 1) == 0);
6725bdbf
AM		 3181 bfd_put_32 (output_bfd, (bfd_vma) 0,
3182 htab->sgot->contents + h->got.offset);
252b5132
RH		 3183 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3184 }
3185
947216bf
AM		 3186 loc = htab->srelgot->contents;
3187 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 3188 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3189 }
3190
791987af 3191 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
252b5132 3192 {
947216bf
AM		 3193 Elf_Internal_Rela rel;
3194 bfd_byte *loc;
252b5132
RH		 3195
3196 /* This symbol needs a copy reloc. Set it up. */
3197
ffb2e45b
AM		 3198 if (h->dynindx == -1
3199 || (h->root.type != bfd_link_hash_defined
3200 && h->root.type != bfd_link_hash_defweak)
3201 || htab->srelbss == NULL)
3202 abort ();
252b5132
RH		 3203
3204 rel.r_offset = (h->root.u.def.value
3205 + h->root.u.def.section->output_section->vma
3206 + h->root.u.def.section->output_offset);
3207 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
947216bf
AM		 3208 loc = htab->srelbss->contents;
3209 loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 3210 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3211 }
3212
3213 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3214 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3215 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3216 sym->st_shndx = SHN_ABS;
3217
b34976b6 3218 return TRUE;
252b5132
RH		 3219}
3220
38701953
AM		 3221/* Used to decide how to sort relocs in an optimal manner for the
3222 dynamic linker, before writing them out. */
3223
3224static enum elf_reloc_type_class
3225elf_i386_reloc_type_class (rela)
3226 const Elf_Internal_Rela *rela;
3227{
3228 switch ((int) ELF32_R_TYPE (rela->r_info))
3229 {
3230 case R_386_RELATIVE:
3231 return reloc_class_relative;
3232 case R_386_JUMP_SLOT:
3233 return reloc_class_plt;
3234 case R_386_COPY:
3235 return reloc_class_copy;
3236 default:
3237 return reloc_class_normal;
3238 }
3239}
3240
252b5132
RH		 3241/* Finish up the dynamic sections. */
3242
b34976b6 3243static bfd_boolean
252b5132
RH		 3244elf_i386_finish_dynamic_sections (output_bfd, info)
3245 bfd *output_bfd;
3246 struct bfd_link_info *info;
3247{
6725bdbf 3248 struct elf_i386_link_hash_table *htab;
252b5132 3249 bfd *dynobj;
252b5132
RH		 3250 asection *sdyn;
3251
6725bdbf 3252 htab = elf_i386_hash_table (info);
ebe50bae 3253 dynobj = htab->elf.dynobj;
252b5132
RH		 3254 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3255
ebe50bae 3256 if (htab->elf.dynamic_sections_created)
252b5132 3257 {
252b5132
RH		 3258 Elf32_External_Dyn *dyncon, *dynconend;
3259
ffb2e45b
AM		 3260 if (sdyn == NULL || htab->sgot == NULL)
3261 abort ();
252b5132
RH		 3262
3263 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3264 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3265 for (; dyncon < dynconend; dyncon++)
3266 {
3267 Elf_Internal_Dyn dyn;
51b64d56 3268 asection *s;
252b5132
RH		 3269
3270 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3271
3272 switch (dyn.d_tag)
3273 {
3274 default:
0ac8d2ca 3275 continue;
252b5132
RH		 3276
3277 case DT_PLTGOT:
6725bdbf 3278 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
6725bdbf
AM		 3279 break;
3280
252b5132 3281 case DT_JMPREL:
6348e046
AM		 3282 s = htab->srelplt;
3283 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
252b5132
RH		 3284 break;
3285
3286 case DT_PLTRELSZ:
6348e046
AM		 3287 s = htab->srelplt;
3288 dyn.d_un.d_val = s->_raw_size;
252b5132
RH		 3289 break;
3290
3291 case DT_RELSZ:
3292 /* My reading of the SVR4 ABI indicates that the
3293 procedure linkage table relocs (DT_JMPREL) should be
3294 included in the overall relocs (DT_REL). This is
3295 what Solaris does. However, UnixWare can not handle
3296 that case. Therefore, we override the DT_RELSZ entry
6348e046
AM		 3297 here to make it not include the JMPREL relocs. */
3298 s = htab->srelplt;
3299 if (s == NULL)
3300 continue;
3301 dyn.d_un.d_val -= s->_raw_size;
3302 break;
3303
3304 case DT_REL:
3305 /* We may not be using the standard ELF linker script.
3306 If .rel.plt is the first .rel section, we adjust
3307 DT_REL to not include it. */
3308 s = htab->srelplt;
3309 if (s == NULL)
3310 continue;
3311 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3312 continue;
3313 dyn.d_un.d_ptr += s->_raw_size;
252b5132
RH		 3314 break;
3315 }
0ac8d2ca
AM		 3316
3317 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
252b5132
RH		 3318 }
3319
3320 /* Fill in the first entry in the procedure linkage table. */
6725bdbf 3321 if (htab->splt && htab->splt->_raw_size > 0)
252b5132
RH		 3322 {
3323 if (info->shared)
6725bdbf
AM		 3324 memcpy (htab->splt->contents,
3325 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
252b5132
RH		 3326 else
3327 {
6725bdbf
AM		 3328 memcpy (htab->splt->contents,
3329 elf_i386_plt0_entry, PLT_ENTRY_SIZE);
252b5132 3330 bfd_put_32 (output_bfd,
6725bdbf
AM		 3331 (htab->sgotplt->output_section->vma
3332 + htab->sgotplt->output_offset
3333 + 4),
3334 htab->splt->contents + 2);
252b5132 3335 bfd_put_32 (output_bfd,
6725bdbf
AM		 3336 (htab->sgotplt->output_section->vma
3337 + htab->sgotplt->output_offset
3338 + 8),
3339 htab->splt->contents + 8);
252b5132
RH		 3340 }
3341
3342 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3343 really seem like the right value. */
6725bdbf
AM		 3344 elf_section_data (htab->splt->output_section)
3345 ->this_hdr.sh_entsize = 4;
252b5132
RH		 3346 }
3347 }
3348
12d0ee4a 3349 if (htab->sgotplt)
252b5132 3350 {
12d0ee4a
AM		 3351 /* Fill in the first three entries in the global offset table. */
3352 if (htab->sgotplt->_raw_size > 0)
3353 {
3354 bfd_put_32 (output_bfd,
3355 (sdyn == NULL ? (bfd_vma) 0
3356 : sdyn->output_section->vma + sdyn->output_offset),
3357 htab->sgotplt->contents);
3358 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
3359 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3360 }
252b5132 3361
12d0ee4a
AM		 3362 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3363 }
b34976b6 3364 return TRUE;
252b5132
RH		 3365}
3366
3367#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3368#define TARGET_LITTLE_NAME "elf32-i386"
3369#define ELF_ARCH bfd_arch_i386
3370#define ELF_MACHINE_CODE EM_386
3371#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 3372
3373#define elf_backend_can_gc_sections 1
51b64d56 3374#define elf_backend_can_refcount 1
252b5132
RH		 3375#define elf_backend_want_got_plt 1
3376#define elf_backend_plt_readonly 1
3377#define elf_backend_want_plt_sym 0
3378#define elf_backend_got_header_size 12
3379#define elf_backend_plt_header_size PLT_ENTRY_SIZE
3380
8c29f035
AM		 3381/* Support RELA for objdump of prelink objects. */
3382#define elf_info_to_howto elf_i386_info_to_howto_rel
dd5724d5
AM		 3383#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3384
13ae64f3
JJ		 3385#define bfd_elf32_mkobject elf_i386_mkobject
3386#define elf_backend_object_p elf_i386_object_p
3387
dd5724d5
AM		 3388#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3389#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3390#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3391
3392#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3393#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 3394#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 3395#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 3396#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 3397#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3398#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3399#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3400#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
c5fccbec
DJ		 3401#define elf_backend_grok_prstatus elf_i386_grok_prstatus
3402#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 3403#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 3404#define elf_backend_relocate_section elf_i386_relocate_section
3405#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
dd5724d5 3406
252b5132 3407#include "elf32-target.h"
2bc3c89a
AM		 3408
3409/* FreeBSD support. */
3410
3411#undef TARGET_LITTLE_SYM
3412#define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
3413#undef TARGET_LITTLE_NAME
3414#define TARGET_LITTLE_NAME "elf32-i386-freebsd"
3415
3416/* The kernel recognizes executables as valid only if they carry a
3417 "FreeBSD" label in the ELF header. So we put this label on all
3418 executables and (for simplicity) also all other object files. */
3419
3420static void elf_i386_post_process_headers
3421 PARAMS ((bfd *, struct bfd_link_info *));
3422
3423static void
3424elf_i386_post_process_headers (abfd, link_info)
3425 bfd *abfd;
3426 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3427{
3428 Elf_Internal_Ehdr *i_ehdrp;
3429
3430 i_ehdrp = elf_elfheader (abfd);
3431
3432 /* Put an ABI label supported by FreeBSD >= 4.1. */
3433 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3434#ifdef OLD_FREEBSD_ABI_LABEL
3435 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
3436 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
caf47ea6 3437#endif
2bc3c89a
AM		 3438}
3439
3440#undef elf_backend_post_process_headers
571fe01f
NC		 3441#define elf_backend_post_process_headers elf_i386_post_process_headers
3442#undef elf32_bed
3443#define elf32_bed elf32_i386_fbsd_bed
2bc3c89a
AM		 3444
3445#include "elf32-target.h"
Empty description
This page took 0.914425 seconds and 4 git commands to generate.