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