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