projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
include/
[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 624{
13ae64f3 625 if (abfd->tdata.any == NULL)
62d7a5f6
AM		 626 {
627 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
628 abfd->tdata.any = bfd_zalloc (abfd, amt);
629 if (abfd->tdata.any == NULL)
630 return FALSE;
631 }
632 return bfd_elf_mkobject (abfd);
13ae64f3 633}
cedb70c5 634
252b5132
RH		 635/* i386 ELF linker hash table. */
636
637struct elf_i386_link_hash_table
638{
ebe50bae 639 struct elf_link_hash_table elf;
252b5132 640
6725bdbf
AM		 641 /* Short-cuts to get to dynamic linker sections. */
642 asection *sgot;
643 asection *sgotplt;
644 asection *srelgot;
645 asection *splt;
646 asection *srelplt;
647 asection *sdynbss;
648 asection *srelbss;
9635fe29 649
eac338cf
PB		 650 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
651 asection *srelplt2;
652
eac338cf
PB		 653 /* True if the target system is VxWorks. */
654 int is_vxworks;
ec338859 655
eac338cf
PB		 656 /* Value used to fill the last word of the first plt entry. */
657 bfd_byte plt0_pad_byte;
9635fe29 658
5ae0bfb6
RS		 659 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
660 bfd_vma next_tls_desc_index;
661
13ae64f3
JJ		 662 union {
663 bfd_signed_vma refcount;
664 bfd_vma offset;
665 } tls_ldm_got;
666
67a4f2b7
AO		 667 /* The amount of space used by the reserved portion of the sgotplt
668 section, plus whatever space is used by the jump slots. */
669 bfd_vma sgotplt_jump_table_size;
670
ec338859
AM		 671 /* Small local sym to section mapping cache. */
672 struct sym_sec_cache sym_sec;
6725bdbf 673};
252b5132
RH		 674
675/* Get the i386 ELF linker hash table from a link_info structure. */
676
677#define elf_i386_hash_table(p) \
678 ((struct elf_i386_link_hash_table *) ((p)->hash))
679
67a4f2b7 680#define elf_i386_compute_jump_table_size(htab) \
5ae0bfb6 681 ((htab)->next_tls_desc_index * 4)
67a4f2b7 682
252b5132
RH		 683/* Create an entry in an i386 ELF linker hash table. */
684
685static struct bfd_hash_entry *
55fd94b0
AM		 686link_hash_newfunc (struct bfd_hash_entry *entry,
687 struct bfd_hash_table *table,
688 const char *string)
252b5132 689{
252b5132
RH		 690 /* Allocate the structure if it has not already been allocated by a
691 subclass. */
ebe50bae
AM		 692 if (entry == NULL)
693 {
694 entry = bfd_hash_allocate (table,
695 sizeof (struct elf_i386_link_hash_entry));
696 if (entry == NULL)
697 return entry;
698 }
252b5132
RH		 699
700 /* Call the allocation method of the superclass. */
ebe50bae
AM		 701 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
702 if (entry != NULL)
252b5132 703 {
ebe50bae
AM		 704 struct elf_i386_link_hash_entry *eh;
705
706 eh = (struct elf_i386_link_hash_entry *) entry;
707 eh->dyn_relocs = NULL;
13ae64f3 708 eh->tls_type = GOT_UNKNOWN;
67a4f2b7 709 eh->tlsdesc_got = (bfd_vma) -1;
252b5132
RH		 710 }
711
ebe50bae 712 return entry;
252b5132
RH		 713}
714
715/* Create an i386 ELF linker hash table. */
716
717static struct bfd_link_hash_table *
55fd94b0 718elf_i386_link_hash_table_create (bfd *abfd)
252b5132
RH		 719{
720 struct elf_i386_link_hash_table *ret;
dc810e39 721 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
252b5132 722
55fd94b0 723 ret = bfd_malloc (amt);
ebe50bae 724 if (ret == NULL)
252b5132
RH		 725 return NULL;
726
66eb6687
AM		 727 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
728 sizeof (struct elf_i386_link_hash_entry)))
252b5132 729 {
e2d34d7d 730 free (ret);
252b5132
RH		 731 return NULL;
732 }
733
6725bdbf
AM		 734 ret->sgot = NULL;
735 ret->sgotplt = NULL;
736 ret->srelgot = NULL;
737 ret->splt = NULL;
738 ret->srelplt = NULL;
739 ret->sdynbss = NULL;
740 ret->srelbss = NULL;
7a624474 741 ret->tls_ldm_got.refcount = 0;
5ae0bfb6 742 ret->next_tls_desc_index = 0;
67a4f2b7 743 ret->sgotplt_jump_table_size = 0;
ec338859 744 ret->sym_sec.abfd = NULL;
eac338cf
PB		 745 ret->is_vxworks = 0;
746 ret->srelplt2 = NULL;
eac338cf 747 ret->plt0_pad_byte = 0;
6725bdbf 748
ebe50bae 749 return &ret->elf.root;
252b5132
RH		 750}
751
6725bdbf
AM		 752/* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
753 shortcuts to them in our hash table. */
754
b34976b6 755static bfd_boolean
55fd94b0 756create_got_section (bfd *dynobj, struct bfd_link_info *info)
6725bdbf
AM		 757{
758 struct elf_i386_link_hash_table *htab;
759
760 if (! _bfd_elf_create_got_section (dynobj, info))
b34976b6 761 return FALSE;
6725bdbf
AM		 762
763 htab = elf_i386_hash_table (info);
764 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
765 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
766 if (!htab->sgot || !htab->sgotplt)
767 abort ();
768
3496cb2a
L		 769 htab->srelgot = bfd_make_section_with_flags (dynobj, ".rel.got",
770 (SEC_ALLOC | SEC_LOAD
771 | SEC_HAS_CONTENTS
772 | SEC_IN_MEMORY
773 | SEC_LINKER_CREATED
774 | SEC_READONLY));
6725bdbf 775 if (htab->srelgot == NULL
6725bdbf 776 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
b34976b6
AM		 777 return FALSE;
778 return TRUE;
6725bdbf
AM		 779}
780
781/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
782 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
783 hash table. */
784
b34976b6 785static bfd_boolean
55fd94b0 786elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
6725bdbf
AM		 787{
788 struct elf_i386_link_hash_table *htab;
789
790 htab = elf_i386_hash_table (info);
791 if (!htab->sgot && !create_got_section (dynobj, info))
b34976b6 792 return FALSE;
6725bdbf
AM		 793
794 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 795 return FALSE;
6725bdbf
AM		 796
797 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
798 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
799 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
800 if (!info->shared)
801 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
802
803 if (!htab->splt || !htab->srelplt || !htab->sdynbss
804 || (!info->shared && !htab->srelbss))
805 abort ();
806
711de32c
RS		 807 if (htab->is_vxworks
808 && !elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
809 return FALSE;
eac338cf 810
b34976b6 811 return TRUE;
6725bdbf
AM		 812}
813
ebe50bae
AM		 814/* Copy the extra info we tack onto an elf_link_hash_entry. */
815
51b64d56 816static void
fcfa13d2 817elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
55fd94b0
AM		 818 struct elf_link_hash_entry *dir,
819 struct elf_link_hash_entry *ind)
ebe50bae
AM		 820{
821 struct elf_i386_link_hash_entry *edir, *eind;
822
823 edir = (struct elf_i386_link_hash_entry *) dir;
824 eind = (struct elf_i386_link_hash_entry *) ind;
825
bbd7ec4a 826 if (eind->dyn_relocs != NULL)
ebe50bae 827 {
bbd7ec4a
AM		 828 if (edir->dyn_relocs != NULL)
829 {
830 struct elf_i386_dyn_relocs **pp;
831 struct elf_i386_dyn_relocs *p;
832
fcfa13d2 833 /* Add reloc counts against the indirect sym to the direct sym
bbd7ec4a
AM		 834 list. Merge any entries against the same section. */
835 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
836 {
837 struct elf_i386_dyn_relocs *q;
838
839 for (q = edir->dyn_relocs; q != NULL; q = q->next)
840 if (q->sec == p->sec)
841 {
842 q->pc_count += p->pc_count;
843 q->count += p->count;
844 *pp = p->next;
845 break;
846 }
847 if (q == NULL)
848 pp = &p->next;
849 }
850 *pp = edir->dyn_relocs;
851 }
852
ebe50bae
AM		 853 edir->dyn_relocs = eind->dyn_relocs;
854 eind->dyn_relocs = NULL;
855 }
ebe50bae 856
cd67d266
JJ		 857 if (ind->root.type == bfd_link_hash_indirect
858 && dir->got.refcount <= 0)
859 {
860 edir->tls_type = eind->tls_type;
861 eind->tls_type = GOT_UNKNOWN;
862 }
81848ca0
AM		 863
864 if (ELIMINATE_COPY_RELOCS
865 && ind->root.type != bfd_link_hash_indirect
f5385ebf
AM		 866 && dir->dynamic_adjusted)
867 {
868 /* If called to transfer flags for a weakdef during processing
869 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
870 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
871 dir->ref_dynamic |= ind->ref_dynamic;
872 dir->ref_regular |= ind->ref_regular;
873 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
874 dir->needs_plt |= ind->needs_plt;
875 dir->pointer_equality_needed |= ind->pointer_equality_needed;
876 }
81848ca0 877 else
fcfa13d2 878 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
ebe50bae
AM		 879}
880
13ae64f3 881static int
55fd94b0 882elf_i386_tls_transition (struct bfd_link_info *info, int r_type, int is_local)
13ae64f3
JJ		 883{
884 if (info->shared)
885 return r_type;
886
887 switch (r_type)
888 {
889 case R_386_TLS_GD:
67a4f2b7
AO		 890 case R_386_TLS_GOTDESC:
891 case R_386_TLS_DESC_CALL:
13ae64f3
JJ		 892 case R_386_TLS_IE_32:
893 if (is_local)
894 return R_386_TLS_LE_32;
895 return R_386_TLS_IE_32;
37e55690
JJ		 896 case R_386_TLS_IE:
897 case R_386_TLS_GOTIE:
898 if (is_local)
899 return R_386_TLS_LE_32;
900 return r_type;
13ae64f3
JJ		 901 case R_386_TLS_LDM:
902 return R_386_TLS_LE_32;
903 }
904
905 return r_type;
906}
907
252b5132 908/* Look through the relocs for a section during the first phase, and
0ac8d2ca
AM		 909 calculate needed space in the global offset table, procedure linkage
910 table, and dynamic reloc sections. */
252b5132 911
b34976b6 912static bfd_boolean
55fd94b0
AM		 913elf_i386_check_relocs (bfd *abfd,
914 struct bfd_link_info *info,
915 asection *sec,
916 const Elf_Internal_Rela *relocs)
252b5132 917{
6725bdbf 918 struct elf_i386_link_hash_table *htab;
252b5132
RH		 919 Elf_Internal_Shdr *symtab_hdr;
920 struct elf_link_hash_entry **sym_hashes;
252b5132
RH		 921 const Elf_Internal_Rela *rel;
922 const Elf_Internal_Rela *rel_end;
252b5132
RH		 923 asection *sreloc;
924
1049f94e 925 if (info->relocatable)
b34976b6 926 return TRUE;
252b5132 927
6725bdbf 928 htab = elf_i386_hash_table (info);
252b5132
RH		 929 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
930 sym_hashes = elf_sym_hashes (abfd);
252b5132 931
252b5132
RH		 932 sreloc = NULL;
933
934 rel_end = relocs + sec->reloc_count;
935 for (rel = relocs; rel < rel_end; rel++)
936 {
13ae64f3 937 unsigned int r_type;
252b5132
RH		 938 unsigned long r_symndx;
939 struct elf_link_hash_entry *h;
940
941 r_symndx = ELF32_R_SYM (rel->r_info);
13ae64f3 942 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 943
d9bc7a44 944 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
f5f31454 945 {
d003868e
AM		 946 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
947 abfd,
8f615d07 948 r_symndx);
b34976b6 949 return FALSE;
f5f31454
L		 950 }
951
252b5132
RH		 952 if (r_symndx < symtab_hdr->sh_info)
953 h = NULL;
954 else
71cb9464
L		 955 {
956 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
957 while (h->root.type == bfd_link_hash_indirect
958 || h->root.type == bfd_link_hash_warning)
959 h = (struct elf_link_hash_entry *) h->root.u.i.link;
960 }
252b5132 961
13ae64f3
JJ		 962 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
963
964 switch (r_type)
252b5132 965 {
37e55690
JJ		 966 case R_386_TLS_LDM:
967 htab->tls_ldm_got.refcount += 1;
968 goto create_got;
969
970 case R_386_PLT32:
971 /* This symbol requires a procedure linkage table entry. We
972 actually build the entry in adjust_dynamic_symbol,
973 because this might be a case of linking PIC code which is
974 never referenced by a dynamic object, in which case we
975 don't need to generate a procedure linkage table entry
976 after all. */
977
978 /* If this is a local symbol, we resolve it directly without
979 creating a procedure linkage table entry. */
980 if (h == NULL)
981 continue;
982
f5385ebf 983 h->needs_plt = 1;
37e55690
JJ		 984 h->plt.refcount += 1;
985 break;
986
13ae64f3 987 case R_386_TLS_IE_32:
37e55690
JJ		 988 case R_386_TLS_IE:
989 case R_386_TLS_GOTIE:
13ae64f3
JJ		 990 if (info->shared)
991 info->flags |= DF_STATIC_TLS;
37e55690
JJ		 992 /* Fall through */
993
252b5132 994 case R_386_GOT32:
13ae64f3 995 case R_386_TLS_GD:
67a4f2b7
AO		 996 case R_386_TLS_GOTDESC:
997 case R_386_TLS_DESC_CALL:
252b5132 998 /* This symbol requires a global offset table entry. */
13ae64f3
JJ		 999 {
1000 int tls_type, old_tls_type;
1001
1002 switch (r_type)
1003 {
1004 default:
1005 case R_386_GOT32: tls_type = GOT_NORMAL; break;
1006 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
67a4f2b7
AO		 1007 case R_386_TLS_GOTDESC:
1008 case R_386_TLS_DESC_CALL:
1009 tls_type = GOT_TLS_GDESC; break;
37e55690
JJ		 1010 case R_386_TLS_IE_32:
1011 if (ELF32_R_TYPE (rel->r_info) == r_type)
1012 tls_type = GOT_TLS_IE_NEG;
1013 else
ebcfb3c0
JJ		 1014 /* If this is a GD->IE transition, we may use either of
1015 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
37e55690
JJ		 1016 tls_type = GOT_TLS_IE;
1017 break;
1018 case R_386_TLS_IE:
1019 case R_386_TLS_GOTIE:
1020 tls_type = GOT_TLS_IE_POS; break;
13ae64f3
JJ		 1021 }
1022
1023 if (h != NULL)
1024 {
1025 h->got.refcount += 1;
1026 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1027 }
1028 else
1029 {
1030 bfd_signed_vma *local_got_refcounts;
1031
1032 /* This is a global offset table entry for a local symbol. */
1033 local_got_refcounts = elf_local_got_refcounts (abfd);
1034 if (local_got_refcounts == NULL)
1035 {
1036 bfd_size_type size;
1037
1038 size = symtab_hdr->sh_info;
67a4f2b7
AO		 1039 size *= (sizeof (bfd_signed_vma)
1040 + sizeof (bfd_vma) + sizeof(char));
55fd94b0 1041 local_got_refcounts = bfd_zalloc (abfd, size);
13ae64f3 1042 if (local_got_refcounts == NULL)
b34976b6 1043 return FALSE;
13ae64f3 1044 elf_local_got_refcounts (abfd) = local_got_refcounts;
67a4f2b7
AO		 1045 elf_i386_local_tlsdesc_gotent (abfd)
1046 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
13ae64f3 1047 elf_i386_local_got_tls_type (abfd)
67a4f2b7 1048 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
13ae64f3
JJ		 1049 }
1050 local_got_refcounts[r_symndx] += 1;
1051 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1052 }
1053
37e55690
JJ		 1054 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1055 tls_type |= old_tls_type;
13ae64f3
JJ		 1056 /* If a TLS symbol is accessed using IE at least once,
1057 there is no point to use dynamic model for it. */
ebcfb3c0 1058 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
67a4f2b7 1059 && (! GOT_TLS_GD_ANY_P (old_tls_type)
37e55690 1060 || (tls_type & GOT_TLS_IE) == 0))
13ae64f3 1061 {
67a4f2b7 1062 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
37e55690 1063 tls_type = old_tls_type;
67a4f2b7
AO		 1064 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1065 && GOT_TLS_GD_ANY_P (tls_type))
1066 tls_type |= old_tls_type;
13ae64f3
JJ		 1067 else
1068 {
1069 (*_bfd_error_handler)
d003868e 1070 (_("%B: `%s' accessed both as normal and "
55fd94b0 1071 "thread local symbol"),
d003868e 1072 abfd,
37e55690 1073 h ? h->root.root.string : "<local>");
b34976b6 1074 return FALSE;
13ae64f3
JJ		 1075 }
1076 }
1077
1078 if (old_tls_type != tls_type)
1079 {
1080 if (h != NULL)
1081 elf_i386_hash_entry (h)->tls_type = tls_type;
1082 else
1083 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1084 }
1085 }
0ac8d2ca
AM		 1086 /* Fall through */
1087
1088 case R_386_GOTOFF:
1089 case R_386_GOTPC:
13ae64f3 1090 create_got:
0ac8d2ca
AM		 1091 if (htab->sgot == NULL)
1092 {
1093 if (htab->elf.dynobj == NULL)
1094 htab->elf.dynobj = abfd;
1095 if (!create_got_section (htab->elf.dynobj, info))
b34976b6 1096 return FALSE;
0ac8d2ca 1097 }
37e55690
JJ		 1098 if (r_type != R_386_TLS_IE)
1099 break;
1100 /* Fall through */
252b5132 1101
37e55690
JJ		 1102 case R_386_TLS_LE_32:
1103 case R_386_TLS_LE:
1104 if (!info->shared)
1105 break;
bffbf940 1106 info->flags |= DF_STATIC_TLS;
b34976b6 1107 /* Fall through */
252b5132
RH		 1108
1109 case R_386_32:
1110 case R_386_PC32:
12d0ee4a 1111 if (h != NULL && !info->shared)
6725bdbf 1112 {
12d0ee4a 1113 /* If this reloc is in a read-only section, we might
ebe50bae
AM		 1114 need a copy reloc. We can't check reliably at this
1115 stage whether the section is read-only, as input
1116 sections have not yet been mapped to output sections.
1117 Tentatively set the flag for now, and correct in
1118 adjust_dynamic_symbol. */
f5385ebf 1119 h->non_got_ref = 1;
12d0ee4a
AM		 1120
1121 /* We may need a .plt entry if the function this reloc
1122 refers to is in a shared lib. */
51b64d56 1123 h->plt.refcount += 1;
c6585bbb 1124 if (r_type != R_386_PC32)
f5385ebf 1125 h->pointer_equality_needed = 1;
6725bdbf 1126 }
7843f00e 1127
252b5132 1128 /* If we are creating a shared library, and this is a reloc
f69da49f
AM		 1129 against a global symbol, or a non PC relative reloc
1130 against a local symbol, then we need to copy the reloc
1131 into the shared library. However, if we are linking with
1132 -Bsymbolic, we do not need to copy a reloc against a
1133 global symbol which is defined in an object we are
1134 including in the link (i.e., DEF_REGULAR is set). At
1135 this point we have not seen all the input files, so it is
1136 possible that DEF_REGULAR is not set now but will be set
1f655a09
L		 1137 later (it is never cleared). In case of a weak definition,
1138 DEF_REGULAR may be cleared later by a strong definition in
ebe50bae 1139 a shared library. We account for that possibility below by
1f655a09
L		 1140 storing information in the relocs_copied field of the hash
1141 table entry. A similar situation occurs when creating
1142 shared libraries and symbol visibility changes render the
12d0ee4a 1143 symbol local.
56882138 1144
12d0ee4a
AM		 1145 If on the other hand, we are creating an executable, we
1146 may need to keep relocations for symbols satisfied by a
1147 dynamic library if we manage to avoid copy relocs for the
1148 symbol. */
1149 if ((info->shared
1150 && (sec->flags & SEC_ALLOC) != 0
13ae64f3 1151 && (r_type != R_386_PC32
12d0ee4a
AM		 1152 || (h != NULL
1153 && (! info->symbolic
1154 || h->root.type == bfd_link_hash_defweak
f5385ebf 1155 || !h->def_regular))))
a23b6845
AM		 1156 || (ELIMINATE_COPY_RELOCS
1157 && !info->shared
12d0ee4a
AM		 1158 && (sec->flags & SEC_ALLOC) != 0
1159 && h != NULL
12d0ee4a 1160 && (h->root.type == bfd_link_hash_defweak
f5385ebf 1161 || !h->def_regular)))
252b5132 1162 {
ec338859
AM		 1163 struct elf_i386_dyn_relocs *p;
1164 struct elf_i386_dyn_relocs **head;
1165
12d0ee4a
AM		 1166 /* We must copy these reloc types into the output file.
1167 Create a reloc section in dynobj and make room for
1168 this reloc. */
252b5132
RH		 1169 if (sreloc == NULL)
1170 {
1171 const char *name;
0ac8d2ca 1172 bfd *dynobj;
e92d460e
AM		 1173 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1174 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
252b5132 1175
e92d460e 1176 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
252b5132 1177 if (name == NULL)
b34976b6 1178 return FALSE;
252b5132 1179
c8492176
L		 1180 if (strncmp (name, ".rel", 4) != 0
1181 || strcmp (bfd_get_section_name (abfd, sec),
1182 name + 4) != 0)
1183 {
0c715baa 1184 (*_bfd_error_handler)
d003868e
AM		 1185 (_("%B: bad relocation section name `%s\'"),
1186 abfd, name);
f5f31454 1187 }
252b5132 1188
0ac8d2ca
AM		 1189 if (htab->elf.dynobj == NULL)
1190 htab->elf.dynobj = abfd;
1191
1192 dynobj = htab->elf.dynobj;
252b5132
RH		 1193 sreloc = bfd_get_section_by_name (dynobj, name);
1194 if (sreloc == NULL)
1195 {
1196 flagword flags;
1197
252b5132
RH		 1198 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1199 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1200 if ((sec->flags & SEC_ALLOC) != 0)
1201 flags |= SEC_ALLOC | SEC_LOAD;
3496cb2a
L		 1202 sreloc = bfd_make_section_with_flags (dynobj,
1203 name,
1204 flags);
252b5132 1205 if (sreloc == NULL
252b5132 1206 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
b34976b6 1207 return FALSE;
252b5132 1208 }
0c715baa 1209 elf_section_data (sec)->sreloc = sreloc;
252b5132
RH		 1210 }
1211
0c715baa
AM		 1212 /* If this is a global symbol, we count the number of
1213 relocations we need for this symbol. */
1214 if (h != NULL)
252b5132 1215 {
ec338859 1216 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
0c715baa
AM		 1217 }
1218 else
1219 {
e81d3500 1220 void **vpp;
ec338859
AM		 1221 /* Track dynamic relocs needed for local syms too.
1222 We really need local syms available to do this
1223 easily. Oh well. */
1224
1225 asection *s;
1226 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1227 sec, r_symndx);
1228 if (s == NULL)
b34976b6 1229 return FALSE;
ec338859 1230
e81d3500
DD		 1231 vpp = &elf_section_data (s)->local_dynrel;
1232 head = (struct elf_i386_dyn_relocs **)vpp;
ec338859
AM		 1233 }
1234
1235 p = *head;
1236 if (p == NULL || p->sec != sec)
1237 {
1238 bfd_size_type amt = sizeof *p;
55fd94b0 1239 p = bfd_alloc (htab->elf.dynobj, amt);
ec338859 1240 if (p == NULL)
b34976b6 1241 return FALSE;
ec338859
AM		 1242 p->next = *head;
1243 *head = p;
1244 p->sec = sec;
1245 p->count = 0;
1246 p->pc_count = 0;
252b5132 1247 }
ec338859
AM		 1248
1249 p->count += 1;
13ae64f3 1250 if (r_type == R_386_PC32)
ec338859 1251 p->pc_count += 1;
252b5132 1252 }
252b5132
RH		 1253 break;
1254
1255 /* This relocation describes the C++ object vtable hierarchy.
1256 Reconstruct it for later use during GC. */
1257 case R_386_GNU_VTINHERIT:
c152c796 1258 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 1259 return FALSE;
252b5132
RH		 1260 break;
1261
1262 /* This relocation describes which C++ vtable entries are actually
1263 used. Record for later use during GC. */
1264 case R_386_GNU_VTENTRY:
c152c796 1265 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
b34976b6 1266 return FALSE;
252b5132
RH		 1267 break;
1268
1269 default:
1270 break;
1271 }
1272 }
1273
b34976b6 1274 return TRUE;
252b5132
RH		 1275}
1276
1277/* Return the section that should be marked against GC for a given
1278 relocation. */
1279
1280static asection *
55fd94b0
AM		 1281elf_i386_gc_mark_hook (asection *sec,
1282 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1283 Elf_Internal_Rela *rel,
1284 struct elf_link_hash_entry *h,
1285 Elf_Internal_Sym *sym)
252b5132
RH		 1286{
1287 if (h != NULL)
1288 {
1289 switch (ELF32_R_TYPE (rel->r_info))
1290 {
1291 case R_386_GNU_VTINHERIT:
1292 case R_386_GNU_VTENTRY:
1293 break;
1294
1295 default:
1296 switch (h->root.type)
1297 {
1298 case bfd_link_hash_defined:
1299 case bfd_link_hash_defweak:
1300 return h->root.u.def.section;
1301
1302 case bfd_link_hash_common:
1303 return h->root.u.c.p->section;
1304
1305 default:
1306 break;
1307 }
1308 }
1309 }
1310 else
1e2f5b6e 1311 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
252b5132
RH		 1312
1313 return NULL;
1314}
1315
1316/* Update the got entry reference counts for the section being removed. */
1317
b34976b6 1318static bfd_boolean
55fd94b0
AM		 1319elf_i386_gc_sweep_hook (bfd *abfd,
1320 struct bfd_link_info *info,
1321 asection *sec,
1322 const Elf_Internal_Rela *relocs)
252b5132 1323{
dd5724d5
AM		 1324 Elf_Internal_Shdr *symtab_hdr;
1325 struct elf_link_hash_entry **sym_hashes;
1326 bfd_signed_vma *local_got_refcounts;
1327 const Elf_Internal_Rela *rel, *relend;
dd5724d5 1328
ec338859 1329 elf_section_data (sec)->local_dynrel = NULL;
dd5724d5 1330
6725bdbf
AM		 1331 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1332 sym_hashes = elf_sym_hashes (abfd);
1333 local_got_refcounts = elf_local_got_refcounts (abfd);
dd5724d5
AM		 1334
1335 relend = relocs + sec->reloc_count;
1336 for (rel = relocs; rel < relend; rel++)
26e41594
AM		 1337 {
1338 unsigned long r_symndx;
1339 unsigned int r_type;
1340 struct elf_link_hash_entry *h = NULL;
37e55690 1341
26e41594
AM		 1342 r_symndx = ELF32_R_SYM (rel->r_info);
1343 if (r_symndx >= symtab_hdr->sh_info)
1344 {
1345 struct elf_i386_link_hash_entry *eh;
1346 struct elf_i386_dyn_relocs **pp;
1347 struct elf_i386_dyn_relocs *p;
dd5724d5 1348
26e41594 1349 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3eb128b2
AM		 1350 while (h->root.type == bfd_link_hash_indirect
1351 || h->root.type == bfd_link_hash_warning)
1352 h = (struct elf_link_hash_entry *) h->root.u.i.link;
26e41594 1353 eh = (struct elf_i386_link_hash_entry *) h;
0c715baa 1354
26e41594
AM		 1355 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1356 if (p->sec == sec)
1357 {
1358 /* Everything must go for SEC. */
1359 *pp = p->next;
1360 break;
1361 }
1362 }
0c715baa 1363
26e41594
AM		 1364 r_type = ELF32_R_TYPE (rel->r_info);
1365 r_type = elf_i386_tls_transition (info, r_type, h != NULL);
1366 switch (r_type)
1367 {
1368 case R_386_TLS_LDM:
1369 if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1370 elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1371 break;
0c715baa 1372
26e41594 1373 case R_386_TLS_GD:
67a4f2b7
AO		 1374 case R_386_TLS_GOTDESC:
1375 case R_386_TLS_DESC_CALL:
26e41594
AM		 1376 case R_386_TLS_IE_32:
1377 case R_386_TLS_IE:
1378 case R_386_TLS_GOTIE:
1379 case R_386_GOT32:
1380 if (h != NULL)
1381 {
1382 if (h->got.refcount > 0)
1383 h->got.refcount -= 1;
1384 }
1385 else if (local_got_refcounts != NULL)
1386 {
1387 if (local_got_refcounts[r_symndx] > 0)
1388 local_got_refcounts[r_symndx] -= 1;
1389 }
1390 break;
0c715baa 1391
26e41594
AM		 1392 case R_386_32:
1393 case R_386_PC32:
1394 if (info->shared)
1395 break;
1396 /* Fall through */
6725bdbf 1397
26e41594
AM		 1398 case R_386_PLT32:
1399 if (h != NULL)
1400 {
1401 if (h->plt.refcount > 0)
1402 h->plt.refcount -= 1;
1403 }
1404 break;
dd5724d5 1405
26e41594
AM		 1406 default:
1407 break;
1408 }
1409 }
252b5132 1410
b34976b6 1411 return TRUE;
252b5132
RH		 1412}
1413
1414/* Adjust a symbol defined by a dynamic object and referenced by a
1415 regular object. The current definition is in some section of the
1416 dynamic object, but we're not including those sections. We have to
1417 change the definition to something the rest of the link can
1418 understand. */
1419
b34976b6 1420static bfd_boolean
55fd94b0
AM		 1421elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
1422 struct elf_link_hash_entry *h)
252b5132 1423{
6725bdbf 1424 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1425 asection *s;
1426 unsigned int power_of_two;
1427
252b5132
RH		 1428 /* If this is a function, put it in the procedure linkage table. We
1429 will fill in the contents of the procedure linkage table later,
1430 when we know the address of the .got section. */
1431 if (h->type == STT_FUNC
f5385ebf 1432 || h->needs_plt)
252b5132 1433 {
6725bdbf 1434 if (h->plt.refcount <= 0
9c7a29a3
AM		 1435 || SYMBOL_CALLS_LOCAL (info, h)
1436 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1437 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 1438 {
1439 /* This case can occur if we saw a PLT32 reloc in an input
dd5724d5
AM		 1440 file, but the symbol was never referred to by a dynamic
1441 object, or if all references were garbage collected. In
1442 such a case, we don't actually need to build a procedure
1443 linkage table, and we can just do a PC32 reloc instead. */
bbd7ec4a 1444 h->plt.offset = (bfd_vma) -1;
f5385ebf 1445 h->needs_plt = 0;
252b5132
RH		 1446 }
1447
b34976b6 1448 return TRUE;
252b5132 1449 }
6725bdbf
AM		 1450 else
1451 /* It's possible that we incorrectly decided a .plt reloc was
1452 needed for an R_386_PC32 reloc to a non-function sym in
1453 check_relocs. We can't decide accurately between function and
1454 non-function syms in check-relocs; Objects loaded later in
1455 the link may change h->type. So fix it now. */
bbd7ec4a 1456 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 1457
1458 /* If this is a weak symbol, and there is a real definition, the
1459 processor independent code will have arranged for us to see the
1460 real definition first, and we can just use the same value. */
f6e332e6 1461 if (h->u.weakdef != NULL)
252b5132 1462 {
f6e332e6
AM		 1463 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1464 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1465 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1466 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 1467 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
f6e332e6 1468 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 1469 return TRUE;
252b5132
RH		 1470 }
1471
1472 /* This is a reference to a symbol defined by a dynamic object which
1473 is not a function. */
1474
1475 /* If we are creating a shared library, we must presume that the
1476 only references to the symbol are via the global offset table.
1477 For such cases we need not do anything here; the relocations will
1478 be handled correctly by relocate_section. */
1479 if (info->shared)
b34976b6 1480 return TRUE;
252b5132 1481
7843f00e
ILT		 1482 /* If there are no references to this symbol that do not use the
1483 GOT, we don't need to generate a copy reloc. */
f5385ebf 1484 if (!h->non_got_ref)
b34976b6 1485 return TRUE;
7843f00e 1486
8bd621d8
AM		 1487 /* If -z nocopyreloc was given, we won't generate them either. */
1488 if (info->nocopyreloc)
1489 {
f5385ebf 1490 h->non_got_ref = 0;
b34976b6 1491 return TRUE;
8bd621d8
AM		 1492 }
1493
643796e3
DJ		 1494 htab = elf_i386_hash_table (info);
1495
1496 /* If there aren't any dynamic relocs in read-only sections, then
1497 we can keep the dynamic relocs and avoid the copy reloc. This
1498 doesn't work on VxWorks, where we can not have dynamic relocations
1499 (other than copy and jump slot relocations) in an executable. */
1500 if (ELIMINATE_COPY_RELOCS && !htab->is_vxworks)
ebe50bae 1501 {
a23b6845
AM		 1502 struct elf_i386_link_hash_entry * eh;
1503 struct elf_i386_dyn_relocs *p;
ebe50bae 1504
a23b6845
AM		 1505 eh = (struct elf_i386_link_hash_entry *) h;
1506 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1507 {
1508 s = p->sec->output_section;
1509 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1510 break;
1511 }
1512
a23b6845
AM		 1513 if (p == NULL)
1514 {
f5385ebf 1515 h->non_got_ref = 0;
a23b6845
AM		 1516 return TRUE;
1517 }
ebe50bae
AM		 1518 }
1519
909272ee
AM		 1520 if (h->size == 0)
1521 {
1522 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1523 h->root.root.string);
1524 return TRUE;
1525 }
1526
252b5132
RH		 1527 /* We must allocate the symbol in our .dynbss section, which will
1528 become part of the .bss section of the executable. There will be
1529 an entry for this symbol in the .dynsym section. The dynamic
1530 object will contain position independent code, so all references
1531 from the dynamic object to this symbol will go through the global
1532 offset table. The dynamic linker will use the .dynsym entry to
1533 determine the address it must put in the global offset table, so
1534 both the dynamic object and the regular object will refer to the
1535 same memory location for the variable. */
1536
252b5132
RH		 1537 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1538 copy the initial value out of the dynamic object and into the
0ac8d2ca 1539 runtime process image. */
252b5132
RH		 1540 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1541 {
eea6121a 1542 htab->srelbss->size += sizeof (Elf32_External_Rel);
f5385ebf 1543 h->needs_copy = 1;
252b5132
RH		 1544 }
1545
1546 /* We need to figure out the alignment required for this symbol. I
1547 have no idea how ELF linkers handle this. */
1548 power_of_two = bfd_log2 (h->size);
1549 if (power_of_two > 3)
1550 power_of_two = 3;
1551
1552 /* Apply the required alignment. */
0ac8d2ca 1553 s = htab->sdynbss;
eea6121a 1554 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
0ac8d2ca 1555 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
252b5132 1556 {
0ac8d2ca 1557 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
b34976b6 1558 return FALSE;
252b5132
RH		 1559 }
1560
1561 /* Define the symbol as being at this point in the section. */
1562 h->root.u.def.section = s;
eea6121a 1563 h->root.u.def.value = s->size;
252b5132
RH		 1564
1565 /* Increment the section size to make room for the symbol. */
eea6121a 1566 s->size += h->size;
252b5132 1567
b34976b6 1568 return TRUE;
252b5132
RH		 1569}
1570
6725bdbf 1571/* Allocate space in .plt, .got and associated reloc sections for
0c715baa 1572 dynamic relocs. */
6725bdbf 1573
b34976b6 1574static bfd_boolean
55fd94b0 1575allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
6725bdbf
AM		 1576{
1577 struct bfd_link_info *info;
1578 struct elf_i386_link_hash_table *htab;
5a15f56f 1579 struct elf_i386_link_hash_entry *eh;
0c715baa 1580 struct elf_i386_dyn_relocs *p;
6725bdbf 1581
e92d460e 1582 if (h->root.type == bfd_link_hash_indirect)
b34976b6 1583 return TRUE;
6725bdbf 1584
e92d460e
AM		 1585 if (h->root.type == bfd_link_hash_warning)
1586 /* When warning symbols are created, they **replace** the "real"
1587 entry in the hash table, thus we never get to see the real
1588 symbol in a hash traversal. So look at it now. */
1589 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1590
6725bdbf
AM		 1591 info = (struct bfd_link_info *) inf;
1592 htab = elf_i386_hash_table (info);
1593
ebe50bae 1594 if (htab->elf.dynamic_sections_created
9c7a29a3 1595 && h->plt.refcount > 0)
6725bdbf 1596 {
5a15f56f
AM		 1597 /* Make sure this symbol is output as a dynamic symbol.
1598 Undefined weak syms won't yet be marked as dynamic. */
1599 if (h->dynindx == -1
f5385ebf 1600 && !h->forced_local)
5a15f56f 1601 {
c152c796 1602 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 1603 return FALSE;
5a15f56f
AM		 1604 }
1605
4e795f50
AM		 1606 if (info->shared
1607 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
ced53ee5 1608 {
0ac8d2ca 1609 asection *s = htab->splt;
6725bdbf 1610
ced53ee5
AM		 1611 /* If this is the first .plt entry, make room for the special
1612 first entry. */
eea6121a
AM		 1613 if (s->size == 0)
1614 s->size += PLT_ENTRY_SIZE;
6725bdbf 1615
eea6121a 1616 h->plt.offset = s->size;
6725bdbf 1617
ced53ee5
AM		 1618 /* If this symbol is not defined in a regular file, and we are
1619 not generating a shared library, then set the symbol to this
1620 location in the .plt. This is required to make function
1621 pointers compare as equal between the normal executable and
1622 the shared library. */
1623 if (! info->shared
f5385ebf 1624 && !h->def_regular)
ced53ee5
AM		 1625 {
1626 h->root.u.def.section = s;
1627 h->root.u.def.value = h->plt.offset;
1628 }
6725bdbf 1629
ced53ee5 1630 /* Make room for this entry. */
eea6121a 1631 s->size += PLT_ENTRY_SIZE;
6725bdbf 1632
ced53ee5
AM		 1633 /* We also need to make an entry in the .got.plt section, which
1634 will be placed in the .got section by the linker script. */
eea6121a 1635 htab->sgotplt->size += 4;
6725bdbf 1636
6725bdbf 1637 /* We also need to make an entry in the .rel.plt section. */
eea6121a 1638 htab->srelplt->size += sizeof (Elf32_External_Rel);
5ae0bfb6 1639 htab->next_tls_desc_index++;
eac338cf
PB		 1640
1641 if (htab->is_vxworks && !info->shared)
1642 {
1643 /* VxWorks has a second set of relocations for each PLT entry
1644 in executables. They go in a separate relocation section,
1645 which is processed by the kernel loader. */
1646
1647 /* There are two relocations for the initial PLT entry: an
1648 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
1649 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
1650
1651 if (h->plt.offset == PLT_ENTRY_SIZE)
1652 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1653
1654 /* There are two extra relocations for each subsequent PLT entry:
1655 an R_386_32 relocation for the GOT entry, and an R_386_32
1656 relocation for the PLT entry. */
1657
1658 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1659 }
6725bdbf 1660 }
ced53ee5
AM		 1661 else
1662 {
51b64d56 1663 h->plt.offset = (bfd_vma) -1;
f5385ebf 1664 h->needs_plt = 0;
ced53ee5 1665 }
6725bdbf
AM		 1666 }
1667 else
1668 {
51b64d56 1669 h->plt.offset = (bfd_vma) -1;
f5385ebf 1670 h->needs_plt = 0;
6725bdbf
AM		 1671 }
1672
67a4f2b7
AO		 1673 eh = (struct elf_i386_link_hash_entry *) h;
1674 eh->tlsdesc_got = (bfd_vma) -1;
1675
37e55690 1676 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
13ae64f3
JJ		 1677 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1678 if (h->got.refcount > 0
1679 && !info->shared
1680 && h->dynindx == -1
37e55690 1681 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
cedb70c5 1682 h->got.offset = (bfd_vma) -1;
13ae64f3 1683 else if (h->got.refcount > 0)
6725bdbf 1684 {
0ac8d2ca 1685 asection *s;
b34976b6 1686 bfd_boolean dyn;
13ae64f3 1687 int tls_type = elf_i386_hash_entry(h)->tls_type;
6725bdbf 1688
5a15f56f
AM		 1689 /* Make sure this symbol is output as a dynamic symbol.
1690 Undefined weak syms won't yet be marked as dynamic. */
1691 if (h->dynindx == -1
f5385ebf 1692 && !h->forced_local)
5a15f56f 1693 {
c152c796 1694 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 1695 return FALSE;
5a15f56f
AM		 1696 }
1697
6725bdbf 1698 s = htab->sgot;
67a4f2b7
AO		 1699 if (GOT_TLS_GDESC_P (tls_type))
1700 {
1701 eh->tlsdesc_got = htab->sgotplt->size
1702 - elf_i386_compute_jump_table_size (htab);
1703 htab->sgotplt->size += 8;
1704 h->got.offset = (bfd_vma) -2;
1705 }
1706 if (! GOT_TLS_GDESC_P (tls_type)
1707 || GOT_TLS_GD_P (tls_type))
1708 {
1709 h->got.offset = s->size;
1710 s->size += 4;
1711 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1712 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
1713 s->size += 4;
1714 }
ebe50bae 1715 dyn = htab->elf.dynamic_sections_created;
13ae64f3 1716 /* R_386_TLS_IE_32 needs one dynamic relocation,
37e55690
JJ		 1717 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1718 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1719 need two), R_386_TLS_GD needs one if local symbol and two if
1720 global. */
1721 if (tls_type == GOT_TLS_IE_BOTH)
eea6121a 1722 htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7 1723 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
37e55690 1724 || (tls_type & GOT_TLS_IE))
eea6121a 1725 htab->srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7 1726 else if (GOT_TLS_GD_P (tls_type))
eea6121a 1727 htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7
AO		 1728 else if (! GOT_TLS_GDESC_P (tls_type)
1729 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1730 || h->root.type != bfd_link_hash_undefweak)
ef5aade5
L		 1731 && (info->shared
1732 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
eea6121a 1733 htab->srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7
AO		 1734 if (GOT_TLS_GDESC_P (tls_type))
1735 htab->srelplt->size += sizeof (Elf32_External_Rel);
6725bdbf
AM		 1736 }
1737 else
51b64d56 1738 h->got.offset = (bfd_vma) -1;
6725bdbf 1739
5a15f56f 1740 if (eh->dyn_relocs == NULL)
b34976b6 1741 return TRUE;
5a15f56f 1742
0c715baa
AM		 1743 /* In the shared -Bsymbolic case, discard space allocated for
1744 dynamic pc-relative relocs against symbols which turn out to be
1745 defined in regular objects. For the normal shared case, discard
0ac8d2ca
AM		 1746 space for pc-relative relocs that have become local due to symbol
1747 visibility changes. */
0c715baa
AM		 1748
1749 if (info->shared)
5a15f56f 1750 {
09695f56
AM		 1751 /* The only reloc that uses pc_count is R_386_PC32, which will
1752 appear on a call or on something like ".long foo - .". We
1753 want calls to protected symbols to resolve directly to the
1754 function rather than going via the plt. If people want
1755 function pointer comparisons to work as expected then they
1756 should avoid writing assembly like ".long foo - .". */
1757 if (SYMBOL_CALLS_LOCAL (info, h))
5a15f56f 1758 {
0c715baa
AM		 1759 struct elf_i386_dyn_relocs **pp;
1760
1761 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1762 {
1763 p->count -= p->pc_count;
1764 p->pc_count = 0;
1765 if (p->count == 0)
1766 *pp = p->next;
1767 else
1768 pp = &p->next;
1769 }
5a15f56f 1770 }
4e795f50
AM		 1771
1772 /* Also discard relocs on undefined weak syms with non-default
1773 visibility. */
22d606e9 1774 if (eh->dyn_relocs != NULL
4e795f50 1775 && h->root.type == bfd_link_hash_undefweak)
22d606e9
AM		 1776 {
1777 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1778 eh->dyn_relocs = NULL;
1779
1780 /* Make sure undefined weak symbols are output as a dynamic
1781 symbol in PIEs. */
1782 else if (h->dynindx == -1
1783 && !h->forced_local)
1784 {
1785 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1786 return FALSE;
1787 }
1788 }
0c715baa 1789 }
a23b6845 1790 else if (ELIMINATE_COPY_RELOCS)
0c715baa
AM		 1791 {
1792 /* For the non-shared case, discard space for relocs against
1793 symbols which turn out to need copy relocs or are not
1794 dynamic. */
1795
f5385ebf
AM		 1796 if (!h->non_got_ref
1797 && ((h->def_dynamic
1798 && !h->def_regular)
ebe50bae 1799 || (htab->elf.dynamic_sections_created
0c715baa
AM		 1800 && (h->root.type == bfd_link_hash_undefweak
1801 || h->root.type == bfd_link_hash_undefined))))
1802 {
1803 /* Make sure this symbol is output as a dynamic symbol.
1804 Undefined weak syms won't yet be marked as dynamic. */
1805 if (h->dynindx == -1
f5385ebf 1806 && !h->forced_local)
0c715baa 1807 {
c152c796 1808 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 1809 return FALSE;
0c715baa 1810 }
5a15f56f 1811
0c715baa
AM		 1812 /* If that succeeded, we know we'll be keeping all the
1813 relocs. */
1814 if (h->dynindx != -1)
1815 goto keep;
1816 }
1817
1818 eh->dyn_relocs = NULL;
1819
ec338859 1820 keep: ;
5a15f56f
AM		 1821 }
1822
0c715baa
AM		 1823 /* Finally, allocate space. */
1824 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12d0ee4a 1825 {
0c715baa 1826 asection *sreloc = elf_section_data (p->sec)->sreloc;
eea6121a 1827 sreloc->size += p->count * sizeof (Elf32_External_Rel);
12d0ee4a
AM		 1828 }
1829
b34976b6 1830 return TRUE;
6725bdbf
AM		 1831}
1832
0c715baa
AM		 1833/* Find any dynamic relocs that apply to read-only sections. */
1834
b34976b6 1835static bfd_boolean
55fd94b0 1836readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
0c715baa
AM		 1837{
1838 struct elf_i386_link_hash_entry *eh;
1839 struct elf_i386_dyn_relocs *p;
1840
e92d460e
AM		 1841 if (h->root.type == bfd_link_hash_warning)
1842 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1843
0c715baa
AM		 1844 eh = (struct elf_i386_link_hash_entry *) h;
1845 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1846 {
1847 asection *s = p->sec->output_section;
1848
1849 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1850 {
1851 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1852
1853 info->flags |= DF_TEXTREL;
1854
1855 /* Not an error, just cut short the traversal. */
b34976b6 1856 return FALSE;
0c715baa
AM		 1857 }
1858 }
b34976b6 1859 return TRUE;
0c715baa
AM		 1860}
1861
252b5132
RH		 1862/* Set the sizes of the dynamic sections. */
1863
b34976b6 1864static bfd_boolean
55fd94b0
AM		 1865elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1866 struct bfd_link_info *info)
252b5132 1867{
6725bdbf 1868 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1869 bfd *dynobj;
1870 asection *s;
b34976b6 1871 bfd_boolean relocs;
0c715baa 1872 bfd *ibfd;
252b5132 1873
6725bdbf 1874 htab = elf_i386_hash_table (info);
ebe50bae 1875 dynobj = htab->elf.dynobj;
ffb2e45b
AM		 1876 if (dynobj == NULL)
1877 abort ();
252b5132 1878
ebe50bae 1879 if (htab->elf.dynamic_sections_created)
252b5132
RH		 1880 {
1881 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 1882 if (info->executable)
252b5132
RH		 1883 {
1884 s = bfd_get_section_by_name (dynobj, ".interp");
ffb2e45b
AM		 1885 if (s == NULL)
1886 abort ();
eea6121a 1887 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
252b5132
RH		 1888 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1889 }
161d71a6 1890 }
6725bdbf 1891
0c715baa
AM		 1892 /* Set up .got offsets for local syms, and space for local dynamic
1893 relocs. */
1894 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
161d71a6
L		 1895 {
1896 bfd_signed_vma *local_got;
1897 bfd_signed_vma *end_local_got;
13ae64f3 1898 char *local_tls_type;
67a4f2b7 1899 bfd_vma *local_tlsdesc_gotent;
161d71a6
L		 1900 bfd_size_type locsymcount;
1901 Elf_Internal_Shdr *symtab_hdr;
1902 asection *srel;
6725bdbf 1903
0c715baa 1904 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
161d71a6 1905 continue;
6725bdbf 1906
0c715baa
AM		 1907 for (s = ibfd->sections; s != NULL; s = s->next)
1908 {
ec338859 1909 struct elf_i386_dyn_relocs *p;
0c715baa 1910
e81d3500
DD		 1911 for (p = ((struct elf_i386_dyn_relocs *)
1912 elf_section_data (s)->local_dynrel);
ec338859
AM		 1913 p != NULL;
1914 p = p->next)
0c715baa 1915 {
ec338859
AM		 1916 if (!bfd_is_abs_section (p->sec)
1917 && bfd_is_abs_section (p->sec->output_section))
1918 {
1919 /* Input section has been discarded, either because
1920 it is a copy of a linkonce section or due to
1921 linker script /DISCARD/, so we'll be discarding
1922 the relocs too. */
1923 }
248866a8 1924 else if (p->count != 0)
ec338859
AM		 1925 {
1926 srel = elf_section_data (p->sec)->sreloc;
eea6121a 1927 srel->size += p->count * sizeof (Elf32_External_Rel);
248866a8
AM		 1928 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1929 info->flags |= DF_TEXTREL;
ec338859 1930 }
0c715baa
AM		 1931 }
1932 }
1933
1934 local_got = elf_local_got_refcounts (ibfd);
161d71a6
L		 1935 if (!local_got)
1936 continue;
6725bdbf 1937
0c715baa 1938 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
161d71a6
L		 1939 locsymcount = symtab_hdr->sh_info;
1940 end_local_got = local_got + locsymcount;
13ae64f3 1941 local_tls_type = elf_i386_local_got_tls_type (ibfd);
67a4f2b7 1942 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
161d71a6
L		 1943 s = htab->sgot;
1944 srel = htab->srelgot;
67a4f2b7
AO		 1945 for (; local_got < end_local_got;
1946 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
161d71a6 1947 {
67a4f2b7 1948 *local_tlsdesc_gotent = (bfd_vma) -1;
161d71a6 1949 if (*local_got > 0)
6725bdbf 1950 {
67a4f2b7
AO		 1951 if (GOT_TLS_GDESC_P (*local_tls_type))
1952 {
1953 *local_tlsdesc_gotent = htab->sgotplt->size
1954 - elf_i386_compute_jump_table_size (htab);
1955 htab->sgotplt->size += 8;
1956 *local_got = (bfd_vma) -2;
1957 }
1958 if (! GOT_TLS_GDESC_P (*local_tls_type)
1959 || GOT_TLS_GD_P (*local_tls_type))
1960 {
1961 *local_got = s->size;
1962 s->size += 4;
1963 if (GOT_TLS_GD_P (*local_tls_type)
1964 || *local_tls_type == GOT_TLS_IE_BOTH)
1965 s->size += 4;
1966 }
13ae64f3 1967 if (info->shared
67a4f2b7 1968 || GOT_TLS_GD_ANY_P (*local_tls_type)
37e55690
JJ		 1969 || (*local_tls_type & GOT_TLS_IE))
1970 {
1971 if (*local_tls_type == GOT_TLS_IE_BOTH)
eea6121a 1972 srel->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7
AO		 1973 else if (GOT_TLS_GD_P (*local_tls_type)
1974 || ! GOT_TLS_GDESC_P (*local_tls_type))
eea6121a 1975 srel->size += sizeof (Elf32_External_Rel);
67a4f2b7
AO		 1976 if (GOT_TLS_GDESC_P (*local_tls_type))
1977 htab->srelplt->size += sizeof (Elf32_External_Rel);
37e55690 1978 }
6725bdbf 1979 }
161d71a6
L		 1980 else
1981 *local_got = (bfd_vma) -1;
6725bdbf 1982 }
252b5132 1983 }
6725bdbf 1984
13ae64f3
JJ		 1985 if (htab->tls_ldm_got.refcount > 0)
1986 {
1987 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1988 relocs. */
eea6121a
AM		 1989 htab->tls_ldm_got.offset = htab->sgot->size;
1990 htab->sgot->size += 8;
1991 htab->srelgot->size += sizeof (Elf32_External_Rel);
13ae64f3
JJ		 1992 }
1993 else
1994 htab->tls_ldm_got.offset = -1;
1995
0c715baa
AM		 1996 /* Allocate global sym .plt and .got entries, and space for global
1997 sym dynamic relocs. */
ebe50bae 1998 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
252b5132 1999
67a4f2b7
AO		 2000 /* For every jump slot reserved in the sgotplt, reloc_count is
2001 incremented. However, when we reserve space for TLS descriptors,
2002 it's not incremented, so in order to compute the space reserved
2003 for them, it suffices to multiply the reloc count by the jump
2004 slot size. */
2005 if (htab->srelplt)
5ae0bfb6 2006 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
67a4f2b7 2007
5a15f56f
AM		 2008 /* We now have determined the sizes of the various dynamic sections.
2009 Allocate memory for them. */
b34976b6 2010 relocs = FALSE;
252b5132
RH		 2011 for (s = dynobj->sections; s != NULL; s = s->next)
2012 {
eac338cf
PB		 2013 bfd_boolean strip_section = TRUE;
2014
252b5132
RH		 2015 if ((s->flags & SEC_LINKER_CREATED) == 0)
2016 continue;
2017
6725bdbf
AM		 2018 if (s == htab->splt
2019 || s == htab->sgot
75ff4589
L		 2020 || s == htab->sgotplt
2021 || s == htab->sdynbss)
252b5132 2022 {
6725bdbf
AM		 2023 /* Strip this section if we don't need it; see the
2024 comment below. */
eac338cf
PB		 2025 /* We'd like to strip these sections if they aren't needed, but if
2026 we've exported dynamic symbols from them we must leave them.
2027 It's too late to tell BFD to get rid of the symbols. */
2028
7325306f 2029 if (htab->elf.hplt != NULL)
eac338cf 2030 strip_section = FALSE;
252b5132 2031 }
6725bdbf 2032 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
252b5132 2033 {
eac338cf 2034 if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
b34976b6 2035 relocs = TRUE;
252b5132 2036
0ac8d2ca
AM		 2037 /* We use the reloc_count field as a counter if we need
2038 to copy relocs into the output file. */
5ae0bfb6 2039 s->reloc_count = 0;
252b5132 2040 }
6725bdbf 2041 else
252b5132
RH		 2042 {
2043 /* It's not one of our sections, so don't allocate space. */
2044 continue;
2045 }
2046
c456f082 2047 if (s->size == 0)
252b5132 2048 {
0ac8d2ca
AM		 2049 /* If we don't need this section, strip it from the
2050 output file. This is mostly to handle .rel.bss and
2051 .rel.plt. We must create both sections in
2052 create_dynamic_sections, because they must be created
2053 before the linker maps input sections to output
2054 sections. The linker does that before
2055 adjust_dynamic_symbol is called, and it is that
2056 function which decides whether anything needs to go
2057 into these sections. */
c456f082
AM		 2058 if (strip_section)
2059 s->flags |= SEC_EXCLUDE;
252b5132
RH		 2060 continue;
2061 }
2062
c456f082
AM		 2063 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2064 continue;
2065
f69da49f
AM		 2066 /* Allocate memory for the section contents. We use bfd_zalloc
2067 here in case unused entries are not reclaimed before the
2068 section's contents are written out. This should not happen,
2069 but this way if it does, we get a R_386_NONE reloc instead
2070 of garbage. */
eea6121a 2071 s->contents = bfd_zalloc (dynobj, s->size);
6725bdbf 2072 if (s->contents == NULL)
b34976b6 2073 return FALSE;
252b5132
RH		 2074 }
2075
ebe50bae 2076 if (htab->elf.dynamic_sections_created)
252b5132
RH		 2077 {
2078 /* Add some entries to the .dynamic section. We fill in the
2079 values later, in elf_i386_finish_dynamic_sections, but we
2080 must add the entries now so that we get the correct size for
2081 the .dynamic section. The DT_DEBUG entry is filled in by the
2082 dynamic linker and used by the debugger. */
dc810e39 2083#define add_dynamic_entry(TAG, VAL) \
5a580b3a 2084 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 2085
36af4a4e 2086 if (info->executable)
252b5132 2087 {
dc810e39 2088 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 2089 return FALSE;
252b5132
RH		 2090 }
2091
eea6121a 2092 if (htab->splt->size != 0)
252b5132 2093 {
dc810e39
AM		 2094 if (!add_dynamic_entry (DT_PLTGOT, 0)
2095 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2096 || !add_dynamic_entry (DT_PLTREL, DT_REL)
2097 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 2098 return FALSE;
252b5132
RH		 2099 }
2100
2101 if (relocs)
2102 {
dc810e39
AM		 2103 if (!add_dynamic_entry (DT_REL, 0)
2104 || !add_dynamic_entry (DT_RELSZ, 0)
2105 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
b34976b6 2106 return FALSE;
252b5132 2107
0c715baa
AM		 2108 /* If any dynamic relocs apply to a read-only section,
2109 then we need a DT_TEXTREL entry. */
248866a8
AM		 2110 if ((info->flags & DF_TEXTREL) == 0)
2111 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2112 (PTR) info);
0c715baa
AM		 2113
2114 if ((info->flags & DF_TEXTREL) != 0)
2115 {
2116 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 2117 return FALSE;
0c715baa 2118 }
252b5132
RH		 2119 }
2120 }
dc810e39 2121#undef add_dynamic_entry
252b5132 2122
b34976b6 2123 return TRUE;
252b5132
RH		 2124}
2125
67a4f2b7
AO		 2126static bfd_boolean
2127elf_i386_always_size_sections (bfd *output_bfd,
2128 struct bfd_link_info *info)
2129{
2130 asection *tls_sec = elf_hash_table (info)->tls_sec;
2131
2132 if (tls_sec)
2133 {
2134 struct elf_link_hash_entry *tlsbase;
2135
2136 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2137 "_TLS_MODULE_BASE_",
2138 FALSE, FALSE, FALSE);
2139
2140 if (tlsbase && tlsbase->type == STT_TLS)
2141 {
2142 struct bfd_link_hash_entry *bh = NULL;
2143 const struct elf_backend_data *bed
2144 = get_elf_backend_data (output_bfd);
2145
2146 if (!(_bfd_generic_link_add_one_symbol
2147 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2148 tls_sec, 0, NULL, FALSE,
2149 bed->collect, &bh)))
2150 return FALSE;
2151 tlsbase = (struct elf_link_hash_entry *)bh;
2152 tlsbase->def_regular = 1;
2153 tlsbase->other = STV_HIDDEN;
2154 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2155 }
2156 }
2157
2158 return TRUE;
2159}
2160
38701953
AM		 2161/* Set the correct type for an x86 ELF section. We do this by the
2162 section name, which is a hack, but ought to work. */
2163
b34976b6 2164static bfd_boolean
55fd94b0
AM		 2165elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2166 Elf_Internal_Shdr *hdr,
2167 asection *sec)
38701953
AM		 2168{
2169 register const char *name;
2170
2171 name = bfd_get_section_name (abfd, sec);
2172
2173 /* This is an ugly, but unfortunately necessary hack that is
2174 needed when producing EFI binaries on x86. It tells
2175 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2176 containing ELF relocation info. We need this hack in order to
2177 be able to generate ELF binaries that can be translated into
2178 EFI applications (which are essentially COFF objects). Those
2179 files contain a COFF ".reloc" section inside an ELFNN object,
2180 which would normally cause BFD to segfault because it would
2181 attempt to interpret this section as containing relocation
2182 entries for section "oc". With this hack enabled, ".reloc"
2183 will be treated as a normal data section, which will avoid the
2184 segfault. However, you won't be able to create an ELFNN binary
2185 with a section named "oc" that needs relocations, but that's
2186 the kind of ugly side-effects you get when detecting section
2187 types based on their names... In practice, this limitation is
2188 unlikely to bite. */
2189 if (strcmp (name, ".reloc") == 0)
2190 hdr->sh_type = SHT_PROGBITS;
2191
b34976b6 2192 return TRUE;
38701953
AM		 2193}
2194
13ae64f3
JJ		 2195/* Return the base VMA address which should be subtracted from real addresses
2196 when resolving @dtpoff relocation.
2197 This is PT_TLS segment p_vaddr. */
2198
2199static bfd_vma
55fd94b0 2200dtpoff_base (struct bfd_link_info *info)
13ae64f3 2201{
e1918d23
AM		 2202 /* If tls_sec is NULL, we should have signalled an error already. */
2203 if (elf_hash_table (info)->tls_sec == NULL)
6a30718d 2204 return 0;
e1918d23 2205 return elf_hash_table (info)->tls_sec->vma;
13ae64f3
JJ		 2206}
2207
2208/* Return the relocation value for @tpoff relocation
2209 if STT_TLS virtual address is ADDRESS. */
2210
2211static bfd_vma
55fd94b0 2212tpoff (struct bfd_link_info *info, bfd_vma address)
13ae64f3 2213{
e1918d23 2214 struct elf_link_hash_table *htab = elf_hash_table (info);
13ae64f3 2215
e1918d23
AM		 2216 /* If tls_sec is NULL, we should have signalled an error already. */
2217 if (htab->tls_sec == NULL)
6a30718d 2218 return 0;
e1918d23 2219 return htab->tls_size + htab->tls_sec->vma - address;
13ae64f3
JJ		 2220}
2221
252b5132
RH		 2222/* Relocate an i386 ELF section. */
2223
b34976b6 2224static bfd_boolean
55fd94b0
AM		 2225elf_i386_relocate_section (bfd *output_bfd,
2226 struct bfd_link_info *info,
2227 bfd *input_bfd,
2228 asection *input_section,
2229 bfd_byte *contents,
2230 Elf_Internal_Rela *relocs,
2231 Elf_Internal_Sym *local_syms,
2232 asection **local_sections)
252b5132 2233{
6725bdbf 2234 struct elf_i386_link_hash_table *htab;
252b5132
RH		 2235 Elf_Internal_Shdr *symtab_hdr;
2236 struct elf_link_hash_entry **sym_hashes;
2237 bfd_vma *local_got_offsets;
67a4f2b7 2238 bfd_vma *local_tlsdesc_gotents;
252b5132
RH		 2239 Elf_Internal_Rela *rel;
2240 Elf_Internal_Rela *relend;
2241
6725bdbf 2242 htab = elf_i386_hash_table (info);
252b5132
RH		 2243 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2244 sym_hashes = elf_sym_hashes (input_bfd);
2245 local_got_offsets = elf_local_got_offsets (input_bfd);
67a4f2b7 2246 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
252b5132 2247
252b5132
RH		 2248 rel = relocs;
2249 relend = relocs + input_section->reloc_count;
2250 for (; rel < relend; rel++)
2251 {
13ae64f3 2252 unsigned int r_type;
252b5132
RH		 2253 reloc_howto_type *howto;
2254 unsigned long r_symndx;
2255 struct elf_link_hash_entry *h;
2256 Elf_Internal_Sym *sym;
2257 asection *sec;
67a4f2b7 2258 bfd_vma off, offplt;
252b5132 2259 bfd_vma relocation;
b34976b6 2260 bfd_boolean unresolved_reloc;
252b5132 2261 bfd_reloc_status_type r;
1b452ec6 2262 unsigned int indx;
13ae64f3 2263 int tls_type;
252b5132
RH		 2264
2265 r_type = ELF32_R_TYPE (rel->r_info);
55fd94b0
AM		 2266 if (r_type == R_386_GNU_VTINHERIT
2267 || r_type == R_386_GNU_VTENTRY)
252b5132 2268 continue;
dc47f327 2269
55fd94b0 2270 if ((indx = r_type) >= R_386_standard
13ae64f3
JJ		 2271 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2272 >= R_386_ext - R_386_standard)
2273 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2274 >= R_386_tls - R_386_ext))
252b5132 2275 {
6ba842b6 2276 (*_bfd_error_handler)
d003868e
AM		 2277 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2278 input_bfd, input_section, r_type);
252b5132 2279 bfd_set_error (bfd_error_bad_value);
b34976b6 2280 return FALSE;
252b5132 2281 }
1b452ec6 2282 howto = elf_howto_table + indx;
252b5132
RH		 2283
2284 r_symndx = ELF32_R_SYM (rel->r_info);
2285
1049f94e 2286 if (info->relocatable)
252b5132 2287 {
4a335f3d 2288 bfd_vma val;
4a335f3d
AM		 2289 bfd_byte *where;
2290
0ac8d2ca 2291 /* This is a relocatable link. We don't have to change
252b5132
RH		 2292 anything, unless the reloc is against a section symbol,
2293 in which case we have to adjust according to where the
2294 section symbol winds up in the output section. */
4a335f3d
AM		 2295 if (r_symndx >= symtab_hdr->sh_info)
2296 continue;
2297
2298 sym = local_syms + r_symndx;
2299 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2300 continue;
2301
2302 sec = local_sections[r_symndx];
2303 val = sec->output_offset;
2304 if (val == 0)
2305 continue;
2306
2307 where = contents + rel->r_offset;
2308 switch (howto->size)
252b5132 2309 {
16a10388 2310 /* FIXME: overflow checks. */
4a335f3d 2311 case 0:
16a10388 2312 val += bfd_get_8 (input_bfd, where);
4a335f3d 2313 bfd_put_8 (input_bfd, val, where);
4a335f3d
AM		 2314 break;
2315 case 1:
16a10388 2316 val += bfd_get_16 (input_bfd, where);
4a335f3d 2317 bfd_put_16 (input_bfd, val, where);
4a335f3d
AM		 2318 break;
2319 case 2:
2320 val += bfd_get_32 (input_bfd, where);
2321 bfd_put_32 (input_bfd, val, where);
2322 break;
2323 default:
2324 abort ();
252b5132 2325 }
252b5132
RH		 2326 continue;
2327 }
2328
2329 /* This is a final link. */
2330 h = NULL;
2331 sym = NULL;
2332 sec = NULL;
b34976b6 2333 unresolved_reloc = FALSE;
252b5132
RH		 2334 if (r_symndx < symtab_hdr->sh_info)
2335 {
2336 sym = local_syms + r_symndx;
2337 sec = local_sections[r_symndx];
2338 relocation = (sec->output_section->vma
2339 + sec->output_offset
2340 + sym->st_value);
f8df10f4
JJ		 2341 if ((sec->flags & SEC_MERGE)
2342 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2343 {
2344 asection *msec;
2345 bfd_vma addend;
4a335f3d 2346 bfd_byte *where = contents + rel->r_offset;
f8df10f4 2347
4a335f3d 2348 switch (howto->size)
f8df10f4 2349 {
4a335f3d
AM		 2350 case 0:
2351 addend = bfd_get_8 (input_bfd, where);
2352 if (howto->pc_relative)
2353 {
2354 addend = (addend ^ 0x80) - 0x80;
2355 addend += 1;
2356 }
2357 break;
2358 case 1:
2359 addend = bfd_get_16 (input_bfd, where);
2360 if (howto->pc_relative)
2361 {
2362 addend = (addend ^ 0x8000) - 0x8000;
2363 addend += 2;
2364 }
2365 break;
2366 case 2:
2367 addend = bfd_get_32 (input_bfd, where);
2368 if (howto->pc_relative)
2369 {
2370 addend = (addend ^ 0x80000000) - 0x80000000;
2371 addend += 4;
2372 }
2373 break;
2374 default:
2375 abort ();
f8df10f4
JJ		 2376 }
2377
f8df10f4 2378 msec = sec;
4a335f3d
AM		 2379 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2380 addend -= relocation;
f8df10f4 2381 addend += msec->output_section->vma + msec->output_offset;
4a335f3d
AM		 2382
2383 switch (howto->size)
2384 {
2385 case 0:
16a10388 2386 /* FIXME: overflow checks. */
4a335f3d
AM		 2387 if (howto->pc_relative)
2388 addend -= 1;
2389 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 2390 break;
2391 case 1:
2392 if (howto->pc_relative)
2393 addend -= 2;
2394 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 2395 break;
2396 case 2:
2397 if (howto->pc_relative)
2398 addend -= 4;
2399 bfd_put_32 (input_bfd, addend, where);
2400 break;
2401 }
f8df10f4 2402 }
252b5132
RH		 2403 }
2404 else
2405 {
560e09e9 2406 bfd_boolean warned;
ffb2e45b 2407
b2a8e766
AM		 2408 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2409 r_symndx, symtab_hdr, sym_hashes,
2410 h, sec, relocation,
2411 unresolved_reloc, warned);
252b5132
RH		 2412 }
2413
9635fe29
AM		 2414 if (r_symndx == 0)
2415 {
2416 /* r_symndx will be zero only for relocs against symbols from
2417 removed linkonce sections, or sections discarded by a linker
2418 script. For these relocs, we just want the section contents
2419 zeroed. Avoid any special processing in the switch below. */
2420 r_type = R_386_NONE;
2421
2422 relocation = 0;
2423 if (howto->pc_relative)
2424 relocation = (input_section->output_section->vma
2425 + input_section->output_offset
2426 + rel->r_offset);
2427 }
2428
252b5132
RH		 2429 switch (r_type)
2430 {
2431 case R_386_GOT32:
2432 /* Relocation is to the entry for this symbol in the global
2433 offset table. */
ffb2e45b
AM		 2434 if (htab->sgot == NULL)
2435 abort ();
252b5132
RH		 2436
2437 if (h != NULL)
2438 {
b34976b6 2439 bfd_boolean dyn;
252b5132
RH		 2440
2441 off = h->got.offset;
ebe50bae 2442 dyn = htab->elf.dynamic_sections_created;
26e41594 2443 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
252b5132 2444 || (info->shared
586119b3 2445 && SYMBOL_REFERENCES_LOCAL (info, h))
ef5aade5
L		 2446 || (ELF_ST_VISIBILITY (h->other)
2447 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 2448 {
2449 /* This is actually a static link, or it is a
2450 -Bsymbolic link and the symbol is defined
2451 locally, or the symbol was forced to be local
2452 because of a version file. We must initialize
2453 this entry in the global offset table. Since the
2454 offset must always be a multiple of 4, we use the
2455 least significant bit to record whether we have
2456 initialized it already.
2457
2458 When doing a dynamic link, we create a .rel.got
2459 relocation entry to initialize the value. This
2460 is done in the finish_dynamic_symbol routine. */
2461 if ((off & 1) != 0)
2462 off &= ~1;
2463 else
2464 {
2465 bfd_put_32 (output_bfd, relocation,
6725bdbf 2466 htab->sgot->contents + off);
252b5132
RH		 2467 h->got.offset |= 1;
2468 }
2469 }
8c694914 2470 else
b34976b6 2471 unresolved_reloc = FALSE;
252b5132
RH		 2472 }
2473 else
2474 {
ffb2e45b
AM		 2475 if (local_got_offsets == NULL)
2476 abort ();
252b5132
RH		 2477
2478 off = local_got_offsets[r_symndx];
2479
2480 /* The offset must always be a multiple of 4. We use
83be169b
AM		 2481 the least significant bit to record whether we have
2482 already generated the necessary reloc. */
252b5132
RH		 2483 if ((off & 1) != 0)
2484 off &= ~1;
2485 else
2486 {
6725bdbf
AM		 2487 bfd_put_32 (output_bfd, relocation,
2488 htab->sgot->contents + off);
252b5132
RH		 2489
2490 if (info->shared)
2491 {
947216bf
AM		 2492 asection *s;
2493 Elf_Internal_Rela outrel;
2494 bfd_byte *loc;
252b5132 2495
947216bf
AM		 2496 s = htab->srelgot;
2497 if (s == NULL)
ffb2e45b 2498 abort ();
252b5132 2499
6725bdbf
AM		 2500 outrel.r_offset = (htab->sgot->output_section->vma
2501 + htab->sgot->output_offset
252b5132
RH		 2502 + off);
2503 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
947216bf
AM		 2504 loc = s->contents;
2505 loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 2506 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2507 }
2508
2509 local_got_offsets[r_symndx] |= 1;
2510 }
252b5132
RH		 2511 }
2512
ffb2e45b
AM		 2513 if (off >= (bfd_vma) -2)
2514 abort ();
2515
8c37241b
JJ		 2516 relocation = htab->sgot->output_section->vma
2517 + htab->sgot->output_offset + off
2518 - htab->sgotplt->output_section->vma
2519 - htab->sgotplt->output_offset;
252b5132
RH		 2520 break;
2521
2522 case R_386_GOTOFF:
2523 /* Relocation is relative to the start of the global offset
2524 table. */
2525
90f487df
L		 2526 /* Check to make sure it isn't a protected function symbol
2527 for shared library since it may not be local when used
2528 as function address. */
2529 if (info->shared
8fe76924 2530 && !info->executable
90f487df
L		 2531 && h
2532 && h->def_regular
2533 && h->type == STT_FUNC
2534 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2535 {
2536 (*_bfd_error_handler)
2537 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2538 input_bfd, h->root.root.string);
2539 bfd_set_error (bfd_error_bad_value);
2540 return FALSE;
2541 }
2542
8c37241b
JJ		 2543 /* Note that sgot is not involved in this
2544 calculation. We always want the start of .got.plt. If we
2545 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
252b5132
RH		 2546 permitted by the ABI, we might have to change this
2547 calculation. */
8c37241b
JJ		 2548 relocation -= htab->sgotplt->output_section->vma
2549 + htab->sgotplt->output_offset;
252b5132
RH		 2550 break;
2551
2552 case R_386_GOTPC:
2553 /* Use global offset table as symbol value. */
8c37241b
JJ		 2554 relocation = htab->sgotplt->output_section->vma
2555 + htab->sgotplt->output_offset;
b34976b6 2556 unresolved_reloc = FALSE;
252b5132
RH		 2557 break;
2558
2559 case R_386_PLT32:
2560 /* Relocation is to the entry for this symbol in the
2561 procedure linkage table. */
2562
dd5724d5 2563 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 2564 without using the procedure linkage table. */
252b5132
RH		 2565 if (h == NULL)
2566 break;
2567
dd5724d5 2568 if (h->plt.offset == (bfd_vma) -1
6725bdbf 2569 || htab->splt == NULL)
252b5132
RH		 2570 {
2571 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 2572 happens when statically linking PIC code, or when
2573 using -Bsymbolic. */
252b5132
RH		 2574 break;
2575 }
2576
6725bdbf
AM		 2577 relocation = (htab->splt->output_section->vma
2578 + htab->splt->output_offset
252b5132 2579 + h->plt.offset);
b34976b6 2580 unresolved_reloc = FALSE;
252b5132
RH		 2581 break;
2582
2583 case R_386_32:
2584 case R_386_PC32:
f855931b 2585 if ((input_section->flags & SEC_ALLOC) == 0)
ec338859
AM		 2586 break;
2587
12d0ee4a 2588 if ((info->shared
ef5aade5
L		 2589 && (h == NULL
2590 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2591 || h->root.type != bfd_link_hash_undefweak)
12d0ee4a 2592 && (r_type != R_386_PC32
f6c52c13 2593 || !SYMBOL_CALLS_LOCAL (info, h)))
a23b6845
AM		 2594 || (ELIMINATE_COPY_RELOCS
2595 && !info->shared
12d0ee4a
AM		 2596 && h != NULL
2597 && h->dynindx != -1
f5385ebf
AM		 2598 && !h->non_got_ref
2599 && ((h->def_dynamic
2600 && !h->def_regular)
28d0b90e
AM		 2601 || h->root.type == bfd_link_hash_undefweak
2602 || h->root.type == bfd_link_hash_undefined)))
252b5132 2603 {
947216bf
AM		 2604 Elf_Internal_Rela outrel;
2605 bfd_byte *loc;
b34976b6 2606 bfd_boolean skip, relocate;
0c715baa 2607 asection *sreloc;
252b5132
RH		 2608
2609 /* When generating a shared object, these relocations
2610 are copied into the output file to be resolved at run
2611 time. */
2612
b34976b6
AM		 2613 skip = FALSE;
2614 relocate = FALSE;
252b5132 2615
c629eae0
JJ		 2616 outrel.r_offset =
2617 _bfd_elf_section_offset (output_bfd, info, input_section,
2618 rel->r_offset);
2619 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 2620 skip = TRUE;
0bb2d96a 2621 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 2622 skip = TRUE, relocate = TRUE;
252b5132
RH		 2623 outrel.r_offset += (input_section->output_section->vma
2624 + input_section->output_offset);
2625
2626 if (skip)
0bb2d96a 2627 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 2628 else if (h != NULL
2629 && h->dynindx != -1
2630 && (r_type == R_386_PC32
2631 || !info->shared
2632 || !info->symbolic
f5385ebf 2633 || !h->def_regular))
0bb2d96a 2634 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 2635 else
2636 {
5a15f56f 2637 /* This symbol is local, or marked to become local. */
b34976b6 2638 relocate = TRUE;
5a15f56f 2639 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 2640 }
2641
0c715baa
AM		 2642 sreloc = elf_section_data (input_section)->sreloc;
2643 if (sreloc == NULL)
2644 abort ();
2645
947216bf
AM		 2646 loc = sreloc->contents;
2647 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
0c715baa 2648 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2649
2650 /* If this reloc is against an external symbol, we do
2651 not want to fiddle with the addend. Otherwise, we
2652 need to include the symbol value so that it becomes
2653 an addend for the dynamic reloc. */
2654 if (! relocate)
2655 continue;
2656 }
252b5132
RH		 2657 break;
2658
37e55690
JJ		 2659 case R_386_TLS_IE:
2660 if (info->shared)
2661 {
947216bf
AM		 2662 Elf_Internal_Rela outrel;
2663 bfd_byte *loc;
37e55690 2664 asection *sreloc;
37e55690
JJ		 2665
2666 outrel.r_offset = rel->r_offset
2667 + input_section->output_section->vma
2668 + input_section->output_offset;
2669 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2670 sreloc = elf_section_data (input_section)->sreloc;
2671 if (sreloc == NULL)
2672 abort ();
947216bf
AM		 2673 loc = sreloc->contents;
2674 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
37e55690
JJ		 2675 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2676 }
2677 /* Fall through */
2678
13ae64f3 2679 case R_386_TLS_GD:
67a4f2b7
AO		 2680 case R_386_TLS_GOTDESC:
2681 case R_386_TLS_DESC_CALL:
13ae64f3 2682 case R_386_TLS_IE_32:
37e55690 2683 case R_386_TLS_GOTIE:
13ae64f3
JJ		 2684 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2685 tls_type = GOT_UNKNOWN;
2686 if (h == NULL && local_got_offsets)
2687 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2688 else if (h != NULL)
2689 {
2690 tls_type = elf_i386_hash_entry(h)->tls_type;
37e55690 2691 if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
13ae64f3
JJ		 2692 r_type = R_386_TLS_LE_32;
2693 }
37e55690
JJ		 2694 if (tls_type == GOT_TLS_IE)
2695 tls_type = GOT_TLS_IE_NEG;
67a4f2b7
AO		 2696 if (r_type == R_386_TLS_GD
2697 || r_type == R_386_TLS_GOTDESC
2698 || r_type == R_386_TLS_DESC_CALL)
37e55690
JJ		 2699 {
2700 if (tls_type == GOT_TLS_IE_POS)
2701 r_type = R_386_TLS_GOTIE;
2702 else if (tls_type & GOT_TLS_IE)
2703 r_type = R_386_TLS_IE_32;
2704 }
13ae64f3
JJ		 2705
2706 if (r_type == R_386_TLS_LE_32)
2707 {
82e51918 2708 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2709 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2710 {
2711 unsigned int val, type;
2712 bfd_vma roff;
2713
2714 /* GD->LE transition. */
2715 BFD_ASSERT (rel->r_offset >= 2);
2716 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2717 BFD_ASSERT (type == 0x8d || type == 0x04);
eea6121a 2718 BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
13ae64f3
JJ		 2719 BFD_ASSERT (bfd_get_8 (input_bfd,
2720 contents + rel->r_offset + 4)
2721 == 0xe8);
2722 BFD_ASSERT (rel + 1 < relend);
2723 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2724 roff = rel->r_offset + 5;
2725 val = bfd_get_8 (input_bfd,
2726 contents + rel->r_offset - 1);
2727 if (type == 0x04)
2728 {
2729 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2730 Change it into:
2731 movl %gs:0, %eax; subl $foo@tpoff, %eax
2732 (6 byte form of subl). */
2733 BFD_ASSERT (rel->r_offset >= 3);
2734 BFD_ASSERT (bfd_get_8 (input_bfd,
2735 contents + rel->r_offset - 3)
2736 == 0x8d);
2737 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2738 memcpy (contents + rel->r_offset - 3,
2739 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2740 }
2741 else
2742 {
2743 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
eea6121a 2744 if (rel->r_offset + 10 <= input_section->size
13ae64f3
JJ		 2745 && bfd_get_8 (input_bfd,
2746 contents + rel->r_offset + 9) == 0x90)
2747 {
2748 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2749 Change it into:
2750 movl %gs:0, %eax; subl $foo@tpoff, %eax
2751 (6 byte form of subl). */
2752 memcpy (contents + rel->r_offset - 2,
2753 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2754 roff = rel->r_offset + 6;
2755 }
2756 else
2757 {
2758 /* leal foo(%reg), %eax; call ___tls_get_addr
2759 Change it into:
2760 movl %gs:0, %eax; subl $foo@tpoff, %eax
2761 (5 byte form of subl). */
2762 memcpy (contents + rel->r_offset - 2,
2763 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2764 }
2765 }
2766 bfd_put_32 (output_bfd, tpoff (info, relocation),
2767 contents + roff);
2768 /* Skip R_386_PLT32. */
2769 rel++;
2770 continue;
2771 }
67a4f2b7
AO		 2772 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
2773 {
2774 /* GDesc -> LE transition.
2775 It's originally something like:
2776 leal x@tlsdesc(%ebx), %eax
2777
2778 leal x@ntpoff, %eax
2779
2780 Registers other than %eax may be set up here. */
2781
2782 unsigned int val, type;
2783 bfd_vma roff;
2784
2785 /* First, make sure it's a leal adding ebx to a
2786 32-bit offset into any register, although it's
2787 probably almost always going to be eax. */
2788 roff = rel->r_offset;
2789 BFD_ASSERT (roff >= 2);
2790 type = bfd_get_8 (input_bfd, contents + roff - 2);
2791 BFD_ASSERT (type == 0x8d);
2792 val = bfd_get_8 (input_bfd, contents + roff - 1);
2793 BFD_ASSERT ((val & 0xc7) == 0x83);
2794 BFD_ASSERT (roff + 4 <= input_section->size);
2795
2796 /* Now modify the instruction as appropriate. */
2797 /* aoliva FIXME: remove the above and xor the byte
2798 below with 0x86. */
2799 bfd_put_8 (output_bfd, val ^ 0x86,
2800 contents + roff - 1);
2801 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2802 contents + roff);
2803 continue;
2804 }
2805 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
2806 {
2807 /* GDesc -> LE transition.
2808 It's originally:
2809 call *(%eax)
2810 Turn it into:
2811 nop; nop */
2812
2813 unsigned int val, type;
2814 bfd_vma roff;
2815
2816 /* First, make sure it's a call *(%eax). */
2817 roff = rel->r_offset;
2818 BFD_ASSERT (roff + 2 <= input_section->size);
2819 type = bfd_get_8 (input_bfd, contents + roff);
2820 BFD_ASSERT (type == 0xff);
2821 val = bfd_get_8 (input_bfd, contents + roff + 1);
2822 BFD_ASSERT (val == 0x10);
2823
10efb593
L		 2824 /* Now modify the instruction as appropriate. Use
2825 xchg %ax,%ax instead of 2 nops. */
2826 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 2827 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
2828 continue;
2829 }
37e55690 2830 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
13ae64f3
JJ		 2831 {
2832 unsigned int val, type;
2833
2834 /* IE->LE transition:
37e55690
JJ		 2835 Originally it can be one of:
2836 movl foo, %eax
2837 movl foo, %reg
2838 addl foo, %reg
2839 We change it into:
2840 movl $foo, %eax
2841 movl $foo, %reg
2842 addl $foo, %reg. */
2843 BFD_ASSERT (rel->r_offset >= 1);
2844 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
eea6121a 2845 BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
37e55690
JJ		 2846 if (val == 0xa1)
2847 {
2848 /* movl foo, %eax. */
55fd94b0
AM		 2849 bfd_put_8 (output_bfd, 0xb8,
2850 contents + rel->r_offset - 1);
37e55690 2851 }
299bf759 2852 else
37e55690 2853 {
299bf759 2854 BFD_ASSERT (rel->r_offset >= 2);
55fd94b0
AM		 2855 type = bfd_get_8 (input_bfd,
2856 contents + rel->r_offset - 2);
299bf759 2857 switch (type)
26e41594 2858 {
299bf759
L		 2859 case 0x8b:
2860 /* movl */
2861 BFD_ASSERT ((val & 0xc7) == 0x05);
2862 bfd_put_8 (output_bfd, 0xc7,
2863 contents + rel->r_offset - 2);
2864 bfd_put_8 (output_bfd,
2865 0xc0 | ((val >> 3) & 7),
2866 contents + rel->r_offset - 1);
2867 break;
2868 case 0x03:
2869 /* addl */
2870 BFD_ASSERT ((val & 0xc7) == 0x05);
2871 bfd_put_8 (output_bfd, 0x81,
2872 contents + rel->r_offset - 2);
2873 bfd_put_8 (output_bfd,
2874 0xc0 | ((val >> 3) & 7),
2875 contents + rel->r_offset - 1);
2876 break;
2877 default:
2878 BFD_FAIL ();
2879 break;
26e41594 2880 }
37e55690 2881 }
37e55690
JJ		 2882 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2883 contents + rel->r_offset);
2884 continue;
2885 }
2886 else
2887 {
2888 unsigned int val, type;
2889
2890 /* {IE_32,GOTIE}->LE transition:
2891 Originally it can be one of:
13ae64f3 2892 subl foo(%reg1), %reg2
13ae64f3 2893 movl foo(%reg1), %reg2
37e55690 2894 addl foo(%reg1), %reg2
13ae64f3
JJ		 2895 We change it into:
2896 subl $foo, %reg2
37e55690
JJ		 2897 movl $foo, %reg2 (6 byte form)
2898 addl $foo, %reg2. */
13ae64f3
JJ		 2899 BFD_ASSERT (rel->r_offset >= 2);
2900 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2901 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
eea6121a 2902 BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
37e55690 2903 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
13ae64f3
JJ		 2904 if (type == 0x8b)
2905 {
2906 /* movl */
13ae64f3
JJ		 2907 bfd_put_8 (output_bfd, 0xc7,
2908 contents + rel->r_offset - 2);
2909 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2910 contents + rel->r_offset - 1);
2911 }
2912 else if (type == 0x2b)
2913 {
2914 /* subl */
13ae64f3
JJ		 2915 bfd_put_8 (output_bfd, 0x81,
2916 contents + rel->r_offset - 2);
2917 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2918 contents + rel->r_offset - 1);
2919 }
37e55690
JJ		 2920 else if (type == 0x03)
2921 {
2922 /* addl */
2923 bfd_put_8 (output_bfd, 0x81,
2924 contents + rel->r_offset - 2);
2925 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2926 contents + rel->r_offset - 1);
2927 }
13ae64f3
JJ		 2928 else
2929 BFD_FAIL ();
37e55690
JJ		 2930 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2931 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2932 contents + rel->r_offset);
2933 else
2934 bfd_put_32 (output_bfd, tpoff (info, relocation),
2935 contents + rel->r_offset);
13ae64f3
JJ		 2936 continue;
2937 }
2938 }
2939
2940 if (htab->sgot == NULL)
2941 abort ();
2942
2943 if (h != NULL)
67a4f2b7
AO		 2944 {
2945 off = h->got.offset;
2946 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
2947 }
13ae64f3
JJ		 2948 else
2949 {
2950 if (local_got_offsets == NULL)
2951 abort ();
2952
2953 off = local_got_offsets[r_symndx];
67a4f2b7 2954 offplt = local_tlsdesc_gotents[r_symndx];
13ae64f3
JJ		 2955 }
2956
2957 if ((off & 1) != 0)
2958 off &= ~1;
26e41594 2959 else
13ae64f3 2960 {
947216bf
AM		 2961 Elf_Internal_Rela outrel;
2962 bfd_byte *loc;
13ae64f3 2963 int dr_type, indx;
67a4f2b7 2964 asection *sreloc;
13ae64f3
JJ		 2965
2966 if (htab->srelgot == NULL)
2967 abort ();
2968
67a4f2b7
AO		 2969 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2970
2971 if (GOT_TLS_GDESC_P (tls_type))
2972 {
2973 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
2974 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
2975 <= htab->sgotplt->size);
2976 outrel.r_offset = (htab->sgotplt->output_section->vma
2977 + htab->sgotplt->output_offset
2978 + offplt
2979 + htab->sgotplt_jump_table_size);
2980 sreloc = htab->srelplt;
2981 loc = sreloc->contents;
5ae0bfb6
RS		 2982 loc += (htab->next_tls_desc_index++
2983 * sizeof (Elf32_External_Rel));
67a4f2b7
AO		 2984 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
2985 <= sreloc->contents + sreloc->size);
2986 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2987 if (indx == 0)
2988 {
2989 BFD_ASSERT (! unresolved_reloc);
2990 bfd_put_32 (output_bfd,
2991 relocation - dtpoff_base (info),
2992 htab->sgotplt->contents + offplt
2993 + htab->sgotplt_jump_table_size + 4);
2994 }
2995 else
2996 {
2997 bfd_put_32 (output_bfd, 0,
2998 htab->sgotplt->contents + offplt
2999 + htab->sgotplt_jump_table_size + 4);
3000 }
3001 }
3002
3003 sreloc = htab->srelgot;
3004
13ae64f3
JJ		 3005 outrel.r_offset = (htab->sgot->output_section->vma
3006 + htab->sgot->output_offset + off);
3007
67a4f2b7 3008 if (GOT_TLS_GD_P (tls_type))
13ae64f3 3009 dr_type = R_386_TLS_DTPMOD32;
67a4f2b7
AO		 3010 else if (GOT_TLS_GDESC_P (tls_type))
3011 goto dr_done;
37e55690
JJ		 3012 else if (tls_type == GOT_TLS_IE_POS)
3013 dr_type = R_386_TLS_TPOFF;
13ae64f3
JJ		 3014 else
3015 dr_type = R_386_TLS_TPOFF32;
67a4f2b7 3016
37e55690
JJ		 3017 if (dr_type == R_386_TLS_TPOFF && indx == 0)
3018 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3019 htab->sgot->contents + off);
3020 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
c5c1f40c 3021 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
c366c25e 3022 htab->sgot->contents + off);
67a4f2b7 3023 else if (dr_type != R_386_TLS_DESC)
c366c25e
JJ		 3024 bfd_put_32 (output_bfd, 0,
3025 htab->sgot->contents + off);
13ae64f3 3026 outrel.r_info = ELF32_R_INFO (indx, dr_type);
67a4f2b7
AO		 3027
3028 loc = sreloc->contents;
3029 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3030 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3031 <= sreloc->contents + sreloc->size);
13ae64f3
JJ		 3032 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3033
67a4f2b7 3034 if (GOT_TLS_GD_P (tls_type))
13ae64f3
JJ		 3035 {
3036 if (indx == 0)
3037 {
82e51918 3038 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 3039 bfd_put_32 (output_bfd,
3040 relocation - dtpoff_base (info),
3041 htab->sgot->contents + off + 4);
3042 }
3043 else
3044 {
3045 bfd_put_32 (output_bfd, 0,
3046 htab->sgot->contents + off + 4);
3047 outrel.r_info = ELF32_R_INFO (indx,
3048 R_386_TLS_DTPOFF32);
3049 outrel.r_offset += 4;
67a4f2b7 3050 sreloc->reloc_count++;
947216bf 3051 loc += sizeof (Elf32_External_Rel);
67a4f2b7
AO		 3052 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3053 <= sreloc->contents + sreloc->size);
947216bf 3054 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
13ae64f3
JJ		 3055 }
3056 }
37e55690
JJ		 3057 else if (tls_type == GOT_TLS_IE_BOTH)
3058 {
3059 bfd_put_32 (output_bfd,
3060 indx == 0 ? relocation - dtpoff_base (info) : 0,
3061 htab->sgot->contents + off + 4);
3062 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3063 outrel.r_offset += 4;
67a4f2b7 3064 sreloc->reloc_count++;
947216bf 3065 loc += sizeof (Elf32_External_Rel);
37e55690
JJ		 3066 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3067 }
13ae64f3 3068
67a4f2b7 3069 dr_done:
13ae64f3
JJ		 3070 if (h != NULL)
3071 h->got.offset |= 1;
3072 else
3073 local_got_offsets[r_symndx] |= 1;
3074 }
3075
67a4f2b7
AO		 3076 if (off >= (bfd_vma) -2
3077 && ! GOT_TLS_GDESC_P (tls_type))
13ae64f3 3078 abort ();
67a4f2b7
AO		 3079 if (r_type == R_386_TLS_GOTDESC
3080 || r_type == R_386_TLS_DESC_CALL)
3081 {
3082 relocation = htab->sgotplt_jump_table_size + offplt;
3083 unresolved_reloc = FALSE;
3084 }
3085 else if (r_type == ELF32_R_TYPE (rel->r_info))
13ae64f3 3086 {
8c37241b
JJ		 3087 bfd_vma g_o_t = htab->sgotplt->output_section->vma
3088 + htab->sgotplt->output_offset;
3089 relocation = htab->sgot->output_section->vma
67a4f2b7 3090 + htab->sgot->output_offset + off - g_o_t;
37e55690
JJ		 3091 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
3092 && tls_type == GOT_TLS_IE_BOTH)
3093 relocation += 4;
3094 if (r_type == R_386_TLS_IE)
8c37241b 3095 relocation += g_o_t;
b34976b6 3096 unresolved_reloc = FALSE;
13ae64f3 3097 }
67a4f2b7 3098 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
13ae64f3
JJ		 3099 {
3100 unsigned int val, type;
3101 bfd_vma roff;
3102
3103 /* GD->IE transition. */
3104 BFD_ASSERT (rel->r_offset >= 2);
3105 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3106 BFD_ASSERT (type == 0x8d || type == 0x04);
eea6121a 3107 BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
13ae64f3
JJ		 3108 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
3109 == 0xe8);
3110 BFD_ASSERT (rel + 1 < relend);
3111 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
3112 roff = rel->r_offset - 3;
3113 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3114 if (type == 0x04)
3115 {
3116 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3117 Change it into:
3118 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
3119 BFD_ASSERT (rel->r_offset >= 3);
3120 BFD_ASSERT (bfd_get_8 (input_bfd,
3121 contents + rel->r_offset - 3)
3122 == 0x8d);
3123 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
3124 val >>= 3;
3125 }
3126 else
3127 {
3128 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3129 Change it into:
3130 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
eea6121a 3131 BFD_ASSERT (rel->r_offset + 10 <= input_section->size);
13ae64f3
JJ		 3132 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
3133 BFD_ASSERT (bfd_get_8 (input_bfd,
3134 contents + rel->r_offset + 9)
3135 == 0x90);
3136 roff = rel->r_offset - 2;
3137 }
3138 memcpy (contents + roff,
3139 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3140 contents[roff + 7] = 0x80 | (val & 7);
37e55690
JJ		 3141 /* If foo is used only with foo@gotntpoff(%reg) and
3142 foo@indntpoff, but not with foo@gottpoff(%reg), change
3143 subl $foo@gottpoff(%reg), %eax
3144 into:
3145 addl $foo@gotntpoff(%reg), %eax. */
ebcfb3c0
JJ		 3146 if (tls_type == GOT_TLS_IE_POS)
3147 contents[roff + 6] = 0x03;
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 {
10efb593
L		 3231 /* xchg %ax,%ax */
3232 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 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
fdc90cb4
JJ		 3842/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
3843
3844static bfd_boolean
3845elf_i386_hash_symbol (struct elf_link_hash_entry *h)
3846{
3847 if (h->plt.offset != (bfd_vma) -1
3848 && !h->def_regular
3849 && !h->pointer_equality_needed)
3850 return FALSE;
3851
3852 return _bfd_elf_hash_symbol (h);
3853}
4c45e5c9 3854
252b5132
RH		 3855#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3856#define TARGET_LITTLE_NAME "elf32-i386"
3857#define ELF_ARCH bfd_arch_i386
3858#define ELF_MACHINE_CODE EM_386
3859#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 3860
3861#define elf_backend_can_gc_sections 1
51b64d56 3862#define elf_backend_can_refcount 1
252b5132
RH		 3863#define elf_backend_want_got_plt 1
3864#define elf_backend_plt_readonly 1
3865#define elf_backend_want_plt_sym 0
3866#define elf_backend_got_header_size 12
252b5132 3867
8c29f035
AM		 3868/* Support RELA for objdump of prelink objects. */
3869#define elf_info_to_howto elf_i386_info_to_howto_rel
dd5724d5
AM		 3870#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3871
13ae64f3 3872#define bfd_elf32_mkobject elf_i386_mkobject
13ae64f3 3873
dd5724d5
AM		 3874#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3875#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3876#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3877
3878#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3879#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 3880#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 3881#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 3882#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 3883#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3884#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3885#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3886#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
c5fccbec
DJ		 3887#define elf_backend_grok_prstatus elf_i386_grok_prstatus
3888#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 3889#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 3890#define elf_backend_relocate_section elf_i386_relocate_section
3891#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
67a4f2b7 3892#define elf_backend_always_size_sections elf_i386_always_size_sections
4c45e5c9 3893#define elf_backend_plt_sym_val elf_i386_plt_sym_val
fdc90cb4 3894#define elf_backend_hash_symbol elf_i386_hash_symbol
dd5724d5 3895
252b5132 3896#include "elf32-target.h"
2bc3c89a
AM		 3897
3898/* FreeBSD support. */
3899
3900#undef TARGET_LITTLE_SYM
3901#define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
3902#undef TARGET_LITTLE_NAME
3903#define TARGET_LITTLE_NAME "elf32-i386-freebsd"
3904
3905/* The kernel recognizes executables as valid only if they carry a
3906 "FreeBSD" label in the ELF header. So we put this label on all
3907 executables and (for simplicity) also all other object files. */
3908
2bc3c89a 3909static void
55fd94b0
AM		 3910elf_i386_post_process_headers (bfd *abfd,
3911 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2bc3c89a
AM		 3912{
3913 Elf_Internal_Ehdr *i_ehdrp;
3914
3915 i_ehdrp = elf_elfheader (abfd);
3916
3917 /* Put an ABI label supported by FreeBSD >= 4.1. */
3918 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3919#ifdef OLD_FREEBSD_ABI_LABEL
3920 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
3921 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
caf47ea6 3922#endif
2bc3c89a
AM		 3923}
3924
3925#undef elf_backend_post_process_headers
571fe01f
NC		 3926#define elf_backend_post_process_headers elf_i386_post_process_headers
3927#undef elf32_bed
3928#define elf32_bed elf32_i386_fbsd_bed
2bc3c89a
AM		 3929
3930#include "elf32-target.h"
eac338cf
PB		 3931
3932/* VxWorks support. */
3933
3934#undef TARGET_LITTLE_SYM
3935#define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
3936#undef TARGET_LITTLE_NAME
3937#define TARGET_LITTLE_NAME "elf32-i386-vxworks"
3938
3939
3940/* Like elf_i386_link_hash_table_create but with tweaks for VxWorks. */
3941
3942static struct bfd_link_hash_table *
3943elf_i386_vxworks_link_hash_table_create (bfd *abfd)
3944{
3945 struct bfd_link_hash_table *ret;
3946 struct elf_i386_link_hash_table *htab;
3947
3948 ret = elf_i386_link_hash_table_create (abfd);
3949 if (ret)
3950 {
3951 htab = (struct elf_i386_link_hash_table *) ret;
3952 htab->is_vxworks = 1;
3953 htab->plt0_pad_byte = 0x90;
3954 }
3955
3956 return ret;
3957}
3958
3959
eac338cf
PB		 3960#undef elf_backend_post_process_headers
3961#undef bfd_elf32_bfd_link_hash_table_create
3962#define bfd_elf32_bfd_link_hash_table_create \
3963 elf_i386_vxworks_link_hash_table_create
3964#undef elf_backend_add_symbol_hook
3965#define elf_backend_add_symbol_hook \
3966 elf_vxworks_add_symbol_hook
3967#undef elf_backend_link_output_symbol_hook
3968#define elf_backend_link_output_symbol_hook \
9c72ff84 3969 elf_vxworks_link_output_symbol_hook
eac338cf
PB		 3970#undef elf_backend_emit_relocs
3971#define elf_backend_emit_relocs elf_vxworks_emit_relocs
3972#undef elf_backend_final_write_processing
3973#define elf_backend_final_write_processing \
3974 elf_vxworks_final_write_processing
3975
3976/* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
3977 define it. */
3978#undef elf_backend_want_plt_sym
3979#define elf_backend_want_plt_sym 1
3980
3981#undef elf32_bed
3982#define elf32_bed elf32_i386_vxworks_bed
3983
3984#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.578194 seconds and 4 git commands to generate.