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