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