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
4b95cf5c 2 Copyright (C) 1993-2014 Free Software Foundation, Inc.
252b5132 3
571fe01f 4 This file is part of BFD, the Binary File Descriptor library.
252b5132 5
571fe01f
NC		 6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
cd123cb7 8 the Free Software Foundation; either version 3 of the License, or
571fe01f 9 (at your option) any later version.
252b5132 10
571fe01f
NC		 11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
252b5132 15
571fe01f
NC		 16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
cd123cb7
NC		 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
252b5132 20
252b5132 21#include "sysdep.h"
3db64b00 22#include "bfd.h"
252b5132
RH		 23#include "bfdlink.h"
24#include "libbfd.h"
25#include "elf-bfd.h"
5a68afcf 26#include "elf-nacl.h"
eac338cf 27#include "elf-vxworks.h"
142411ca 28#include "bfd_stdint.h"
c25bc9fc
L		 29#include "objalloc.h"
30#include "hashtab.h"
e41b3a13 31#include "dwarf2.h"
252b5132 32
55fd94b0
AM		 33/* 386 uses REL relocations instead of RELA. */
34#define USE_REL 1
252b5132
RH		 35
36#include "elf/i386.h"
37
38static reloc_howto_type elf_howto_table[]=
39{
b34976b6 40 HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
1b452ec6 41 bfd_elf_generic_reloc, "R_386_NONE",
b34976b6
AM		 42 TRUE, 0x00000000, 0x00000000, FALSE),
43 HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 44 bfd_elf_generic_reloc, "R_386_32",
b34976b6
AM		 45 TRUE, 0xffffffff, 0xffffffff, FALSE),
46 HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 47 bfd_elf_generic_reloc, "R_386_PC32",
b34976b6
AM		 48 TRUE, 0xffffffff, 0xffffffff, TRUE),
49 HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 50 bfd_elf_generic_reloc, "R_386_GOT32",
b34976b6
AM		 51 TRUE, 0xffffffff, 0xffffffff, FALSE),
52 HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 53 bfd_elf_generic_reloc, "R_386_PLT32",
b34976b6
AM		 54 TRUE, 0xffffffff, 0xffffffff, TRUE),
55 HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 56 bfd_elf_generic_reloc, "R_386_COPY",
b34976b6
AM		 57 TRUE, 0xffffffff, 0xffffffff, FALSE),
58 HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 59 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
b34976b6
AM		 60 TRUE, 0xffffffff, 0xffffffff, FALSE),
61 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 62 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
b34976b6
AM		 63 TRUE, 0xffffffff, 0xffffffff, FALSE),
64 HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 65 bfd_elf_generic_reloc, "R_386_RELATIVE",
b34976b6
AM		 66 TRUE, 0xffffffff, 0xffffffff, FALSE),
67 HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 68 bfd_elf_generic_reloc, "R_386_GOTOFF",
b34976b6
AM		 69 TRUE, 0xffffffff, 0xffffffff, FALSE),
70 HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 71 bfd_elf_generic_reloc, "R_386_GOTPC",
b34976b6 72 TRUE, 0xffffffff, 0xffffffff, TRUE),
1b452ec6 73
dc47f327
AM		 74 /* We have a gap in the reloc numbers here.
75 R_386_standard counts the number up to this point, and
76 R_386_ext_offset is the value to subtract from a reloc type of
77 R_386_16 thru R_386_PC8 to form an index into this table. */
55fd94b0
AM		 78#define R_386_standard (R_386_GOTPC + 1)
79#define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
1b452ec6 80
37e55690 81 /* These relocs are a GNU extension. */
b34976b6 82 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 83 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
b34976b6
AM		 84 TRUE, 0xffffffff, 0xffffffff, FALSE),
85 HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 86 bfd_elf_generic_reloc, "R_386_TLS_IE",
b34976b6
AM		 87 TRUE, 0xffffffff, 0xffffffff, FALSE),
88 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 89 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
b34976b6
AM		 90 TRUE, 0xffffffff, 0xffffffff, FALSE),
91 HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 92 bfd_elf_generic_reloc, "R_386_TLS_LE",
b34976b6
AM		 93 TRUE, 0xffffffff, 0xffffffff, FALSE),
94 HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 95 bfd_elf_generic_reloc, "R_386_TLS_GD",
b34976b6
AM		 96 TRUE, 0xffffffff, 0xffffffff, FALSE),
97 HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 98 bfd_elf_generic_reloc, "R_386_TLS_LDM",
b34976b6
AM		 99 TRUE, 0xffffffff, 0xffffffff, FALSE),
100 HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
1b452ec6 101 bfd_elf_generic_reloc, "R_386_16",
b34976b6 102 TRUE, 0xffff, 0xffff, FALSE),
b0360d8c 103 HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
1b452ec6 104 bfd_elf_generic_reloc, "R_386_PC16",
b34976b6
AM		 105 TRUE, 0xffff, 0xffff, TRUE),
106 HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
1b452ec6 107 bfd_elf_generic_reloc, "R_386_8",
b34976b6
AM		 108 TRUE, 0xff, 0xff, FALSE),
109 HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
1b452ec6 110 bfd_elf_generic_reloc, "R_386_PC8",
b34976b6 111 TRUE, 0xff, 0xff, TRUE),
dc47f327 112
55fd94b0
AM		 113#define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
114#define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
13ae64f3 115 /* These are common with Solaris TLS implementation. */
b34976b6 116 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 117 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
b34976b6
AM		 118 TRUE, 0xffffffff, 0xffffffff, FALSE),
119 HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 120 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
b34976b6
AM		 121 TRUE, 0xffffffff, 0xffffffff, FALSE),
122 HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 123 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
b34976b6
AM		 124 TRUE, 0xffffffff, 0xffffffff, FALSE),
125 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 126 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
b34976b6
AM		 127 TRUE, 0xffffffff, 0xffffffff, FALSE),
128 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 129 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
b34976b6
AM		 130 TRUE, 0xffffffff, 0xffffffff, FALSE),
131 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 132 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
b34976b6 133 TRUE, 0xffffffff, 0xffffffff, FALSE),
1788fc08
L		 134 HOWTO(R_386_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
135 bfd_elf_generic_reloc, "R_386_SIZE32",
136 TRUE, 0xffffffff, 0xffffffff, FALSE),
67a4f2b7
AO		 137 HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
138 bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
139 TRUE, 0xffffffff, 0xffffffff, FALSE),
140 HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
141 bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
142 FALSE, 0, 0, FALSE),
143 HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
144 bfd_elf_generic_reloc, "R_386_TLS_DESC",
145 TRUE, 0xffffffff, 0xffffffff, FALSE),
cbe950e9
L		 146 HOWTO(R_386_IRELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
147 bfd_elf_generic_reloc, "R_386_IRELATIVE",
148 TRUE, 0xffffffff, 0xffffffff, FALSE),
13ae64f3
JJ		 149
150 /* Another gap. */
cbe950e9
L		 151#define R_386_irelative (R_386_IRELATIVE + 1 - R_386_tls_offset)
152#define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_irelative)
252b5132
RH		 153
154/* GNU extension to record C++ vtable hierarchy. */
252b5132
RH		 155 HOWTO (R_386_GNU_VTINHERIT, /* type */
156 0, /* rightshift */
157 2, /* size (0 = byte, 1 = short, 2 = long) */
158 0, /* bitsize */
b34976b6 159 FALSE, /* pc_relative */
252b5132
RH		 160 0, /* bitpos */
161 complain_overflow_dont, /* complain_on_overflow */
162 NULL, /* special_function */
163 "R_386_GNU_VTINHERIT", /* name */
b34976b6 164 FALSE, /* partial_inplace */
252b5132
RH		 165 0, /* src_mask */
166 0, /* dst_mask */
b34976b6 167 FALSE), /* pcrel_offset */
252b5132
RH		 168
169/* GNU extension to record C++ vtable member usage. */
252b5132
RH		 170 HOWTO (R_386_GNU_VTENTRY, /* type */
171 0, /* rightshift */
172 2, /* size (0 = byte, 1 = short, 2 = long) */
173 0, /* bitsize */
b34976b6 174 FALSE, /* pc_relative */
252b5132
RH		 175 0, /* bitpos */
176 complain_overflow_dont, /* complain_on_overflow */
177 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
178 "R_386_GNU_VTENTRY", /* name */
b34976b6 179 FALSE, /* partial_inplace */
252b5132
RH		 180 0, /* src_mask */
181 0, /* dst_mask */
b34976b6 182 FALSE) /* pcrel_offset */
dc47f327 183
55fd94b0 184#define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
dc47f327
AM		 185
186};
187
252b5132 188#ifdef DEBUG_GEN_RELOC
55fd94b0
AM		 189#define TRACE(str) \
190 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
252b5132
RH		 191#else
192#define TRACE(str)
193#endif
194
195static reloc_howto_type *
55fd94b0
AM		 196elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
197 bfd_reloc_code_real_type code)
252b5132
RH		 198{
199 switch (code)
200 {
201 case BFD_RELOC_NONE:
202 TRACE ("BFD_RELOC_NONE");
55fd94b0 203 return &elf_howto_table[R_386_NONE];
252b5132
RH		 204
205 case BFD_RELOC_32:
206 TRACE ("BFD_RELOC_32");
55fd94b0 207 return &elf_howto_table[R_386_32];
252b5132
RH		 208
209 case BFD_RELOC_CTOR:
210 TRACE ("BFD_RELOC_CTOR");
55fd94b0 211 return &elf_howto_table[R_386_32];
252b5132
RH		 212
213 case BFD_RELOC_32_PCREL:
214 TRACE ("BFD_RELOC_PC32");
55fd94b0 215 return &elf_howto_table[R_386_PC32];
252b5132
RH		 216
217 case BFD_RELOC_386_GOT32:
218 TRACE ("BFD_RELOC_386_GOT32");
55fd94b0 219 return &elf_howto_table[R_386_GOT32];
252b5132
RH		 220
221 case BFD_RELOC_386_PLT32:
222 TRACE ("BFD_RELOC_386_PLT32");
55fd94b0 223 return &elf_howto_table[R_386_PLT32];
252b5132
RH		 224
225 case BFD_RELOC_386_COPY:
226 TRACE ("BFD_RELOC_386_COPY");
55fd94b0 227 return &elf_howto_table[R_386_COPY];
252b5132
RH		 228
229 case BFD_RELOC_386_GLOB_DAT:
230 TRACE ("BFD_RELOC_386_GLOB_DAT");
55fd94b0 231 return &elf_howto_table[R_386_GLOB_DAT];
252b5132
RH		 232
233 case BFD_RELOC_386_JUMP_SLOT:
234 TRACE ("BFD_RELOC_386_JUMP_SLOT");
55fd94b0 235 return &elf_howto_table[R_386_JUMP_SLOT];
252b5132
RH		 236
237 case BFD_RELOC_386_RELATIVE:
238 TRACE ("BFD_RELOC_386_RELATIVE");
55fd94b0 239 return &elf_howto_table[R_386_RELATIVE];
252b5132
RH		 240
241 case BFD_RELOC_386_GOTOFF:
242 TRACE ("BFD_RELOC_386_GOTOFF");
55fd94b0 243 return &elf_howto_table[R_386_GOTOFF];
252b5132
RH		 244
245 case BFD_RELOC_386_GOTPC:
246 TRACE ("BFD_RELOC_386_GOTPC");
55fd94b0 247 return &elf_howto_table[R_386_GOTPC];
252b5132 248
37e55690
JJ		 249 /* These relocs are a GNU extension. */
250 case BFD_RELOC_386_TLS_TPOFF:
251 TRACE ("BFD_RELOC_386_TLS_TPOFF");
55fd94b0 252 return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
37e55690
JJ		 253
254 case BFD_RELOC_386_TLS_IE:
255 TRACE ("BFD_RELOC_386_TLS_IE");
55fd94b0 256 return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
37e55690
JJ		 257
258 case BFD_RELOC_386_TLS_GOTIE:
259 TRACE ("BFD_RELOC_386_TLS_GOTIE");
55fd94b0 260 return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
37e55690 261
13ae64f3
JJ		 262 case BFD_RELOC_386_TLS_LE:
263 TRACE ("BFD_RELOC_386_TLS_LE");
55fd94b0 264 return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
13ae64f3
JJ		 265
266 case BFD_RELOC_386_TLS_GD:
267 TRACE ("BFD_RELOC_386_TLS_GD");
55fd94b0 268 return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
13ae64f3
JJ		 269
270 case BFD_RELOC_386_TLS_LDM:
271 TRACE ("BFD_RELOC_386_TLS_LDM");
55fd94b0 272 return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
13ae64f3 273
252b5132
RH		 274 case BFD_RELOC_16:
275 TRACE ("BFD_RELOC_16");
55fd94b0 276 return &elf_howto_table[R_386_16 - R_386_ext_offset];
252b5132
RH		 277
278 case BFD_RELOC_16_PCREL:
279 TRACE ("BFD_RELOC_16_PCREL");
55fd94b0 280 return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
252b5132
RH		 281
282 case BFD_RELOC_8:
283 TRACE ("BFD_RELOC_8");
55fd94b0 284 return &elf_howto_table[R_386_8 - R_386_ext_offset];
252b5132
RH		 285
286 case BFD_RELOC_8_PCREL:
287 TRACE ("BFD_RELOC_8_PCREL");
55fd94b0 288 return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
252b5132 289
13ae64f3
JJ		 290 /* Common with Sun TLS implementation. */
291 case BFD_RELOC_386_TLS_LDO_32:
292 TRACE ("BFD_RELOC_386_TLS_LDO_32");
55fd94b0 293 return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
13ae64f3
JJ		 294
295 case BFD_RELOC_386_TLS_IE_32:
296 TRACE ("BFD_RELOC_386_TLS_IE_32");
55fd94b0 297 return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
13ae64f3
JJ		 298
299 case BFD_RELOC_386_TLS_LE_32:
300 TRACE ("BFD_RELOC_386_TLS_LE_32");
55fd94b0 301 return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
13ae64f3
JJ		 302
303 case BFD_RELOC_386_TLS_DTPMOD32:
304 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
55fd94b0 305 return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
13ae64f3
JJ		 306
307 case BFD_RELOC_386_TLS_DTPOFF32:
308 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
55fd94b0 309 return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
13ae64f3
JJ		 310
311 case BFD_RELOC_386_TLS_TPOFF32:
312 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
55fd94b0 313 return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
13ae64f3 314
1788fc08
L		 315 case BFD_RELOC_SIZE32:
316 TRACE ("BFD_RELOC_SIZE32");
317 return &elf_howto_table[R_386_SIZE32 - R_386_tls_offset];
318
67a4f2b7
AO		 319 case BFD_RELOC_386_TLS_GOTDESC:
320 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
321 return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
322
323 case BFD_RELOC_386_TLS_DESC_CALL:
324 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
325 return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
326
327 case BFD_RELOC_386_TLS_DESC:
328 TRACE ("BFD_RELOC_386_TLS_DESC");
329 return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
330
cbe950e9
L		 331 case BFD_RELOC_386_IRELATIVE:
332 TRACE ("BFD_RELOC_386_IRELATIVE");
2a750708 333 return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
cbe950e9 334
252b5132
RH		 335 case BFD_RELOC_VTABLE_INHERIT:
336 TRACE ("BFD_RELOC_VTABLE_INHERIT");
55fd94b0 337 return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
252b5132
RH		 338
339 case BFD_RELOC_VTABLE_ENTRY:
340 TRACE ("BFD_RELOC_VTABLE_ENTRY");
55fd94b0 341 return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
252b5132
RH		 342
343 default:
344 break;
345 }
346
347 TRACE ("Unknown");
348 return 0;
349}
350
157090f7
AM		 351static reloc_howto_type *
352elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
353 const char *r_name)
354{
355 unsigned int i;
356
357 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
358 if (elf_howto_table[i].name != NULL
359 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
360 return &elf_howto_table[i];
361
362 return NULL;
363}
364
142411ca
L		 365static reloc_howto_type *
366elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
252b5132 367{
dc47f327
AM		 368 unsigned int indx;
369
370 if ((indx = r_type) >= R_386_standard
371 && ((indx = r_type - R_386_ext_offset) - R_386_standard
372 >= R_386_ext - R_386_standard)
13ae64f3 373 && ((indx = r_type - R_386_tls_offset) - R_386_ext
cbe950e9
L		 374 >= R_386_irelative - R_386_ext)
375 && ((indx = r_type - R_386_vt_offset) - R_386_irelative
376 >= R_386_vt - R_386_irelative))
252b5132 377 {
d003868e
AM		 378 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
379 abfd, (int) r_type);
55fd94b0 380 indx = R_386_NONE;
252b5132 381 }
142411ca
L		 382 BFD_ASSERT (elf_howto_table [indx].type == r_type);
383 return &elf_howto_table[indx];
384}
385
386static void
387elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
388 arelent *cache_ptr,
389 Elf_Internal_Rela *dst)
390{
391 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
392 cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
252b5132
RH		 393}
394
395/* Return whether a symbol name implies a local label. The UnixWare
396 2.1 cc generates temporary symbols that start with .X, so we
397 recognize them here. FIXME: do other SVR4 compilers also use .X?.
398 If so, we should move the .X recognition into
399 _bfd_elf_is_local_label_name. */
400
b34976b6 401static bfd_boolean
55fd94b0 402elf_i386_is_local_label_name (bfd *abfd, const char *name)
252b5132
RH		 403{
404 if (name[0] == '.' && name[1] == 'X')
b34976b6 405 return TRUE;
252b5132
RH		 406
407 return _bfd_elf_is_local_label_name (abfd, name);
408}
409\f
38701953 410/* Support for core dump NOTE sections. */
61adc1a4 411
b34976b6 412static bfd_boolean
55fd94b0 413elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
38701953
AM		 414{
415 int offset;
eea6121a 416 size_t size;
38701953 417
61adc1a4 418 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
38701953 419 {
61adc1a4
NC		 420 int pr_version = bfd_get_32 (abfd, note->descdata);
421
422 if (pr_version != 1)
423 return FALSE;
424
425 /* pr_cursig */
228e534f 426 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 20);
61adc1a4
NC		 427
428 /* pr_pid */
228e534f 429 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
61adc1a4
NC		 430
431 /* pr_reg */
432 offset = 28;
eea6121a 433 size = bfd_get_32 (abfd, note->descdata + 8);
61adc1a4
NC		 434 }
435 else
436 {
437 switch (note->descsz)
438 {
439 default:
440 return FALSE;
38701953 441
61adc1a4
NC		 442 case 144: /* Linux/i386 */
443 /* pr_cursig */
228e534f 444 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
38701953 445
61adc1a4 446 /* pr_pid */
228e534f 447 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
38701953 448
61adc1a4
NC		 449 /* pr_reg */
450 offset = 72;
eea6121a 451 size = 68;
38701953 452
61adc1a4
NC		 453 break;
454 }
38701953
AM		 455 }
456
457 /* Make a ".reg/999" section. */
458 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 459 size, note->descpos + offset);
38701953
AM		 460}
461
b34976b6 462static bfd_boolean
55fd94b0 463elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
38701953 464{
61adc1a4 465 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
38701953 466 {
61adc1a4
NC		 467 int pr_version = bfd_get_32 (abfd, note->descdata);
468
469 if (pr_version != 1)
b34976b6 470 return FALSE;
38701953 471
228e534f 472 elf_tdata (abfd)->core->program
61adc1a4 473 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
228e534f 474 elf_tdata (abfd)->core->command
61adc1a4
NC		 475 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
476 }
477 else
478 {
479 switch (note->descsz)
480 {
481 default:
482 return FALSE;
483
484 case 124: /* Linux/i386 elf_prpsinfo. */
228e534f 485 elf_tdata (abfd)->core->pid
261b8d08 486 = bfd_get_32 (abfd, note->descdata + 12);
228e534f 487 elf_tdata (abfd)->core->program
61adc1a4 488 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
228e534f 489 elf_tdata (abfd)->core->command
61adc1a4
NC		 490 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
491 }
38701953
AM		 492 }
493
494 /* Note that for some reason, a spurious space is tacked
495 onto the end of the args in some (at least one anyway)
496 implementations, so strip it off if it exists. */
38701953 497 {
228e534f 498 char *command = elf_tdata (abfd)->core->command;
38701953
AM		 499 int n = strlen (command);
500
501 if (0 < n && command[n - 1] == ' ')
502 command[n - 1] = '\0';
503 }
504
b34976b6 505 return TRUE;
38701953
AM		 506}
507\f
508/* Functions for the i386 ELF linker.
509
510 In order to gain some understanding of code in this file without
511 knowing all the intricate details of the linker, note the
512 following:
513
514 Functions named elf_i386_* are called by external routines, other
515 functions are only called locally. elf_i386_* functions appear
516 in this file more or less in the order in which they are called
517 from external routines. eg. elf_i386_check_relocs is called
518 early in the link process, elf_i386_finish_dynamic_sections is
519 one of the last functions. */
520
252b5132
RH		 521
522/* The name of the dynamic interpreter. This is put in the .interp
523 section. */
524
525#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
526
a23b6845
AM		 527/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
528 copying dynamic variables from a shared lib into an app's dynbss
529 section, and instead use a dynamic relocation to point into the
530 shared lib. */
531#define ELIMINATE_COPY_RELOCS 1
532
252b5132
RH		 533/* The size in bytes of an entry in the procedure linkage table. */
534
535#define PLT_ENTRY_SIZE 16
536
537/* The first entry in an absolute procedure linkage table looks like
eac338cf
PB		 538 this. See the SVR4 ABI i386 supplement to see how this works.
539 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
252b5132 540
eac338cf 541static const bfd_byte elf_i386_plt0_entry[12] =
252b5132
RH		 542{
543 0xff, 0x35, /* pushl contents of address */
544 0, 0, 0, 0, /* replaced with address of .got + 4. */
545 0xff, 0x25, /* jmp indirect */
eac338cf 546 0, 0, 0, 0 /* replaced with address of .got + 8. */
252b5132
RH		 547};
548
549/* Subsequent entries in an absolute procedure linkage table look like
550 this. */
551
552static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
553{
554 0xff, 0x25, /* jmp indirect */
555 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
556 0x68, /* pushl immediate */
557 0, 0, 0, 0, /* replaced with offset into relocation table. */
558 0xe9, /* jmp relative */
559 0, 0, 0, 0 /* replaced with offset to start of .plt. */
560};
561
eac338cf
PB		 562/* The first entry in a PIC procedure linkage table look like this.
563 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
252b5132 564
eac338cf 565static const bfd_byte elf_i386_pic_plt0_entry[12] =
252b5132
RH		 566{
567 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
eac338cf 568 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
252b5132
RH		 569};
570
571/* Subsequent entries in a PIC procedure linkage table look like this. */
572
573static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
574{
575 0xff, 0xa3, /* jmp *offset(%ebx) */
576 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
577 0x68, /* pushl immediate */
578 0, 0, 0, 0, /* replaced with offset into relocation table. */
579 0xe9, /* jmp relative */
580 0, 0, 0, 0 /* replaced with offset to start of .plt. */
581};
582
e41b3a13
JJ		 583/* .eh_frame covering the .plt section. */
584
585static const bfd_byte elf_i386_eh_frame_plt[] =
586{
587#define PLT_CIE_LENGTH 20
588#define PLT_FDE_LENGTH 36
589#define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
590#define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
591 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
592 0, 0, 0, 0, /* CIE ID */
593 1, /* CIE version */
594 'z', 'R', 0, /* Augmentation string */
595 1, /* Code alignment factor */
596 0x7c, /* Data alignment factor */
597 8, /* Return address column */
598 1, /* Augmentation size */
599 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
600 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
601 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
602 DW_CFA_nop, DW_CFA_nop,
603
604 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
605 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
606 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
607 0, 0, 0, 0, /* .plt size goes here */
608 0, /* Augmentation size */
609 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
610 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
611 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
612 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
613 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
614 11, /* Block length */
615 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
616 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
617 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
28ede8be 618 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
e41b3a13
JJ		 619 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
620};
621
25e762b9
RM		 622struct elf_i386_plt_layout
623{
624 /* The first entry in an absolute procedure linkage table looks like this. */
625 const bfd_byte *plt0_entry;
626 unsigned int plt0_entry_size;
627
628 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
629 unsigned int plt0_got1_offset;
630 unsigned int plt0_got2_offset;
631
632 /* Later entries in an absolute procedure linkage table look like this. */
633 const bfd_byte *plt_entry;
634 unsigned int plt_entry_size;
635
636 /* Offsets into plt_entry that are to be replaced with... */
637 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
638 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
639 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
640
641 /* Offset into plt_entry where the initial value of the GOT entry points. */
642 unsigned int plt_lazy_offset;
643
644 /* The first entry in a PIC procedure linkage table looks like this. */
645 const bfd_byte *pic_plt0_entry;
646
647 /* Subsequent entries in a PIC procedure linkage table look like this. */
648 const bfd_byte *pic_plt_entry;
649
650 /* .eh_frame covering the .plt section. */
651 const bfd_byte *eh_frame_plt;
652 unsigned int eh_frame_plt_size;
653};
654
655#define GET_PLT_ENTRY_SIZE(abfd) \
656 get_elf_i386_backend_data (abfd)->plt->plt_entry_size
657
658/* These are the standard parameters. */
659static const struct elf_i386_plt_layout elf_i386_plt =
660 {
661 elf_i386_plt0_entry, /* plt0_entry */
662 sizeof (elf_i386_plt0_entry), /* plt0_entry_size */
663 2, /* plt0_got1_offset */
664 8, /* plt0_got2_offset */
665 elf_i386_plt_entry, /* plt_entry */
666 PLT_ENTRY_SIZE, /* plt_entry_size */
667 2, /* plt_got_offset */
668 7, /* plt_reloc_offset */
669 12, /* plt_plt_offset */
670 6, /* plt_lazy_offset */
671 elf_i386_pic_plt0_entry, /* pic_plt0_entry */
672 elf_i386_pic_plt_entry, /* pic_plt_entry */
673 elf_i386_eh_frame_plt, /* eh_frame_plt */
674 sizeof (elf_i386_eh_frame_plt), /* eh_frame_plt_size */
675 };
676\f
677
eac338cf
PB		 678/* On VxWorks, the .rel.plt.unloaded section has absolute relocations
679 for the PLTResolve stub and then for each PLT entry. */
680#define PLTRESOLVE_RELOCS_SHLIB 0
681#define PLTRESOLVE_RELOCS 2
682#define PLT_NON_JUMP_SLOT_RELOCS 2
683
23209a78
RM		 684/* Architecture-specific backend data for i386. */
685
686struct elf_i386_backend_data
687{
25e762b9
RM		 688 /* Parameters describing PLT generation. */
689 const struct elf_i386_plt_layout *plt;
690
23209a78
RM		 691 /* Value used to fill the unused bytes of the first PLT entry. */
692 bfd_byte plt0_pad_byte;
693
694 /* True if the target system is VxWorks. */
695 int is_vxworks;
696};
697
698#define get_elf_i386_backend_data(abfd) \
699 ((const struct elf_i386_backend_data *) \
700 get_elf_backend_data (abfd)->arch_data)
701
702/* These are the standard parameters. */
703static const struct elf_i386_backend_data elf_i386_arch_bed =
704 {
25e762b9 705 &elf_i386_plt, /* plt */
23209a78
RM		 706 0, /* plt0_pad_byte */
707 0, /* is_vxworks */
708 };
709
710#define elf_backend_arch_data &elf_i386_arch_bed
711
252b5132
RH		 712/* i386 ELF linker hash entry. */
713
714struct elf_i386_link_hash_entry
715{
ebe50bae 716 struct elf_link_hash_entry elf;
252b5132 717
0c715baa 718 /* Track dynamic relocs copied for this symbol. */
e03a8ed8 719 struct elf_dyn_relocs *dyn_relocs;
13ae64f3 720
37e55690
JJ		 721#define GOT_UNKNOWN 0
722#define GOT_NORMAL 1
723#define GOT_TLS_GD 2
724#define GOT_TLS_IE 4
725#define GOT_TLS_IE_POS 5
726#define GOT_TLS_IE_NEG 6
727#define GOT_TLS_IE_BOTH 7
67a4f2b7
AO		 728#define GOT_TLS_GDESC 8
729#define GOT_TLS_GD_BOTH_P(type) \
730 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
731#define GOT_TLS_GD_P(type) \
732 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
733#define GOT_TLS_GDESC_P(type) \
734 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
735#define GOT_TLS_GD_ANY_P(type) \
736 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
37e55690 737 unsigned char tls_type;
67a4f2b7
AO		 738
739 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
740 starting at the end of the jump table. */
741 bfd_vma tlsdesc_got;
13ae64f3
JJ		 742};
743
744#define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
745
746struct elf_i386_obj_tdata
747{
748 struct elf_obj_tdata root;
749
750 /* tls_type for each local got entry. */
751 char *local_got_tls_type;
67a4f2b7
AO		 752
753 /* GOTPLT entries for TLS descriptors. */
754 bfd_vma *local_tlsdesc_gotent;
252b5132
RH		 755};
756
13ae64f3
JJ		 757#define elf_i386_tdata(abfd) \
758 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
759
760#define elf_i386_local_got_tls_type(abfd) \
761 (elf_i386_tdata (abfd)->local_got_tls_type)
762
67a4f2b7
AO		 763#define elf_i386_local_tlsdesc_gotent(abfd) \
764 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
765
0ffa91dd
NC		 766#define is_i386_elf(bfd) \
767 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
768 && elf_tdata (bfd) != NULL \
4dfe6ac6 769 && elf_object_id (bfd) == I386_ELF_DATA)
0ffa91dd 770
b34976b6 771static bfd_boolean
55fd94b0 772elf_i386_mkobject (bfd *abfd)
13ae64f3 773{
0ffa91dd 774 return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
4dfe6ac6 775 I386_ELF_DATA);
13ae64f3 776}
cedb70c5 777
252b5132
RH		 778/* i386 ELF linker hash table. */
779
780struct elf_i386_link_hash_table
781{
ebe50bae 782 struct elf_link_hash_table elf;
252b5132 783
6725bdbf 784 /* Short-cuts to get to dynamic linker sections. */
6725bdbf
AM		 785 asection *sdynbss;
786 asection *srelbss;
e41b3a13 787 asection *plt_eh_frame;
9635fe29 788
4dfe6ac6
NC		 789 union
790 {
13ae64f3
JJ		 791 bfd_signed_vma refcount;
792 bfd_vma offset;
793 } tls_ldm_got;
794
67a4f2b7
AO		 795 /* The amount of space used by the reserved portion of the sgotplt
796 section, plus whatever space is used by the jump slots. */
797 bfd_vma sgotplt_jump_table_size;
798
87d72d41
AM		 799 /* Small local sym cache. */
800 struct sym_cache sym_cache;
9f03412a
AO		 801
802 /* _TLS_MODULE_BASE_ symbol. */
803 struct bfd_link_hash_entry *tls_module_base;
c25bc9fc
L		 804
805 /* Used by local STT_GNU_IFUNC symbols. */
806 htab_t loc_hash_table;
4dfe6ac6
NC		 807 void * loc_hash_memory;
808
809 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
810 asection *srelplt2;
811
4dfe6ac6
NC		 812 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
813 bfd_vma next_tls_desc_index;
e1f98742
L		 814
815 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
816 bfd_vma next_jump_slot_index;
817
818 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
819 bfd_vma next_irelative_index;
6725bdbf 820};
252b5132
RH		 821
822/* Get the i386 ELF linker hash table from a link_info structure. */
823
824#define elf_i386_hash_table(p) \
4dfe6ac6
NC		 825 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
826 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
252b5132 827
67a4f2b7 828#define elf_i386_compute_jump_table_size(htab) \
5ae0bfb6 829 ((htab)->next_tls_desc_index * 4)
67a4f2b7 830
252b5132
RH		 831/* Create an entry in an i386 ELF linker hash table. */
832
833static struct bfd_hash_entry *
eb4ff4d6
L		 834elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry,
835 struct bfd_hash_table *table,
836 const char *string)
252b5132 837{
252b5132
RH		 838 /* Allocate the structure if it has not already been allocated by a
839 subclass. */
ebe50bae
AM		 840 if (entry == NULL)
841 {
a50b1753
NC		 842 entry = (struct bfd_hash_entry *)
843 bfd_hash_allocate (table, sizeof (struct elf_i386_link_hash_entry));
ebe50bae
AM		 844 if (entry == NULL)
845 return entry;
846 }
252b5132
RH		 847
848 /* Call the allocation method of the superclass. */
ebe50bae
AM		 849 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
850 if (entry != NULL)
252b5132 851 {
ebe50bae
AM		 852 struct elf_i386_link_hash_entry *eh;
853
854 eh = (struct elf_i386_link_hash_entry *) entry;
855 eh->dyn_relocs = NULL;
13ae64f3 856 eh->tls_type = GOT_UNKNOWN;
67a4f2b7 857 eh->tlsdesc_got = (bfd_vma) -1;
252b5132
RH		 858 }
859
ebe50bae 860 return entry;
252b5132
RH		 861}
862
c25bc9fc
L		 863/* Compute a hash of a local hash entry. We use elf_link_hash_entry
864 for local symbol so that we can handle local STT_GNU_IFUNC symbols
865 as global symbol. We reuse indx and dynstr_index for local symbol
866 hash since they aren't used by global symbols in this backend. */
867
868static hashval_t
869elf_i386_local_htab_hash (const void *ptr)
870{
871 struct elf_link_hash_entry *h
872 = (struct elf_link_hash_entry *) ptr;
d2149d72 873 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
c25bc9fc
L		 874}
875
876/* Compare local hash entries. */
877
878static int
879elf_i386_local_htab_eq (const void *ptr1, const void *ptr2)
880{
881 struct elf_link_hash_entry *h1
882 = (struct elf_link_hash_entry *) ptr1;
883 struct elf_link_hash_entry *h2
884 = (struct elf_link_hash_entry *) ptr2;
885
886 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
887}
888
889/* Find and/or create a hash entry for local symbol. */
890
891static struct elf_link_hash_entry *
892elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab,
893 bfd *abfd, const Elf_Internal_Rela *rel,
894 bfd_boolean create)
895{
896 struct elf_i386_link_hash_entry e, *ret;
897 asection *sec = abfd->sections;
d2149d72
L		 898 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
899 ELF32_R_SYM (rel->r_info));
c25bc9fc
L		 900 void **slot;
901
902 e.elf.indx = sec->id;
903 e.elf.dynstr_index = ELF32_R_SYM (rel->r_info);
904 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
905 create ? INSERT : NO_INSERT);
906
907 if (!slot)
908 return NULL;
909
910 if (*slot)
911 {
912 ret = (struct elf_i386_link_hash_entry *) *slot;
913 return &ret->elf;
914 }
915
916 ret = (struct elf_i386_link_hash_entry *)
917 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
918 sizeof (struct elf_i386_link_hash_entry));
919 if (ret)
920 {
921 memset (ret, 0, sizeof (*ret));
922 ret->elf.indx = sec->id;
923 ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info);
924 ret->elf.dynindx = -1;
c25bc9fc
L		 925 *slot = ret;
926 }
927 return &ret->elf;
928}
929
252b5132
RH		 930/* Create an i386 ELF linker hash table. */
931
932static struct bfd_link_hash_table *
55fd94b0 933elf_i386_link_hash_table_create (bfd *abfd)
252b5132
RH		 934{
935 struct elf_i386_link_hash_table *ret;
dc810e39 936 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
252b5132 937
7bf52ea2 938 ret = (struct elf_i386_link_hash_table *) bfd_zmalloc (amt);
ebe50bae 939 if (ret == NULL)
252b5132
RH		 940 return NULL;
941
eb4ff4d6
L		 942 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
943 elf_i386_link_hash_newfunc,
4dfe6ac6
NC		 944 sizeof (struct elf_i386_link_hash_entry),
945 I386_ELF_DATA))
252b5132 946 {
e2d34d7d 947 free (ret);
252b5132
RH		 948 return NULL;
949 }
950
c25bc9fc
L		 951 ret->loc_hash_table = htab_try_create (1024,
952 elf_i386_local_htab_hash,
953 elf_i386_local_htab_eq,
954 NULL);
955 ret->loc_hash_memory = objalloc_create ();
956 if (!ret->loc_hash_table || !ret->loc_hash_memory)
957 {
958 free (ret);
959 return NULL;
960 }
961
ebe50bae 962 return &ret->elf.root;
252b5132
RH		 963}
964
c25bc9fc
L		 965/* Destroy an i386 ELF linker hash table. */
966
967static void
968elf_i386_link_hash_table_free (struct bfd_link_hash_table *hash)
969{
970 struct elf_i386_link_hash_table *htab
971 = (struct elf_i386_link_hash_table *) hash;
972
973 if (htab->loc_hash_table)
974 htab_delete (htab->loc_hash_table);
975 if (htab->loc_hash_memory)
976 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
9f7c3e5e 977 _bfd_elf_link_hash_table_free (hash);
c25bc9fc
L		 978}
979
6725bdbf
AM		 980/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
981 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
982 hash table. */
983
b34976b6 984static bfd_boolean
55fd94b0 985elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
6725bdbf
AM		 986{
987 struct elf_i386_link_hash_table *htab;
988
6725bdbf 989 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 990 return FALSE;
6725bdbf 991
6de2ae4a 992 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 993 if (htab == NULL)
994 return FALSE;
995
3d4d4302 996 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
6725bdbf 997 if (!info->shared)
3d4d4302 998 htab->srelbss = bfd_get_linker_section (dynobj, ".rel.bss");
6725bdbf 999
6de2ae4a 1000 if (!htab->sdynbss
6725bdbf
AM		 1001 || (!info->shared && !htab->srelbss))
1002 abort ();
1003
23209a78 1004 if (get_elf_i386_backend_data (dynobj)->is_vxworks
6de2ae4a
L		 1005 && !elf_vxworks_create_dynamic_sections (dynobj, info,
1006 &htab->srelplt2))
711de32c 1007 return FALSE;
eac338cf 1008
e41b3a13 1009 if (!info->no_ld_generated_unwind_info
2fe0fd06 1010 && htab->plt_eh_frame == NULL
e4de50d4 1011 && htab->elf.splt != NULL)
e41b3a13 1012 {
bbf96e4e
L		 1013 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1014 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1015 | SEC_LINKER_CREATED);
e41b3a13 1016 htab->plt_eh_frame
bbf96e4e 1017 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
e41b3a13
JJ		 1018 if (htab->plt_eh_frame == NULL
1019 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 2))
1020 return FALSE;
e41b3a13
JJ		 1021 }
1022
b34976b6 1023 return TRUE;
6725bdbf
AM		 1024}
1025
ebe50bae
AM		 1026/* Copy the extra info we tack onto an elf_link_hash_entry. */
1027
51b64d56 1028static void
fcfa13d2 1029elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
55fd94b0
AM		 1030 struct elf_link_hash_entry *dir,
1031 struct elf_link_hash_entry *ind)
ebe50bae
AM		 1032{
1033 struct elf_i386_link_hash_entry *edir, *eind;
1034
1035 edir = (struct elf_i386_link_hash_entry *) dir;
1036 eind = (struct elf_i386_link_hash_entry *) ind;
1037
bbd7ec4a 1038 if (eind->dyn_relocs != NULL)
ebe50bae 1039 {
bbd7ec4a
AM		 1040 if (edir->dyn_relocs != NULL)
1041 {
e03a8ed8
L		 1042 struct elf_dyn_relocs **pp;
1043 struct elf_dyn_relocs *p;
bbd7ec4a 1044
fcfa13d2 1045 /* Add reloc counts against the indirect sym to the direct sym
bbd7ec4a
AM		 1046 list. Merge any entries against the same section. */
1047 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1048 {
e03a8ed8 1049 struct elf_dyn_relocs *q;
bbd7ec4a
AM		 1050
1051 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1052 if (q->sec == p->sec)
1053 {
1054 q->pc_count += p->pc_count;
1055 q->count += p->count;
1056 *pp = p->next;
1057 break;
1058 }
1059 if (q == NULL)
1060 pp = &p->next;
1061 }
1062 *pp = edir->dyn_relocs;
1063 }
1064
ebe50bae
AM		 1065 edir->dyn_relocs = eind->dyn_relocs;
1066 eind->dyn_relocs = NULL;
1067 }
ebe50bae 1068
cd67d266
JJ		 1069 if (ind->root.type == bfd_link_hash_indirect
1070 && dir->got.refcount <= 0)
1071 {
1072 edir->tls_type = eind->tls_type;
1073 eind->tls_type = GOT_UNKNOWN;
1074 }
81848ca0
AM		 1075
1076 if (ELIMINATE_COPY_RELOCS
1077 && ind->root.type != bfd_link_hash_indirect
f5385ebf
AM		 1078 && dir->dynamic_adjusted)
1079 {
1080 /* If called to transfer flags for a weakdef during processing
1081 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1082 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1083 dir->ref_dynamic |= ind->ref_dynamic;
1084 dir->ref_regular |= ind->ref_regular;
1085 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1086 dir->needs_plt |= ind->needs_plt;
1087 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1088 }
81848ca0 1089 else
fcfa13d2 1090 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
ebe50bae
AM		 1091}
1092
142411ca
L		 1093/* Return TRUE if the TLS access code sequence support transition
1094 from R_TYPE. */
1095
1096static bfd_boolean
1097elf_i386_check_tls_transition (bfd *abfd, asection *sec,
1098 bfd_byte *contents,
1099 Elf_Internal_Shdr *symtab_hdr,
1100 struct elf_link_hash_entry **sym_hashes,
1101 unsigned int r_type,
1102 const Elf_Internal_Rela *rel,
1103 const Elf_Internal_Rela *relend)
13ae64f3 1104{
142411ca
L		 1105 unsigned int val, type;
1106 unsigned long r_symndx;
1107 struct elf_link_hash_entry *h;
1108 bfd_vma offset;
1109
1110 /* Get the section contents. */
1111 if (contents == NULL)
1112 {
1113 if (elf_section_data (sec)->this_hdr.contents != NULL)
1114 contents = elf_section_data (sec)->this_hdr.contents;
1115 else
1116 {
1117 /* FIXME: How to better handle error condition? */
1118 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1119 return FALSE;
13ae64f3 1120
142411ca
L		 1121 /* Cache the section contents for elf_link_input_bfd. */
1122 elf_section_data (sec)->this_hdr.contents = contents;
1123 }
1124 }
1125
1126 offset = rel->r_offset;
13ae64f3 1127 switch (r_type)
142411ca
L		 1128 {
1129 case R_386_TLS_GD:
1130 case R_386_TLS_LDM:
1131 if (offset < 2 || (rel + 1) >= relend)
1132 return FALSE;
1133
1134 type = bfd_get_8 (abfd, contents + offset - 2);
1135 if (r_type == R_386_TLS_GD)
1136 {
09e8c3bf 1137 /* Check transition from GD access model. Only
142411ca
L		 1138 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1139 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1140 can transit to different access model. */
1141 if ((offset + 10) > sec->size ||
1142 (type != 0x8d && type != 0x04))
1143 return FALSE;
1144
1145 val = bfd_get_8 (abfd, contents + offset - 1);
1146 if (type == 0x04)
1147 {
1148 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1149 if (offset < 3)
1150 return FALSE;
1151
1152 if (bfd_get_8 (abfd, contents + offset - 3) != 0x8d)
1153 return FALSE;
1154
1155 if ((val & 0xc7) != 0x05 || val == (4 << 3))
1156 return FALSE;
1157 }
1158 else
1159 {
1160 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
1161 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1162 return FALSE;
1163
1164 if (bfd_get_8 (abfd, contents + offset + 9) != 0x90)
1165 return FALSE;
1166 }
1167 }
1168 else
1169 {
1170 /* Check transition from LD access model. Only
1171 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1172 can transit to different access model. */
1173 if (type != 0x8d || (offset + 9) > sec->size)
1174 return FALSE;
1175
1176 val = bfd_get_8 (abfd, contents + offset - 1);
1177 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1178 return FALSE;
1179 }
1180
1181 if (bfd_get_8 (abfd, contents + offset + 4) != 0xe8)
1182 return FALSE;
1183
1184 r_symndx = ELF32_R_SYM (rel[1].r_info);
1185 if (r_symndx < symtab_hdr->sh_info)
1186 return FALSE;
1187
1188 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
c4fb387b
L		 1189 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1190 may be versioned. */
142411ca
L		 1191 return (h != NULL
1192 && h->root.root.string != NULL
1193 && (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1194 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32)
c4fb387b
L		 1195 && (strncmp (h->root.root.string, "___tls_get_addr",
1196 15) == 0));
142411ca
L		 1197
1198 case R_386_TLS_IE:
1199 /* Check transition from IE access model:
1200 movl foo@indntpoff(%rip), %eax
1201 movl foo@indntpoff(%rip), %reg
1202 addl foo@indntpoff(%rip), %reg
1203 */
1204
1205 if (offset < 1 || (offset + 4) > sec->size)
1206 return FALSE;
1207
1208 /* Check "movl foo@tpoff(%rip), %eax" first. */
1209 val = bfd_get_8 (abfd, contents + offset - 1);
1210 if (val == 0xa1)
1211 return TRUE;
1212
1213 if (offset < 2)
1214 return FALSE;
1215
1216 /* Check movl|addl foo@tpoff(%rip), %reg. */
1217 type = bfd_get_8 (abfd, contents + offset - 2);
1218 return ((type == 0x8b || type == 0x03)
1219 && (val & 0xc7) == 0x05);
1220
1221 case R_386_TLS_GOTIE:
1222 case R_386_TLS_IE_32:
1223 /* Check transition from {IE_32,GOTIE} access model:
1224 subl foo@{tpoff,gontoff}(%reg1), %reg2
1225 movl foo@{tpoff,gontoff}(%reg1), %reg2
1226 addl foo@{tpoff,gontoff}(%reg1), %reg2
1227 */
1228
1229 if (offset < 2 || (offset + 4) > sec->size)
1230 return FALSE;
1231
1232 val = bfd_get_8 (abfd, contents + offset - 1);
1233 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1234 return FALSE;
1235
1236 type = bfd_get_8 (abfd, contents + offset - 2);
1237 return type == 0x8b || type == 0x2b || type == 0x03;
1238
1239 case R_386_TLS_GOTDESC:
1240 /* Check transition from GDesc access model:
1241 leal x@tlsdesc(%ebx), %eax
1242
1243 Make sure it's a leal adding ebx to a 32-bit offset
1244 into any register, although it's probably almost always
1245 going to be eax. */
1246
1247 if (offset < 2 || (offset + 4) > sec->size)
1248 return FALSE;
1249
1250 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1251 return FALSE;
1252
1253 val = bfd_get_8 (abfd, contents + offset - 1);
1254 return (val & 0xc7) == 0x83;
1255
1256 case R_386_TLS_DESC_CALL:
1257 /* Check transition from GDesc access model:
1258 call *x@tlsdesc(%rax)
1259 */
1260 if (offset + 2 <= sec->size)
1261 {
1262 /* Make sure that it's a call *x@tlsdesc(%rax). */
fa289a5f
AM		 1263 static const unsigned char call[] = { 0xff, 0x10 };
1264 return memcmp (contents + offset, call, 2) == 0;
142411ca
L		 1265 }
1266
1267 return FALSE;
1268
1269 default:
1270 abort ();
1271 }
1272}
1273
1274/* Return TRUE if the TLS access transition is OK or no transition
1275 will be performed. Update R_TYPE if there is a transition. */
1276
1277static bfd_boolean
1278elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1279 asection *sec, bfd_byte *contents,
1280 Elf_Internal_Shdr *symtab_hdr,
1281 struct elf_link_hash_entry **sym_hashes,
1282 unsigned int *r_type, int tls_type,
1283 const Elf_Internal_Rela *rel,
1284 const Elf_Internal_Rela *relend,
4c544807
L		 1285 struct elf_link_hash_entry *h,
1286 unsigned long r_symndx)
142411ca
L		 1287{
1288 unsigned int from_type = *r_type;
1289 unsigned int to_type = from_type;
1290 bfd_boolean check = TRUE;
1291
bb1cb422
L		 1292 /* Skip TLS transition for functions. */
1293 if (h != NULL
1294 && (h->type == STT_FUNC
1295 || h->type == STT_GNU_IFUNC))
1296 return TRUE;
1297
142411ca 1298 switch (from_type)
13ae64f3
JJ		 1299 {
1300 case R_386_TLS_GD:
67a4f2b7
AO		 1301 case R_386_TLS_GOTDESC:
1302 case R_386_TLS_DESC_CALL:
13ae64f3 1303 case R_386_TLS_IE_32:
37e55690
JJ		 1304 case R_386_TLS_IE:
1305 case R_386_TLS_GOTIE:
1d85728f 1306 if (info->executable)
142411ca
L		 1307 {
1308 if (h == NULL)
1309 to_type = R_386_TLS_LE_32;
1310 else if (from_type != R_386_TLS_IE
1311 && from_type != R_386_TLS_GOTIE)
1312 to_type = R_386_TLS_IE_32;
1313 }
1314
1315 /* When we are called from elf_i386_relocate_section, CONTENTS
1316 isn't NULL and there may be additional transitions based on
1317 TLS_TYPE. */
1318 if (contents != NULL)
1319 {
1320 unsigned int new_to_type = to_type;
1321
1d85728f 1322 if (info->executable
142411ca
L		 1323 && h != NULL
1324 && h->dynindx == -1
1325 && (tls_type & GOT_TLS_IE))
1326 new_to_type = R_386_TLS_LE_32;
1327
1328 if (to_type == R_386_TLS_GD
1329 || to_type == R_386_TLS_GOTDESC
1330 || to_type == R_386_TLS_DESC_CALL)
1331 {
1332 if (tls_type == GOT_TLS_IE_POS)
1333 new_to_type = R_386_TLS_GOTIE;
1334 else if (tls_type & GOT_TLS_IE)
1335 new_to_type = R_386_TLS_IE_32;
1336 }
1337
1338 /* We checked the transition before when we were called from
1339 elf_i386_check_relocs. We only want to check the new
1340 transition which hasn't been checked before. */
1341 check = new_to_type != to_type && from_type == to_type;
1342 to_type = new_to_type;
1343 }
1344
1345 break;
1346
13ae64f3 1347 case R_386_TLS_LDM:
1d85728f 1348 if (info->executable)
142411ca
L		 1349 to_type = R_386_TLS_LE_32;
1350 break;
1351
1352 default:
1353 return TRUE;
1354 }
1355
1356 /* Return TRUE if there is no transition. */
1357 if (from_type == to_type)
1358 return TRUE;
1359
1360 /* Check if the transition can be performed. */
1361 if (check
1362 && ! elf_i386_check_tls_transition (abfd, sec, contents,
1363 symtab_hdr, sym_hashes,
1364 from_type, rel, relend))
1365 {
2f629d23 1366 reloc_howto_type *from, *to;
4c544807 1367 const char *name;
142411ca
L		 1368
1369 from = elf_i386_rtype_to_howto (abfd, from_type);
1370 to = elf_i386_rtype_to_howto (abfd, to_type);
1371
4c544807
L		 1372 if (h)
1373 name = h->root.root.string;
1374 else
1375 {
4c544807 1376 struct elf_i386_link_hash_table *htab;
4dfe6ac6 1377
4c544807 1378 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 1379 if (htab == NULL)
1380 name = "*unknown*";
1381 else
1382 {
1383 Elf_Internal_Sym *isym;
1384
1385 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1386 abfd, r_symndx);
1387 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1388 }
4c544807
L		 1389 }
1390
142411ca
L		 1391 (*_bfd_error_handler)
1392 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1393 "in section `%A' failed"),
4c544807 1394 abfd, sec, from->name, to->name, name,
142411ca
L		 1395 (unsigned long) rel->r_offset);
1396 bfd_set_error (bfd_error_bad_value);
1397 return FALSE;
13ae64f3
JJ		 1398 }
1399
142411ca
L		 1400 *r_type = to_type;
1401 return TRUE;
13ae64f3
JJ		 1402}
1403
252b5132 1404/* Look through the relocs for a section during the first phase, and
0ac8d2ca
AM		 1405 calculate needed space in the global offset table, procedure linkage
1406 table, and dynamic reloc sections. */
252b5132 1407
b34976b6 1408static bfd_boolean
55fd94b0
AM		 1409elf_i386_check_relocs (bfd *abfd,
1410 struct bfd_link_info *info,
1411 asection *sec,
1412 const Elf_Internal_Rela *relocs)
252b5132 1413{
6725bdbf 1414 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1415 Elf_Internal_Shdr *symtab_hdr;
1416 struct elf_link_hash_entry **sym_hashes;
252b5132
RH		 1417 const Elf_Internal_Rela *rel;
1418 const Elf_Internal_Rela *rel_end;
252b5132
RH		 1419 asection *sreloc;
1420
1049f94e 1421 if (info->relocatable)
b34976b6 1422 return TRUE;
252b5132 1423
0ffa91dd
NC		 1424 BFD_ASSERT (is_i386_elf (abfd));
1425
6725bdbf 1426 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 1427 if (htab == NULL)
1428 return FALSE;
1429
0ffa91dd 1430 symtab_hdr = &elf_symtab_hdr (abfd);
252b5132 1431 sym_hashes = elf_sym_hashes (abfd);
252b5132 1432
252b5132
RH		 1433 sreloc = NULL;
1434
1435 rel_end = relocs + sec->reloc_count;
1436 for (rel = relocs; rel < rel_end; rel++)
1437 {
13ae64f3 1438 unsigned int r_type;
252b5132
RH		 1439 unsigned long r_symndx;
1440 struct elf_link_hash_entry *h;
4c544807
L		 1441 Elf_Internal_Sym *isym;
1442 const char *name;
06a6a421 1443 bfd_boolean size_reloc;
252b5132
RH		 1444
1445 r_symndx = ELF32_R_SYM (rel->r_info);
13ae64f3 1446 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 1447
d9bc7a44 1448 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
f5f31454 1449 {
d003868e
AM		 1450 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1451 abfd,
8f615d07 1452 r_symndx);
b34976b6 1453 return FALSE;
f5f31454
L		 1454 }
1455
252b5132 1456 if (r_symndx < symtab_hdr->sh_info)
c25bc9fc
L		 1457 {
1458 /* A local symbol. */
c2e61a4e
L		 1459 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1460 abfd, r_symndx);
1461 if (isym == NULL)
1462 return FALSE;
c25bc9fc
L		 1463
1464 /* Check relocation against local STT_GNU_IFUNC symbol. */
c25bc9fc
L		 1465 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1466 {
9fff0c39 1467 h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE);
c25bc9fc 1468 if (h == NULL)
c2e61a4e 1469 return FALSE;
6bbec505 1470
c25bc9fc
L		 1471 /* Fake a STT_GNU_IFUNC symbol. */
1472 h->type = STT_GNU_IFUNC;
1473 h->def_regular = 1;
1474 h->ref_regular = 1;
1475 h->forced_local = 1;
1476 h->root.type = bfd_link_hash_defined;
1477 }
1478 else
1479 h = NULL;
1480 }
252b5132 1481 else
71cb9464 1482 {
4c544807 1483 isym = NULL;
71cb9464
L		 1484 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1485 while (h->root.type == bfd_link_hash_indirect
1486 || h->root.type == bfd_link_hash_warning)
1487 h = (struct elf_link_hash_entry *) h->root.u.i.link;
c25bc9fc 1488 }
cbe950e9 1489
c25bc9fc
L		 1490 if (h != NULL)
1491 {
cbe950e9
L		 1492 /* Create the ifunc sections for static executables. If we
1493 never see an indirect function symbol nor we are building
1494 a static executable, those sections will be empty and
1495 won't appear in output. */
1496 switch (r_type)
1497 {
1498 default:
1499 break;
1500
1501 case R_386_32:
1502 case R_386_PC32:
1503 case R_386_PLT32:
1504 case R_386_GOT32:
1505 case R_386_GOTOFF:
9d4057ee
AM		 1506 if (htab->elf.dynobj == NULL)
1507 htab->elf.dynobj = abfd;
1508 if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
c2e61a4e 1509 return FALSE;
cbe950e9
L		 1510 break;
1511 }
1512
ad1e85de
L		 1513 /* It is referenced by a non-shared object. */
1514 h->ref_regular = 1;
61315175 1515 h->root.non_ir_ref = 1;
71cb9464 1516 }
252b5132 1517
142411ca
L		 1518 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1519 symtab_hdr, sym_hashes,
1520 &r_type, GOT_UNKNOWN,
23209a78 1521 rel, rel_end, h, r_symndx))
c2e61a4e 1522 return FALSE;
13ae64f3
JJ		 1523
1524 switch (r_type)
252b5132 1525 {
37e55690
JJ		 1526 case R_386_TLS_LDM:
1527 htab->tls_ldm_got.refcount += 1;
1528 goto create_got;
1529
1530 case R_386_PLT32:
1531 /* This symbol requires a procedure linkage table entry. We
1532 actually build the entry in adjust_dynamic_symbol,
1533 because this might be a case of linking PIC code which is
1534 never referenced by a dynamic object, in which case we
1535 don't need to generate a procedure linkage table entry
1536 after all. */
1537
1538 /* If this is a local symbol, we resolve it directly without
1539 creating a procedure linkage table entry. */
1540 if (h == NULL)
1541 continue;
1542
f5385ebf 1543 h->needs_plt = 1;
37e55690
JJ		 1544 h->plt.refcount += 1;
1545 break;
1546
6a3e1bae 1547 case R_386_SIZE32:
06a6a421 1548 size_reloc = TRUE;
6a3e1bae
L		 1549 goto do_size;
1550
13ae64f3 1551 case R_386_TLS_IE_32:
37e55690
JJ		 1552 case R_386_TLS_IE:
1553 case R_386_TLS_GOTIE:
1d85728f 1554 if (!info->executable)
13ae64f3 1555 info->flags |= DF_STATIC_TLS;
37e55690
JJ		 1556 /* Fall through */
1557
252b5132 1558 case R_386_GOT32:
13ae64f3 1559 case R_386_TLS_GD:
67a4f2b7
AO		 1560 case R_386_TLS_GOTDESC:
1561 case R_386_TLS_DESC_CALL:
252b5132 1562 /* This symbol requires a global offset table entry. */
13ae64f3
JJ		 1563 {
1564 int tls_type, old_tls_type;
1565
1566 switch (r_type)
1567 {
1568 default:
1569 case R_386_GOT32: tls_type = GOT_NORMAL; break;
1570 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
67a4f2b7
AO		 1571 case R_386_TLS_GOTDESC:
1572 case R_386_TLS_DESC_CALL:
1573 tls_type = GOT_TLS_GDESC; break;
37e55690
JJ		 1574 case R_386_TLS_IE_32:
1575 if (ELF32_R_TYPE (rel->r_info) == r_type)
1576 tls_type = GOT_TLS_IE_NEG;
1577 else
ebcfb3c0
JJ		 1578 /* If this is a GD->IE transition, we may use either of
1579 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
37e55690
JJ		 1580 tls_type = GOT_TLS_IE;
1581 break;
1582 case R_386_TLS_IE:
1583 case R_386_TLS_GOTIE:
1584 tls_type = GOT_TLS_IE_POS; break;
13ae64f3
JJ		 1585 }
1586
1587 if (h != NULL)
1588 {
1589 h->got.refcount += 1;
1590 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1591 }
1592 else
1593 {
1594 bfd_signed_vma *local_got_refcounts;
1595
1596 /* This is a global offset table entry for a local symbol. */
1597 local_got_refcounts = elf_local_got_refcounts (abfd);
1598 if (local_got_refcounts == NULL)
1599 {
1600 bfd_size_type size;
1601
1602 size = symtab_hdr->sh_info;
67a4f2b7
AO		 1603 size *= (sizeof (bfd_signed_vma)
1604 + sizeof (bfd_vma) + sizeof(char));
a50b1753
NC		 1605 local_got_refcounts = (bfd_signed_vma *)
1606 bfd_zalloc (abfd, size);
13ae64f3 1607 if (local_got_refcounts == NULL)
c2e61a4e 1608 return FALSE;
13ae64f3 1609 elf_local_got_refcounts (abfd) = local_got_refcounts;
67a4f2b7
AO		 1610 elf_i386_local_tlsdesc_gotent (abfd)
1611 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
13ae64f3 1612 elf_i386_local_got_tls_type (abfd)
67a4f2b7 1613 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
13ae64f3
JJ		 1614 }
1615 local_got_refcounts[r_symndx] += 1;
1616 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1617 }
1618
37e55690
JJ		 1619 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1620 tls_type |= old_tls_type;
13ae64f3
JJ		 1621 /* If a TLS symbol is accessed using IE at least once,
1622 there is no point to use dynamic model for it. */
ebcfb3c0 1623 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
67a4f2b7 1624 && (! GOT_TLS_GD_ANY_P (old_tls_type)
37e55690 1625 || (tls_type & GOT_TLS_IE) == 0))
13ae64f3 1626 {
67a4f2b7 1627 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
37e55690 1628 tls_type = old_tls_type;
67a4f2b7
AO		 1629 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1630 && GOT_TLS_GD_ANY_P (tls_type))
1631 tls_type |= old_tls_type;
13ae64f3
JJ		 1632 else
1633 {
09a24cbf 1634 if (h)
4c544807
L		 1635 name = h->root.root.string;
1636 else
1637 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1638 NULL);
13ae64f3 1639 (*_bfd_error_handler)
d003868e 1640 (_("%B: `%s' accessed both as normal and "
55fd94b0 1641 "thread local symbol"),
4c544807 1642 abfd, name);
68c4a57e 1643 bfd_set_error (bfd_error_bad_value);
c2e61a4e 1644 return FALSE;
13ae64f3
JJ		 1645 }
1646 }
1647
1648 if (old_tls_type != tls_type)
1649 {
1650 if (h != NULL)
1651 elf_i386_hash_entry (h)->tls_type = tls_type;
1652 else
1653 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1654 }
1655 }
0ac8d2ca
AM		 1656 /* Fall through */
1657
1658 case R_386_GOTOFF:
1659 case R_386_GOTPC:
13ae64f3 1660 create_got:
6de2ae4a 1661 if (htab->elf.sgot == NULL)
0ac8d2ca
AM		 1662 {
1663 if (htab->elf.dynobj == NULL)
1664 htab->elf.dynobj = abfd;
6de2ae4a 1665 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
c2e61a4e 1666 return FALSE;
0ac8d2ca 1667 }
37e55690
JJ		 1668 if (r_type != R_386_TLS_IE)
1669 break;
1670 /* Fall through */
252b5132 1671
37e55690
JJ		 1672 case R_386_TLS_LE_32:
1673 case R_386_TLS_LE:
1d85728f 1674 if (info->executable)
37e55690 1675 break;
bffbf940 1676 info->flags |= DF_STATIC_TLS;
b34976b6 1677 /* Fall through */
252b5132
RH		 1678
1679 case R_386_32:
1680 case R_386_PC32:
710ab287 1681 if (h != NULL && info->executable)
6725bdbf 1682 {
12d0ee4a 1683 /* If this reloc is in a read-only section, we might
ebe50bae
AM		 1684 need a copy reloc. We can't check reliably at this
1685 stage whether the section is read-only, as input
1686 sections have not yet been mapped to output sections.
1687 Tentatively set the flag for now, and correct in
1688 adjust_dynamic_symbol. */
f5385ebf 1689 h->non_got_ref = 1;
12d0ee4a
AM		 1690
1691 /* We may need a .plt entry if the function this reloc
1692 refers to is in a shared lib. */
51b64d56 1693 h->plt.refcount += 1;
c6585bbb 1694 if (r_type != R_386_PC32)
f5385ebf 1695 h->pointer_equality_needed = 1;
6725bdbf 1696 }
7843f00e 1697
06a6a421 1698 size_reloc = FALSE;
6a3e1bae 1699do_size:
252b5132 1700 /* If we are creating a shared library, and this is a reloc
f69da49f
AM		 1701 against a global symbol, or a non PC relative reloc
1702 against a local symbol, then we need to copy the reloc
1703 into the shared library. However, if we are linking with
1704 -Bsymbolic, we do not need to copy a reloc against a
1705 global symbol which is defined in an object we are
1706 including in the link (i.e., DEF_REGULAR is set). At
1707 this point we have not seen all the input files, so it is
1708 possible that DEF_REGULAR is not set now but will be set
1f655a09
L		 1709 later (it is never cleared). In case of a weak definition,
1710 DEF_REGULAR may be cleared later by a strong definition in
ebe50bae 1711 a shared library. We account for that possibility below by
1f655a09
L		 1712 storing information in the relocs_copied field of the hash
1713 table entry. A similar situation occurs when creating
1714 shared libraries and symbol visibility changes render the
12d0ee4a 1715 symbol local.
56882138 1716
12d0ee4a
AM		 1717 If on the other hand, we are creating an executable, we
1718 may need to keep relocations for symbols satisfied by a
1719 dynamic library if we manage to avoid copy relocs for the
1720 symbol. */
1721 if ((info->shared
1722 && (sec->flags & SEC_ALLOC) != 0
13ae64f3 1723 && (r_type != R_386_PC32
12d0ee4a 1724 || (h != NULL
55255dae 1725 && (! SYMBOLIC_BIND (info, h)
12d0ee4a 1726 || h->root.type == bfd_link_hash_defweak
f5385ebf 1727 || !h->def_regular))))
a23b6845
AM		 1728 || (ELIMINATE_COPY_RELOCS
1729 && !info->shared
12d0ee4a
AM		 1730 && (sec->flags & SEC_ALLOC) != 0
1731 && h != NULL
12d0ee4a 1732 && (h->root.type == bfd_link_hash_defweak
0f88be7a 1733 || !h->def_regular)))
252b5132 1734 {
e03a8ed8
L		 1735 struct elf_dyn_relocs *p;
1736 struct elf_dyn_relocs **head;
ec338859 1737
12d0ee4a
AM		 1738 /* We must copy these reloc types into the output file.
1739 Create a reloc section in dynobj and make room for
1740 this reloc. */
252b5132
RH		 1741 if (sreloc == NULL)
1742 {
0ac8d2ca
AM		 1743 if (htab->elf.dynobj == NULL)
1744 htab->elf.dynobj = abfd;
1745
83bac4b0
NC		 1746 sreloc = _bfd_elf_make_dynamic_reloc_section
1747 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
1748
252b5132 1749 if (sreloc == NULL)
c2e61a4e 1750 return FALSE;
252b5132
RH		 1751 }
1752
0c715baa
AM		 1753 /* If this is a global symbol, we count the number of
1754 relocations we need for this symbol. */
1755 if (h != NULL)
252b5132 1756 {
ec338859 1757 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
0c715baa
AM		 1758 }
1759 else
1760 {
ec338859
AM		 1761 /* Track dynamic relocs needed for local syms too.
1762 We really need local syms available to do this
1763 easily. Oh well. */
87d72d41 1764 void **vpp;
ec338859 1765 asection *s;
87d72d41
AM		 1766
1767 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1768 abfd, r_symndx);
1769 if (isym == NULL)
1770 return FALSE;
1771
1772 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
ec338859 1773 if (s == NULL)
87d72d41 1774 s = sec;
ec338859 1775
e81d3500 1776 vpp = &elf_section_data (s)->local_dynrel;
e03a8ed8 1777 head = (struct elf_dyn_relocs **)vpp;
ec338859
AM		 1778 }
1779
1780 p = *head;
1781 if (p == NULL || p->sec != sec)
1782 {
1783 bfd_size_type amt = sizeof *p;
a50b1753
NC		 1784 p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
1785 amt);
ec338859 1786 if (p == NULL)
c2e61a4e 1787 return FALSE;
ec338859
AM		 1788 p->next = *head;
1789 *head = p;
1790 p->sec = sec;
1791 p->count = 0;
1792 p->pc_count = 0;
252b5132 1793 }
ec338859
AM		 1794
1795 p->count += 1;
06a6a421
L		 1796 /* Count size relocation as PC-relative relocation. */
1797 if (r_type == R_386_PC32 || size_reloc)
ec338859 1798 p->pc_count += 1;
252b5132 1799 }
252b5132
RH		 1800 break;
1801
1802 /* This relocation describes the C++ object vtable hierarchy.
1803 Reconstruct it for later use during GC. */
1804 case R_386_GNU_VTINHERIT:
d17e0c6e 1805 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
c2e61a4e 1806 return FALSE;
252b5132
RH		 1807 break;
1808
1809 /* This relocation describes which C++ vtable entries are actually
1810 used. Record for later use during GC. */
1811 case R_386_GNU_VTENTRY:
c6aa130f
MS		 1812 BFD_ASSERT (h != NULL);
1813 if (h != NULL
1814 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
c2e61a4e 1815 return FALSE;
252b5132
RH		 1816 break;
1817
1818 default:
1819 break;
1820 }
1821 }
1822
b34976b6 1823 return TRUE;
252b5132
RH		 1824}
1825
1826/* Return the section that should be marked against GC for a given
1827 relocation. */
1828
1829static asection *
55fd94b0 1830elf_i386_gc_mark_hook (asection *sec,
07adf181 1831 struct bfd_link_info *info,
55fd94b0
AM		 1832 Elf_Internal_Rela *rel,
1833 struct elf_link_hash_entry *h,
1834 Elf_Internal_Sym *sym)
252b5132
RH		 1835{
1836 if (h != NULL)
07adf181
AM		 1837 switch (ELF32_R_TYPE (rel->r_info))
1838 {
1839 case R_386_GNU_VTINHERIT:
1840 case R_386_GNU_VTENTRY:
1841 return NULL;
1842 }
1843
1844 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
252b5132
RH		 1845}
1846
1847/* Update the got entry reference counts for the section being removed. */
1848
b34976b6 1849static bfd_boolean
55fd94b0
AM		 1850elf_i386_gc_sweep_hook (bfd *abfd,
1851 struct bfd_link_info *info,
1852 asection *sec,
1853 const Elf_Internal_Rela *relocs)
252b5132 1854{
4dfe6ac6 1855 struct elf_i386_link_hash_table *htab;
dd5724d5
AM		 1856 Elf_Internal_Shdr *symtab_hdr;
1857 struct elf_link_hash_entry **sym_hashes;
1858 bfd_signed_vma *local_got_refcounts;
1859 const Elf_Internal_Rela *rel, *relend;
dd5724d5 1860
7dda2462
TG		 1861 if (info->relocatable)
1862 return TRUE;
1863
4dfe6ac6
NC		 1864 htab = elf_i386_hash_table (info);
1865 if (htab == NULL)
1866 return FALSE;
1867
ec338859 1868 elf_section_data (sec)->local_dynrel = NULL;
dd5724d5 1869
0ffa91dd 1870 symtab_hdr = &elf_symtab_hdr (abfd);
6725bdbf
AM		 1871 sym_hashes = elf_sym_hashes (abfd);
1872 local_got_refcounts = elf_local_got_refcounts (abfd);
dd5724d5
AM		 1873
1874 relend = relocs + sec->reloc_count;
1875 for (rel = relocs; rel < relend; rel++)
26e41594
AM		 1876 {
1877 unsigned long r_symndx;
1878 unsigned int r_type;
1879 struct elf_link_hash_entry *h = NULL;
37e55690 1880
26e41594
AM		 1881 r_symndx = ELF32_R_SYM (rel->r_info);
1882 if (r_symndx >= symtab_hdr->sh_info)
1883 {
26e41594 1884 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3eb128b2
AM		 1885 while (h->root.type == bfd_link_hash_indirect
1886 || h->root.type == bfd_link_hash_warning)
1887 h = (struct elf_link_hash_entry *) h->root.u.i.link;
26e41594 1888 }
bb1cb422
L		 1889 else
1890 {
1891 /* A local symbol. */
1892 Elf_Internal_Sym *isym;
1893
1894 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1895 abfd, r_symndx);
1896
1897 /* Check relocation against local STT_GNU_IFUNC symbol. */
1898 if (isym != NULL
1899 && ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1900 {
1901 h = elf_i386_get_local_sym_hash (htab, abfd, rel, FALSE);
1902 if (h == NULL)
1903 abort ();
1904 }
1905 }
0c715baa 1906
3db2e7dd
L		 1907 if (h)
1908 {
1909 struct elf_i386_link_hash_entry *eh;
1910 struct elf_dyn_relocs **pp;
1911 struct elf_dyn_relocs *p;
1912
1913 eh = (struct elf_i386_link_hash_entry *) h;
1914 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1915 if (p->sec == sec)
1916 {
1917 /* Everything must go for SEC. */
1918 *pp = p->next;
1919 break;
1920 }
1921 }
1922
26e41594 1923 r_type = ELF32_R_TYPE (rel->r_info);
142411ca
L		 1924 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1925 symtab_hdr, sym_hashes,
1926 &r_type, GOT_UNKNOWN,
23209a78 1927 rel, relend, h, r_symndx))
142411ca
L		 1928 return FALSE;
1929
26e41594
AM		 1930 switch (r_type)
1931 {
1932 case R_386_TLS_LDM:
4dfe6ac6
NC		 1933 if (htab->tls_ldm_got.refcount > 0)
1934 htab->tls_ldm_got.refcount -= 1;
26e41594 1935 break;
0c715baa 1936
26e41594 1937 case R_386_TLS_GD:
67a4f2b7
AO		 1938 case R_386_TLS_GOTDESC:
1939 case R_386_TLS_DESC_CALL:
26e41594
AM		 1940 case R_386_TLS_IE_32:
1941 case R_386_TLS_IE:
1942 case R_386_TLS_GOTIE:
1943 case R_386_GOT32:
1944 if (h != NULL)
1945 {
1946 if (h->got.refcount > 0)
1947 h->got.refcount -= 1;
bb1cb422
L		 1948 if (h->type == STT_GNU_IFUNC)
1949 {
1950 if (h->plt.refcount > 0)
1951 h->plt.refcount -= 1;
1952 }
26e41594
AM		 1953 }
1954 else if (local_got_refcounts != NULL)
1955 {
1956 if (local_got_refcounts[r_symndx] > 0)
1957 local_got_refcounts[r_symndx] -= 1;
1958 }
1959 break;
0c715baa 1960
26e41594
AM		 1961 case R_386_32:
1962 case R_386_PC32:
1788fc08 1963 case R_386_SIZE32:
3db2e7dd
L		 1964 if (info->shared
1965 && (h == NULL || h->type != STT_GNU_IFUNC))
26e41594
AM		 1966 break;
1967 /* Fall through */
6725bdbf 1968
26e41594
AM		 1969 case R_386_PLT32:
1970 if (h != NULL)
1971 {
1972 if (h->plt.refcount > 0)
1973 h->plt.refcount -= 1;
1974 }
1975 break;
dd5724d5 1976
bb1cb422
L		 1977 case R_386_GOTOFF:
1978 if (h != NULL && h->type == STT_GNU_IFUNC)
1979 {
1980 if (h->got.refcount > 0)
1981 h->got.refcount -= 1;
1982 if (h->plt.refcount > 0)
1983 h->plt.refcount -= 1;
1984 }
1985 break;
1986
26e41594
AM		 1987 default:
1988 break;
1989 }
1990 }
252b5132 1991
b34976b6 1992 return TRUE;
252b5132
RH		 1993}
1994
1995/* Adjust a symbol defined by a dynamic object and referenced by a
1996 regular object. The current definition is in some section of the
1997 dynamic object, but we're not including those sections. We have to
1998 change the definition to something the rest of the link can
1999 understand. */
2000
b34976b6 2001static bfd_boolean
55fd94b0
AM		 2002elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2003 struct elf_link_hash_entry *h)
252b5132 2004{
6725bdbf 2005 struct elf_i386_link_hash_table *htab;
252b5132 2006 asection *s;
5ca5bb35
L		 2007 struct elf_i386_link_hash_entry *eh;
2008 struct elf_dyn_relocs *p;
252b5132 2009
cbe950e9
L		 2010 /* STT_GNU_IFUNC symbol must go through PLT. */
2011 if (h->type == STT_GNU_IFUNC)
2012 {
73bcf233
L		 2013 /* All local STT_GNU_IFUNC references must be treate as local
2014 calls via local PLT. */
5ca5bb35
L		 2015 if (h->ref_regular
2016 && SYMBOL_CALLS_LOCAL (info, h))
2017 {
73bcf233 2018 bfd_size_type pc_count = 0, count = 0;
5ca5bb35
L		 2019 struct elf_dyn_relocs **pp;
2020
2021 eh = (struct elf_i386_link_hash_entry *) h;
2022 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2023 {
2024 pc_count += p->pc_count;
2025 p->count -= p->pc_count;
2026 p->pc_count = 0;
73bcf233 2027 count += p->count;
5ca5bb35
L		 2028 if (p->count == 0)
2029 *pp = p->next;
2030 else
2031 pp = &p->next;
2032 }
2033
73bcf233 2034 if (pc_count || count)
5ca5bb35
L		 2035 {
2036 h->needs_plt = 1;
5ca5bb35 2037 h->non_got_ref = 1;
a5479e5f
L		 2038 if (h->plt.refcount <= 0)
2039 h->plt.refcount = 1;
2040 else
2041 h->plt.refcount += 1;
5ca5bb35
L		 2042 }
2043 }
2044
cbe950e9
L		 2045 if (h->plt.refcount <= 0)
2046 {
2047 h->plt.offset = (bfd_vma) -1;
2048 h->needs_plt = 0;
2049 }
2050 return TRUE;
2051 }
2052
252b5132
RH		 2053 /* If this is a function, put it in the procedure linkage table. We
2054 will fill in the contents of the procedure linkage table later,
2055 when we know the address of the .got section. */
2056 if (h->type == STT_FUNC
f5385ebf 2057 || h->needs_plt)
252b5132 2058 {
6725bdbf 2059 if (h->plt.refcount <= 0
9c7a29a3
AM		 2060 || SYMBOL_CALLS_LOCAL (info, h)
2061 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2062 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 2063 {
2064 /* This case can occur if we saw a PLT32 reloc in an input
dd5724d5
AM		 2065 file, but the symbol was never referred to by a dynamic
2066 object, or if all references were garbage collected. In
2067 such a case, we don't actually need to build a procedure
2068 linkage table, and we can just do a PC32 reloc instead. */
bbd7ec4a 2069 h->plt.offset = (bfd_vma) -1;
f5385ebf 2070 h->needs_plt = 0;
252b5132
RH		 2071 }
2072
b34976b6 2073 return TRUE;
252b5132 2074 }
6725bdbf
AM		 2075 else
2076 /* It's possible that we incorrectly decided a .plt reloc was
2077 needed for an R_386_PC32 reloc to a non-function sym in
2078 check_relocs. We can't decide accurately between function and
2079 non-function syms in check-relocs; Objects loaded later in
2080 the link may change h->type. So fix it now. */
bbd7ec4a 2081 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 2082
2083 /* If this is a weak symbol, and there is a real definition, the
2084 processor independent code will have arranged for us to see the
2085 real definition first, and we can just use the same value. */
f6e332e6 2086 if (h->u.weakdef != NULL)
252b5132 2087 {
f6e332e6
AM		 2088 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2089 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2090 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2091 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 2092 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
f6e332e6 2093 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 2094 return TRUE;
252b5132
RH		 2095 }
2096
2097 /* This is a reference to a symbol defined by a dynamic object which
2098 is not a function. */
2099
2100 /* If we are creating a shared library, we must presume that the
2101 only references to the symbol are via the global offset table.
2102 For such cases we need not do anything here; the relocations will
2103 be handled correctly by relocate_section. */
2104 if (info->shared)
b34976b6 2105 return TRUE;
252b5132 2106
7843f00e
ILT		 2107 /* If there are no references to this symbol that do not use the
2108 GOT, we don't need to generate a copy reloc. */
f5385ebf 2109 if (!h->non_got_ref)
b34976b6 2110 return TRUE;
7843f00e 2111
8bd621d8
AM		 2112 /* If -z nocopyreloc was given, we won't generate them either. */
2113 if (info->nocopyreloc)
2114 {
f5385ebf 2115 h->non_got_ref = 0;
b34976b6 2116 return TRUE;
8bd621d8
AM		 2117 }
2118
643796e3 2119 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 2120 if (htab == NULL)
2121 return FALSE;
643796e3
DJ		 2122
2123 /* If there aren't any dynamic relocs in read-only sections, then
2124 we can keep the dynamic relocs and avoid the copy reloc. This
2125 doesn't work on VxWorks, where we can not have dynamic relocations
2126 (other than copy and jump slot relocations) in an executable. */
23209a78
RM		 2127 if (ELIMINATE_COPY_RELOCS
2128 && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
ebe50bae 2129 {
a23b6845
AM		 2130 eh = (struct elf_i386_link_hash_entry *) h;
2131 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2132 {
2133 s = p->sec->output_section;
2134 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2135 break;
2136 }
2137
a23b6845
AM		 2138 if (p == NULL)
2139 {
f5385ebf 2140 h->non_got_ref = 0;
a23b6845
AM		 2141 return TRUE;
2142 }
ebe50bae
AM		 2143 }
2144
252b5132
RH		 2145 /* We must allocate the symbol in our .dynbss section, which will
2146 become part of the .bss section of the executable. There will be
2147 an entry for this symbol in the .dynsym section. The dynamic
2148 object will contain position independent code, so all references
2149 from the dynamic object to this symbol will go through the global
2150 offset table. The dynamic linker will use the .dynsym entry to
2151 determine the address it must put in the global offset table, so
2152 both the dynamic object and the regular object will refer to the
2153 same memory location for the variable. */
2154
252b5132
RH		 2155 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2156 copy the initial value out of the dynamic object and into the
0ac8d2ca 2157 runtime process image. */
1d7e9d18 2158 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
252b5132 2159 {
eea6121a 2160 htab->srelbss->size += sizeof (Elf32_External_Rel);
f5385ebf 2161 h->needs_copy = 1;
252b5132
RH		 2162 }
2163
0ac8d2ca 2164 s = htab->sdynbss;
252b5132 2165
027297b7 2166 return _bfd_elf_adjust_dynamic_copy (h, s);
252b5132
RH		 2167}
2168
6725bdbf 2169/* Allocate space in .plt, .got and associated reloc sections for
0c715baa 2170 dynamic relocs. */
6725bdbf 2171
b34976b6 2172static bfd_boolean
eb4ff4d6 2173elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
6725bdbf
AM		 2174{
2175 struct bfd_link_info *info;
2176 struct elf_i386_link_hash_table *htab;
5a15f56f 2177 struct elf_i386_link_hash_entry *eh;
e03a8ed8 2178 struct elf_dyn_relocs *p;
25e762b9 2179 unsigned plt_entry_size;
6725bdbf 2180
e92d460e 2181 if (h->root.type == bfd_link_hash_indirect)
b34976b6 2182 return TRUE;
6725bdbf 2183
cbe950e9 2184 eh = (struct elf_i386_link_hash_entry *) h;
e92d460e 2185
6725bdbf
AM		 2186 info = (struct bfd_link_info *) inf;
2187 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 2188 if (htab == NULL)
2189 return FALSE;
6725bdbf 2190
25e762b9
RM		 2191 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2192
cbe950e9
L		 2193 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2194 here if it is defined and referenced in a non-shared object. */
2195 if (h->type == STT_GNU_IFUNC
2196 && h->def_regular)
25e762b9 2197 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
7b70956d
WN		 2198 plt_entry_size,
2199 plt_entry_size, 4);
cbe950e9
L		 2200 else if (htab->elf.dynamic_sections_created
2201 && h->plt.refcount > 0)
6725bdbf 2202 {
5a15f56f
AM		 2203 /* Make sure this symbol is output as a dynamic symbol.
2204 Undefined weak syms won't yet be marked as dynamic. */
2205 if (h->dynindx == -1
f5385ebf 2206 && !h->forced_local)
5a15f56f 2207 {
c152c796 2208 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2209 return FALSE;
5a15f56f
AM		 2210 }
2211
4e795f50
AM		 2212 if (info->shared
2213 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
ced53ee5 2214 {
6de2ae4a 2215 asection *s = htab->elf.splt;
6725bdbf 2216
ced53ee5
AM		 2217 /* If this is the first .plt entry, make room for the special
2218 first entry. */
eea6121a 2219 if (s->size == 0)
bb81b736 2220 s->size = plt_entry_size;
6725bdbf 2221
eea6121a 2222 h->plt.offset = s->size;
6725bdbf 2223
ced53ee5
AM		 2224 /* If this symbol is not defined in a regular file, and we are
2225 not generating a shared library, then set the symbol to this
2226 location in the .plt. This is required to make function
2227 pointers compare as equal between the normal executable and
2228 the shared library. */
2229 if (! info->shared
f5385ebf 2230 && !h->def_regular)
ced53ee5
AM		 2231 {
2232 h->root.u.def.section = s;
2233 h->root.u.def.value = h->plt.offset;
2234 }
6725bdbf 2235
ced53ee5 2236 /* Make room for this entry. */
25e762b9 2237 s->size += plt_entry_size;
6725bdbf 2238
ced53ee5
AM		 2239 /* We also need to make an entry in the .got.plt section, which
2240 will be placed in the .got section by the linker script. */
6de2ae4a 2241 htab->elf.sgotplt->size += 4;
6725bdbf 2242
6725bdbf 2243 /* We also need to make an entry in the .rel.plt section. */
6de2ae4a 2244 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
e1f98742 2245 htab->elf.srelplt->reloc_count++;
eac338cf 2246
23209a78
RM		 2247 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
2248 && !info->shared)
eac338cf
PB		 2249 {
2250 /* VxWorks has a second set of relocations for each PLT entry
2251 in executables. They go in a separate relocation section,
2252 which is processed by the kernel loader. */
2253
2254 /* There are two relocations for the initial PLT entry: an
2255 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2256 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2257
25e762b9 2258 if (h->plt.offset == plt_entry_size)
eac338cf
PB		 2259 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2260
2261 /* There are two extra relocations for each subsequent PLT entry:
2262 an R_386_32 relocation for the GOT entry, and an R_386_32
2263 relocation for the PLT entry. */
2264
2265 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2266 }
6725bdbf 2267 }
ced53ee5
AM		 2268 else
2269 {
51b64d56 2270 h->plt.offset = (bfd_vma) -1;
f5385ebf 2271 h->needs_plt = 0;
ced53ee5 2272 }
6725bdbf
AM		 2273 }
2274 else
2275 {
51b64d56 2276 h->plt.offset = (bfd_vma) -1;
f5385ebf 2277 h->needs_plt = 0;
6725bdbf
AM		 2278 }
2279
67a4f2b7
AO		 2280 eh->tlsdesc_got = (bfd_vma) -1;
2281
37e55690 2282 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
13ae64f3
JJ		 2283 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2284 if (h->got.refcount > 0
1d85728f 2285 && info->executable
13ae64f3 2286 && h->dynindx == -1
37e55690 2287 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
cedb70c5 2288 h->got.offset = (bfd_vma) -1;
13ae64f3 2289 else if (h->got.refcount > 0)
6725bdbf 2290 {
0ac8d2ca 2291 asection *s;
b34976b6 2292 bfd_boolean dyn;
13ae64f3 2293 int tls_type = elf_i386_hash_entry(h)->tls_type;
6725bdbf 2294
5a15f56f
AM		 2295 /* Make sure this symbol is output as a dynamic symbol.
2296 Undefined weak syms won't yet be marked as dynamic. */
2297 if (h->dynindx == -1
f5385ebf 2298 && !h->forced_local)
5a15f56f 2299 {
c152c796 2300 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2301 return FALSE;
5a15f56f
AM		 2302 }
2303
6de2ae4a 2304 s = htab->elf.sgot;
67a4f2b7
AO		 2305 if (GOT_TLS_GDESC_P (tls_type))
2306 {
6de2ae4a 2307 eh->tlsdesc_got = htab->elf.sgotplt->size
67a4f2b7 2308 - elf_i386_compute_jump_table_size (htab);
6de2ae4a 2309 htab->elf.sgotplt->size += 8;
67a4f2b7
AO		 2310 h->got.offset = (bfd_vma) -2;
2311 }
2312 if (! GOT_TLS_GDESC_P (tls_type)
2313 || GOT_TLS_GD_P (tls_type))
2314 {
2315 h->got.offset = s->size;
2316 s->size += 4;
2317 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2318 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2319 s->size += 4;
2320 }
ebe50bae 2321 dyn = htab->elf.dynamic_sections_created;
13ae64f3 2322 /* R_386_TLS_IE_32 needs one dynamic relocation,
37e55690
JJ		 2323 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2324 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2325 need two), R_386_TLS_GD needs one if local symbol and two if
2326 global. */
2327 if (tls_type == GOT_TLS_IE_BOTH)
6de2ae4a 2328 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7 2329 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
37e55690 2330 || (tls_type & GOT_TLS_IE))
6de2ae4a 2331 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7 2332 else if (GOT_TLS_GD_P (tls_type))
6de2ae4a 2333 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7
AO		 2334 else if (! GOT_TLS_GDESC_P (tls_type)
2335 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2336 || h->root.type != bfd_link_hash_undefweak)
ef5aade5
L		 2337 && (info->shared
2338 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
6de2ae4a 2339 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7 2340 if (GOT_TLS_GDESC_P (tls_type))
6de2ae4a 2341 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
6725bdbf
AM		 2342 }
2343 else
51b64d56 2344 h->got.offset = (bfd_vma) -1;
6725bdbf 2345
5a15f56f 2346 if (eh->dyn_relocs == NULL)
b34976b6 2347 return TRUE;
5a15f56f 2348
0c715baa
AM		 2349 /* In the shared -Bsymbolic case, discard space allocated for
2350 dynamic pc-relative relocs against symbols which turn out to be
2351 defined in regular objects. For the normal shared case, discard
0ac8d2ca
AM		 2352 space for pc-relative relocs that have become local due to symbol
2353 visibility changes. */
0c715baa
AM		 2354
2355 if (info->shared)
5a15f56f 2356 {
09695f56
AM		 2357 /* The only reloc that uses pc_count is R_386_PC32, which will
2358 appear on a call or on something like ".long foo - .". We
2359 want calls to protected symbols to resolve directly to the
2360 function rather than going via the plt. If people want
2361 function pointer comparisons to work as expected then they
2362 should avoid writing assembly like ".long foo - .". */
2363 if (SYMBOL_CALLS_LOCAL (info, h))
5a15f56f 2364 {
e03a8ed8 2365 struct elf_dyn_relocs **pp;
0c715baa
AM		 2366
2367 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2368 {
c3ce498c
L		 2369 p->count -= p->pc_count;
2370 p->pc_count = 0;
0c715baa
AM		 2371 if (p->count == 0)
2372 *pp = p->next;
2373 else
2374 pp = &p->next;
2375 }
5a15f56f 2376 }
4e795f50 2377
23209a78 2378 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
3348747a 2379 {
e03a8ed8 2380 struct elf_dyn_relocs **pp;
3348747a
NS		 2381 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2382 {
2383 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2384 *pp = p->next;
2385 else
2386 pp = &p->next;
2387 }
2388 }
2389
4e795f50 2390 /* Also discard relocs on undefined weak syms with non-default
c353e543 2391 visibility. */
22d606e9 2392 if (eh->dyn_relocs != NULL
c353e543 2393 && h->root.type == bfd_link_hash_undefweak)
22d606e9
AM		 2394 {
2395 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2396 eh->dyn_relocs = NULL;
2397
2398 /* Make sure undefined weak symbols are output as a dynamic
2399 symbol in PIEs. */
2400 else if (h->dynindx == -1
2401 && !h->forced_local)
2402 {
2403 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2404 return FALSE;
2405 }
2406 }
0c715baa 2407 }
a23b6845 2408 else if (ELIMINATE_COPY_RELOCS)
0c715baa
AM		 2409 {
2410 /* For the non-shared case, discard space for relocs against
2411 symbols which turn out to need copy relocs or are not
2412 dynamic. */
2413
f5385ebf
AM		 2414 if (!h->non_got_ref
2415 && ((h->def_dynamic
2416 && !h->def_regular)
ebe50bae 2417 || (htab->elf.dynamic_sections_created
0c715baa
AM		 2418 && (h->root.type == bfd_link_hash_undefweak
2419 || h->root.type == bfd_link_hash_undefined))))
2420 {
2421 /* Make sure this symbol is output as a dynamic symbol.
2422 Undefined weak syms won't yet be marked as dynamic. */
2423 if (h->dynindx == -1
f5385ebf 2424 && !h->forced_local)
0c715baa 2425 {
c152c796 2426 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2427 return FALSE;
0c715baa 2428 }
5a15f56f 2429
0c715baa
AM		 2430 /* If that succeeded, we know we'll be keeping all the
2431 relocs. */
2432 if (h->dynindx != -1)
2433 goto keep;
2434 }
2435
2436 eh->dyn_relocs = NULL;
2437
ec338859 2438 keep: ;
5a15f56f
AM		 2439 }
2440
0c715baa
AM		 2441 /* Finally, allocate space. */
2442 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12d0ee4a 2443 {
e7c33416
NC		 2444 asection *sreloc;
2445
cbe950e9 2446 sreloc = elf_section_data (p->sec)->sreloc;
e7c33416
NC		 2447
2448 BFD_ASSERT (sreloc != NULL);
eea6121a 2449 sreloc->size += p->count * sizeof (Elf32_External_Rel);
12d0ee4a
AM		 2450 }
2451
b34976b6 2452 return TRUE;
6725bdbf
AM		 2453}
2454
c25bc9fc
L		 2455/* Allocate space in .plt, .got and associated reloc sections for
2456 local dynamic relocs. */
2457
2458static bfd_boolean
2459elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2460{
2461 struct elf_link_hash_entry *h
2462 = (struct elf_link_hash_entry *) *slot;
2463
2464 if (h->type != STT_GNU_IFUNC
2465 || !h->def_regular
2466 || !h->ref_regular
2467 || !h->forced_local
2468 || h->root.type != bfd_link_hash_defined)
2469 abort ();
2470
2471 return elf_i386_allocate_dynrelocs (h, inf);
2472}
2473
0c715baa
AM		 2474/* Find any dynamic relocs that apply to read-only sections. */
2475
b34976b6 2476static bfd_boolean
eb4ff4d6 2477elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
0c715baa
AM		 2478{
2479 struct elf_i386_link_hash_entry *eh;
e03a8ed8 2480 struct elf_dyn_relocs *p;
0c715baa 2481
aa715242
L		 2482 /* Skip local IFUNC symbols. */
2483 if (h->forced_local && h->type == STT_GNU_IFUNC)
2484 return TRUE;
2485
0c715baa
AM		 2486 eh = (struct elf_i386_link_hash_entry *) h;
2487 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2488 {
2489 asection *s = p->sec->output_section;
2490
2491 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2492 {
2493 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2494
2495 info->flags |= DF_TEXTREL;
2496
b70321a2
L		 2497 if (info->warn_shared_textrel && info->shared)
2498 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2499 p->sec->owner, h->root.root.string,
2500 p->sec);
2501
0c715baa 2502 /* Not an error, just cut short the traversal. */
b34976b6 2503 return FALSE;
0c715baa
AM		 2504 }
2505 }
b34976b6 2506 return TRUE;
0c715baa
AM		 2507}
2508
daa67607
L		 2509/* Convert
2510 mov foo@GOT(%reg), %reg
2511 to
2512 lea foo@GOTOFF(%reg), %reg
2513 with the local symbol, foo. */
2514
2515static bfd_boolean
2516elf_i386_convert_mov_to_lea (bfd *abfd, asection *sec,
2517 struct bfd_link_info *link_info)
2518{
2519 Elf_Internal_Shdr *symtab_hdr;
2520 Elf_Internal_Rela *internal_relocs;
2521 Elf_Internal_Rela *irel, *irelend;
2522 bfd_byte *contents;
2523 struct elf_i386_link_hash_table *htab;
2524 bfd_boolean changed_contents;
2525 bfd_boolean changed_relocs;
2526 bfd_signed_vma *local_got_refcounts;
2527
2528 /* Don't even try to convert non-ELF outputs. */
2529 if (!is_elf_hash_table (link_info->hash))
2530 return FALSE;
2531
fbdc86d9 2532 /* Nothing to do if there are no codes, no relocations or no output. */
daa67607 2533 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
fbdc86d9
L		 2534 || sec->reloc_count == 0
2535 || discarded_section (sec))
daa67607
L		 2536 return TRUE;
2537
2538 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2539
2540 /* Load the relocations for this section. */
2541 internal_relocs = (_bfd_elf_link_read_relocs
2542 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2543 link_info->keep_memory));
2544 if (internal_relocs == NULL)
2545 return FALSE;
2546
2547 htab = elf_i386_hash_table (link_info);
2548 changed_contents = FALSE;
2549 changed_relocs = FALSE;
2550 local_got_refcounts = elf_local_got_refcounts (abfd);
2551
2552 /* Get the section contents. */
2553 if (elf_section_data (sec)->this_hdr.contents != NULL)
2554 contents = elf_section_data (sec)->this_hdr.contents;
2555 else
2556 {
2557 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2558 goto error_return;
2559 }
2560
2561 irelend = internal_relocs + sec->reloc_count;
2562 for (irel = internal_relocs; irel < irelend; irel++)
2563 {
2564 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2565 unsigned int r_symndx = ELF32_R_SYM (irel->r_info);
2566 unsigned int indx;
2567 struct elf_link_hash_entry *h;
2568
2569 if (r_type != R_386_GOT32)
2570 continue;
2571
2572 /* Get the symbol referred to by the reloc. */
2573 if (r_symndx < symtab_hdr->sh_info)
2574 {
2575 Elf_Internal_Sym *isym;
2576
2577 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2578 abfd, r_symndx);
2579
2580 /* STT_GNU_IFUNC must keep R_386_GOT32 relocation. */
2581 if (ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC
2582 && bfd_get_8 (input_bfd,
2583 contents + irel->r_offset - 2) == 0x8b)
2584 {
2585 bfd_put_8 (output_bfd, 0x8d,
2586 contents + irel->r_offset - 2);
2587 irel->r_info = ELF32_R_INFO (r_symndx, R_386_GOTOFF);
2588 if (local_got_refcounts != NULL
2589 && local_got_refcounts[r_symndx] > 0)
2590 local_got_refcounts[r_symndx] -= 1;
2591 changed_contents = TRUE;
2592 changed_relocs = TRUE;
2593 }
2594 continue;
2595 }
2596
2597 indx = r_symndx - symtab_hdr->sh_info;
2598 h = elf_sym_hashes (abfd)[indx];
2599 BFD_ASSERT (h != NULL);
2600
2601 while (h->root.type == bfd_link_hash_indirect
2602 || h->root.type == bfd_link_hash_warning)
2603 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2604
3f65f599
L		 2605 /* STT_GNU_IFUNC must keep R_386_GOT32 relocation. We also avoid
2606 optimizing _DYNAMIC since ld.so may use its link-time address. */
daa67607
L		 2607 if (h->def_regular
2608 && h->type != STT_GNU_IFUNC
9637f6ef 2609 && h != htab->elf.hdynamic
daa67607
L		 2610 && SYMBOL_REFERENCES_LOCAL (link_info, h)
2611 && bfd_get_8 (input_bfd,
2612 contents + irel->r_offset - 2) == 0x8b)
2613 {
2614 bfd_put_8 (output_bfd, 0x8d,
2615 contents + irel->r_offset - 2);
2616 irel->r_info = ELF32_R_INFO (r_symndx, R_386_GOTOFF);
2617 if (h->got.refcount > 0)
2618 h->got.refcount -= 1;
2619 changed_contents = TRUE;
2620 changed_relocs = TRUE;
2621 }
2622 }
2623
2624 if (contents != NULL
2625 && elf_section_data (sec)->this_hdr.contents != contents)
2626 {
2627 if (!changed_contents && !link_info->keep_memory)
2628 free (contents);
2629 else
2630 {
2631 /* Cache the section contents for elf_link_input_bfd. */
2632 elf_section_data (sec)->this_hdr.contents = contents;
2633 }
2634 }
2635
2636 if (elf_section_data (sec)->relocs != internal_relocs)
2637 {
2638 if (!changed_relocs)
2639 free (internal_relocs);
2640 else
2641 elf_section_data (sec)->relocs = internal_relocs;
2642 }
2643
2644 return TRUE;
2645
2646 error_return:
2647 if (contents != NULL
2648 && elf_section_data (sec)->this_hdr.contents != contents)
2649 free (contents);
2650 if (internal_relocs != NULL
2651 && elf_section_data (sec)->relocs != internal_relocs)
2652 free (internal_relocs);
2653 return FALSE;
2654}
2655
252b5132
RH		 2656/* Set the sizes of the dynamic sections. */
2657
b34976b6 2658static bfd_boolean
23209a78 2659elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
252b5132 2660{
6725bdbf 2661 struct elf_i386_link_hash_table *htab;
252b5132
RH		 2662 bfd *dynobj;
2663 asection *s;
b34976b6 2664 bfd_boolean relocs;
0c715baa 2665 bfd *ibfd;
252b5132 2666
6725bdbf 2667 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 2668 if (htab == NULL)
2669 return FALSE;
ebe50bae 2670 dynobj = htab->elf.dynobj;
ffb2e45b
AM		 2671 if (dynobj == NULL)
2672 abort ();
252b5132 2673
ebe50bae 2674 if (htab->elf.dynamic_sections_created)
252b5132
RH		 2675 {
2676 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 2677 if (info->executable)
252b5132 2678 {
3d4d4302 2679 s = bfd_get_linker_section (dynobj, ".interp");
ffb2e45b
AM		 2680 if (s == NULL)
2681 abort ();
eea6121a 2682 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
252b5132
RH		 2683 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2684 }
161d71a6 2685 }
6725bdbf 2686
0c715baa
AM		 2687 /* Set up .got offsets for local syms, and space for local dynamic
2688 relocs. */
2689 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
161d71a6
L		 2690 {
2691 bfd_signed_vma *local_got;
2692 bfd_signed_vma *end_local_got;
13ae64f3 2693 char *local_tls_type;
67a4f2b7 2694 bfd_vma *local_tlsdesc_gotent;
161d71a6
L		 2695 bfd_size_type locsymcount;
2696 Elf_Internal_Shdr *symtab_hdr;
2697 asection *srel;
6725bdbf 2698
0ffa91dd 2699 if (! is_i386_elf (ibfd))
161d71a6 2700 continue;
6725bdbf 2701
0c715baa
AM		 2702 for (s = ibfd->sections; s != NULL; s = s->next)
2703 {
e03a8ed8 2704 struct elf_dyn_relocs *p;
0c715baa 2705
daa67607
L		 2706 if (!elf_i386_convert_mov_to_lea (ibfd, s, info))
2707 return FALSE;
2708
e03a8ed8 2709 for (p = ((struct elf_dyn_relocs *)
e81d3500 2710 elf_section_data (s)->local_dynrel);
ec338859
AM		 2711 p != NULL;
2712 p = p->next)
0c715baa 2713 {
ec338859
AM		 2714 if (!bfd_is_abs_section (p->sec)
2715 && bfd_is_abs_section (p->sec->output_section))
2716 {
2717 /* Input section has been discarded, either because
2718 it is a copy of a linkonce section or due to
2719 linker script /DISCARD/, so we'll be discarding
2720 the relocs too. */
2721 }
23209a78 2722 else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3348747a
NS		 2723 && strcmp (p->sec->output_section->name,
2724 ".tls_vars") == 0)
2725 {
2726 /* Relocations in vxworks .tls_vars sections are
2727 handled specially by the loader. */
2728 }
248866a8 2729 else if (p->count != 0)
ec338859
AM		 2730 {
2731 srel = elf_section_data (p->sec)->sreloc;
eea6121a 2732 srel->size += p->count * sizeof (Elf32_External_Rel);
4b819e1f
L		 2733 if ((p->sec->output_section->flags & SEC_READONLY) != 0
2734 && (info->flags & DF_TEXTREL) == 0)
b70321a2
L		 2735 {
2736 info->flags |= DF_TEXTREL;
2737 if (info->warn_shared_textrel && info->shared)
2738 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2739 p->sec->owner, p->sec);
b70321a2 2740 }
ec338859 2741 }
0c715baa
AM		 2742 }
2743 }
2744
2745 local_got = elf_local_got_refcounts (ibfd);
161d71a6
L		 2746 if (!local_got)
2747 continue;
6725bdbf 2748
0ffa91dd 2749 symtab_hdr = &elf_symtab_hdr (ibfd);
161d71a6
L		 2750 locsymcount = symtab_hdr->sh_info;
2751 end_local_got = local_got + locsymcount;
13ae64f3 2752 local_tls_type = elf_i386_local_got_tls_type (ibfd);
67a4f2b7 2753 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
6de2ae4a
L		 2754 s = htab->elf.sgot;
2755 srel = htab->elf.srelgot;
67a4f2b7
AO		 2756 for (; local_got < end_local_got;
2757 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
161d71a6 2758 {
67a4f2b7 2759 *local_tlsdesc_gotent = (bfd_vma) -1;
161d71a6 2760 if (*local_got > 0)
6725bdbf 2761 {
67a4f2b7
AO		 2762 if (GOT_TLS_GDESC_P (*local_tls_type))
2763 {
6de2ae4a 2764 *local_tlsdesc_gotent = htab->elf.sgotplt->size
67a4f2b7 2765 - elf_i386_compute_jump_table_size (htab);
6de2ae4a 2766 htab->elf.sgotplt->size += 8;
67a4f2b7
AO		 2767 *local_got = (bfd_vma) -2;
2768 }
2769 if (! GOT_TLS_GDESC_P (*local_tls_type)
2770 || GOT_TLS_GD_P (*local_tls_type))
2771 {
2772 *local_got = s->size;
2773 s->size += 4;
2774 if (GOT_TLS_GD_P (*local_tls_type)
2775 || *local_tls_type == GOT_TLS_IE_BOTH)
2776 s->size += 4;
2777 }
13ae64f3 2778 if (info->shared
67a4f2b7 2779 || GOT_TLS_GD_ANY_P (*local_tls_type)
37e55690
JJ		 2780 || (*local_tls_type & GOT_TLS_IE))
2781 {
2782 if (*local_tls_type == GOT_TLS_IE_BOTH)
eea6121a 2783 srel->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7
AO		 2784 else if (GOT_TLS_GD_P (*local_tls_type)
2785 || ! GOT_TLS_GDESC_P (*local_tls_type))
eea6121a 2786 srel->size += sizeof (Elf32_External_Rel);
67a4f2b7 2787 if (GOT_TLS_GDESC_P (*local_tls_type))
6de2ae4a 2788 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
37e55690 2789 }
6725bdbf 2790 }
161d71a6
L		 2791 else
2792 *local_got = (bfd_vma) -1;
6725bdbf 2793 }
252b5132 2794 }
6725bdbf 2795
13ae64f3
JJ		 2796 if (htab->tls_ldm_got.refcount > 0)
2797 {
2798 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2799 relocs. */
6de2ae4a
L		 2800 htab->tls_ldm_got.offset = htab->elf.sgot->size;
2801 htab->elf.sgot->size += 8;
2802 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
13ae64f3
JJ		 2803 }
2804 else
2805 htab->tls_ldm_got.offset = -1;
2806
0c715baa
AM		 2807 /* Allocate global sym .plt and .got entries, and space for global
2808 sym dynamic relocs. */
eb4ff4d6 2809 elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
252b5132 2810
c25bc9fc
L		 2811 /* Allocate .plt and .got entries, and space for local symbols. */
2812 htab_traverse (htab->loc_hash_table,
2813 elf_i386_allocate_local_dynrelocs,
2814 info);
2815
67a4f2b7
AO		 2816 /* For every jump slot reserved in the sgotplt, reloc_count is
2817 incremented. However, when we reserve space for TLS descriptors,
2818 it's not incremented, so in order to compute the space reserved
2819 for them, it suffices to multiply the reloc count by the jump
e1f98742 2820 slot size.
caa0075c 2821
e1f98742
L		 2822 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2823 so that R_386_IRELATIVE entries come last. */
6de2ae4a 2824 if (htab->elf.srelplt)
e1f98742
L		 2825 {
2826 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
2827 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
2828 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2829 }
2830 else if (htab->elf.irelplt)
2831 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2832
67a4f2b7 2833
a7b16ceb
L		 2834 if (htab->elf.sgotplt)
2835 {
2836 /* Don't allocate .got.plt section if there are no GOT nor PLT
9a2a56cc 2837 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
9d4b2dba
L		 2838 if ((htab->elf.hgot == NULL
2839 || !htab->elf.hgot->ref_regular_nonweak)
e28df02b
L		 2840 && (htab->elf.sgotplt->size
2841 == get_elf_backend_data (output_bfd)->got_header_size)
a7b16ceb
L		 2842 && (htab->elf.splt == NULL
2843 || htab->elf.splt->size == 0)
2844 && (htab->elf.sgot == NULL
2845 || htab->elf.sgot->size == 0)
2846 && (htab->elf.iplt == NULL
2847 || htab->elf.iplt->size == 0)
2848 && (htab->elf.igotplt == NULL
2849 || htab->elf.igotplt->size == 0))
2850 htab->elf.sgotplt->size = 0;
2851 }
2852
9a2a56cc
AM		 2853
2854 if (htab->plt_eh_frame != NULL
2855 && htab->elf.splt != NULL
2856 && htab->elf.splt->size != 0
2857 && !bfd_is_abs_section (htab->elf.splt->output_section)
2858 && _bfd_elf_eh_frame_present (info))
2859 htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
2860
5a15f56f
AM		 2861 /* We now have determined the sizes of the various dynamic sections.
2862 Allocate memory for them. */
b34976b6 2863 relocs = FALSE;
252b5132
RH		 2864 for (s = dynobj->sections; s != NULL; s = s->next)
2865 {
eac338cf
PB		 2866 bfd_boolean strip_section = TRUE;
2867
252b5132
RH		 2868 if ((s->flags & SEC_LINKER_CREATED) == 0)
2869 continue;
2870
6de2ae4a 2871 if (s == htab->elf.splt
9a2a56cc 2872 || s == htab->elf.sgot)
252b5132 2873 {
6725bdbf
AM		 2874 /* Strip this section if we don't need it; see the
2875 comment below. */
eac338cf
PB		 2876 /* We'd like to strip these sections if they aren't needed, but if
2877 we've exported dynamic symbols from them we must leave them.
2878 It's too late to tell BFD to get rid of the symbols. */
2879
7325306f 2880 if (htab->elf.hplt != NULL)
eac338cf 2881 strip_section = FALSE;
252b5132 2882 }
9a2a56cc
AM		 2883 else if (s == htab->elf.sgotplt
2884 || s == htab->elf.iplt
2885 || s == htab->elf.igotplt
2886 || s == htab->plt_eh_frame
2887 || s == htab->sdynbss)
2888 {
2889 /* Strip these too. */
2890 }
0112cd26 2891 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
252b5132 2892 {
6de2ae4a
L		 2893 if (s->size != 0
2894 && s != htab->elf.srelplt
2895 && s != htab->srelplt2)
b34976b6 2896 relocs = TRUE;
252b5132 2897
0ac8d2ca
AM		 2898 /* We use the reloc_count field as a counter if we need
2899 to copy relocs into the output file. */
5ae0bfb6 2900 s->reloc_count = 0;
252b5132 2901 }
6725bdbf 2902 else
252b5132
RH		 2903 {
2904 /* It's not one of our sections, so don't allocate space. */
2905 continue;
2906 }
2907
c456f082 2908 if (s->size == 0)
252b5132 2909 {
0ac8d2ca
AM		 2910 /* If we don't need this section, strip it from the
2911 output file. This is mostly to handle .rel.bss and
2912 .rel.plt. We must create both sections in
2913 create_dynamic_sections, because they must be created
2914 before the linker maps input sections to output
2915 sections. The linker does that before
2916 adjust_dynamic_symbol is called, and it is that
2917 function which decides whether anything needs to go
2918 into these sections. */
c456f082
AM		 2919 if (strip_section)
2920 s->flags |= SEC_EXCLUDE;
252b5132
RH		 2921 continue;
2922 }
2923
c456f082
AM		 2924 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2925 continue;
2926
f69da49f
AM		 2927 /* Allocate memory for the section contents. We use bfd_zalloc
2928 here in case unused entries are not reclaimed before the
2929 section's contents are written out. This should not happen,
2930 but this way if it does, we get a R_386_NONE reloc instead
2931 of garbage. */
a50b1753 2932 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
6725bdbf 2933 if (s->contents == NULL)
b34976b6 2934 return FALSE;
252b5132
RH		 2935 }
2936
e41b3a13 2937 if (htab->plt_eh_frame != NULL
9a2a56cc
AM		 2938 && htab->plt_eh_frame->contents != NULL)
2939 {
2940 memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
2941 sizeof (elf_i386_eh_frame_plt));
2942 bfd_put_32 (dynobj, htab->elf.splt->size,
2943 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2944 }
e41b3a13 2945
ebe50bae 2946 if (htab->elf.dynamic_sections_created)
252b5132
RH		 2947 {
2948 /* Add some entries to the .dynamic section. We fill in the
2949 values later, in elf_i386_finish_dynamic_sections, but we
2950 must add the entries now so that we get the correct size for
2951 the .dynamic section. The DT_DEBUG entry is filled in by the
2952 dynamic linker and used by the debugger. */
dc810e39 2953#define add_dynamic_entry(TAG, VAL) \
5a580b3a 2954 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 2955
36af4a4e 2956 if (info->executable)
252b5132 2957 {
dc810e39 2958 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 2959 return FALSE;
252b5132
RH		 2960 }
2961
6de2ae4a 2962 if (htab->elf.splt->size != 0)
252b5132 2963 {
dc810e39
AM		 2964 if (!add_dynamic_entry (DT_PLTGOT, 0)
2965 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2966 || !add_dynamic_entry (DT_PLTREL, DT_REL)
2967 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 2968 return FALSE;
252b5132
RH		 2969 }
2970
2971 if (relocs)
2972 {
dc810e39
AM		 2973 if (!add_dynamic_entry (DT_REL, 0)
2974 || !add_dynamic_entry (DT_RELSZ, 0)
2975 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
b34976b6 2976 return FALSE;
252b5132 2977
0c715baa
AM		 2978 /* If any dynamic relocs apply to a read-only section,
2979 then we need a DT_TEXTREL entry. */
248866a8 2980 if ((info->flags & DF_TEXTREL) == 0)
eb4ff4d6
L		 2981 elf_link_hash_traverse (&htab->elf,
2982 elf_i386_readonly_dynrelocs, info);
0c715baa
AM		 2983
2984 if ((info->flags & DF_TEXTREL) != 0)
2985 {
2986 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 2987 return FALSE;
0c715baa 2988 }
252b5132 2989 }
23209a78 2990 if (get_elf_i386_backend_data (output_bfd)->is_vxworks
7a2b07ff
NS		 2991 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2992 return FALSE;
252b5132 2993 }
dc810e39 2994#undef add_dynamic_entry
252b5132 2995
b34976b6 2996 return TRUE;
252b5132
RH		 2997}
2998
67a4f2b7
AO		 2999static bfd_boolean
3000elf_i386_always_size_sections (bfd *output_bfd,
3001 struct bfd_link_info *info)
3002{
3003 asection *tls_sec = elf_hash_table (info)->tls_sec;
3004
3005 if (tls_sec)
3006 {
3007 struct elf_link_hash_entry *tlsbase;
3008
3009 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3010 "_TLS_MODULE_BASE_",
3011 FALSE, FALSE, FALSE);
3012
3013 if (tlsbase && tlsbase->type == STT_TLS)
3014 {
4dfe6ac6 3015 struct elf_i386_link_hash_table *htab;
67a4f2b7
AO		 3016 struct bfd_link_hash_entry *bh = NULL;
3017 const struct elf_backend_data *bed
3018 = get_elf_backend_data (output_bfd);
3019
4dfe6ac6
NC		 3020 htab = elf_i386_hash_table (info);
3021 if (htab == NULL)
3022 return FALSE;
3023
67a4f2b7
AO		 3024 if (!(_bfd_generic_link_add_one_symbol
3025 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3026 tls_sec, 0, NULL, FALSE,
3027 bed->collect, &bh)))
3028 return FALSE;
9f03412a 3029
4dfe6ac6 3030 htab->tls_module_base = bh;
9f03412a 3031
67a4f2b7
AO		 3032 tlsbase = (struct elf_link_hash_entry *)bh;
3033 tlsbase->def_regular = 1;
3034 tlsbase->other = STV_HIDDEN;
3035 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3036 }
3037 }
3038
3039 return TRUE;
3040}
3041
38701953
AM		 3042/* Set the correct type for an x86 ELF section. We do this by the
3043 section name, which is a hack, but ought to work. */
3044
b34976b6 3045static bfd_boolean
55fd94b0
AM		 3046elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3047 Elf_Internal_Shdr *hdr,
3048 asection *sec)
38701953 3049{
91d6fa6a 3050 const char *name;
38701953
AM		 3051
3052 name = bfd_get_section_name (abfd, sec);
3053
3054 /* This is an ugly, but unfortunately necessary hack that is
3055 needed when producing EFI binaries on x86. It tells
3056 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3057 containing ELF relocation info. We need this hack in order to
3058 be able to generate ELF binaries that can be translated into
3059 EFI applications (which are essentially COFF objects). Those
3060 files contain a COFF ".reloc" section inside an ELFNN object,
3061 which would normally cause BFD to segfault because it would
3062 attempt to interpret this section as containing relocation
3063 entries for section "oc". With this hack enabled, ".reloc"
3064 will be treated as a normal data section, which will avoid the
3065 segfault. However, you won't be able to create an ELFNN binary
3066 with a section named "oc" that needs relocations, but that's
3067 the kind of ugly side-effects you get when detecting section
3068 types based on their names... In practice, this limitation is
3069 unlikely to bite. */
3070 if (strcmp (name, ".reloc") == 0)
3071 hdr->sh_type = SHT_PROGBITS;
3072
b34976b6 3073 return TRUE;
38701953
AM		 3074}
3075
9f03412a
AO		 3076/* _TLS_MODULE_BASE_ needs to be treated especially when linking
3077 executables. Rather than setting it to the beginning of the TLS
3078 section, we have to set it to the end. This function may be called
3079 multiple times, it is idempotent. */
3080
3081static void
eb4ff4d6 3082elf_i386_set_tls_module_base (struct bfd_link_info *info)
9f03412a 3083{
4dfe6ac6 3084 struct elf_i386_link_hash_table *htab;
9f03412a
AO		 3085 struct bfd_link_hash_entry *base;
3086
3087 if (!info->executable)
3088 return;
3089
4dfe6ac6
NC		 3090 htab = elf_i386_hash_table (info);
3091 if (htab == NULL)
3092 return;
9f03412a 3093
4dfe6ac6
NC		 3094 base = htab->tls_module_base;
3095 if (base == NULL)
9f03412a
AO		 3096 return;
3097
4dfe6ac6 3098 base->u.def.value = htab->elf.tls_size;
9f03412a
AO		 3099}
3100
13ae64f3
JJ		 3101/* Return the base VMA address which should be subtracted from real addresses
3102 when resolving @dtpoff relocation.
3103 This is PT_TLS segment p_vaddr. */
3104
3105static bfd_vma
eb4ff4d6 3106elf_i386_dtpoff_base (struct bfd_link_info *info)
13ae64f3 3107{
e1918d23
AM		 3108 /* If tls_sec is NULL, we should have signalled an error already. */
3109 if (elf_hash_table (info)->tls_sec == NULL)
6a30718d 3110 return 0;
e1918d23 3111 return elf_hash_table (info)->tls_sec->vma;
13ae64f3
JJ		 3112}
3113
3114/* Return the relocation value for @tpoff relocation
3115 if STT_TLS virtual address is ADDRESS. */
3116
3117static bfd_vma
eb4ff4d6 3118elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
13ae64f3 3119{
e1918d23 3120 struct elf_link_hash_table *htab = elf_hash_table (info);
7dc98aea
RO		 3121 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3122 bfd_vma static_tls_size;
13ae64f3 3123
e1918d23
AM		 3124 /* If tls_sec is NULL, we should have signalled an error already. */
3125 if (htab->tls_sec == NULL)
6a30718d 3126 return 0;
7dc98aea
RO		 3127
3128 /* Consider special static TLS alignment requirements. */
3129 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3130 return static_tls_size + htab->tls_sec->vma - address;
13ae64f3
JJ		 3131}
3132
252b5132
RH		 3133/* Relocate an i386 ELF section. */
3134
b34976b6 3135static bfd_boolean
55fd94b0
AM		 3136elf_i386_relocate_section (bfd *output_bfd,
3137 struct bfd_link_info *info,
3138 bfd *input_bfd,
3139 asection *input_section,
3140 bfd_byte *contents,
3141 Elf_Internal_Rela *relocs,
3142 Elf_Internal_Sym *local_syms,
3143 asection **local_sections)
252b5132 3144{
6725bdbf 3145 struct elf_i386_link_hash_table *htab;
252b5132
RH		 3146 Elf_Internal_Shdr *symtab_hdr;
3147 struct elf_link_hash_entry **sym_hashes;
3148 bfd_vma *local_got_offsets;
67a4f2b7 3149 bfd_vma *local_tlsdesc_gotents;
252b5132
RH		 3150 Elf_Internal_Rela *rel;
3151 Elf_Internal_Rela *relend;
3348747a 3152 bfd_boolean is_vxworks_tls;
25e762b9 3153 unsigned plt_entry_size;
252b5132 3154
0ffa91dd 3155 BFD_ASSERT (is_i386_elf (input_bfd));
6bbec505 3156
6725bdbf 3157 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 3158 if (htab == NULL)
3159 return FALSE;
0ffa91dd 3160 symtab_hdr = &elf_symtab_hdr (input_bfd);
252b5132
RH		 3161 sym_hashes = elf_sym_hashes (input_bfd);
3162 local_got_offsets = elf_local_got_offsets (input_bfd);
67a4f2b7 3163 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3348747a
NS		 3164 /* We have to handle relocations in vxworks .tls_vars sections
3165 specially, because the dynamic loader is 'weird'. */
23209a78
RM		 3166 is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
3167 && info->shared
3348747a
NS		 3168 && !strcmp (input_section->output_section->name,
3169 ".tls_vars"));
252b5132 3170
eb4ff4d6 3171 elf_i386_set_tls_module_base (info);
9f03412a 3172
25e762b9
RM		 3173 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3174
252b5132
RH		 3175 rel = relocs;
3176 relend = relocs + input_section->reloc_count;
3177 for (; rel < relend; rel++)
3178 {
13ae64f3 3179 unsigned int r_type;
252b5132
RH		 3180 reloc_howto_type *howto;
3181 unsigned long r_symndx;
3182 struct elf_link_hash_entry *h;
3183 Elf_Internal_Sym *sym;
3184 asection *sec;
67a4f2b7 3185 bfd_vma off, offplt;
252b5132 3186 bfd_vma relocation;
b34976b6 3187 bfd_boolean unresolved_reloc;
252b5132 3188 bfd_reloc_status_type r;
1b452ec6 3189 unsigned int indx;
13ae64f3 3190 int tls_type;
1788fc08 3191 bfd_vma st_size;
252b5132
RH		 3192
3193 r_type = ELF32_R_TYPE (rel->r_info);
55fd94b0
AM		 3194 if (r_type == R_386_GNU_VTINHERIT
3195 || r_type == R_386_GNU_VTENTRY)
252b5132 3196 continue;
dc47f327 3197
55fd94b0 3198 if ((indx = r_type) >= R_386_standard
13ae64f3
JJ		 3199 && ((indx = r_type - R_386_ext_offset) - R_386_standard
3200 >= R_386_ext - R_386_standard)
3201 && ((indx = r_type - R_386_tls_offset) - R_386_ext
cbe950e9 3202 >= R_386_irelative - R_386_ext))
252b5132 3203 {
6ba842b6 3204 (*_bfd_error_handler)
d003868e
AM		 3205 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3206 input_bfd, input_section, r_type);
252b5132 3207 bfd_set_error (bfd_error_bad_value);
b34976b6 3208 return FALSE;
252b5132 3209 }
1b452ec6 3210 howto = elf_howto_table + indx;
252b5132
RH		 3211
3212 r_symndx = ELF32_R_SYM (rel->r_info);
252b5132
RH		 3213 h = NULL;
3214 sym = NULL;
3215 sec = NULL;
b34976b6 3216 unresolved_reloc = FALSE;
252b5132
RH		 3217 if (r_symndx < symtab_hdr->sh_info)
3218 {
3219 sym = local_syms + r_symndx;
3220 sec = local_sections[r_symndx];
3221 relocation = (sec->output_section->vma
3222 + sec->output_offset
3223 + sym->st_value);
1788fc08 3224 st_size = sym->st_size;
ab96bf03
AM		 3225
3226 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3227 && ((sec->flags & SEC_MERGE) != 0
3228 || (info->relocatable
3229 && sec->output_offset != 0)))
f8df10f4 3230 {
f8df10f4 3231 bfd_vma addend;
4a335f3d 3232 bfd_byte *where = contents + rel->r_offset;
f8df10f4 3233
4a335f3d 3234 switch (howto->size)
f8df10f4 3235 {
4a335f3d
AM		 3236 case 0:
3237 addend = bfd_get_8 (input_bfd, where);
3238 if (howto->pc_relative)
3239 {
3240 addend = (addend ^ 0x80) - 0x80;
3241 addend += 1;
3242 }
3243 break;
3244 case 1:
3245 addend = bfd_get_16 (input_bfd, where);
3246 if (howto->pc_relative)
3247 {
3248 addend = (addend ^ 0x8000) - 0x8000;
3249 addend += 2;
3250 }
3251 break;
3252 case 2:
3253 addend = bfd_get_32 (input_bfd, where);
3254 if (howto->pc_relative)
3255 {
3256 addend = (addend ^ 0x80000000) - 0x80000000;
3257 addend += 4;
3258 }
3259 break;
3260 default:
3261 abort ();
f8df10f4
JJ		 3262 }
3263
ab96bf03
AM		 3264 if (info->relocatable)
3265 addend += sec->output_offset;
3266 else
3267 {
3268 asection *msec = sec;
3269 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3270 addend);
3271 addend -= relocation;
3272 addend += msec->output_section->vma + msec->output_offset;
3273 }
4a335f3d
AM		 3274
3275 switch (howto->size)
3276 {
3277 case 0:
16a10388 3278 /* FIXME: overflow checks. */
4a335f3d
AM		 3279 if (howto->pc_relative)
3280 addend -= 1;
3281 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 3282 break;
3283 case 1:
3284 if (howto->pc_relative)
3285 addend -= 2;
3286 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 3287 break;
3288 case 2:
3289 if (howto->pc_relative)
3290 addend -= 4;
3291 bfd_put_32 (input_bfd, addend, where);
3292 break;
3293 }
f8df10f4 3294 }
1f85278f
L		 3295 else if (!info->relocatable
3296 && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
c25bc9fc
L		 3297 {
3298 /* Relocate against local STT_GNU_IFUNC symbol. */
9fff0c39
L		 3299 h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3300 FALSE);
c25bc9fc
L		 3301 if (h == NULL)
3302 abort ();
3303
23209a78 3304 /* Set STT_GNU_IFUNC symbol value. */
c25bc9fc
L		 3305 h->root.u.def.value = sym->st_value;
3306 h->root.u.def.section = sec;
3307 }
252b5132
RH		 3308 }
3309 else
3310 {
3d540e93 3311 bfd_boolean warned ATTRIBUTE_UNUSED;
62d887d4 3312 bfd_boolean ignored ATTRIBUTE_UNUSED;
ffb2e45b 3313
b2a8e766
AM		 3314 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3315 r_symndx, symtab_hdr, sym_hashes,
3316 h, sec, relocation,
62d887d4 3317 unresolved_reloc, warned, ignored);
1788fc08 3318 st_size = h->size;
252b5132
RH		 3319 }
3320
dbaa2011 3321 if (sec != NULL && discarded_section (sec))
0672748a 3322 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b 3323 rel, 1, relend, howto, 0, contents);
9635fe29 3324
ab96bf03
AM		 3325 if (info->relocatable)
3326 continue;
3327
cbe950e9
L		 3328 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3329 it here if it is defined in a non-shared object. */
3330 if (h != NULL
3331 && h->type == STT_GNU_IFUNC
3332 && h->def_regular)
3333 {
3334 asection *plt, *gotplt, *base_got;
3335 bfd_vma plt_index;
4c544807 3336 const char *name;
cbe950e9
L		 3337
3338 if ((input_section->flags & SEC_ALLOC) == 0
3339 || h->plt.offset == (bfd_vma) -1)
3340 abort ();
3341
3342 /* STT_GNU_IFUNC symbol must go through PLT. */
6de2ae4a 3343 if (htab->elf.splt != NULL)
cbe950e9 3344 {
6de2ae4a
L		 3345 plt = htab->elf.splt;
3346 gotplt = htab->elf.sgotplt;
cbe950e9
L		 3347 }
3348 else
3349 {
6de2ae4a
L		 3350 plt = htab->elf.iplt;
3351 gotplt = htab->elf.igotplt;
cbe950e9
L		 3352 }
3353
3354 relocation = (plt->output_section->vma
3355 + plt->output_offset + h->plt.offset);
3356
3357 switch (r_type)
3358 {
3359 default:
4c544807
L		 3360 if (h->root.root.string)
3361 name = h->root.root.string;
3362 else
3363 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3364 NULL);
cbe950e9
L		 3365 (*_bfd_error_handler)
3366 (_("%B: relocation %s against STT_GNU_IFUNC "
3367 "symbol `%s' isn't handled by %s"), input_bfd,
3368 elf_howto_table[r_type].name,
4c544807 3369 name, __FUNCTION__);
cbe950e9
L		 3370 bfd_set_error (bfd_error_bad_value);
3371 return FALSE;
3372
3373 case R_386_32:
710ab287 3374 /* Generate dynamic relcoation only when there is a
c293fa49 3375 non-GOT reference in a shared object. */
710ab287
L		 3376 if (info->shared && h->non_got_ref)
3377 {
3378 Elf_Internal_Rela outrel;
710ab287
L		 3379 asection *sreloc;
3380 bfd_vma offset;
3381
c25bc9fc
L		 3382 /* Need a dynamic relocation to get the real function
3383 adddress. */
710ab287
L		 3384 offset = _bfd_elf_section_offset (output_bfd,
3385 info,
3386 input_section,
3387 rel->r_offset);
3388 if (offset == (bfd_vma) -1
3389 || offset == (bfd_vma) -2)
3390 abort ();
3391
3392 outrel.r_offset = (input_section->output_section->vma
3393 + input_section->output_offset
3394 + offset);
3395
3396 if (h->dynindx == -1
44c4ea11
L		 3397 || h->forced_local
3398 || info->executable)
710ab287
L		 3399 {
3400 /* This symbol is resolved locally. */
56b8aada
L		 3401 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3402 bfd_put_32 (output_bfd,
3403 (h->root.u.def.value
3404 + h->root.u.def.section->output_section->vma
3405 + h->root.u.def.section->output_offset),
3406 contents + offset);
710ab287
L		 3407 }
3408 else
56b8aada 3409 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
710ab287 3410
6de2ae4a 3411 sreloc = htab->elf.irelifunc;
59d6ffb2 3412 elf_append_rel (output_bfd, sreloc, &outrel);
710ab287
L		 3413
3414 /* If this reloc is against an external symbol, we
3415 do not want to fiddle with the addend. Otherwise,
3416 we need to include the symbol value so that it
3417 becomes an addend for the dynamic reloc. For an
3418 internal symbol, we have updated addend. */
56b8aada 3419 continue;
710ab287 3420 }
d59a60e9 3421 /* FALLTHROUGH */
cbe950e9
L		 3422 case R_386_PC32:
3423 case R_386_PLT32:
3424 goto do_relocation;
3425
3426 case R_386_GOT32:
6de2ae4a 3427 base_got = htab->elf.sgot;
cbe950e9
L		 3428 off = h->got.offset;
3429
7afd84dc 3430 if (base_got == NULL)
cbe950e9
L		 3431 abort ();
3432
7afd84dc 3433 if (off == (bfd_vma) -1)
cbe950e9 3434 {
7afd84dc
L		 3435 /* We can't use h->got.offset here to save state, or
3436 even just remember the offset, as finish_dynamic_symbol
3437 would use that as offset into .got. */
6bbec505 3438
6de2ae4a 3439 if (htab->elf.splt != NULL)
7afd84dc 3440 {
25e762b9 3441 plt_index = h->plt.offset / plt_entry_size - 1;
7afd84dc 3442 off = (plt_index + 3) * 4;
6de2ae4a 3443 base_got = htab->elf.sgotplt;
7afd84dc 3444 }
cbe950e9
L		 3445 else
3446 {
25e762b9 3447 plt_index = h->plt.offset / plt_entry_size;
7afd84dc 3448 off = plt_index * 4;
6de2ae4a 3449 base_got = htab->elf.igotplt;
7afd84dc
L		 3450 }
3451
3452 if (h->dynindx == -1
3453 || h->forced_local
3454 || info->symbolic)
3455 {
3456 /* This references the local defitionion. We must
3457 initialize this entry in the global offset table.
3458 Since the offset must always be a multiple of 8,
3459 we use the least significant bit to record
3460 whether we have initialized it already.
3461
3462 When doing a dynamic link, we create a .rela.got
3463 relocation entry to initialize the value. This
3464 is done in the finish_dynamic_symbol routine. */
3465 if ((off & 1) != 0)
3466 off &= ~1;
3467 else
3468 {
3469 bfd_put_32 (output_bfd, relocation,
3470 base_got->contents + off);
3471 h->got.offset |= 1;
3472 }
cbe950e9 3473 }
cbe950e9 3474
7afd84dc 3475 relocation = off;
cbe950e9 3476
7afd84dc 3477 /* Adjust for static executables. */
6de2ae4a 3478 if (htab->elf.splt == NULL)
7afd84dc
L		 3479 relocation += gotplt->output_offset;
3480 }
3481 else
0018b0a3
L		 3482 {
3483 relocation = (base_got->output_section->vma
3484 + base_got->output_offset + off
3485 - gotplt->output_section->vma
3486 - gotplt->output_offset);
3487 /* Adjust for static executables. */
6de2ae4a 3488 if (htab->elf.splt == NULL)
0018b0a3
L		 3489 relocation += gotplt->output_offset;
3490 }
3491
cbe950e9
L		 3492 goto do_relocation;
3493
3494 case R_386_GOTOFF:
3495 relocation -= (gotplt->output_section->vma
3496 + gotplt->output_offset);
3497 goto do_relocation;
3498 }
3499 }
3500
252b5132
RH		 3501 switch (r_type)
3502 {
3503 case R_386_GOT32:
3504 /* Relocation is to the entry for this symbol in the global
3505 offset table. */
6de2ae4a 3506 if (htab->elf.sgot == NULL)
ffb2e45b 3507 abort ();
252b5132
RH		 3508
3509 if (h != NULL)
3510 {
b34976b6 3511 bfd_boolean dyn;
252b5132
RH		 3512
3513 off = h->got.offset;
ebe50bae 3514 dyn = htab->elf.dynamic_sections_created;
26e41594 3515 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
252b5132 3516 || (info->shared
586119b3 3517 && SYMBOL_REFERENCES_LOCAL (info, h))
ef5aade5
L		 3518 || (ELF_ST_VISIBILITY (h->other)
3519 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 3520 {
3521 /* This is actually a static link, or it is a
3522 -Bsymbolic link and the symbol is defined
3523 locally, or the symbol was forced to be local
3524 because of a version file. We must initialize
3525 this entry in the global offset table. Since the
3526 offset must always be a multiple of 4, we use the
3527 least significant bit to record whether we have
3528 initialized it already.
3529
3530 When doing a dynamic link, we create a .rel.got
3531 relocation entry to initialize the value. This
3532 is done in the finish_dynamic_symbol routine. */
3533 if ((off & 1) != 0)
3534 off &= ~1;
3535 else
3536 {
3537 bfd_put_32 (output_bfd, relocation,
6de2ae4a 3538 htab->elf.sgot->contents + off);
252b5132
RH		 3539 h->got.offset |= 1;
3540 }
3541 }
8c694914 3542 else
b34976b6 3543 unresolved_reloc = FALSE;
252b5132
RH		 3544 }
3545 else
3546 {
ffb2e45b
AM		 3547 if (local_got_offsets == NULL)
3548 abort ();
252b5132
RH		 3549
3550 off = local_got_offsets[r_symndx];
3551
3552 /* The offset must always be a multiple of 4. We use
83be169b
AM		 3553 the least significant bit to record whether we have
3554 already generated the necessary reloc. */
252b5132
RH		 3555 if ((off & 1) != 0)
3556 off &= ~1;
3557 else
3558 {
6725bdbf 3559 bfd_put_32 (output_bfd, relocation,
6de2ae4a 3560 htab->elf.sgot->contents + off);
252b5132
RH		 3561
3562 if (info->shared)
3563 {
947216bf
AM		 3564 asection *s;
3565 Elf_Internal_Rela outrel;
252b5132 3566
6de2ae4a 3567 s = htab->elf.srelgot;
947216bf 3568 if (s == NULL)
ffb2e45b 3569 abort ();
252b5132 3570
6de2ae4a
L		 3571 outrel.r_offset = (htab->elf.sgot->output_section->vma
3572 + htab->elf.sgot->output_offset
252b5132
RH		 3573 + off);
3574 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
59d6ffb2 3575 elf_append_rel (output_bfd, s, &outrel);
252b5132
RH		 3576 }
3577
3578 local_got_offsets[r_symndx] |= 1;
3579 }
252b5132
RH		 3580 }
3581
ffb2e45b
AM		 3582 if (off >= (bfd_vma) -2)
3583 abort ();
3584
6de2ae4a
L		 3585 relocation = htab->elf.sgot->output_section->vma
3586 + htab->elf.sgot->output_offset + off
3587 - htab->elf.sgotplt->output_section->vma
3588 - htab->elf.sgotplt->output_offset;
252b5132
RH		 3589 break;
3590
3591 case R_386_GOTOFF:
3592 /* Relocation is relative to the start of the global offset
3593 table. */
3594
90f487df
L		 3595 /* Check to make sure it isn't a protected function symbol
3596 for shared library since it may not be local when used
41bed6dd
L		 3597 as function address. We also need to make sure that a
3598 symbol is defined locally. */
3599 if (info->shared && h)
90f487df 3600 {
41bed6dd
L		 3601 if (!h->def_regular)
3602 {
3603 const char *v;
3604
3605 switch (ELF_ST_VISIBILITY (h->other))
3606 {
3607 case STV_HIDDEN:
3608 v = _("hidden symbol");
3609 break;
3610 case STV_INTERNAL:
3611 v = _("internal symbol");
3612 break;
3613 case STV_PROTECTED:
3614 v = _("protected symbol");
3615 break;
3616 default:
3617 v = _("symbol");
3618 break;
3619 }
3620
3621 (*_bfd_error_handler)
3622 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
3623 input_bfd, v, h->root.root.string);
3624 bfd_set_error (bfd_error_bad_value);
3625 return FALSE;
3626 }
3627 else if (!info->executable
bdb892b9 3628 && !SYMBOLIC_BIND (info, h)
41bed6dd
L		 3629 && h->type == STT_FUNC
3630 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3631 {
3632 (*_bfd_error_handler)
3633 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
3634 input_bfd, h->root.root.string);
3635 bfd_set_error (bfd_error_bad_value);
3636 return FALSE;
3637 }
90f487df
L		 3638 }
3639
8c37241b
JJ		 3640 /* Note that sgot is not involved in this
3641 calculation. We always want the start of .got.plt. If we
3642 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
252b5132
RH		 3643 permitted by the ABI, we might have to change this
3644 calculation. */
6de2ae4a
L		 3645 relocation -= htab->elf.sgotplt->output_section->vma
3646 + htab->elf.sgotplt->output_offset;
252b5132
RH		 3647 break;
3648
3649 case R_386_GOTPC:
3650 /* Use global offset table as symbol value. */
6de2ae4a
L		 3651 relocation = htab->elf.sgotplt->output_section->vma
3652 + htab->elf.sgotplt->output_offset;
b34976b6 3653 unresolved_reloc = FALSE;
252b5132
RH		 3654 break;
3655
3656 case R_386_PLT32:
3657 /* Relocation is to the entry for this symbol in the
3658 procedure linkage table. */
3659
dd5724d5 3660 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 3661 without using the procedure linkage table. */
252b5132
RH		 3662 if (h == NULL)
3663 break;
3664
dd5724d5 3665 if (h->plt.offset == (bfd_vma) -1
6de2ae4a 3666 || htab->elf.splt == NULL)
252b5132
RH		 3667 {
3668 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 3669 happens when statically linking PIC code, or when
3670 using -Bsymbolic. */
252b5132
RH		 3671 break;
3672 }
3673
6de2ae4a
L		 3674 relocation = (htab->elf.splt->output_section->vma
3675 + htab->elf.splt->output_offset
252b5132 3676 + h->plt.offset);
b34976b6 3677 unresolved_reloc = FALSE;
252b5132
RH		 3678 break;
3679
1788fc08 3680 case R_386_SIZE32:
1788fc08
L		 3681 /* Set to symbol size. */
3682 relocation = st_size;
3683 /* Fall through. */
3684
252b5132
RH		 3685 case R_386_32:
3686 case R_386_PC32:
3348747a
NS		 3687 if ((input_section->flags & SEC_ALLOC) == 0
3688 || is_vxworks_tls)
ec338859
AM		 3689 break;
3690
12d0ee4a 3691 if ((info->shared
ef5aade5
L		 3692 && (h == NULL
3693 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3694 || h->root.type != bfd_link_hash_undefweak)
1788fc08 3695 && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
f6c52c13 3696 || !SYMBOL_CALLS_LOCAL (info, h)))
a23b6845
AM		 3697 || (ELIMINATE_COPY_RELOCS
3698 && !info->shared
12d0ee4a
AM		 3699 && h != NULL
3700 && h->dynindx != -1
f5385ebf
AM		 3701 && !h->non_got_ref
3702 && ((h->def_dynamic
3703 && !h->def_regular)
28d0b90e 3704 || h->root.type == bfd_link_hash_undefweak
0f88be7a 3705 || h->root.type == bfd_link_hash_undefined)))
252b5132 3706 {
947216bf 3707 Elf_Internal_Rela outrel;
b34976b6 3708 bfd_boolean skip, relocate;
0c715baa 3709 asection *sreloc;
252b5132
RH		 3710
3711 /* When generating a shared object, these relocations
3712 are copied into the output file to be resolved at run
3713 time. */
3714
b34976b6
AM		 3715 skip = FALSE;
3716 relocate = FALSE;
252b5132 3717
c629eae0
JJ		 3718 outrel.r_offset =
3719 _bfd_elf_section_offset (output_bfd, info, input_section,
3720 rel->r_offset);
3721 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 3722 skip = TRUE;
0bb2d96a 3723 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 3724 skip = TRUE, relocate = TRUE;
252b5132
RH		 3725 outrel.r_offset += (input_section->output_section->vma
3726 + input_section->output_offset);
3727
3728 if (skip)
0bb2d96a 3729 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 3730 else if (h != NULL
3731 && h->dynindx != -1
3732 && (r_type == R_386_PC32
3733 || !info->shared
55255dae 3734 || !SYMBOLIC_BIND (info, h)
f5385ebf 3735 || !h->def_regular))
0bb2d96a 3736 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 3737 else
3738 {
5a15f56f 3739 /* This symbol is local, or marked to become local. */
b34976b6 3740 relocate = TRUE;
5a15f56f 3741 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 3742 }
3743
cbe950e9 3744 sreloc = elf_section_data (input_section)->sreloc;
e7c33416 3745
62d78908
L		 3746 if (sreloc == NULL || sreloc->contents == NULL)
3747 {
3748 r = bfd_reloc_notsupported;
3749 goto check_relocation_error;
3750 }
0c715baa 3751
59d6ffb2 3752 elf_append_rel (output_bfd, sreloc, &outrel);
252b5132
RH		 3753
3754 /* If this reloc is against an external symbol, we do
3755 not want to fiddle with the addend. Otherwise, we
3756 need to include the symbol value so that it becomes
3757 an addend for the dynamic reloc. */
0f88be7a 3758 if (! relocate)
252b5132
RH		 3759 continue;
3760 }
252b5132
RH		 3761 break;
3762
37e55690 3763 case R_386_TLS_IE:
1d85728f 3764 if (!info->executable)
37e55690 3765 {
947216bf 3766 Elf_Internal_Rela outrel;
37e55690 3767 asection *sreloc;
37e55690
JJ		 3768
3769 outrel.r_offset = rel->r_offset
3770 + input_section->output_section->vma
3771 + input_section->output_offset;
3772 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3773 sreloc = elf_section_data (input_section)->sreloc;
3774 if (sreloc == NULL)
3775 abort ();
59d6ffb2 3776 elf_append_rel (output_bfd, sreloc, &outrel);
37e55690
JJ		 3777 }
3778 /* Fall through */
3779
13ae64f3 3780 case R_386_TLS_GD:
67a4f2b7
AO		 3781 case R_386_TLS_GOTDESC:
3782 case R_386_TLS_DESC_CALL:
13ae64f3 3783 case R_386_TLS_IE_32:
37e55690 3784 case R_386_TLS_GOTIE:
13ae64f3
JJ		 3785 tls_type = GOT_UNKNOWN;
3786 if (h == NULL && local_got_offsets)
3787 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
3788 else if (h != NULL)
142411ca 3789 tls_type = elf_i386_hash_entry(h)->tls_type;
37e55690
JJ		 3790 if (tls_type == GOT_TLS_IE)
3791 tls_type = GOT_TLS_IE_NEG;
142411ca
L		 3792
3793 if (! elf_i386_tls_transition (info, input_bfd,
3794 input_section, contents,
3795 symtab_hdr, sym_hashes,
3796 &r_type, tls_type, rel,
4c544807 3797 relend, h, r_symndx))
142411ca 3798 return FALSE;
13ae64f3
JJ		 3799
3800 if (r_type == R_386_TLS_LE_32)
3801 {
82e51918 3802 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 3803 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3804 {
142411ca 3805 unsigned int type;
13ae64f3
JJ		 3806 bfd_vma roff;
3807
3808 /* GD->LE transition. */
13ae64f3 3809 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
13ae64f3
JJ		 3810 if (type == 0x04)
3811 {
3812 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3813 Change it into:
3814 movl %gs:0, %eax; subl $foo@tpoff, %eax
3815 (6 byte form of subl). */
13ae64f3
JJ		 3816 memcpy (contents + rel->r_offset - 3,
3817 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
142411ca 3818 roff = rel->r_offset + 5;
13ae64f3
JJ		 3819 }
3820 else
3821 {
142411ca
L		 3822 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3823 Change it into:
3824 movl %gs:0, %eax; subl $foo@tpoff, %eax
3825 (6 byte form of subl). */
3826 memcpy (contents + rel->r_offset - 2,
3827 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3828 roff = rel->r_offset + 6;
13ae64f3 3829 }
eb4ff4d6 3830 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
13ae64f3 3831 contents + roff);
a3fadc9a 3832 /* Skip R_386_PC32/R_386_PLT32. */
13ae64f3
JJ		 3833 rel++;
3834 continue;
3835 }
67a4f2b7
AO		 3836 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3837 {
3838 /* GDesc -> LE transition.
3839 It's originally something like:
3840 leal x@tlsdesc(%ebx), %eax
3841
3842 leal x@ntpoff, %eax
3843
3844 Registers other than %eax may be set up here. */
3845
142411ca 3846 unsigned int val;
67a4f2b7
AO		 3847 bfd_vma roff;
3848
67a4f2b7 3849 roff = rel->r_offset;
67a4f2b7 3850 val = bfd_get_8 (input_bfd, contents + roff - 1);
67a4f2b7
AO		 3851
3852 /* Now modify the instruction as appropriate. */
3853 /* aoliva FIXME: remove the above and xor the byte
3854 below with 0x86. */
3855 bfd_put_8 (output_bfd, val ^ 0x86,
3856 contents + roff - 1);
eb4ff4d6 3857 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
67a4f2b7
AO		 3858 contents + roff);
3859 continue;
3860 }
3861 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3862 {
3863 /* GDesc -> LE transition.
3864 It's originally:
3865 call *(%eax)
3866 Turn it into:
142411ca 3867 xchg %ax,%ax */
67a4f2b7 3868
67a4f2b7 3869 bfd_vma roff;
6bbec505 3870
67a4f2b7 3871 roff = rel->r_offset;
10efb593 3872 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 3873 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3874 continue;
3875 }
37e55690 3876 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
13ae64f3 3877 {
142411ca 3878 unsigned int val;
13ae64f3
JJ		 3879
3880 /* IE->LE transition:
37e55690
JJ		 3881 Originally it can be one of:
3882 movl foo, %eax
3883 movl foo, %reg
3884 addl foo, %reg
3885 We change it into:
3886 movl $foo, %eax
3887 movl $foo, %reg
3888 addl $foo, %reg. */
37e55690 3889 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
37e55690
JJ		 3890 if (val == 0xa1)
3891 {
3892 /* movl foo, %eax. */
55fd94b0
AM		 3893 bfd_put_8 (output_bfd, 0xb8,
3894 contents + rel->r_offset - 1);
37e55690 3895 }
299bf759 3896 else
37e55690 3897 {
142411ca
L		 3898 unsigned int type;
3899
55fd94b0
AM		 3900 type = bfd_get_8 (input_bfd,
3901 contents + rel->r_offset - 2);
299bf759 3902 switch (type)
26e41594 3903 {
299bf759
L		 3904 case 0x8b:
3905 /* movl */
299bf759
L		 3906 bfd_put_8 (output_bfd, 0xc7,
3907 contents + rel->r_offset - 2);
3908 bfd_put_8 (output_bfd,
3909 0xc0 | ((val >> 3) & 7),
3910 contents + rel->r_offset - 1);
3911 break;
3912 case 0x03:
3913 /* addl */
299bf759
L		 3914 bfd_put_8 (output_bfd, 0x81,
3915 contents + rel->r_offset - 2);
3916 bfd_put_8 (output_bfd,
3917 0xc0 | ((val >> 3) & 7),
3918 contents + rel->r_offset - 1);
3919 break;
3920 default:
3921 BFD_FAIL ();
3922 break;
26e41594 3923 }
37e55690 3924 }
eb4ff4d6 3925 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
37e55690
JJ		 3926 contents + rel->r_offset);
3927 continue;
3928 }
3929 else
3930 {
3931 unsigned int val, type;
3932
3933 /* {IE_32,GOTIE}->LE transition:
3934 Originally it can be one of:
13ae64f3 3935 subl foo(%reg1), %reg2
13ae64f3 3936 movl foo(%reg1), %reg2
37e55690 3937 addl foo(%reg1), %reg2
13ae64f3
JJ		 3938 We change it into:
3939 subl $foo, %reg2
37e55690
JJ		 3940 movl $foo, %reg2 (6 byte form)
3941 addl $foo, %reg2. */
13ae64f3
JJ		 3942 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3943 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
13ae64f3
JJ		 3944 if (type == 0x8b)
3945 {
3946 /* movl */
13ae64f3
JJ		 3947 bfd_put_8 (output_bfd, 0xc7,
3948 contents + rel->r_offset - 2);
3949 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3950 contents + rel->r_offset - 1);
3951 }
3952 else if (type == 0x2b)
3953 {
3954 /* subl */
13ae64f3
JJ		 3955 bfd_put_8 (output_bfd, 0x81,
3956 contents + rel->r_offset - 2);
3957 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
3958 contents + rel->r_offset - 1);
3959 }
37e55690
JJ		 3960 else if (type == 0x03)
3961 {
3962 /* addl */
3963 bfd_put_8 (output_bfd, 0x81,
3964 contents + rel->r_offset - 2);
3965 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3966 contents + rel->r_offset - 1);
3967 }
13ae64f3
JJ		 3968 else
3969 BFD_FAIL ();
37e55690 3970 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
eb4ff4d6 3971 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
37e55690
JJ		 3972 contents + rel->r_offset);
3973 else
eb4ff4d6 3974 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
37e55690 3975 contents + rel->r_offset);
13ae64f3
JJ		 3976 continue;
3977 }
3978 }
3979
6de2ae4a 3980 if (htab->elf.sgot == NULL)
13ae64f3
JJ		 3981 abort ();
3982
3983 if (h != NULL)
67a4f2b7
AO		 3984 {
3985 off = h->got.offset;
3986 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
3987 }
13ae64f3
JJ		 3988 else
3989 {
3990 if (local_got_offsets == NULL)
3991 abort ();
3992
3993 off = local_got_offsets[r_symndx];
67a4f2b7 3994 offplt = local_tlsdesc_gotents[r_symndx];
13ae64f3
JJ		 3995 }
3996
3997 if ((off & 1) != 0)
3998 off &= ~1;
26e41594 3999 else
13ae64f3 4000 {
947216bf 4001 Elf_Internal_Rela outrel;
91d6fa6a 4002 int dr_type;
67a4f2b7 4003 asection *sreloc;
13ae64f3 4004
6de2ae4a 4005 if (htab->elf.srelgot == NULL)
13ae64f3
JJ		 4006 abort ();
4007
67a4f2b7
AO		 4008 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4009
4010 if (GOT_TLS_GDESC_P (tls_type))
4011 {
59d6ffb2 4012 bfd_byte *loc;
67a4f2b7
AO		 4013 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4014 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
6de2ae4a
L		 4015 <= htab->elf.sgotplt->size);
4016 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4017 + htab->elf.sgotplt->output_offset
67a4f2b7
AO		 4018 + offplt
4019 + htab->sgotplt_jump_table_size);
6de2ae4a 4020 sreloc = htab->elf.srelplt;
67a4f2b7 4021 loc = sreloc->contents;
5ae0bfb6
RS		 4022 loc += (htab->next_tls_desc_index++
4023 * sizeof (Elf32_External_Rel));
67a4f2b7 4024 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
c3b02097 4025 <= sreloc->contents + sreloc->size);
67a4f2b7
AO		 4026 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4027 if (indx == 0)
4028 {
4029 BFD_ASSERT (! unresolved_reloc);
4030 bfd_put_32 (output_bfd,
eb4ff4d6 4031 relocation - elf_i386_dtpoff_base (info),
6de2ae4a 4032 htab->elf.sgotplt->contents + offplt
67a4f2b7
AO		 4033 + htab->sgotplt_jump_table_size + 4);
4034 }
4035 else
4036 {
4037 bfd_put_32 (output_bfd, 0,
6de2ae4a 4038 htab->elf.sgotplt->contents + offplt
67a4f2b7
AO		 4039 + htab->sgotplt_jump_table_size + 4);
4040 }
4041 }
4042
6de2ae4a 4043 sreloc = htab->elf.srelgot;
67a4f2b7 4044
6de2ae4a
L		 4045 outrel.r_offset = (htab->elf.sgot->output_section->vma
4046 + htab->elf.sgot->output_offset + off);
13ae64f3 4047
67a4f2b7 4048 if (GOT_TLS_GD_P (tls_type))
13ae64f3 4049 dr_type = R_386_TLS_DTPMOD32;
67a4f2b7
AO		 4050 else if (GOT_TLS_GDESC_P (tls_type))
4051 goto dr_done;
37e55690
JJ		 4052 else if (tls_type == GOT_TLS_IE_POS)
4053 dr_type = R_386_TLS_TPOFF;
13ae64f3
JJ		 4054 else
4055 dr_type = R_386_TLS_TPOFF32;
67a4f2b7 4056
37e55690 4057 if (dr_type == R_386_TLS_TPOFF && indx == 0)
eb4ff4d6
L		 4058 bfd_put_32 (output_bfd,
4059 relocation - elf_i386_dtpoff_base (info),
6de2ae4a 4060 htab->elf.sgot->contents + off);
37e55690 4061 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
23209a78 4062 bfd_put_32 (output_bfd,
eb4ff4d6 4063 elf_i386_dtpoff_base (info) - relocation,
6de2ae4a 4064 htab->elf.sgot->contents + off);
67a4f2b7 4065 else if (dr_type != R_386_TLS_DESC)
c366c25e 4066 bfd_put_32 (output_bfd, 0,
6de2ae4a 4067 htab->elf.sgot->contents + off);
13ae64f3 4068 outrel.r_info = ELF32_R_INFO (indx, dr_type);
67a4f2b7 4069
59d6ffb2 4070 elf_append_rel (output_bfd, sreloc, &outrel);
13ae64f3 4071
67a4f2b7 4072 if (GOT_TLS_GD_P (tls_type))
13ae64f3
JJ		 4073 {
4074 if (indx == 0)
4075 {
82e51918 4076 BFD_ASSERT (! unresolved_reloc);
13ae64f3 4077 bfd_put_32 (output_bfd,
eb4ff4d6 4078 relocation - elf_i386_dtpoff_base (info),
6de2ae4a 4079 htab->elf.sgot->contents + off + 4);
13ae64f3
JJ		 4080 }
4081 else
4082 {
4083 bfd_put_32 (output_bfd, 0,
6de2ae4a 4084 htab->elf.sgot->contents + off + 4);
13ae64f3
JJ		 4085 outrel.r_info = ELF32_R_INFO (indx,
4086 R_386_TLS_DTPOFF32);
4087 outrel.r_offset += 4;
59d6ffb2 4088 elf_append_rel (output_bfd, sreloc, &outrel);
13ae64f3
JJ		 4089 }
4090 }
37e55690
JJ		 4091 else if (tls_type == GOT_TLS_IE_BOTH)
4092 {
4093 bfd_put_32 (output_bfd,
eb4ff4d6
L		 4094 (indx == 0
4095 ? relocation - elf_i386_dtpoff_base (info)
4096 : 0),
6de2ae4a 4097 htab->elf.sgot->contents + off + 4);
37e55690
JJ		 4098 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4099 outrel.r_offset += 4;
59d6ffb2 4100 elf_append_rel (output_bfd, sreloc, &outrel);
37e55690 4101 }
13ae64f3 4102
67a4f2b7 4103 dr_done:
13ae64f3
JJ		 4104 if (h != NULL)
4105 h->got.offset |= 1;
4106 else
4107 local_got_offsets[r_symndx] |= 1;
4108 }
4109
67a4f2b7
AO		 4110 if (off >= (bfd_vma) -2
4111 && ! GOT_TLS_GDESC_P (tls_type))
13ae64f3 4112 abort ();
67a4f2b7
AO		 4113 if (r_type == R_386_TLS_GOTDESC
4114 || r_type == R_386_TLS_DESC_CALL)
4115 {
4116 relocation = htab->sgotplt_jump_table_size + offplt;
4117 unresolved_reloc = FALSE;
4118 }
4119 else if (r_type == ELF32_R_TYPE (rel->r_info))
13ae64f3 4120 {
6de2ae4a
L		 4121 bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4122 + htab->elf.sgotplt->output_offset;
4123 relocation = htab->elf.sgot->output_section->vma
4124 + htab->elf.sgot->output_offset + off - g_o_t;
37e55690
JJ		 4125 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4126 && tls_type == GOT_TLS_IE_BOTH)
4127 relocation += 4;
4128 if (r_type == R_386_TLS_IE)
8c37241b 4129 relocation += g_o_t;
b34976b6 4130 unresolved_reloc = FALSE;
13ae64f3 4131 }
67a4f2b7 4132 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
13ae64f3
JJ		 4133 {
4134 unsigned int val, type;
4135 bfd_vma roff;
4136
4137 /* GD->IE transition. */
13ae64f3 4138 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
13ae64f3
JJ		 4139 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4140 if (type == 0x04)
4141 {
4142 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4143 Change it into:
4144 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
13ae64f3 4145 val >>= 3;
142411ca 4146 roff = rel->r_offset - 3;
13ae64f3
JJ		 4147 }
4148 else
4149 {
4150 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4151 Change it into:
4152 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
13ae64f3
JJ		 4153 roff = rel->r_offset - 2;
4154 }
4155 memcpy (contents + roff,
4156 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4157 contents[roff + 7] = 0x80 | (val & 7);
37e55690
JJ		 4158 /* If foo is used only with foo@gotntpoff(%reg) and
4159 foo@indntpoff, but not with foo@gottpoff(%reg), change
4160 subl $foo@gottpoff(%reg), %eax
4161 into:
4162 addl $foo@gotntpoff(%reg), %eax. */
ebcfb3c0
JJ		 4163 if (tls_type == GOT_TLS_IE_POS)
4164 contents[roff + 6] = 0x03;
8c37241b 4165 bfd_put_32 (output_bfd,
6de2ae4a
L		 4166 htab->elf.sgot->output_section->vma
4167 + htab->elf.sgot->output_offset + off
4168 - htab->elf.sgotplt->output_section->vma
4169 - htab->elf.sgotplt->output_offset,
13ae64f3
JJ		 4170 contents + roff + 8);
4171 /* Skip R_386_PLT32. */
4172 rel++;
4173 continue;
4174 }
67a4f2b7
AO		 4175 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4176 {
4177 /* GDesc -> IE transition.
4178 It's originally something like:
4179 leal x@tlsdesc(%ebx), %eax
4180
4181 Change it to:
142411ca 4182 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
67a4f2b7
AO		 4183 or:
4184 movl x@gottpoff(%ebx), %eax # before negl %eax
4185
4186 Registers other than %eax may be set up here. */
4187
67a4f2b7
AO		 4188 bfd_vma roff;
4189
4190 /* First, make sure it's a leal adding ebx to a 32-bit
4191 offset into any register, although it's probably
4192 almost always going to be eax. */
4193 roff = rel->r_offset;
67a4f2b7
AO		 4194
4195 /* Now modify the instruction as appropriate. */
4196 /* To turn a leal into a movl in the form we use it, it
4197 suffices to change the first byte from 0x8d to 0x8b.
4198 aoliva FIXME: should we decide to keep the leal, all
4199 we have to do is remove the statement below, and
4200 adjust the relaxation of R_386_TLS_DESC_CALL. */
4201 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4202
4203 if (tls_type == GOT_TLS_IE_BOTH)
4204 off += 4;
4205
4206 bfd_put_32 (output_bfd,
6de2ae4a
L		 4207 htab->elf.sgot->output_section->vma
4208 + htab->elf.sgot->output_offset + off
4209 - htab->elf.sgotplt->output_section->vma
4210 - htab->elf.sgotplt->output_offset,
67a4f2b7
AO		 4211 contents + roff);
4212 continue;
4213 }
4214 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4215 {
4216 /* GDesc -> IE transition.
4217 It's originally:
4218 call *(%eax)
4219
4220 Change it to:
142411ca 4221 xchg %ax,%ax
67a4f2b7
AO		 4222 or
4223 negl %eax
4224 depending on how we transformed the TLS_GOTDESC above.
4225 */
4226
67a4f2b7
AO		 4227 bfd_vma roff;
4228
67a4f2b7 4229 roff = rel->r_offset;
67a4f2b7
AO		 4230
4231 /* Now modify the instruction as appropriate. */
4232 if (tls_type != GOT_TLS_IE_NEG)
4233 {
10efb593
L		 4234 /* xchg %ax,%ax */
4235 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 4236 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4237 }
4238 else
4239 {
4240 /* negl %eax */
4241 bfd_put_8 (output_bfd, 0xf7, contents + roff);
4242 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4243 }
4244
4245 continue;
4246 }
4247 else
4248 BFD_ASSERT (FALSE);
13ae64f3
JJ		 4249 break;
4250
4251 case R_386_TLS_LDM:
142411ca
L		 4252 if (! elf_i386_tls_transition (info, input_bfd,
4253 input_section, contents,
4254 symtab_hdr, sym_hashes,
4255 &r_type, GOT_UNKNOWN, rel,
4c544807 4256 relend, h, r_symndx))
142411ca 4257 return FALSE;
13ae64f3 4258
142411ca
L		 4259 if (r_type != R_386_TLS_LDM)
4260 {
13ae64f3 4261 /* LD->LE transition:
13ae64f3
JJ		 4262 leal foo(%reg), %eax; call ___tls_get_addr.
4263 We change it into:
4264 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
142411ca 4265 BFD_ASSERT (r_type == R_386_TLS_LE_32);
13ae64f3
JJ		 4266 memcpy (contents + rel->r_offset - 2,
4267 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
a3fadc9a 4268 /* Skip R_386_PC32/R_386_PLT32. */
13ae64f3
JJ		 4269 rel++;
4270 continue;
4271 }
4272
6de2ae4a 4273 if (htab->elf.sgot == NULL)
13ae64f3
JJ		 4274 abort ();
4275
4276 off = htab->tls_ldm_got.offset;
4277 if (off & 1)
4278 off &= ~1;
4279 else
4280 {
947216bf 4281 Elf_Internal_Rela outrel;
13ae64f3 4282
6de2ae4a 4283 if (htab->elf.srelgot == NULL)
13ae64f3
JJ		 4284 abort ();
4285
6de2ae4a
L		 4286 outrel.r_offset = (htab->elf.sgot->output_section->vma
4287 + htab->elf.sgot->output_offset + off);
13ae64f3
JJ		 4288
4289 bfd_put_32 (output_bfd, 0,
6de2ae4a 4290 htab->elf.sgot->contents + off);
13ae64f3 4291 bfd_put_32 (output_bfd, 0,
6de2ae4a 4292 htab->elf.sgot->contents + off + 4);
13ae64f3 4293 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
59d6ffb2 4294 elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
13ae64f3
JJ		 4295 htab->tls_ldm_got.offset |= 1;
4296 }
6de2ae4a
L		 4297 relocation = htab->elf.sgot->output_section->vma
4298 + htab->elf.sgot->output_offset + off
4299 - htab->elf.sgotplt->output_section->vma
4300 - htab->elf.sgotplt->output_offset;
b34976b6 4301 unresolved_reloc = FALSE;
13ae64f3
JJ		 4302 break;
4303
4304 case R_386_TLS_LDO_32:
959b0961 4305 if (!info->executable || (input_section->flags & SEC_CODE) == 0)
eb4ff4d6 4306 relocation -= elf_i386_dtpoff_base (info);
13ae64f3
JJ		 4307 else
4308 /* When converting LDO to LE, we must negate. */
eb4ff4d6 4309 relocation = -elf_i386_tpoff (info, relocation);
13ae64f3
JJ		 4310 break;
4311
4312 case R_386_TLS_LE_32:
13ae64f3 4313 case R_386_TLS_LE:
1d85728f 4314 if (!info->executable)
37e55690 4315 {
947216bf 4316 Elf_Internal_Rela outrel;
37e55690 4317 asection *sreloc;
37e55690
JJ		 4318
4319 outrel.r_offset = rel->r_offset
4320 + input_section->output_section->vma
4321 + input_section->output_offset;
4322 if (h != NULL && h->dynindx != -1)
4323 indx = h->dynindx;
4324 else
4325 indx = 0;
4326 if (r_type == R_386_TLS_LE_32)
4327 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4328 else
4329 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4330 sreloc = elf_section_data (input_section)->sreloc;
4331 if (sreloc == NULL)
4332 abort ();
59d6ffb2 4333 elf_append_rel (output_bfd, sreloc, &outrel);
37e55690
JJ		 4334 if (indx)
4335 continue;
4336 else if (r_type == R_386_TLS_LE_32)
eb4ff4d6 4337 relocation = elf_i386_dtpoff_base (info) - relocation;
37e55690 4338 else
eb4ff4d6 4339 relocation -= elf_i386_dtpoff_base (info);
37e55690
JJ		 4340 }
4341 else if (r_type == R_386_TLS_LE_32)
eb4ff4d6 4342 relocation = elf_i386_tpoff (info, relocation);
37e55690 4343 else
eb4ff4d6 4344 relocation = -elf_i386_tpoff (info, relocation);
13ae64f3
JJ		 4345 break;
4346
252b5132
RH		 4347 default:
4348 break;
4349 }
4350
239e1f3a
AM		 4351 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4352 because such sections are not SEC_ALLOC and thus ld.so will
4353 not process them. */
8c694914 4354 if (unresolved_reloc
239e1f3a 4355 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 4356 && h->def_dynamic)
4357 && _bfd_elf_section_offset (output_bfd, info, input_section,
4358 rel->r_offset) != (bfd_vma) -1)
6a30718d
JJ		 4359 {
4360 (*_bfd_error_handler)
843fe662 4361 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
d003868e
AM		 4362 input_bfd,
4363 input_section,
6a30718d 4364 (long) rel->r_offset,
843fe662 4365 howto->name,
6a30718d 4366 h->root.root.string);
b34976b6 4367 return FALSE;
6a30718d 4368 }
83be169b 4369
cbe950e9 4370do_relocation:
252b5132
RH		 4371 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4372 contents, rel->r_offset,
55fd94b0 4373 relocation, 0);
252b5132 4374
62d78908 4375check_relocation_error:
cf5c0c5b 4376 if (r != bfd_reloc_ok)
252b5132 4377 {
cf5c0c5b 4378 const char *name;
ffb2e45b 4379
cf5c0c5b
AM		 4380 if (h != NULL)
4381 name = h->root.root.string;
4382 else
4383 {
4384 name = bfd_elf_string_from_elf_section (input_bfd,
4385 symtab_hdr->sh_link,
4386 sym->st_name);
4387 if (name == NULL)
b34976b6 4388 return FALSE;
cf5c0c5b
AM		 4389 if (*name == '\0')
4390 name = bfd_section_name (input_bfd, sec);
4391 }
ffb2e45b 4392
cf5c0c5b
AM		 4393 if (r == bfd_reloc_overflow)
4394 {
cf5c0c5b 4395 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L		 4396 (info, (h ? &h->root : NULL), name, howto->name,
4397 (bfd_vma) 0, input_bfd, input_section,
4398 rel->r_offset)))
b34976b6 4399 return FALSE;
cf5c0c5b
AM		 4400 }
4401 else
4402 {
4403 (*_bfd_error_handler)
d003868e
AM		 4404 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4405 input_bfd, input_section,
cf5c0c5b 4406 (long) rel->r_offset, name, (int) r);
b34976b6 4407 return FALSE;
cf5c0c5b 4408 }
252b5132
RH		 4409 }
4410 }
4411
b34976b6 4412 return TRUE;
252b5132
RH		 4413}
4414
4415/* Finish up dynamic symbol handling. We set the contents of various
4416 dynamic sections here. */
4417
b34976b6 4418static bfd_boolean
55fd94b0
AM		 4419elf_i386_finish_dynamic_symbol (bfd *output_bfd,
4420 struct bfd_link_info *info,
4421 struct elf_link_hash_entry *h,
4422 Elf_Internal_Sym *sym)
252b5132 4423{
6725bdbf 4424 struct elf_i386_link_hash_table *htab;
25e762b9
RM		 4425 unsigned plt_entry_size;
4426 const struct elf_i386_backend_data *abed;
252b5132 4427
6725bdbf 4428 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 4429 if (htab == NULL)
4430 return FALSE;
252b5132 4431
25e762b9
RM		 4432 abed = get_elf_i386_backend_data (output_bfd);
4433 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
4434
252b5132
RH		 4435 if (h->plt.offset != (bfd_vma) -1)
4436 {
252b5132
RH		 4437 bfd_vma plt_index;
4438 bfd_vma got_offset;
947216bf
AM		 4439 Elf_Internal_Rela rel;
4440 bfd_byte *loc;
cbe950e9
L		 4441 asection *plt, *gotplt, *relplt;
4442
4443 /* When building a static executable, use .iplt, .igot.plt and
4444 .rel.iplt sections for STT_GNU_IFUNC symbols. */
6de2ae4a 4445 if (htab->elf.splt != NULL)
cbe950e9 4446 {
6de2ae4a
L		 4447 plt = htab->elf.splt;
4448 gotplt = htab->elf.sgotplt;
4449 relplt = htab->elf.srelplt;
cbe950e9
L		 4450 }
4451 else
4452 {
6de2ae4a
L		 4453 plt = htab->elf.iplt;
4454 gotplt = htab->elf.igotplt;
4455 relplt = htab->elf.irelplt;
cbe950e9 4456 }
252b5132
RH		 4457
4458 /* This symbol has an entry in the procedure linkage table. Set
4459 it up. */
4460
cbe950e9
L		 4461 if ((h->dynindx == -1
4462 && !((h->forced_local || info->executable)
4463 && h->def_regular
4464 && h->type == STT_GNU_IFUNC))
4465 || plt == NULL
4466 || gotplt == NULL
4467 || relplt == NULL)
cec7f46a 4468 abort ();
252b5132
RH		 4469
4470 /* Get the index in the procedure linkage table which
4471 corresponds to this symbol. This is the index of this symbol
4472 in all the symbols for which we are making plt entries. The
cbe950e9 4473 first entry in the procedure linkage table is reserved.
252b5132 4474
cbe950e9 4475 Get the offset into the .got table of the entry that
252b5132 4476 corresponds to this function. Each .got entry is 4 bytes.
cbe950e9 4477 The first three are reserved.
6bbec505 4478
cbe950e9
L		 4479 For static executables, we don't reserve anything. */
4480
6de2ae4a 4481 if (plt == htab->elf.splt)
cbe950e9 4482 {
e1f98742
L		 4483 got_offset = h->plt.offset / plt_entry_size - 1;
4484 got_offset = (got_offset + 3) * 4;
cbe950e9
L		 4485 }
4486 else
4487 {
e1f98742
L		 4488 got_offset = h->plt.offset / plt_entry_size;
4489 got_offset = got_offset * 4;
cbe950e9 4490 }
252b5132
RH		 4491
4492 /* Fill in the entry in the procedure linkage table. */
4493 if (! info->shared)
4494 {
25e762b9
RM		 4495 memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
4496 abed->plt->plt_entry_size);
252b5132 4497 bfd_put_32 (output_bfd,
cbe950e9
L		 4498 (gotplt->output_section->vma
4499 + gotplt->output_offset
252b5132 4500 + got_offset),
25e762b9
RM		 4501 plt->contents + h->plt.offset
4502 + abed->plt->plt_got_offset);
eac338cf 4503
25e762b9 4504 if (abed->is_vxworks)
eac338cf
PB		 4505 {
4506 int s, k, reloc_index;
4507
4508 /* Create the R_386_32 relocation referencing the GOT
4509 for this PLT entry. */
4510
4511 /* S: Current slot number (zero-based). */
25e762b9
RM		 4512 s = ((h->plt.offset - abed->plt->plt_entry_size)
4513 / abed->plt->plt_entry_size);
eac338cf
PB		 4514 /* K: Number of relocations for PLTResolve. */
4515 if (info->shared)
4516 k = PLTRESOLVE_RELOCS_SHLIB;
4517 else
4518 k = PLTRESOLVE_RELOCS;
4519 /* Skip the PLTresolve relocations, and the relocations for
4520 the other PLT slots. */
4521 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
4522 loc = (htab->srelplt2->contents + reloc_index
4523 * sizeof (Elf32_External_Rel));
4524
6de2ae4a
L		 4525 rel.r_offset = (htab->elf.splt->output_section->vma
4526 + htab->elf.splt->output_offset
eac338cf 4527 + h->plt.offset + 2),
7325306f 4528 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 4529 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4530
4531 /* Create the R_386_32 relocation referencing the beginning of
4532 the PLT for this GOT entry. */
6de2ae4a
L		 4533 rel.r_offset = (htab->elf.sgotplt->output_section->vma
4534 + htab->elf.sgotplt->output_offset
eac338cf 4535 + got_offset);
7325306f 4536 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
eac338cf 4537 bfd_elf32_swap_reloc_out (output_bfd, &rel,
13ca3149 4538 loc + sizeof (Elf32_External_Rel));
eac338cf 4539 }
252b5132
RH		 4540 }
4541 else
4542 {
25e762b9
RM		 4543 memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
4544 abed->plt->plt_entry_size);
252b5132 4545 bfd_put_32 (output_bfd, got_offset,
25e762b9
RM		 4546 plt->contents + h->plt.offset
4547 + abed->plt->plt_got_offset);
252b5132
RH		 4548 }
4549
252b5132
RH		 4550 /* Fill in the entry in the global offset table. */
4551 bfd_put_32 (output_bfd,
cbe950e9
L		 4552 (plt->output_section->vma
4553 + plt->output_offset
252b5132 4554 + h->plt.offset
25e762b9 4555 + abed->plt->plt_lazy_offset),
cbe950e9 4556 gotplt->contents + got_offset);
252b5132
RH		 4557
4558 /* Fill in the entry in the .rel.plt section. */
cbe950e9
L		 4559 rel.r_offset = (gotplt->output_section->vma
4560 + gotplt->output_offset
252b5132 4561 + got_offset);
cbe950e9
L		 4562 if (h->dynindx == -1
4563 || ((info->executable
4564 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4565 && h->def_regular
4566 && h->type == STT_GNU_IFUNC))
4567 {
4568 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4569 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
4570 in the .got.plt section. */
4571 bfd_put_32 (output_bfd,
23209a78 4572 (h->root.u.def.value
cbe950e9
L		 4573 + h->root.u.def.section->output_section->vma
4574 + h->root.u.def.section->output_offset),
4575 gotplt->contents + got_offset);
4576 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
e1f98742
L		 4577 /* R_386_IRELATIVE comes last. */
4578 plt_index = htab->next_irelative_index--;
cbe950e9
L		 4579 }
4580 else
e1f98742
L		 4581 {
4582 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
4583 plt_index = htab->next_jump_slot_index++;
4584 }
cbe950e9 4585 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
0ac8d2ca 4586 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132 4587
e1f98742
L		 4588 /* Don't fill PLT entry for static executables. */
4589 if (plt == htab->elf.splt)
4590 {
4591 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
4592 plt->contents + h->plt.offset
4593 + abed->plt->plt_reloc_offset);
4594 bfd_put_32 (output_bfd, - (h->plt.offset
4595 + abed->plt->plt_plt_offset + 4),
4596 plt->contents + h->plt.offset
4597 + abed->plt->plt_plt_offset);
4598 }
4599
f5385ebf 4600 if (!h->def_regular)
252b5132
RH		 4601 {
4602 /* Mark the symbol as undefined, rather than as defined in
c6585bbb
JJ		 4603 the .plt section. Leave the value if there were any
4604 relocations where pointer equality matters (this is a clue
51b64d56
AM		 4605 for the dynamic linker, to make function pointer
4606 comparisons work between an application and shared
c6585bbb
JJ		 4607 library), otherwise set it to zero. If a function is only
4608 called from a binary, there is no need to slow down
4609 shared libraries because of that. */
252b5132 4610 sym->st_shndx = SHN_UNDEF;
f5385ebf 4611 if (!h->pointer_equality_needed)
c6585bbb 4612 sym->st_value = 0;
252b5132
RH		 4613 }
4614 }
4615
13ae64f3 4616 if (h->got.offset != (bfd_vma) -1
67a4f2b7 4617 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
37e55690 4618 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
252b5132 4619 {
947216bf 4620 Elf_Internal_Rela rel;
252b5132
RH		 4621
4622 /* This symbol has an entry in the global offset table. Set it
4623 up. */
4624
6de2ae4a 4625 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
ffb2e45b 4626 abort ();
252b5132 4627
6de2ae4a
L		 4628 rel.r_offset = (htab->elf.sgot->output_section->vma
4629 + htab->elf.sgot->output_offset
dc810e39 4630 + (h->got.offset & ~(bfd_vma) 1));
252b5132 4631
dd5724d5
AM		 4632 /* If this is a static link, or it is a -Bsymbolic link and the
4633 symbol is defined locally or was forced to be local because
4634 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 4635 The entry in the global offset table will already have been
4636 initialized in the relocate_section function. */
710ab287 4637 if (h->def_regular
0018b0a3
L		 4638 && h->type == STT_GNU_IFUNC)
4639 {
710ab287
L		 4640 if (info->shared)
4641 {
4642 /* Generate R_386_GLOB_DAT. */
4643 goto do_glob_dat;
4644 }
4645 else
4646 {
cd2b2c10
L		 4647 asection *plt;
4648
710ab287
L		 4649 if (!h->pointer_equality_needed)
4650 abort ();
4651
4652 /* For non-shared object, we can't use .got.plt, which
4653 contains the real function addres if we need pointer
4654 equality. We load the GOT entry with the PLT entry. */
cd2b2c10 4655 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
710ab287
L		 4656 bfd_put_32 (output_bfd,
4657 (plt->output_section->vma
4658 + plt->output_offset + h->plt.offset),
6de2ae4a 4659 htab->elf.sgot->contents + h->got.offset);
710ab287
L		 4660 return TRUE;
4661 }
0018b0a3
L		 4662 }
4663 else if (info->shared
4664 && SYMBOL_REFERENCES_LOCAL (info, h))
dd5724d5 4665 {
6725bdbf 4666 BFD_ASSERT((h->got.offset & 1) != 0);
dd5724d5
AM		 4667 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4668 }
252b5132
RH		 4669 else
4670 {
dd5724d5 4671 BFD_ASSERT((h->got.offset & 1) == 0);
710ab287 4672do_glob_dat:
6725bdbf 4673 bfd_put_32 (output_bfd, (bfd_vma) 0,
6de2ae4a 4674 htab->elf.sgot->contents + h->got.offset);
252b5132
RH		 4675 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
4676 }
4677
59d6ffb2 4678 elf_append_rel (output_bfd, htab->elf.srelgot, &rel);
252b5132
RH		 4679 }
4680
f5385ebf 4681 if (h->needs_copy)
252b5132 4682 {
947216bf 4683 Elf_Internal_Rela rel;
252b5132
RH		 4684
4685 /* This symbol needs a copy reloc. Set it up. */
4686
ffb2e45b
AM		 4687 if (h->dynindx == -1
4688 || (h->root.type != bfd_link_hash_defined
4689 && h->root.type != bfd_link_hash_defweak)
4690 || htab->srelbss == NULL)
4691 abort ();
252b5132
RH		 4692
4693 rel.r_offset = (h->root.u.def.value
4694 + h->root.u.def.section->output_section->vma
4695 + h->root.u.def.section->output_offset);
4696 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
59d6ffb2 4697 elf_append_rel (output_bfd, htab->srelbss, &rel);
252b5132
RH		 4698 }
4699
b34976b6 4700 return TRUE;
252b5132
RH		 4701}
4702
c25bc9fc
L		 4703/* Finish up local dynamic symbol handling. We set the contents of
4704 various dynamic sections here. */
4705
4706static bfd_boolean
4707elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
4708{
4709 struct elf_link_hash_entry *h
4710 = (struct elf_link_hash_entry *) *slot;
4711 struct bfd_link_info *info
23209a78 4712 = (struct bfd_link_info *) inf;
c25bc9fc
L		 4713
4714 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
4715 h, NULL);
4716}
4717
38701953
AM		 4718/* Used to decide how to sort relocs in an optimal manner for the
4719 dynamic linker, before writing them out. */
4720
4721static enum elf_reloc_type_class
7e612e98
AM		 4722elf_i386_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
4723 const asection *rel_sec ATTRIBUTE_UNUSED,
4724 const Elf_Internal_Rela *rela)
38701953 4725{
55fd94b0 4726 switch (ELF32_R_TYPE (rela->r_info))
38701953
AM		 4727 {
4728 case R_386_RELATIVE:
4729 return reloc_class_relative;
4730 case R_386_JUMP_SLOT:
4731 return reloc_class_plt;
4732 case R_386_COPY:
4733 return reloc_class_copy;
4734 default:
4735 return reloc_class_normal;
4736 }
4737}
4738
252b5132
RH		 4739/* Finish up the dynamic sections. */
4740
b34976b6 4741static bfd_boolean
55fd94b0
AM		 4742elf_i386_finish_dynamic_sections (bfd *output_bfd,
4743 struct bfd_link_info *info)
252b5132 4744{
6725bdbf 4745 struct elf_i386_link_hash_table *htab;
252b5132 4746 bfd *dynobj;
252b5132 4747 asection *sdyn;
25e762b9 4748 const struct elf_i386_backend_data *abed;
252b5132 4749
6725bdbf 4750 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 4751 if (htab == NULL)
4752 return FALSE;
4753
ebe50bae 4754 dynobj = htab->elf.dynobj;
3d4d4302 4755 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
25e762b9 4756 abed = get_elf_i386_backend_data (output_bfd);
252b5132 4757
ebe50bae 4758 if (htab->elf.dynamic_sections_created)
252b5132 4759 {
252b5132
RH		 4760 Elf32_External_Dyn *dyncon, *dynconend;
4761
6de2ae4a 4762 if (sdyn == NULL || htab->elf.sgot == NULL)
ffb2e45b 4763 abort ();
252b5132
RH		 4764
4765 dyncon = (Elf32_External_Dyn *) sdyn->contents;
eea6121a 4766 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
252b5132
RH		 4767 for (; dyncon < dynconend; dyncon++)
4768 {
4769 Elf_Internal_Dyn dyn;
51b64d56 4770 asection *s;
252b5132
RH		 4771
4772 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4773
4774 switch (dyn.d_tag)
4775 {
4776 default:
25e762b9
RM		 4777 if (abed->is_vxworks
4778 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
7a2b07ff 4779 break;
0ac8d2ca 4780 continue;
252b5132
RH		 4781
4782 case DT_PLTGOT:
6de2ae4a 4783 s = htab->elf.sgotplt;
8c37241b 4784 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
6725bdbf
AM		 4785 break;
4786
252b5132 4787 case DT_JMPREL:
6de2ae4a 4788 s = htab->elf.srelplt;
6348e046 4789 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
252b5132
RH		 4790 break;
4791
4792 case DT_PLTRELSZ:
6de2ae4a 4793 s = htab->elf.srelplt;
eea6121a 4794 dyn.d_un.d_val = s->size;
252b5132
RH		 4795 break;
4796
4797 case DT_RELSZ:
4798 /* My reading of the SVR4 ABI indicates that the
4799 procedure linkage table relocs (DT_JMPREL) should be
4800 included in the overall relocs (DT_REL). This is
4801 what Solaris does. However, UnixWare can not handle
4802 that case. Therefore, we override the DT_RELSZ entry
6348e046 4803 here to make it not include the JMPREL relocs. */
6de2ae4a 4804 s = htab->elf.srelplt;
6348e046
AM		 4805 if (s == NULL)
4806 continue;
eea6121a 4807 dyn.d_un.d_val -= s->size;
6348e046
AM		 4808 break;
4809
4810 case DT_REL:
4811 /* We may not be using the standard ELF linker script.
4812 If .rel.plt is the first .rel section, we adjust
4813 DT_REL to not include it. */
6de2ae4a 4814 s = htab->elf.srelplt;
6348e046
AM		 4815 if (s == NULL)
4816 continue;
4817 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
4818 continue;
eea6121a 4819 dyn.d_un.d_ptr += s->size;
252b5132
RH		 4820 break;
4821 }
0ac8d2ca
AM		 4822
4823 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
252b5132
RH		 4824 }
4825
4826 /* Fill in the first entry in the procedure linkage table. */
6de2ae4a 4827 if (htab->elf.splt && htab->elf.splt->size > 0)
252b5132
RH		 4828 {
4829 if (info->shared)
eac338cf 4830 {
25e762b9
RM		 4831 memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
4832 abed->plt->plt0_entry_size);
4833 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
4834 abed->plt0_pad_byte,
4835 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
eac338cf 4836 }
252b5132
RH		 4837 else
4838 {
25e762b9
RM		 4839 memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
4840 abed->plt->plt0_entry_size);
4841 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
4842 abed->plt0_pad_byte,
4843 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
252b5132 4844 bfd_put_32 (output_bfd,
6de2ae4a
L		 4845 (htab->elf.sgotplt->output_section->vma
4846 + htab->elf.sgotplt->output_offset
6725bdbf 4847 + 4),
25e762b9
RM		 4848 htab->elf.splt->contents
4849 + abed->plt->plt0_got1_offset);
252b5132 4850 bfd_put_32 (output_bfd,
6de2ae4a
L		 4851 (htab->elf.sgotplt->output_section->vma
4852 + htab->elf.sgotplt->output_offset
6725bdbf 4853 + 8),
25e762b9
RM		 4854 htab->elf.splt->contents
4855 + abed->plt->plt0_got2_offset);
eac338cf 4856
25e762b9 4857 if (abed->is_vxworks)
eac338cf
PB		 4858 {
4859 Elf_Internal_Rela rel;
7325306f 4860
eac338cf
PB		 4861 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
4862 On IA32 we use REL relocations so the addend goes in
4863 the PLT directly. */
6de2ae4a
L		 4864 rel.r_offset = (htab->elf.splt->output_section->vma
4865 + htab->elf.splt->output_offset
25e762b9 4866 + abed->plt->plt0_got1_offset);
7325306f 4867 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 4868 bfd_elf32_swap_reloc_out (output_bfd, &rel,
4869 htab->srelplt2->contents);
4870 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
6de2ae4a
L		 4871 rel.r_offset = (htab->elf.splt->output_section->vma
4872 + htab->elf.splt->output_offset
25e762b9 4873 + abed->plt->plt0_got2_offset);
7325306f 4874 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 4875 bfd_elf32_swap_reloc_out (output_bfd, &rel,
4876 htab->srelplt2->contents +
4877 sizeof (Elf32_External_Rel));
4878 }
252b5132
RH		 4879 }
4880
4881 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4882 really seem like the right value. */
6de2ae4a 4883 elf_section_data (htab->elf.splt->output_section)
6725bdbf 4884 ->this_hdr.sh_entsize = 4;
eac338cf
PB		 4885
4886 /* Correct the .rel.plt.unloaded relocations. */
25e762b9 4887 if (abed->is_vxworks && !info->shared)
eac338cf 4888 {
25e762b9
RM		 4889 int num_plts = (htab->elf.splt->size
4890 / abed->plt->plt_entry_size) - 1;
4c9b0de6 4891 unsigned char *p;
eac338cf
PB		 4892
4893 p = htab->srelplt2->contents;
4894 if (info->shared)
4895 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
4896 else
4897 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
4898
4899 for (; num_plts; num_plts--)
4900 {
4901 Elf_Internal_Rela rel;
4902 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
7325306f 4903 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 4904 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4905 p += sizeof (Elf32_External_Rel);
4906
4907 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
7325306f 4908 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
eac338cf
PB		 4909 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4910 p += sizeof (Elf32_External_Rel);
4911 }
4912 }
252b5132
RH		 4913 }
4914 }
4915
6de2ae4a 4916 if (htab->elf.sgotplt)
252b5132 4917 {
56d4289c
L		 4918 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4919 {
4920 (*_bfd_error_handler)
4921 (_("discarded output section: `%A'"), htab->elf.sgotplt);
4922 return FALSE;
4923 }
4924
12d0ee4a 4925 /* Fill in the first three entries in the global offset table. */
6de2ae4a 4926 if (htab->elf.sgotplt->size > 0)
12d0ee4a
AM		 4927 {
4928 bfd_put_32 (output_bfd,
55fd94b0 4929 (sdyn == NULL ? 0
12d0ee4a 4930 : sdyn->output_section->vma + sdyn->output_offset),
6de2ae4a
L		 4931 htab->elf.sgotplt->contents);
4932 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
4933 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
12d0ee4a 4934 }
252b5132 4935
6de2ae4a 4936 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
12d0ee4a 4937 }
8c37241b 4938
e41b3a13 4939 /* Adjust .eh_frame for .plt section. */
9a2a56cc
AM		 4940 if (htab->plt_eh_frame != NULL
4941 && htab->plt_eh_frame->contents != NULL)
e41b3a13
JJ		 4942 {
4943 if (htab->elf.splt != NULL
4944 && htab->elf.splt->size != 0
4945 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4946 && htab->elf.splt->output_section != NULL
4947 && htab->plt_eh_frame->output_section != NULL)
4948 {
4949 bfd_vma plt_start = htab->elf.splt->output_section->vma;
4950 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4951 + htab->plt_eh_frame->output_offset
4952 + PLT_FDE_START_OFFSET;
4953 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4954 htab->plt_eh_frame->contents
4955 + PLT_FDE_START_OFFSET);
4956 }
4957 if (htab->plt_eh_frame->sec_info_type
dbaa2011 4958 == SEC_INFO_TYPE_EH_FRAME)
e41b3a13
JJ		 4959 {
4960 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4961 htab->plt_eh_frame,
4962 htab->plt_eh_frame->contents))
4963 return FALSE;
4964 }
4965 }
4966
6de2ae4a
L		 4967 if (htab->elf.sgot && htab->elf.sgot->size > 0)
4968 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
8c37241b 4969
c25bc9fc
L		 4970 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4971 htab_traverse (htab->loc_hash_table,
4972 elf_i386_finish_local_dynamic_symbol,
4973 info);
4974
b34976b6 4975 return TRUE;
252b5132
RH		 4976}
4977
4c45e5c9
JJ		 4978/* Return address for Ith PLT stub in section PLT, for relocation REL
4979 or (bfd_vma) -1 if it should not be included. */
4980
4981static bfd_vma
4982elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
4983 const arelent *rel ATTRIBUTE_UNUSED)
4984{
25e762b9 4985 return plt->vma + (i + 1) * GET_PLT_ENTRY_SIZE (plt->owner);
4c45e5c9
JJ		 4986}
4987
fdc90cb4
JJ		 4988/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4989
4990static bfd_boolean
4991elf_i386_hash_symbol (struct elf_link_hash_entry *h)
4992{
4993 if (h->plt.offset != (bfd_vma) -1
4994 && !h->def_regular
4995 && !h->pointer_equality_needed)
4996 return FALSE;
4997
4998 return _bfd_elf_hash_symbol (h);
4999}
4c45e5c9 5000
d8045f23
NC		 5001/* Hook called by the linker routine which adds symbols from an object
5002 file. */
5003
5004static bfd_boolean
c16153ae 5005elf_i386_add_symbol_hook (bfd * abfd,
d8045f23
NC		 5006 struct bfd_link_info * info ATTRIBUTE_UNUSED,
5007 Elf_Internal_Sym * sym,
5008 const char ** namep ATTRIBUTE_UNUSED,
5009 flagword * flagsp ATTRIBUTE_UNUSED,
5010 asection ** secp ATTRIBUTE_UNUSED,
5011 bfd_vma * valp ATTRIBUTE_UNUSED)
5012{
c16153ae 5013 if ((abfd->flags & DYNAMIC) == 0
f64b2e8d
NC		 5014 && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
5015 || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
5016 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
d8045f23
NC		 5017
5018 return TRUE;
5019}
5020
252b5132
RH		 5021#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
5022#define TARGET_LITTLE_NAME "elf32-i386"
5023#define ELF_ARCH bfd_arch_i386
ae95ffa6 5024#define ELF_TARGET_ID I386_ELF_DATA
252b5132
RH		 5025#define ELF_MACHINE_CODE EM_386
5026#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 5027
5028#define elf_backend_can_gc_sections 1
51b64d56 5029#define elf_backend_can_refcount 1
252b5132
RH		 5030#define elf_backend_want_got_plt 1
5031#define elf_backend_plt_readonly 1
5032#define elf_backend_want_plt_sym 0
5033#define elf_backend_got_header_size 12
e41b3a13 5034#define elf_backend_plt_alignment 4
252b5132 5035
8c29f035
AM		 5036/* Support RELA for objdump of prelink objects. */
5037#define elf_info_to_howto elf_i386_info_to_howto_rel
dd5724d5
AM		 5038#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5039
13ae64f3 5040#define bfd_elf32_mkobject elf_i386_mkobject
13ae64f3 5041
dd5724d5
AM		 5042#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5043#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
c25bc9fc 5044#define bfd_elf32_bfd_link_hash_table_free elf_i386_link_hash_table_free
dd5724d5 5045#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
13285a1b 5046#define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
dd5724d5
AM		 5047
5048#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
13285a1b 5049#define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
dd5724d5 5050#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 5051#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 5052#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 5053#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 5054#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5055#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5056#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
5057#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
c5fccbec
DJ		 5058#define elf_backend_grok_prstatus elf_i386_grok_prstatus
5059#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 5060#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 5061#define elf_backend_relocate_section elf_i386_relocate_section
5062#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
67a4f2b7 5063#define elf_backend_always_size_sections elf_i386_always_size_sections
74541ad4
AM		 5064#define elf_backend_omit_section_dynsym \
5065 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4c45e5c9 5066#define elf_backend_plt_sym_val elf_i386_plt_sym_val
fdc90cb4 5067#define elf_backend_hash_symbol elf_i386_hash_symbol
d8045f23 5068#define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
dd5724d5 5069
252b5132 5070#include "elf32-target.h"
2bc3c89a
AM		 5071
5072/* FreeBSD support. */
5073
5074#undef TARGET_LITTLE_SYM
5075#define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
5076#undef TARGET_LITTLE_NAME
5077#define TARGET_LITTLE_NAME "elf32-i386-freebsd"
d1036acb
L		 5078#undef ELF_OSABI
5079#define ELF_OSABI ELFOSABI_FREEBSD
2bc3c89a
AM		 5080
5081/* The kernel recognizes executables as valid only if they carry a
5082 "FreeBSD" label in the ELF header. So we put this label on all
5083 executables and (for simplicity) also all other object files. */
5084
2bc3c89a 5085static void
d8045f23 5086elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
2bc3c89a 5087{
78245035 5088 _bfd_elf_post_process_headers (abfd, info);
2bc3c89a 5089
2bc3c89a
AM		 5090#ifdef OLD_FREEBSD_ABI_LABEL
5091 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5092 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
caf47ea6 5093#endif
2bc3c89a
AM		 5094}
5095
5096#undef elf_backend_post_process_headers
d8045f23 5097#define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
571fe01f
NC		 5098#undef elf32_bed
5099#define elf32_bed elf32_i386_fbsd_bed
2bc3c89a 5100
d8045f23
NC		 5101#undef elf_backend_add_symbol_hook
5102
2bc3c89a 5103#include "elf32-target.h"
eac338cf 5104
a6cc6b3b
RO		 5105/* Solaris 2. */
5106
5107#undef TARGET_LITTLE_SYM
5108#define TARGET_LITTLE_SYM bfd_elf32_i386_sol2_vec
5109#undef TARGET_LITTLE_NAME
5110#define TARGET_LITTLE_NAME "elf32-i386-sol2"
5111
5112/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5113 objects won't be recognized. */
5114#undef ELF_OSABI
5115
5116#undef elf32_bed
5117#define elf32_bed elf32_i386_sol2_bed
5118
7dc98aea
RO		 5119/* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5120 boundary. */
5121#undef elf_backend_static_tls_alignment
5122#define elf_backend_static_tls_alignment 8
5123
a6cc6b3b
RO		 5124/* The Solaris 2 ABI requires a plt symbol on all platforms.
5125
5126 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5127 File, p.63. */
5128#undef elf_backend_want_plt_sym
5129#define elf_backend_want_plt_sym 1
5130
5131#include "elf32-target.h"
5132
a27e4371
RM		 5133/* Native Client support. */
5134
5135#undef TARGET_LITTLE_SYM
5136#define TARGET_LITTLE_SYM bfd_elf32_i386_nacl_vec
5137#undef TARGET_LITTLE_NAME
5138#define TARGET_LITTLE_NAME "elf32-i386-nacl"
5139#undef elf32_bed
5140#define elf32_bed elf32_i386_nacl_bed
5141
5142#undef ELF_MAXPAGESIZE
5143#define ELF_MAXPAGESIZE 0x10000
5144
5145/* Restore defaults. */
5146#undef ELF_OSABI
5147#undef elf_backend_want_plt_sym
5148#define elf_backend_want_plt_sym 0
5149#undef elf_backend_post_process_headers
a27e4371
RM		 5150#undef elf_backend_static_tls_alignment
5151
5152/* NaCl uses substantially different PLT entries for the same effects. */
5153
5154#undef elf_backend_plt_alignment
5155#define elf_backend_plt_alignment 5
5156#define NACL_PLT_ENTRY_SIZE 64
5157#define NACLMASK 0xe0 /* 32-byte alignment mask. */
5158
5159static const bfd_byte elf_i386_nacl_plt0_entry[] =
5160 {
5161 0xff, 0x35, /* pushl contents of address */
5162 0, 0, 0, 0, /* replaced with address of .got + 4. */
5163 0x8b, 0x0d, /* movl contents of address, %ecx */
5164 0, 0, 0, 0, /* replaced with address of .got + 8. */
5165 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
5166 0xff, 0xe1 /* jmp *%ecx */
5167 };
5168
5169static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5170 {
5171 0x8b, 0x0d, /* movl contents of address, %ecx */
5172 0, 0, 0, 0, /* replaced with GOT slot address. */
5173 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
5174 0xff, 0xe1, /* jmp *%ecx */
5175
5176 /* Pad to the next 32-byte boundary with nop instructions. */
5177 0x90,
5178 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5179 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5180
5181 /* Lazy GOT entries point here (32-byte aligned). */
5182 0x68, /* pushl immediate */
5183 0, 0, 0, 0, /* replaced with reloc offset. */
5184 0xe9, /* jmp relative */
5185 0, 0, 0, 0, /* replaced with offset to .plt. */
5186
5187 /* Pad to the next 32-byte boundary with nop instructions. */
5188 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5189 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5190 0x90, 0x90
5191 };
5192
5193static const bfd_byte
5194elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
5195 {
5196 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
5197 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
5198 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
5199 0xff, 0xe1, /* jmp *%ecx */
caa0075c
RM		 5200
5201 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
5202 so pad to that size with nop instructions. */
5203 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
a27e4371
RM		 5204 };
5205
5206static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
5207 {
5208 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
5209 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
5210 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
5211 0xff, 0xe1, /* jmp *%ecx */
5212
5213 /* Pad to the next 32-byte boundary with nop instructions. */
5214 0x90,
5215 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5216 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5217
5218 /* Lazy GOT entries point here (32-byte aligned). */
5219 0x68, /* pushl immediate */
5220 0, 0, 0, 0, /* replaced with offset into relocation table. */
5221 0xe9, /* jmp relative */
5222 0, 0, 0, 0, /* replaced with offset to start of .plt. */
5223
5224 /* Pad to the next 32-byte boundary with nop instructions. */
5225 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5226 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5227 0x90, 0x90
5228 };
5229
5230static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
5231 {
5232#if (PLT_CIE_LENGTH != 20 \
5233 || PLT_FDE_LENGTH != 36 \
5234 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5235 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5236# error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
5237#endif
5238 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
5239 0, 0, 0, 0, /* CIE ID */
5240 1, /* CIE version */
5241 'z', 'R', 0, /* Augmentation string */
5242 1, /* Code alignment factor */
5243 0x7c, /* Data alignment factor: -4 */
5244 8, /* Return address column */
5245 1, /* Augmentation size */
5246 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5247 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
5248 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
5249 DW_CFA_nop, DW_CFA_nop,
5250
5251 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
5252 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
5253 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
5254 0, 0, 0, 0, /* .plt size goes here */
5255 0, /* Augmentation size */
5256 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
5257 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5258 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
5259 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5260 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
5261 13, /* Block length */
5262 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
5263 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
5264 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5265 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
5266 DW_CFA_nop, DW_CFA_nop
5267 };
5268
5269static const struct elf_i386_plt_layout elf_i386_nacl_plt =
5270 {
5271 elf_i386_nacl_plt0_entry, /* plt0_entry */
5272 sizeof (elf_i386_nacl_plt0_entry), /* plt0_entry_size */
5273 2, /* plt0_got1_offset */
5274 8, /* plt0_got2_offset */
5275 elf_i386_nacl_plt_entry, /* plt_entry */
5276 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
5277 2, /* plt_got_offset */
5278 33, /* plt_reloc_offset */
5279 38, /* plt_plt_offset */
5280 32, /* plt_lazy_offset */
5281 elf_i386_nacl_pic_plt0_entry, /* pic_plt0_entry */
5282 elf_i386_nacl_pic_plt_entry, /* pic_plt_entry */
5283 elf_i386_nacl_eh_frame_plt, /* eh_frame_plt */
5284 sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
5285 };
5286
5287static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
5288 {
5289 &elf_i386_nacl_plt, /* plt */
5290 0x90, /* plt0_pad_byte: nop insn */
5291 0, /* is_vxworks */
5292 };
5293
64b384e1
RM		 5294static bfd_boolean
5295elf32_i386_nacl_elf_object_p (bfd *abfd)
5296{
5297 /* Set the right machine number for a NaCl i386 ELF32 file. */
5298 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386_nacl);
5299 return TRUE;
5300}
5301
a27e4371
RM		 5302#undef elf_backend_arch_data
5303#define elf_backend_arch_data &elf_i386_nacl_arch_bed
5304
64b384e1
RM		 5305#undef elf_backend_object_p
5306#define elf_backend_object_p elf32_i386_nacl_elf_object_p
5a68afcf
RM		 5307#undef elf_backend_modify_segment_map
5308#define elf_backend_modify_segment_map nacl_modify_segment_map
5309#undef elf_backend_modify_program_headers
5310#define elf_backend_modify_program_headers nacl_modify_program_headers
887badb3
RM		 5311#undef elf_backend_final_write_processing
5312#define elf_backend_final_write_processing nacl_final_write_processing
5a68afcf 5313
a27e4371
RM		 5314#include "elf32-target.h"
5315
5a68afcf 5316/* Restore defaults. */
64b384e1 5317#undef elf_backend_object_p
5a68afcf
RM		 5318#undef elf_backend_modify_segment_map
5319#undef elf_backend_modify_program_headers
887badb3 5320#undef elf_backend_final_write_processing
5a68afcf 5321
eac338cf
PB		 5322/* VxWorks support. */
5323
5324#undef TARGET_LITTLE_SYM
5325#define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
5326#undef TARGET_LITTLE_NAME
5327#define TARGET_LITTLE_NAME "elf32-i386-vxworks"
d1036acb 5328#undef ELF_OSABI
a27e4371
RM		 5329#undef elf_backend_plt_alignment
5330#define elf_backend_plt_alignment 4
eac338cf 5331
23209a78
RM		 5332static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
5333 {
25e762b9 5334 &elf_i386_plt, /* plt */
23209a78
RM		 5335 0x90, /* plt0_pad_byte */
5336 1, /* is_vxworks */
5337 };
eac338cf 5338
23209a78
RM		 5339#undef elf_backend_arch_data
5340#define elf_backend_arch_data &elf_i386_vxworks_arch_bed
eac338cf 5341
13285a1b 5342#undef elf_backend_relocs_compatible
eac338cf
PB		 5343#undef elf_backend_add_symbol_hook
5344#define elf_backend_add_symbol_hook \
5345 elf_vxworks_add_symbol_hook
5346#undef elf_backend_link_output_symbol_hook
5347#define elf_backend_link_output_symbol_hook \
9c72ff84 5348 elf_vxworks_link_output_symbol_hook
eac338cf
PB		 5349#undef elf_backend_emit_relocs
5350#define elf_backend_emit_relocs elf_vxworks_emit_relocs
5351#undef elf_backend_final_write_processing
5352#define elf_backend_final_write_processing \
5353 elf_vxworks_final_write_processing
7dc98aea 5354#undef elf_backend_static_tls_alignment
eac338cf
PB		 5355
5356/* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
5357 define it. */
5358#undef elf_backend_want_plt_sym
5359#define elf_backend_want_plt_sym 1
5360
5361#undef elf32_bed
5362#define elf32_bed elf32_i386_vxworks_bed
5363
5364#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 1.12281 seconds and 4 git commands to generate.