1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 static reloc_howto_type
*elf_i386_reloc_type_lookup
28 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
29 static void elf_i386_info_to_howto
30 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
31 static void elf_i386_info_to_howto_rel
32 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
33 static bfd_boolean elf_i386_is_local_label_name
34 PARAMS ((bfd
*, const char *));
35 static bfd_boolean elf_i386_grok_prstatus
36 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
37 static bfd_boolean elf_i386_grok_psinfo
38 PARAMS ((bfd
*abfd
, Elf_Internal_Note
*note
));
39 static struct bfd_hash_entry
*link_hash_newfunc
40 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
41 static struct bfd_link_hash_table
*elf_i386_link_hash_table_create
43 static bfd_boolean create_got_section
44 PARAMS ((bfd
*, struct bfd_link_info
*));
45 static bfd_boolean elf_i386_create_dynamic_sections
46 PARAMS ((bfd
*, struct bfd_link_info
*));
47 static void elf_i386_copy_indirect_symbol
48 PARAMS ((struct elf_backend_data
*, struct elf_link_hash_entry
*,
49 struct elf_link_hash_entry
*));
50 static int elf_i386_tls_transition
51 PARAMS ((struct bfd_link_info
*, int, int));
53 static bfd_boolean elf_i386_mkobject
55 static bfd_boolean elf_i386_object_p
57 static bfd_boolean elf_i386_check_relocs
58 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
59 const Elf_Internal_Rela
*));
60 static asection
*elf_i386_gc_mark_hook
61 PARAMS ((asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
62 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
63 static bfd_boolean elf_i386_gc_sweep_hook
64 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
65 const Elf_Internal_Rela
*));
66 static bfd_boolean elf_i386_adjust_dynamic_symbol
67 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
68 static bfd_boolean allocate_dynrelocs
69 PARAMS ((struct elf_link_hash_entry
*, PTR
));
70 static bfd_boolean readonly_dynrelocs
71 PARAMS ((struct elf_link_hash_entry
*, PTR
));
72 static bfd_boolean elf_i386_fake_sections
73 PARAMS ((bfd
*, Elf_Internal_Shdr
*, asection
*));
74 static bfd_boolean elf_i386_size_dynamic_sections
75 PARAMS ((bfd
*, struct bfd_link_info
*));
76 static bfd_vma dtpoff_base
77 PARAMS ((struct bfd_link_info
*));
79 PARAMS ((struct bfd_link_info
*, bfd_vma
));
80 static bfd_boolean elf_i386_relocate_section
81 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
82 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
83 static bfd_boolean elf_i386_finish_dynamic_symbol
84 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
86 static enum elf_reloc_type_class elf_i386_reloc_type_class
87 PARAMS ((const Elf_Internal_Rela
*));
88 static bfd_boolean elf_i386_finish_dynamic_sections
89 PARAMS ((bfd
*, struct bfd_link_info
*));
91 #define USE_REL 1 /* 386 uses REL relocations instead of RELA. */
95 static reloc_howto_type elf_howto_table
[]=
97 HOWTO(R_386_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_bitfield
,
98 bfd_elf_generic_reloc
, "R_386_NONE",
99 TRUE
, 0x00000000, 0x00000000, FALSE
),
100 HOWTO(R_386_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
101 bfd_elf_generic_reloc
, "R_386_32",
102 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
103 HOWTO(R_386_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
104 bfd_elf_generic_reloc
, "R_386_PC32",
105 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
106 HOWTO(R_386_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
107 bfd_elf_generic_reloc
, "R_386_GOT32",
108 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
109 HOWTO(R_386_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
110 bfd_elf_generic_reloc
, "R_386_PLT32",
111 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
112 HOWTO(R_386_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
113 bfd_elf_generic_reloc
, "R_386_COPY",
114 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
115 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
116 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
117 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
118 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
119 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
120 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
121 HOWTO(R_386_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
122 bfd_elf_generic_reloc
, "R_386_RELATIVE",
123 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
124 HOWTO(R_386_GOTOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
125 bfd_elf_generic_reloc
, "R_386_GOTOFF",
126 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
127 HOWTO(R_386_GOTPC
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
128 bfd_elf_generic_reloc
, "R_386_GOTPC",
129 TRUE
, 0xffffffff, 0xffffffff, TRUE
),
131 /* We have a gap in the reloc numbers here.
132 R_386_standard counts the number up to this point, and
133 R_386_ext_offset is the value to subtract from a reloc type of
134 R_386_16 thru R_386_PC8 to form an index into this table. */
135 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
136 #define R_386_ext_offset ((unsigned int) R_386_TLS_TPOFF - R_386_standard)
138 /* These relocs are a GNU extension. */
139 HOWTO(R_386_TLS_TPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
140 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF",
141 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
142 HOWTO(R_386_TLS_IE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
143 bfd_elf_generic_reloc
, "R_386_TLS_IE",
144 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
145 HOWTO(R_386_TLS_GOTIE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
146 bfd_elf_generic_reloc
, "R_386_TLS_GOTIE",
147 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
148 HOWTO(R_386_TLS_LE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
149 bfd_elf_generic_reloc
, "R_386_TLS_LE",
150 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
151 HOWTO(R_386_TLS_GD
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
152 bfd_elf_generic_reloc
, "R_386_TLS_GD",
153 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
154 HOWTO(R_386_TLS_LDM
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
155 bfd_elf_generic_reloc
, "R_386_TLS_LDM",
156 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
157 HOWTO(R_386_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
158 bfd_elf_generic_reloc
, "R_386_16",
159 TRUE
, 0xffff, 0xffff, FALSE
),
160 HOWTO(R_386_PC16
, 0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
161 bfd_elf_generic_reloc
, "R_386_PC16",
162 TRUE
, 0xffff, 0xffff, TRUE
),
163 HOWTO(R_386_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
164 bfd_elf_generic_reloc
, "R_386_8",
165 TRUE
, 0xff, 0xff, FALSE
),
166 HOWTO(R_386_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
167 bfd_elf_generic_reloc
, "R_386_PC8",
168 TRUE
, 0xff, 0xff, TRUE
),
170 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
171 #define R_386_tls_offset ((unsigned int) R_386_TLS_LDO_32 - R_386_ext)
172 /* These are common with Solaris TLS implementation. */
173 HOWTO(R_386_TLS_LDO_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
174 bfd_elf_generic_reloc
, "R_386_TLS_LDO_32",
175 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
176 HOWTO(R_386_TLS_IE_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
177 bfd_elf_generic_reloc
, "R_386_TLS_IE_32",
178 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
179 HOWTO(R_386_TLS_LE_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
180 bfd_elf_generic_reloc
, "R_386_TLS_LE_32",
181 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
182 HOWTO(R_386_TLS_DTPMOD32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
183 bfd_elf_generic_reloc
, "R_386_TLS_DTPMOD32",
184 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
185 HOWTO(R_386_TLS_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
186 bfd_elf_generic_reloc
, "R_386_TLS_DTPOFF32",
187 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
188 HOWTO(R_386_TLS_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
189 bfd_elf_generic_reloc
, "R_386_TLS_TPOFF32",
190 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
193 #define R_386_tls ((unsigned int) R_386_TLS_TPOFF32 + 1 - R_386_tls_offset)
194 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_tls)
196 /* GNU extension to record C++ vtable hierarchy. */
197 HOWTO (R_386_GNU_VTINHERIT
, /* type */
199 2, /* size (0 = byte, 1 = short, 2 = long) */
201 FALSE
, /* pc_relative */
203 complain_overflow_dont
, /* complain_on_overflow */
204 NULL
, /* special_function */
205 "R_386_GNU_VTINHERIT", /* name */
206 FALSE
, /* partial_inplace */
209 FALSE
), /* pcrel_offset */
211 /* GNU extension to record C++ vtable member usage. */
212 HOWTO (R_386_GNU_VTENTRY
, /* type */
214 2, /* size (0 = byte, 1 = short, 2 = long) */
216 FALSE
, /* pc_relative */
218 complain_overflow_dont
, /* complain_on_overflow */
219 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
220 "R_386_GNU_VTENTRY", /* name */
221 FALSE
, /* partial_inplace */
224 FALSE
) /* pcrel_offset */
226 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
230 #ifdef DEBUG_GEN_RELOC
231 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
236 static reloc_howto_type
*
237 elf_i386_reloc_type_lookup (abfd
, code
)
238 bfd
*abfd ATTRIBUTE_UNUSED
;
239 bfd_reloc_code_real_type code
;
244 TRACE ("BFD_RELOC_NONE");
245 return &elf_howto_table
[(unsigned int) R_386_NONE
];
248 TRACE ("BFD_RELOC_32");
249 return &elf_howto_table
[(unsigned int) R_386_32
];
252 TRACE ("BFD_RELOC_CTOR");
253 return &elf_howto_table
[(unsigned int) R_386_32
];
255 case BFD_RELOC_32_PCREL
:
256 TRACE ("BFD_RELOC_PC32");
257 return &elf_howto_table
[(unsigned int) R_386_PC32
];
259 case BFD_RELOC_386_GOT32
:
260 TRACE ("BFD_RELOC_386_GOT32");
261 return &elf_howto_table
[(unsigned int) R_386_GOT32
];
263 case BFD_RELOC_386_PLT32
:
264 TRACE ("BFD_RELOC_386_PLT32");
265 return &elf_howto_table
[(unsigned int) R_386_PLT32
];
267 case BFD_RELOC_386_COPY
:
268 TRACE ("BFD_RELOC_386_COPY");
269 return &elf_howto_table
[(unsigned int) R_386_COPY
];
271 case BFD_RELOC_386_GLOB_DAT
:
272 TRACE ("BFD_RELOC_386_GLOB_DAT");
273 return &elf_howto_table
[(unsigned int) R_386_GLOB_DAT
];
275 case BFD_RELOC_386_JUMP_SLOT
:
276 TRACE ("BFD_RELOC_386_JUMP_SLOT");
277 return &elf_howto_table
[(unsigned int) R_386_JUMP_SLOT
];
279 case BFD_RELOC_386_RELATIVE
:
280 TRACE ("BFD_RELOC_386_RELATIVE");
281 return &elf_howto_table
[(unsigned int) R_386_RELATIVE
];
283 case BFD_RELOC_386_GOTOFF
:
284 TRACE ("BFD_RELOC_386_GOTOFF");
285 return &elf_howto_table
[(unsigned int) R_386_GOTOFF
];
287 case BFD_RELOC_386_GOTPC
:
288 TRACE ("BFD_RELOC_386_GOTPC");
289 return &elf_howto_table
[(unsigned int) R_386_GOTPC
];
291 /* These relocs are a GNU extension. */
292 case BFD_RELOC_386_TLS_TPOFF
:
293 TRACE ("BFD_RELOC_386_TLS_TPOFF");
294 return &elf_howto_table
[(unsigned int) R_386_TLS_TPOFF
- R_386_ext_offset
];
296 case BFD_RELOC_386_TLS_IE
:
297 TRACE ("BFD_RELOC_386_TLS_IE");
298 return &elf_howto_table
[(unsigned int) R_386_TLS_IE
- R_386_ext_offset
];
300 case BFD_RELOC_386_TLS_GOTIE
:
301 TRACE ("BFD_RELOC_386_TLS_GOTIE");
302 return &elf_howto_table
[(unsigned int) R_386_TLS_GOTIE
- R_386_ext_offset
];
304 case BFD_RELOC_386_TLS_LE
:
305 TRACE ("BFD_RELOC_386_TLS_LE");
306 return &elf_howto_table
[(unsigned int) R_386_TLS_LE
- R_386_ext_offset
];
308 case BFD_RELOC_386_TLS_GD
:
309 TRACE ("BFD_RELOC_386_TLS_GD");
310 return &elf_howto_table
[(unsigned int) R_386_TLS_GD
- R_386_ext_offset
];
312 case BFD_RELOC_386_TLS_LDM
:
313 TRACE ("BFD_RELOC_386_TLS_LDM");
314 return &elf_howto_table
[(unsigned int) R_386_TLS_LDM
- R_386_ext_offset
];
317 TRACE ("BFD_RELOC_16");
318 return &elf_howto_table
[(unsigned int) R_386_16
- R_386_ext_offset
];
320 case BFD_RELOC_16_PCREL
:
321 TRACE ("BFD_RELOC_16_PCREL");
322 return &elf_howto_table
[(unsigned int) R_386_PC16
- R_386_ext_offset
];
325 TRACE ("BFD_RELOC_8");
326 return &elf_howto_table
[(unsigned int) R_386_8
- R_386_ext_offset
];
328 case BFD_RELOC_8_PCREL
:
329 TRACE ("BFD_RELOC_8_PCREL");
330 return &elf_howto_table
[(unsigned int) R_386_PC8
- R_386_ext_offset
];
332 /* Common with Sun TLS implementation. */
333 case BFD_RELOC_386_TLS_LDO_32
:
334 TRACE ("BFD_RELOC_386_TLS_LDO_32");
335 return &elf_howto_table
[(unsigned int) R_386_TLS_LDO_32
- R_386_tls_offset
];
337 case BFD_RELOC_386_TLS_IE_32
:
338 TRACE ("BFD_RELOC_386_TLS_IE_32");
339 return &elf_howto_table
[(unsigned int) R_386_TLS_IE_32
- R_386_tls_offset
];
341 case BFD_RELOC_386_TLS_LE_32
:
342 TRACE ("BFD_RELOC_386_TLS_LE_32");
343 return &elf_howto_table
[(unsigned int) R_386_TLS_LE_32
- R_386_tls_offset
];
345 case BFD_RELOC_386_TLS_DTPMOD32
:
346 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
347 return &elf_howto_table
[(unsigned int) R_386_TLS_DTPMOD32
- R_386_tls_offset
];
349 case BFD_RELOC_386_TLS_DTPOFF32
:
350 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
351 return &elf_howto_table
[(unsigned int) R_386_TLS_DTPOFF32
- R_386_tls_offset
];
353 case BFD_RELOC_386_TLS_TPOFF32
:
354 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
355 return &elf_howto_table
[(unsigned int) R_386_TLS_TPOFF32
- R_386_tls_offset
];
357 case BFD_RELOC_VTABLE_INHERIT
:
358 TRACE ("BFD_RELOC_VTABLE_INHERIT");
359 return &elf_howto_table
[(unsigned int) R_386_GNU_VTINHERIT
362 case BFD_RELOC_VTABLE_ENTRY
:
363 TRACE ("BFD_RELOC_VTABLE_ENTRY");
364 return &elf_howto_table
[(unsigned int) R_386_GNU_VTENTRY
376 elf_i386_info_to_howto (abfd
, cache_ptr
, dst
)
377 bfd
*abfd ATTRIBUTE_UNUSED
;
378 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
379 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
385 elf_i386_info_to_howto_rel (abfd
, cache_ptr
, dst
)
386 bfd
*abfd ATTRIBUTE_UNUSED
;
388 Elf_Internal_Rela
*dst
;
390 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
393 if ((indx
= r_type
) >= R_386_standard
394 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
395 >= R_386_ext
- R_386_standard
)
396 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
397 >= R_386_tls
- R_386_ext
)
398 && ((indx
= r_type
- R_386_vt_offset
) - R_386_tls
399 >= R_386_vt
- R_386_tls
))
401 (*_bfd_error_handler
) (_("%s: invalid relocation type %d"),
402 bfd_archive_filename (abfd
), (int) r_type
);
403 indx
= (unsigned int) R_386_NONE
;
405 cache_ptr
->howto
= &elf_howto_table
[indx
];
408 /* Return whether a symbol name implies a local label. The UnixWare
409 2.1 cc generates temporary symbols that start with .X, so we
410 recognize them here. FIXME: do other SVR4 compilers also use .X?.
411 If so, we should move the .X recognition into
412 _bfd_elf_is_local_label_name. */
415 elf_i386_is_local_label_name (abfd
, name
)
419 if (name
[0] == '.' && name
[1] == 'X')
422 return _bfd_elf_is_local_label_name (abfd
, name
);
425 /* Support for core dump NOTE sections. */
427 elf_i386_grok_prstatus (abfd
, note
)
429 Elf_Internal_Note
*note
;
434 switch (note
->descsz
)
439 case 144: /* Linux/i386 */
441 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
444 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
453 /* Make a ".reg/999" section. */
454 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
455 raw_size
, note
->descpos
+ offset
);
459 elf_i386_grok_psinfo (abfd
, note
)
461 Elf_Internal_Note
*note
;
463 switch (note
->descsz
)
468 case 124: /* Linux/i386 elf_prpsinfo */
469 elf_tdata (abfd
)->core_program
470 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
471 elf_tdata (abfd
)->core_command
472 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
475 /* Note that for some reason, a spurious space is tacked
476 onto the end of the args in some (at least one anyway)
477 implementations, so strip it off if it exists. */
480 char *command
= elf_tdata (abfd
)->core_command
;
481 int n
= strlen (command
);
483 if (0 < n
&& command
[n
- 1] == ' ')
484 command
[n
- 1] = '\0';
490 /* Functions for the i386 ELF linker.
492 In order to gain some understanding of code in this file without
493 knowing all the intricate details of the linker, note the
496 Functions named elf_i386_* are called by external routines, other
497 functions are only called locally. elf_i386_* functions appear
498 in this file more or less in the order in which they are called
499 from external routines. eg. elf_i386_check_relocs is called
500 early in the link process, elf_i386_finish_dynamic_sections is
501 one of the last functions. */
504 /* The name of the dynamic interpreter. This is put in the .interp
507 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
509 /* The size in bytes of an entry in the procedure linkage table. */
511 #define PLT_ENTRY_SIZE 16
513 /* The first entry in an absolute procedure linkage table looks like
514 this. See the SVR4 ABI i386 supplement to see how this works. */
516 static const bfd_byte elf_i386_plt0_entry
[PLT_ENTRY_SIZE
] =
518 0xff, 0x35, /* pushl contents of address */
519 0, 0, 0, 0, /* replaced with address of .got + 4. */
520 0xff, 0x25, /* jmp indirect */
521 0, 0, 0, 0, /* replaced with address of .got + 8. */
522 0, 0, 0, 0 /* pad out to 16 bytes. */
525 /* Subsequent entries in an absolute procedure linkage table look like
528 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
530 0xff, 0x25, /* jmp indirect */
531 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
532 0x68, /* pushl immediate */
533 0, 0, 0, 0, /* replaced with offset into relocation table. */
534 0xe9, /* jmp relative */
535 0, 0, 0, 0 /* replaced with offset to start of .plt. */
538 /* The first entry in a PIC procedure linkage table look like this. */
540 static const bfd_byte elf_i386_pic_plt0_entry
[PLT_ENTRY_SIZE
] =
542 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
543 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
544 0, 0, 0, 0 /* pad out to 16 bytes. */
547 /* Subsequent entries in a PIC procedure linkage table look like this. */
549 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
551 0xff, 0xa3, /* jmp *offset(%ebx) */
552 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
553 0x68, /* pushl immediate */
554 0, 0, 0, 0, /* replaced with offset into relocation table. */
555 0xe9, /* jmp relative */
556 0, 0, 0, 0 /* replaced with offset to start of .plt. */
559 /* The i386 linker needs to keep track of the number of relocs that it
560 decides to copy as dynamic relocs in check_relocs for each symbol.
561 This is so that it can later discard them if they are found to be
562 unnecessary. We store the information in a field extending the
563 regular ELF linker hash table. */
565 struct elf_i386_dyn_relocs
567 struct elf_i386_dyn_relocs
*next
;
569 /* The input section of the reloc. */
572 /* Total number of relocs copied for the input section. */
575 /* Number of pc-relative relocs copied for the input section. */
576 bfd_size_type pc_count
;
579 /* i386 ELF linker hash entry. */
581 struct elf_i386_link_hash_entry
583 struct elf_link_hash_entry elf
;
585 /* Track dynamic relocs copied for this symbol. */
586 struct elf_i386_dyn_relocs
*dyn_relocs
;
588 #define GOT_UNKNOWN 0
592 #define GOT_TLS_IE_POS 5
593 #define GOT_TLS_IE_NEG 6
594 #define GOT_TLS_IE_BOTH 7
595 unsigned char tls_type
;
598 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
600 struct elf_i386_obj_tdata
602 struct elf_obj_tdata root
;
604 /* tls_type for each local got entry. */
605 char *local_got_tls_type
;
608 #define elf_i386_tdata(abfd) \
609 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
611 #define elf_i386_local_got_tls_type(abfd) \
612 (elf_i386_tdata (abfd)->local_got_tls_type)
615 elf_i386_mkobject (abfd
)
618 bfd_size_type amt
= sizeof (struct elf_i386_obj_tdata
);
619 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
620 if (abfd
->tdata
.any
== NULL
)
626 elf_i386_object_p (abfd
)
629 /* Allocate our special target data. */
630 struct elf_i386_obj_tdata
*new_tdata
;
631 bfd_size_type amt
= sizeof (struct elf_i386_obj_tdata
);
632 new_tdata
= bfd_zalloc (abfd
, amt
);
633 if (new_tdata
== NULL
)
635 new_tdata
->root
= *abfd
->tdata
.elf_obj_data
;
636 abfd
->tdata
.any
= new_tdata
;
640 /* i386 ELF linker hash table. */
642 struct elf_i386_link_hash_table
644 struct elf_link_hash_table elf
;
646 /* Short-cuts to get to dynamic linker sections. */
656 bfd_signed_vma refcount
;
660 /* Small local sym to section mapping cache. */
661 struct sym_sec_cache sym_sec
;
664 /* Get the i386 ELF linker hash table from a link_info structure. */
666 #define elf_i386_hash_table(p) \
667 ((struct elf_i386_link_hash_table *) ((p)->hash))
669 /* Create an entry in an i386 ELF linker hash table. */
671 static struct bfd_hash_entry
*
672 link_hash_newfunc (entry
, table
, string
)
673 struct bfd_hash_entry
*entry
;
674 struct bfd_hash_table
*table
;
677 /* Allocate the structure if it has not already been allocated by a
681 entry
= bfd_hash_allocate (table
,
682 sizeof (struct elf_i386_link_hash_entry
));
687 /* Call the allocation method of the superclass. */
688 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
691 struct elf_i386_link_hash_entry
*eh
;
693 eh
= (struct elf_i386_link_hash_entry
*) entry
;
694 eh
->dyn_relocs
= NULL
;
695 eh
->tls_type
= GOT_UNKNOWN
;
701 /* Create an i386 ELF linker hash table. */
703 static struct bfd_link_hash_table
*
704 elf_i386_link_hash_table_create (abfd
)
707 struct elf_i386_link_hash_table
*ret
;
708 bfd_size_type amt
= sizeof (struct elf_i386_link_hash_table
);
710 ret
= (struct elf_i386_link_hash_table
*) bfd_malloc (amt
);
714 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
727 ret
->tls_ldm_got
.refcount
= 0;
728 ret
->sym_sec
.abfd
= NULL
;
730 return &ret
->elf
.root
;
733 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
734 shortcuts to them in our hash table. */
737 create_got_section (dynobj
, info
)
739 struct bfd_link_info
*info
;
741 struct elf_i386_link_hash_table
*htab
;
743 if (! _bfd_elf_create_got_section (dynobj
, info
))
746 htab
= elf_i386_hash_table (info
);
747 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
748 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
749 if (!htab
->sgot
|| !htab
->sgotplt
)
752 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
753 if (htab
->srelgot
== NULL
754 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
755 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
756 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
758 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
763 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
764 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
768 elf_i386_create_dynamic_sections (dynobj
, info
)
770 struct bfd_link_info
*info
;
772 struct elf_i386_link_hash_table
*htab
;
774 htab
= elf_i386_hash_table (info
);
775 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
778 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
781 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
782 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
783 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
785 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
787 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
788 || (!info
->shared
&& !htab
->srelbss
))
794 /* Copy the extra info we tack onto an elf_link_hash_entry. */
797 elf_i386_copy_indirect_symbol (bed
, dir
, ind
)
798 struct elf_backend_data
*bed
;
799 struct elf_link_hash_entry
*dir
, *ind
;
801 struct elf_i386_link_hash_entry
*edir
, *eind
;
803 edir
= (struct elf_i386_link_hash_entry
*) dir
;
804 eind
= (struct elf_i386_link_hash_entry
*) ind
;
806 if (eind
->dyn_relocs
!= NULL
)
808 if (edir
->dyn_relocs
!= NULL
)
810 struct elf_i386_dyn_relocs
**pp
;
811 struct elf_i386_dyn_relocs
*p
;
813 if (ind
->root
.type
== bfd_link_hash_indirect
)
816 /* Add reloc counts against the weak sym to the strong sym
817 list. Merge any entries against the same section. */
818 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
820 struct elf_i386_dyn_relocs
*q
;
822 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
823 if (q
->sec
== p
->sec
)
825 q
->pc_count
+= p
->pc_count
;
826 q
->count
+= p
->count
;
833 *pp
= edir
->dyn_relocs
;
836 edir
->dyn_relocs
= eind
->dyn_relocs
;
837 eind
->dyn_relocs
= NULL
;
840 if (ind
->root
.type
== bfd_link_hash_indirect
841 && dir
->got
.refcount
<= 0)
843 edir
->tls_type
= eind
->tls_type
;
844 eind
->tls_type
= GOT_UNKNOWN
;
846 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
850 elf_i386_tls_transition (info
, r_type
, is_local
)
851 struct bfd_link_info
*info
;
861 case R_386_TLS_IE_32
:
863 return R_386_TLS_LE_32
;
864 return R_386_TLS_IE_32
;
866 case R_386_TLS_GOTIE
:
868 return R_386_TLS_LE_32
;
871 return R_386_TLS_LE_32
;
877 /* Look through the relocs for a section during the first phase, and
878 calculate needed space in the global offset table, procedure linkage
879 table, and dynamic reloc sections. */
882 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
884 struct bfd_link_info
*info
;
886 const Elf_Internal_Rela
*relocs
;
888 struct elf_i386_link_hash_table
*htab
;
889 Elf_Internal_Shdr
*symtab_hdr
;
890 struct elf_link_hash_entry
**sym_hashes
;
891 const Elf_Internal_Rela
*rel
;
892 const Elf_Internal_Rela
*rel_end
;
895 if (info
->relocateable
)
898 htab
= elf_i386_hash_table (info
);
899 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
900 sym_hashes
= elf_sym_hashes (abfd
);
904 rel_end
= relocs
+ sec
->reloc_count
;
905 for (rel
= relocs
; rel
< rel_end
; rel
++)
908 unsigned long r_symndx
;
909 struct elf_link_hash_entry
*h
;
911 r_symndx
= ELF32_R_SYM (rel
->r_info
);
912 r_type
= ELF32_R_TYPE (rel
->r_info
);
914 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
916 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
917 bfd_archive_filename (abfd
),
922 if (r_symndx
< symtab_hdr
->sh_info
)
925 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
927 r_type
= elf_i386_tls_transition (info
, r_type
, h
== NULL
);
932 htab
->tls_ldm_got
.refcount
+= 1;
936 /* This symbol requires a procedure linkage table entry. We
937 actually build the entry in adjust_dynamic_symbol,
938 because this might be a case of linking PIC code which is
939 never referenced by a dynamic object, in which case we
940 don't need to generate a procedure linkage table entry
943 /* If this is a local symbol, we resolve it directly without
944 creating a procedure linkage table entry. */
948 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
949 h
->plt
.refcount
+= 1;
952 case R_386_TLS_IE_32
:
954 case R_386_TLS_GOTIE
:
956 info
->flags
|= DF_STATIC_TLS
;
961 /* This symbol requires a global offset table entry. */
963 int tls_type
, old_tls_type
;
968 case R_386_GOT32
: tls_type
= GOT_NORMAL
; break;
969 case R_386_TLS_GD
: tls_type
= GOT_TLS_GD
; break;
970 case R_386_TLS_IE_32
:
971 if (ELF32_R_TYPE (rel
->r_info
) == r_type
)
972 tls_type
= GOT_TLS_IE_NEG
;
974 /* If this is a GD->IE transition, we may use either of
975 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
976 tls_type
= GOT_TLS_IE
;
979 case R_386_TLS_GOTIE
:
980 tls_type
= GOT_TLS_IE_POS
; break;
985 h
->got
.refcount
+= 1;
986 old_tls_type
= elf_i386_hash_entry(h
)->tls_type
;
990 bfd_signed_vma
*local_got_refcounts
;
992 /* This is a global offset table entry for a local symbol. */
993 local_got_refcounts
= elf_local_got_refcounts (abfd
);
994 if (local_got_refcounts
== NULL
)
998 size
= symtab_hdr
->sh_info
;
999 size
*= (sizeof (bfd_signed_vma
) + sizeof(char));
1000 local_got_refcounts
= ((bfd_signed_vma
*)
1001 bfd_zalloc (abfd
, size
));
1002 if (local_got_refcounts
== NULL
)
1004 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1005 elf_i386_local_got_tls_type (abfd
)
1006 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1008 local_got_refcounts
[r_symndx
] += 1;
1009 old_tls_type
= elf_i386_local_got_tls_type (abfd
) [r_symndx
];
1012 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1013 tls_type
|= old_tls_type
;
1014 /* If a TLS symbol is accessed using IE at least once,
1015 there is no point to use dynamic model for it. */
1016 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1017 && (old_tls_type
!= GOT_TLS_GD
1018 || (tls_type
& GOT_TLS_IE
) == 0))
1020 if ((old_tls_type
& GOT_TLS_IE
) && tls_type
== GOT_TLS_GD
)
1021 tls_type
= old_tls_type
;
1024 (*_bfd_error_handler
)
1025 (_("%s: `%s' accessed both as normal and thread local symbol"),
1026 bfd_archive_filename (abfd
),
1027 h
? h
->root
.root
.string
: "<local>");
1032 if (old_tls_type
!= tls_type
)
1035 elf_i386_hash_entry (h
)->tls_type
= tls_type
;
1037 elf_i386_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1045 if (htab
->sgot
== NULL
)
1047 if (htab
->elf
.dynobj
== NULL
)
1048 htab
->elf
.dynobj
= abfd
;
1049 if (!create_got_section (htab
->elf
.dynobj
, info
))
1052 if (r_type
!= R_386_TLS_IE
)
1056 case R_386_TLS_LE_32
:
1060 info
->flags
|= DF_STATIC_TLS
;
1065 if (h
!= NULL
&& !info
->shared
)
1067 /* If this reloc is in a read-only section, we might
1068 need a copy reloc. We can't check reliably at this
1069 stage whether the section is read-only, as input
1070 sections have not yet been mapped to output sections.
1071 Tentatively set the flag for now, and correct in
1072 adjust_dynamic_symbol. */
1073 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
1075 /* We may need a .plt entry if the function this reloc
1076 refers to is in a shared lib. */
1077 h
->plt
.refcount
+= 1;
1080 /* If we are creating a shared library, and this is a reloc
1081 against a global symbol, or a non PC relative reloc
1082 against a local symbol, then we need to copy the reloc
1083 into the shared library. However, if we are linking with
1084 -Bsymbolic, we do not need to copy a reloc against a
1085 global symbol which is defined in an object we are
1086 including in the link (i.e., DEF_REGULAR is set). At
1087 this point we have not seen all the input files, so it is
1088 possible that DEF_REGULAR is not set now but will be set
1089 later (it is never cleared). In case of a weak definition,
1090 DEF_REGULAR may be cleared later by a strong definition in
1091 a shared library. We account for that possibility below by
1092 storing information in the relocs_copied field of the hash
1093 table entry. A similar situation occurs when creating
1094 shared libraries and symbol visibility changes render the
1097 If on the other hand, we are creating an executable, we
1098 may need to keep relocations for symbols satisfied by a
1099 dynamic library if we manage to avoid copy relocs for the
1102 && (sec
->flags
& SEC_ALLOC
) != 0
1103 && (r_type
!= R_386_PC32
1105 && (! info
->symbolic
1106 || h
->root
.type
== bfd_link_hash_defweak
1107 || (h
->elf_link_hash_flags
1108 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1110 && (sec
->flags
& SEC_ALLOC
) != 0
1112 && (h
->root
.type
== bfd_link_hash_defweak
1113 || (h
->elf_link_hash_flags
1114 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
1116 struct elf_i386_dyn_relocs
*p
;
1117 struct elf_i386_dyn_relocs
**head
;
1119 /* We must copy these reloc types into the output file.
1120 Create a reloc section in dynobj and make room for
1126 unsigned int strndx
= elf_elfheader (abfd
)->e_shstrndx
;
1127 unsigned int shnam
= elf_section_data (sec
)->rel_hdr
.sh_name
;
1129 name
= bfd_elf_string_from_elf_section (abfd
, strndx
, shnam
);
1133 if (strncmp (name
, ".rel", 4) != 0
1134 || strcmp (bfd_get_section_name (abfd
, sec
),
1137 (*_bfd_error_handler
)
1138 (_("%s: bad relocation section name `%s\'"),
1139 bfd_archive_filename (abfd
), name
);
1142 if (htab
->elf
.dynobj
== NULL
)
1143 htab
->elf
.dynobj
= abfd
;
1145 dynobj
= htab
->elf
.dynobj
;
1146 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1151 sreloc
= bfd_make_section (dynobj
, name
);
1152 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1153 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1154 if ((sec
->flags
& SEC_ALLOC
) != 0)
1155 flags
|= SEC_ALLOC
| SEC_LOAD
;
1157 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
1158 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
1161 elf_section_data (sec
)->sreloc
= sreloc
;
1164 /* If this is a global symbol, we count the number of
1165 relocations we need for this symbol. */
1168 head
= &((struct elf_i386_link_hash_entry
*) h
)->dyn_relocs
;
1172 /* Track dynamic relocs needed for local syms too.
1173 We really need local syms available to do this
1177 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1182 head
= ((struct elf_i386_dyn_relocs
**)
1183 &elf_section_data (s
)->local_dynrel
);
1187 if (p
== NULL
|| p
->sec
!= sec
)
1189 bfd_size_type amt
= sizeof *p
;
1190 p
= ((struct elf_i386_dyn_relocs
*)
1191 bfd_alloc (htab
->elf
.dynobj
, amt
));
1202 if (r_type
== R_386_PC32
)
1207 /* This relocation describes the C++ object vtable hierarchy.
1208 Reconstruct it for later use during GC. */
1209 case R_386_GNU_VTINHERIT
:
1210 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1214 /* This relocation describes which C++ vtable entries are actually
1215 used. Record for later use during GC. */
1216 case R_386_GNU_VTENTRY
:
1217 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
1229 /* Return the section that should be marked against GC for a given
1233 elf_i386_gc_mark_hook (sec
, info
, rel
, h
, sym
)
1235 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1236 Elf_Internal_Rela
*rel
;
1237 struct elf_link_hash_entry
*h
;
1238 Elf_Internal_Sym
*sym
;
1242 switch (ELF32_R_TYPE (rel
->r_info
))
1244 case R_386_GNU_VTINHERIT
:
1245 case R_386_GNU_VTENTRY
:
1249 switch (h
->root
.type
)
1251 case bfd_link_hash_defined
:
1252 case bfd_link_hash_defweak
:
1253 return h
->root
.u
.def
.section
;
1255 case bfd_link_hash_common
:
1256 return h
->root
.u
.c
.p
->section
;
1264 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1269 /* Update the got entry reference counts for the section being removed. */
1272 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
1274 struct bfd_link_info
*info
;
1276 const Elf_Internal_Rela
*relocs
;
1278 Elf_Internal_Shdr
*symtab_hdr
;
1279 struct elf_link_hash_entry
**sym_hashes
;
1280 bfd_signed_vma
*local_got_refcounts
;
1281 const Elf_Internal_Rela
*rel
, *relend
;
1283 elf_section_data (sec
)->local_dynrel
= NULL
;
1285 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1286 sym_hashes
= elf_sym_hashes (abfd
);
1287 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1289 relend
= relocs
+ sec
->reloc_count
;
1290 for (rel
= relocs
; rel
< relend
; rel
++)
1292 unsigned long r_symndx
;
1293 unsigned int r_type
;
1294 struct elf_link_hash_entry
*h
= NULL
;
1296 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1297 if (r_symndx
>= symtab_hdr
->sh_info
)
1299 struct elf_i386_link_hash_entry
*eh
;
1300 struct elf_i386_dyn_relocs
**pp
;
1301 struct elf_i386_dyn_relocs
*p
;
1303 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1304 eh
= (struct elf_i386_link_hash_entry
*) h
;
1306 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1309 /* Everything must go for SEC. */
1315 r_type
= ELF32_R_TYPE (rel
->r_info
);
1316 r_type
= elf_i386_tls_transition (info
, r_type
, h
!= NULL
);
1320 if (elf_i386_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1321 elf_i386_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1325 case R_386_TLS_IE_32
:
1327 case R_386_TLS_GOTIE
:
1331 if (h
->got
.refcount
> 0)
1332 h
->got
.refcount
-= 1;
1334 else if (local_got_refcounts
!= NULL
)
1336 if (local_got_refcounts
[r_symndx
] > 0)
1337 local_got_refcounts
[r_symndx
] -= 1;
1350 if (h
->plt
.refcount
> 0)
1351 h
->plt
.refcount
-= 1;
1363 /* Adjust a symbol defined by a dynamic object and referenced by a
1364 regular object. The current definition is in some section of the
1365 dynamic object, but we're not including those sections. We have to
1366 change the definition to something the rest of the link can
1370 elf_i386_adjust_dynamic_symbol (info
, h
)
1371 struct bfd_link_info
*info
;
1372 struct elf_link_hash_entry
*h
;
1374 struct elf_i386_link_hash_table
*htab
;
1375 struct elf_i386_link_hash_entry
* eh
;
1376 struct elf_i386_dyn_relocs
*p
;
1378 unsigned int power_of_two
;
1380 /* If this is a function, put it in the procedure linkage table. We
1381 will fill in the contents of the procedure linkage table later,
1382 when we know the address of the .got section. */
1383 if (h
->type
== STT_FUNC
1384 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1386 if (h
->plt
.refcount
<= 0
1388 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1389 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0
1390 && h
->root
.type
!= bfd_link_hash_undefweak
1391 && h
->root
.type
!= bfd_link_hash_undefined
))
1393 /* This case can occur if we saw a PLT32 reloc in an input
1394 file, but the symbol was never referred to by a dynamic
1395 object, or if all references were garbage collected. In
1396 such a case, we don't actually need to build a procedure
1397 linkage table, and we can just do a PC32 reloc instead. */
1398 h
->plt
.offset
= (bfd_vma
) -1;
1399 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1405 /* It's possible that we incorrectly decided a .plt reloc was
1406 needed for an R_386_PC32 reloc to a non-function sym in
1407 check_relocs. We can't decide accurately between function and
1408 non-function syms in check-relocs; Objects loaded later in
1409 the link may change h->type. So fix it now. */
1410 h
->plt
.offset
= (bfd_vma
) -1;
1412 /* If this is a weak symbol, and there is a real definition, the
1413 processor independent code will have arranged for us to see the
1414 real definition first, and we can just use the same value. */
1415 if (h
->weakdef
!= NULL
)
1417 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1418 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1419 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1420 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1424 /* This is a reference to a symbol defined by a dynamic object which
1425 is not a function. */
1427 /* If we are creating a shared library, we must presume that the
1428 only references to the symbol are via the global offset table.
1429 For such cases we need not do anything here; the relocations will
1430 be handled correctly by relocate_section. */
1434 /* If there are no references to this symbol that do not use the
1435 GOT, we don't need to generate a copy reloc. */
1436 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1439 /* If -z nocopyreloc was given, we won't generate them either. */
1440 if (info
->nocopyreloc
)
1442 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1446 eh
= (struct elf_i386_link_hash_entry
*) h
;
1447 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1449 s
= p
->sec
->output_section
;
1450 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1454 /* If we didn't find any dynamic relocs in read-only sections, then
1455 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1458 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1462 /* We must allocate the symbol in our .dynbss section, which will
1463 become part of the .bss section of the executable. There will be
1464 an entry for this symbol in the .dynsym section. The dynamic
1465 object will contain position independent code, so all references
1466 from the dynamic object to this symbol will go through the global
1467 offset table. The dynamic linker will use the .dynsym entry to
1468 determine the address it must put in the global offset table, so
1469 both the dynamic object and the regular object will refer to the
1470 same memory location for the variable. */
1472 htab
= elf_i386_hash_table (info
);
1474 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1475 copy the initial value out of the dynamic object and into the
1476 runtime process image. */
1477 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1479 htab
->srelbss
->_raw_size
+= sizeof (Elf32_External_Rel
);
1480 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1483 /* We need to figure out the alignment required for this symbol. I
1484 have no idea how ELF linkers handle this. */
1485 power_of_two
= bfd_log2 (h
->size
);
1486 if (power_of_two
> 3)
1489 /* Apply the required alignment. */
1491 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
, (bfd_size_type
) (1 << power_of_two
));
1492 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1494 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1498 /* Define the symbol as being at this point in the section. */
1499 h
->root
.u
.def
.section
= s
;
1500 h
->root
.u
.def
.value
= s
->_raw_size
;
1502 /* Increment the section size to make room for the symbol. */
1503 s
->_raw_size
+= h
->size
;
1508 /* This is the condition under which elf_i386_finish_dynamic_symbol
1509 will be called from elflink.h. If elflink.h doesn't call our
1510 finish_dynamic_symbol routine, we'll need to do something about
1511 initializing any .plt and .got entries in elf_i386_relocate_section. */
1512 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
1515 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1516 && ((H)->dynindx != -1 \
1517 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1519 /* Allocate space in .plt, .got and associated reloc sections for
1523 allocate_dynrelocs (h
, inf
)
1524 struct elf_link_hash_entry
*h
;
1527 struct bfd_link_info
*info
;
1528 struct elf_i386_link_hash_table
*htab
;
1529 struct elf_i386_link_hash_entry
*eh
;
1530 struct elf_i386_dyn_relocs
*p
;
1532 if (h
->root
.type
== bfd_link_hash_indirect
)
1535 if (h
->root
.type
== bfd_link_hash_warning
)
1536 /* When warning symbols are created, they **replace** the "real"
1537 entry in the hash table, thus we never get to see the real
1538 symbol in a hash traversal. So look at it now. */
1539 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1541 info
= (struct bfd_link_info
*) inf
;
1542 htab
= elf_i386_hash_table (info
);
1544 if (htab
->elf
.dynamic_sections_created
1545 && h
->plt
.refcount
> 0)
1547 /* Make sure this symbol is output as a dynamic symbol.
1548 Undefined weak syms won't yet be marked as dynamic. */
1549 if (h
->dynindx
== -1
1550 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1552 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1557 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
1559 asection
*s
= htab
->splt
;
1561 /* If this is the first .plt entry, make room for the special
1563 if (s
->_raw_size
== 0)
1564 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1566 h
->plt
.offset
= s
->_raw_size
;
1568 /* If this symbol is not defined in a regular file, and we are
1569 not generating a shared library, then set the symbol to this
1570 location in the .plt. This is required to make function
1571 pointers compare as equal between the normal executable and
1572 the shared library. */
1574 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1576 h
->root
.u
.def
.section
= s
;
1577 h
->root
.u
.def
.value
= h
->plt
.offset
;
1580 /* Make room for this entry. */
1581 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1583 /* We also need to make an entry in the .got.plt section, which
1584 will be placed in the .got section by the linker script. */
1585 htab
->sgotplt
->_raw_size
+= 4;
1587 /* We also need to make an entry in the .rel.plt section. */
1588 htab
->srelplt
->_raw_size
+= sizeof (Elf32_External_Rel
);
1592 h
->plt
.offset
= (bfd_vma
) -1;
1593 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1598 h
->plt
.offset
= (bfd_vma
) -1;
1599 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1602 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
1603 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1604 if (h
->got
.refcount
> 0
1607 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
))
1608 h
->got
.offset
= (bfd_vma
) -1;
1609 else if (h
->got
.refcount
> 0)
1613 int tls_type
= elf_i386_hash_entry(h
)->tls_type
;
1615 /* Make sure this symbol is output as a dynamic symbol.
1616 Undefined weak syms won't yet be marked as dynamic. */
1617 if (h
->dynindx
== -1
1618 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1620 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1625 h
->got
.offset
= s
->_raw_size
;
1627 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1628 if (tls_type
== GOT_TLS_GD
|| tls_type
== GOT_TLS_IE_BOTH
)
1630 dyn
= htab
->elf
.dynamic_sections_created
;
1631 /* R_386_TLS_IE_32 needs one dynamic relocation,
1632 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1633 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1634 need two), R_386_TLS_GD needs one if local symbol and two if
1636 if (tls_type
== GOT_TLS_IE_BOTH
)
1637 htab
->srelgot
->_raw_size
+= 2 * sizeof (Elf32_External_Rel
);
1638 else if ((tls_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
1639 || (tls_type
& GOT_TLS_IE
))
1640 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1641 else if (tls_type
== GOT_TLS_GD
)
1642 htab
->srelgot
->_raw_size
+= 2 * sizeof (Elf32_External_Rel
);
1643 else if (info
->shared
1644 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
))
1645 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1648 h
->got
.offset
= (bfd_vma
) -1;
1650 eh
= (struct elf_i386_link_hash_entry
*) h
;
1651 if (eh
->dyn_relocs
== NULL
)
1654 /* In the shared -Bsymbolic case, discard space allocated for
1655 dynamic pc-relative relocs against symbols which turn out to be
1656 defined in regular objects. For the normal shared case, discard
1657 space for pc-relative relocs that have become local due to symbol
1658 visibility changes. */
1662 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1663 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1666 struct elf_i386_dyn_relocs
**pp
;
1668 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1670 p
->count
-= p
->pc_count
;
1681 /* For the non-shared case, discard space for relocs against
1682 symbols which turn out to need copy relocs or are not
1685 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1686 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1687 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1688 || (htab
->elf
.dynamic_sections_created
1689 && (h
->root
.type
== bfd_link_hash_undefweak
1690 || h
->root
.type
== bfd_link_hash_undefined
))))
1692 /* Make sure this symbol is output as a dynamic symbol.
1693 Undefined weak syms won't yet be marked as dynamic. */
1694 if (h
->dynindx
== -1
1695 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1697 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1701 /* If that succeeded, we know we'll be keeping all the
1703 if (h
->dynindx
!= -1)
1707 eh
->dyn_relocs
= NULL
;
1712 /* Finally, allocate space. */
1713 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1715 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1716 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
1722 /* Find any dynamic relocs that apply to read-only sections. */
1725 readonly_dynrelocs (h
, inf
)
1726 struct elf_link_hash_entry
*h
;
1729 struct elf_i386_link_hash_entry
*eh
;
1730 struct elf_i386_dyn_relocs
*p
;
1732 if (h
->root
.type
== bfd_link_hash_warning
)
1733 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1735 eh
= (struct elf_i386_link_hash_entry
*) h
;
1736 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1738 asection
*s
= p
->sec
->output_section
;
1740 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1742 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1744 info
->flags
|= DF_TEXTREL
;
1746 /* Not an error, just cut short the traversal. */
1753 /* Set the sizes of the dynamic sections. */
1756 elf_i386_size_dynamic_sections (output_bfd
, info
)
1757 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1758 struct bfd_link_info
*info
;
1760 struct elf_i386_link_hash_table
*htab
;
1766 htab
= elf_i386_hash_table (info
);
1767 dynobj
= htab
->elf
.dynobj
;
1771 if (htab
->elf
.dynamic_sections_created
)
1773 /* Set the contents of the .interp section to the interpreter. */
1776 s
= bfd_get_section_by_name (dynobj
, ".interp");
1779 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1780 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1784 /* Set up .got offsets for local syms, and space for local dynamic
1786 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1788 bfd_signed_vma
*local_got
;
1789 bfd_signed_vma
*end_local_got
;
1790 char *local_tls_type
;
1791 bfd_size_type locsymcount
;
1792 Elf_Internal_Shdr
*symtab_hdr
;
1795 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1798 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1800 struct elf_i386_dyn_relocs
*p
;
1802 for (p
= *((struct elf_i386_dyn_relocs
**)
1803 &elf_section_data (s
)->local_dynrel
);
1807 if (!bfd_is_abs_section (p
->sec
)
1808 && bfd_is_abs_section (p
->sec
->output_section
))
1810 /* Input section has been discarded, either because
1811 it is a copy of a linkonce section or due to
1812 linker script /DISCARD/, so we'll be discarding
1815 else if (p
->count
!= 0)
1817 srel
= elf_section_data (p
->sec
)->sreloc
;
1818 srel
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
1819 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1820 info
->flags
|= DF_TEXTREL
;
1825 local_got
= elf_local_got_refcounts (ibfd
);
1829 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1830 locsymcount
= symtab_hdr
->sh_info
;
1831 end_local_got
= local_got
+ locsymcount
;
1832 local_tls_type
= elf_i386_local_got_tls_type (ibfd
);
1834 srel
= htab
->srelgot
;
1835 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1839 *local_got
= s
->_raw_size
;
1841 if (*local_tls_type
== GOT_TLS_GD
1842 || *local_tls_type
== GOT_TLS_IE_BOTH
)
1845 || *local_tls_type
== GOT_TLS_GD
1846 || (*local_tls_type
& GOT_TLS_IE
))
1848 if (*local_tls_type
== GOT_TLS_IE_BOTH
)
1849 srel
->_raw_size
+= 2 * sizeof (Elf32_External_Rel
);
1851 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1855 *local_got
= (bfd_vma
) -1;
1859 if (htab
->tls_ldm_got
.refcount
> 0)
1861 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1863 htab
->tls_ldm_got
.offset
= htab
->sgot
->_raw_size
;
1864 htab
->sgot
->_raw_size
+= 8;
1865 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1868 htab
->tls_ldm_got
.offset
= -1;
1870 /* Allocate global sym .plt and .got entries, and space for global
1871 sym dynamic relocs. */
1872 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1874 /* We now have determined the sizes of the various dynamic sections.
1875 Allocate memory for them. */
1877 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1879 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1884 || s
== htab
->sgotplt
)
1886 /* Strip this section if we don't need it; see the
1889 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1891 if (s
->_raw_size
!= 0 && s
!= htab
->srelplt
)
1894 /* We use the reloc_count field as a counter if we need
1895 to copy relocs into the output file. */
1900 /* It's not one of our sections, so don't allocate space. */
1904 if (s
->_raw_size
== 0)
1906 /* If we don't need this section, strip it from the
1907 output file. This is mostly to handle .rel.bss and
1908 .rel.plt. We must create both sections in
1909 create_dynamic_sections, because they must be created
1910 before the linker maps input sections to output
1911 sections. The linker does that before
1912 adjust_dynamic_symbol is called, and it is that
1913 function which decides whether anything needs to go
1914 into these sections. */
1916 _bfd_strip_section_from_output (info
, s
);
1920 /* Allocate memory for the section contents. We use bfd_zalloc
1921 here in case unused entries are not reclaimed before the
1922 section's contents are written out. This should not happen,
1923 but this way if it does, we get a R_386_NONE reloc instead
1925 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1926 if (s
->contents
== NULL
)
1930 if (htab
->elf
.dynamic_sections_created
)
1932 /* Add some entries to the .dynamic section. We fill in the
1933 values later, in elf_i386_finish_dynamic_sections, but we
1934 must add the entries now so that we get the correct size for
1935 the .dynamic section. The DT_DEBUG entry is filled in by the
1936 dynamic linker and used by the debugger. */
1937 #define add_dynamic_entry(TAG, VAL) \
1938 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1942 if (!add_dynamic_entry (DT_DEBUG
, 0))
1946 if (htab
->splt
->_raw_size
!= 0)
1948 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1949 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1950 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
1951 || !add_dynamic_entry (DT_JMPREL
, 0))
1957 if (!add_dynamic_entry (DT_REL
, 0)
1958 || !add_dynamic_entry (DT_RELSZ
, 0)
1959 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
1962 /* If any dynamic relocs apply to a read-only section,
1963 then we need a DT_TEXTREL entry. */
1964 if ((info
->flags
& DF_TEXTREL
) == 0)
1965 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
1968 if ((info
->flags
& DF_TEXTREL
) != 0)
1970 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1975 #undef add_dynamic_entry
1980 /* Set the correct type for an x86 ELF section. We do this by the
1981 section name, which is a hack, but ought to work. */
1984 elf_i386_fake_sections (abfd
, hdr
, sec
)
1985 bfd
*abfd ATTRIBUTE_UNUSED
;
1986 Elf_Internal_Shdr
*hdr
;
1989 register const char *name
;
1991 name
= bfd_get_section_name (abfd
, sec
);
1993 /* This is an ugly, but unfortunately necessary hack that is
1994 needed when producing EFI binaries on x86. It tells
1995 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1996 containing ELF relocation info. We need this hack in order to
1997 be able to generate ELF binaries that can be translated into
1998 EFI applications (which are essentially COFF objects). Those
1999 files contain a COFF ".reloc" section inside an ELFNN object,
2000 which would normally cause BFD to segfault because it would
2001 attempt to interpret this section as containing relocation
2002 entries for section "oc". With this hack enabled, ".reloc"
2003 will be treated as a normal data section, which will avoid the
2004 segfault. However, you won't be able to create an ELFNN binary
2005 with a section named "oc" that needs relocations, but that's
2006 the kind of ugly side-effects you get when detecting section
2007 types based on their names... In practice, this limitation is
2008 unlikely to bite. */
2009 if (strcmp (name
, ".reloc") == 0)
2010 hdr
->sh_type
= SHT_PROGBITS
;
2015 /* Return the base VMA address which should be subtracted from real addresses
2016 when resolving @dtpoff relocation.
2017 This is PT_TLS segment p_vaddr. */
2021 struct bfd_link_info
*info
;
2023 /* If tls_segment is NULL, we should have signalled an error already. */
2024 if (elf_hash_table (info
)->tls_segment
== NULL
)
2026 return elf_hash_table (info
)->tls_segment
->start
;
2029 /* Return the relocation value for @tpoff relocation
2030 if STT_TLS virtual address is ADDRESS. */
2033 tpoff (info
, address
)
2034 struct bfd_link_info
*info
;
2037 struct elf_link_tls_segment
*tls_segment
2038 = elf_hash_table (info
)->tls_segment
;
2040 /* If tls_segment is NULL, we should have signalled an error already. */
2041 if (tls_segment
== NULL
)
2043 return (align_power (tls_segment
->size
, tls_segment
->align
)
2044 + tls_segment
->start
- address
);
2047 /* Relocate an i386 ELF section. */
2050 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
2051 contents
, relocs
, local_syms
, local_sections
)
2053 struct bfd_link_info
*info
;
2055 asection
*input_section
;
2057 Elf_Internal_Rela
*relocs
;
2058 Elf_Internal_Sym
*local_syms
;
2059 asection
**local_sections
;
2061 struct elf_i386_link_hash_table
*htab
;
2062 Elf_Internal_Shdr
*symtab_hdr
;
2063 struct elf_link_hash_entry
**sym_hashes
;
2064 bfd_vma
*local_got_offsets
;
2065 Elf_Internal_Rela
*rel
;
2066 Elf_Internal_Rela
*relend
;
2068 htab
= elf_i386_hash_table (info
);
2069 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2070 sym_hashes
= elf_sym_hashes (input_bfd
);
2071 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2074 relend
= relocs
+ input_section
->reloc_count
;
2075 for (; rel
< relend
; rel
++)
2077 unsigned int r_type
;
2078 reloc_howto_type
*howto
;
2079 unsigned long r_symndx
;
2080 struct elf_link_hash_entry
*h
;
2081 Elf_Internal_Sym
*sym
;
2085 bfd_boolean unresolved_reloc
;
2086 bfd_reloc_status_type r
;
2090 r_type
= ELF32_R_TYPE (rel
->r_info
);
2091 if (r_type
== (int) R_386_GNU_VTINHERIT
2092 || r_type
== (int) R_386_GNU_VTENTRY
)
2095 if ((indx
= (unsigned) r_type
) >= R_386_standard
2096 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
2097 >= R_386_ext
- R_386_standard
)
2098 && ((indx
= r_type
- R_386_tls_offset
) - R_386_ext
2099 >= R_386_tls
- R_386_ext
))
2101 bfd_set_error (bfd_error_bad_value
);
2104 howto
= elf_howto_table
+ indx
;
2106 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2108 if (info
->relocateable
)
2113 /* This is a relocatable link. We don't have to change
2114 anything, unless the reloc is against a section symbol,
2115 in which case we have to adjust according to where the
2116 section symbol winds up in the output section. */
2117 if (r_symndx
>= symtab_hdr
->sh_info
)
2120 sym
= local_syms
+ r_symndx
;
2121 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2124 sec
= local_sections
[r_symndx
];
2125 val
= sec
->output_offset
;
2129 where
= contents
+ rel
->r_offset
;
2130 switch (howto
->size
)
2132 /* FIXME: overflow checks. */
2134 val
+= bfd_get_8 (input_bfd
, where
);
2135 bfd_put_8 (input_bfd
, val
, where
);
2138 val
+= bfd_get_16 (input_bfd
, where
);
2139 bfd_put_16 (input_bfd
, val
, where
);
2142 val
+= bfd_get_32 (input_bfd
, where
);
2143 bfd_put_32 (input_bfd
, val
, where
);
2151 /* This is a final link. */
2155 unresolved_reloc
= FALSE
;
2156 if (r_symndx
< symtab_hdr
->sh_info
)
2158 sym
= local_syms
+ r_symndx
;
2159 sec
= local_sections
[r_symndx
];
2160 relocation
= (sec
->output_section
->vma
2161 + sec
->output_offset
2163 if ((sec
->flags
& SEC_MERGE
)
2164 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2168 bfd_byte
*where
= contents
+ rel
->r_offset
;
2170 switch (howto
->size
)
2173 addend
= bfd_get_8 (input_bfd
, where
);
2174 if (howto
->pc_relative
)
2176 addend
= (addend
^ 0x80) - 0x80;
2181 addend
= bfd_get_16 (input_bfd
, where
);
2182 if (howto
->pc_relative
)
2184 addend
= (addend
^ 0x8000) - 0x8000;
2189 addend
= bfd_get_32 (input_bfd
, where
);
2190 if (howto
->pc_relative
)
2192 addend
= (addend
^ 0x80000000) - 0x80000000;
2201 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2202 addend
-= relocation
;
2203 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2205 switch (howto
->size
)
2208 /* FIXME: overflow checks. */
2209 if (howto
->pc_relative
)
2211 bfd_put_8 (input_bfd
, addend
, where
);
2214 if (howto
->pc_relative
)
2216 bfd_put_16 (input_bfd
, addend
, where
);
2219 if (howto
->pc_relative
)
2221 bfd_put_32 (input_bfd
, addend
, where
);
2228 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2229 while (h
->root
.type
== bfd_link_hash_indirect
2230 || h
->root
.type
== bfd_link_hash_warning
)
2231 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2234 if (h
->root
.type
== bfd_link_hash_defined
2235 || h
->root
.type
== bfd_link_hash_defweak
)
2237 sec
= h
->root
.u
.def
.section
;
2238 if (sec
->output_section
== NULL
)
2239 /* Set a flag that will be cleared later if we find a
2240 relocation value for this symbol. output_section
2241 is typically NULL for symbols satisfied by a shared
2243 unresolved_reloc
= TRUE
;
2245 relocation
= (h
->root
.u
.def
.value
2246 + sec
->output_section
->vma
2247 + sec
->output_offset
);
2249 else if (h
->root
.type
== bfd_link_hash_undefweak
)
2251 else if (info
->shared
2252 && !info
->no_undefined
2253 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2257 if (! ((*info
->callbacks
->undefined_symbol
)
2258 (info
, h
->root
.root
.string
, input_bfd
,
2259 input_section
, rel
->r_offset
,
2260 (!info
->shared
|| info
->no_undefined
2261 || ELF_ST_VISIBILITY (h
->other
)))))
2269 /* Relocation is to the entry for this symbol in the global
2271 if (htab
->sgot
== NULL
)
2278 off
= h
->got
.offset
;
2279 dyn
= htab
->elf
.dynamic_sections_created
;
2280 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2284 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2285 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
2287 /* This is actually a static link, or it is a
2288 -Bsymbolic link and the symbol is defined
2289 locally, or the symbol was forced to be local
2290 because of a version file. We must initialize
2291 this entry in the global offset table. Since the
2292 offset must always be a multiple of 4, we use the
2293 least significant bit to record whether we have
2294 initialized it already.
2296 When doing a dynamic link, we create a .rel.got
2297 relocation entry to initialize the value. This
2298 is done in the finish_dynamic_symbol routine. */
2303 bfd_put_32 (output_bfd
, relocation
,
2304 htab
->sgot
->contents
+ off
);
2309 unresolved_reloc
= FALSE
;
2313 if (local_got_offsets
== NULL
)
2316 off
= local_got_offsets
[r_symndx
];
2318 /* The offset must always be a multiple of 4. We use
2319 the least significant bit to record whether we have
2320 already generated the necessary reloc. */
2325 bfd_put_32 (output_bfd
, relocation
,
2326 htab
->sgot
->contents
+ off
);
2331 Elf_Internal_Rela outrel
;
2338 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2339 + htab
->sgot
->output_offset
2341 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2343 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2344 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2347 local_got_offsets
[r_symndx
] |= 1;
2351 if (off
>= (bfd_vma
) -2)
2354 relocation
= htab
->sgot
->output_offset
+ off
;
2358 /* Relocation is relative to the start of the global offset
2361 /* Note that sgot->output_offset is not involved in this
2362 calculation. We always want the start of .got. If we
2363 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2364 permitted by the ABI, we might have to change this
2366 relocation
-= htab
->sgot
->output_section
->vma
;
2370 /* Use global offset table as symbol value. */
2371 relocation
= htab
->sgot
->output_section
->vma
;
2372 unresolved_reloc
= FALSE
;
2376 /* Relocation is to the entry for this symbol in the
2377 procedure linkage table. */
2379 /* Resolve a PLT32 reloc against a local symbol directly,
2380 without using the procedure linkage table. */
2384 if (h
->plt
.offset
== (bfd_vma
) -1
2385 || htab
->splt
== NULL
)
2387 /* We didn't make a PLT entry for this symbol. This
2388 happens when statically linking PIC code, or when
2389 using -Bsymbolic. */
2393 relocation
= (htab
->splt
->output_section
->vma
2394 + htab
->splt
->output_offset
2396 unresolved_reloc
= FALSE
;
2401 /* r_symndx will be zero only for relocs against symbols
2402 from removed linkonce sections, or sections discarded by
2405 || (input_section
->flags
& SEC_ALLOC
) == 0)
2409 && (r_type
!= R_386_PC32
2412 && (! info
->symbolic
2413 || (h
->elf_link_hash_flags
2414 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2418 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
2419 && (((h
->elf_link_hash_flags
2420 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2421 && (h
->elf_link_hash_flags
2422 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
2423 || h
->root
.type
== bfd_link_hash_undefweak
2424 || h
->root
.type
== bfd_link_hash_undefined
)))
2426 Elf_Internal_Rela outrel
;
2428 bfd_boolean skip
, relocate
;
2431 /* When generating a shared object, these relocations
2432 are copied into the output file to be resolved at run
2439 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2441 if (outrel
.r_offset
== (bfd_vma
) -1)
2443 else if (outrel
.r_offset
== (bfd_vma
) -2)
2444 skip
= TRUE
, relocate
= TRUE
;
2445 outrel
.r_offset
+= (input_section
->output_section
->vma
2446 + input_section
->output_offset
);
2449 memset (&outrel
, 0, sizeof outrel
);
2452 && (r_type
== R_386_PC32
2455 || (h
->elf_link_hash_flags
2456 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
2457 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
2460 /* This symbol is local, or marked to become local. */
2462 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2465 sreloc
= elf_section_data (input_section
)->sreloc
;
2469 loc
= sreloc
->contents
;
2470 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2471 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2473 /* If this reloc is against an external symbol, we do
2474 not want to fiddle with the addend. Otherwise, we
2475 need to include the symbol value so that it becomes
2476 an addend for the dynamic reloc. */
2485 Elf_Internal_Rela outrel
;
2489 outrel
.r_offset
= rel
->r_offset
2490 + input_section
->output_section
->vma
2491 + input_section
->output_offset
;
2492 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2493 sreloc
= elf_section_data (input_section
)->sreloc
;
2496 loc
= sreloc
->contents
;
2497 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2498 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2503 case R_386_TLS_IE_32
:
2504 case R_386_TLS_GOTIE
:
2505 r_type
= elf_i386_tls_transition (info
, r_type
, h
== NULL
);
2506 tls_type
= GOT_UNKNOWN
;
2507 if (h
== NULL
&& local_got_offsets
)
2508 tls_type
= elf_i386_local_got_tls_type (input_bfd
) [r_symndx
];
2511 tls_type
= elf_i386_hash_entry(h
)->tls_type
;
2512 if (!info
->shared
&& h
->dynindx
== -1 && (tls_type
& GOT_TLS_IE
))
2513 r_type
= R_386_TLS_LE_32
;
2515 if (tls_type
== GOT_TLS_IE
)
2516 tls_type
= GOT_TLS_IE_NEG
;
2517 if (r_type
== R_386_TLS_GD
)
2519 if (tls_type
== GOT_TLS_IE_POS
)
2520 r_type
= R_386_TLS_GOTIE
;
2521 else if (tls_type
& GOT_TLS_IE
)
2522 r_type
= R_386_TLS_IE_32
;
2525 if (r_type
== R_386_TLS_LE_32
)
2527 BFD_ASSERT (! unresolved_reloc
);
2528 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GD
)
2530 unsigned int val
, type
;
2533 /* GD->LE transition. */
2534 BFD_ASSERT (rel
->r_offset
>= 2);
2535 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2536 BFD_ASSERT (type
== 0x8d || type
== 0x04);
2537 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->_raw_size
);
2538 BFD_ASSERT (bfd_get_8 (input_bfd
,
2539 contents
+ rel
->r_offset
+ 4)
2541 BFD_ASSERT (rel
+ 1 < relend
);
2542 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
2543 roff
= rel
->r_offset
+ 5;
2544 val
= bfd_get_8 (input_bfd
,
2545 contents
+ rel
->r_offset
- 1);
2548 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2550 movl %gs:0, %eax; subl $foo@tpoff, %eax
2551 (6 byte form of subl). */
2552 BFD_ASSERT (rel
->r_offset
>= 3);
2553 BFD_ASSERT (bfd_get_8 (input_bfd
,
2554 contents
+ rel
->r_offset
- 3)
2556 BFD_ASSERT ((val
& 0xc7) == 0x05 && val
!= (4 << 3));
2557 memcpy (contents
+ rel
->r_offset
- 3,
2558 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2562 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
2563 if (rel
->r_offset
+ 10 <= input_section
->_raw_size
2564 && bfd_get_8 (input_bfd
,
2565 contents
+ rel
->r_offset
+ 9) == 0x90)
2567 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2569 movl %gs:0, %eax; subl $foo@tpoff, %eax
2570 (6 byte form of subl). */
2571 memcpy (contents
+ rel
->r_offset
- 2,
2572 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2573 roff
= rel
->r_offset
+ 6;
2577 /* leal foo(%reg), %eax; call ___tls_get_addr
2579 movl %gs:0, %eax; subl $foo@tpoff, %eax
2580 (5 byte form of subl). */
2581 memcpy (contents
+ rel
->r_offset
- 2,
2582 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2585 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2587 /* Skip R_386_PLT32. */
2591 else if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_IE
)
2593 unsigned int val
, type
;
2595 /* IE->LE transition:
2596 Originally it can be one of:
2604 BFD_ASSERT (rel
->r_offset
>= 1);
2605 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2606 BFD_ASSERT (rel
->r_offset
+ 4 <= input_section
->_raw_size
);
2609 /* movl foo, %eax. */
2610 bfd_put_8 (output_bfd
, 0xb8, contents
+ rel
->r_offset
- 1);
2614 BFD_ASSERT (rel
->r_offset
>= 2);
2615 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2620 BFD_ASSERT ((val
& 0xc7) == 0x05);
2621 bfd_put_8 (output_bfd
, 0xc7,
2622 contents
+ rel
->r_offset
- 2);
2623 bfd_put_8 (output_bfd
,
2624 0xc0 | ((val
>> 3) & 7),
2625 contents
+ rel
->r_offset
- 1);
2629 BFD_ASSERT ((val
& 0xc7) == 0x05);
2630 bfd_put_8 (output_bfd
, 0x81,
2631 contents
+ rel
->r_offset
- 2);
2632 bfd_put_8 (output_bfd
,
2633 0xc0 | ((val
>> 3) & 7),
2634 contents
+ rel
->r_offset
- 1);
2641 bfd_put_32 (output_bfd
, -tpoff (info
, relocation
),
2642 contents
+ rel
->r_offset
);
2647 unsigned int val
, type
;
2649 /* {IE_32,GOTIE}->LE transition:
2650 Originally it can be one of:
2651 subl foo(%reg1), %reg2
2652 movl foo(%reg1), %reg2
2653 addl foo(%reg1), %reg2
2656 movl $foo, %reg2 (6 byte form)
2657 addl $foo, %reg2. */
2658 BFD_ASSERT (rel
->r_offset
>= 2);
2659 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2660 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2661 BFD_ASSERT (rel
->r_offset
+ 4 <= input_section
->_raw_size
);
2662 BFD_ASSERT ((val
& 0xc0) == 0x80 && (val
& 7) != 4);
2666 bfd_put_8 (output_bfd
, 0xc7,
2667 contents
+ rel
->r_offset
- 2);
2668 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
2669 contents
+ rel
->r_offset
- 1);
2671 else if (type
== 0x2b)
2674 bfd_put_8 (output_bfd
, 0x81,
2675 contents
+ rel
->r_offset
- 2);
2676 bfd_put_8 (output_bfd
, 0xe8 | ((val
>> 3) & 7),
2677 contents
+ rel
->r_offset
- 1);
2679 else if (type
== 0x03)
2682 bfd_put_8 (output_bfd
, 0x81,
2683 contents
+ rel
->r_offset
- 2);
2684 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
2685 contents
+ rel
->r_offset
- 1);
2689 if (ELF32_R_TYPE (rel
->r_info
) == R_386_TLS_GOTIE
)
2690 bfd_put_32 (output_bfd
, -tpoff (info
, relocation
),
2691 contents
+ rel
->r_offset
);
2693 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2694 contents
+ rel
->r_offset
);
2699 if (htab
->sgot
== NULL
)
2703 off
= h
->got
.offset
;
2706 if (local_got_offsets
== NULL
)
2709 off
= local_got_offsets
[r_symndx
];
2716 Elf_Internal_Rela outrel
;
2720 if (htab
->srelgot
== NULL
)
2723 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2724 + htab
->sgot
->output_offset
+ off
);
2726 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2727 if (r_type
== R_386_TLS_GD
)
2728 dr_type
= R_386_TLS_DTPMOD32
;
2729 else if (tls_type
== GOT_TLS_IE_POS
)
2730 dr_type
= R_386_TLS_TPOFF
;
2732 dr_type
= R_386_TLS_TPOFF32
;
2733 if (dr_type
== R_386_TLS_TPOFF
&& indx
== 0)
2734 bfd_put_32 (output_bfd
, relocation
- dtpoff_base (info
),
2735 htab
->sgot
->contents
+ off
);
2736 else if (dr_type
== R_386_TLS_TPOFF32
&& indx
== 0)
2737 bfd_put_32 (output_bfd
, dtpoff_base (info
) - relocation
,
2738 htab
->sgot
->contents
+ off
);
2740 bfd_put_32 (output_bfd
, 0,
2741 htab
->sgot
->contents
+ off
);
2742 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
2743 loc
= htab
->srelgot
->contents
;
2744 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2745 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2747 if (r_type
== R_386_TLS_GD
)
2751 BFD_ASSERT (! unresolved_reloc
);
2752 bfd_put_32 (output_bfd
,
2753 relocation
- dtpoff_base (info
),
2754 htab
->sgot
->contents
+ off
+ 4);
2758 bfd_put_32 (output_bfd
, 0,
2759 htab
->sgot
->contents
+ off
+ 4);
2760 outrel
.r_info
= ELF32_R_INFO (indx
,
2761 R_386_TLS_DTPOFF32
);
2762 outrel
.r_offset
+= 4;
2763 htab
->srelgot
->reloc_count
++;
2764 loc
+= sizeof (Elf32_External_Rel
);
2765 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2768 else if (tls_type
== GOT_TLS_IE_BOTH
)
2770 bfd_put_32 (output_bfd
,
2771 indx
== 0 ? relocation
- dtpoff_base (info
) : 0,
2772 htab
->sgot
->contents
+ off
+ 4);
2773 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
2774 outrel
.r_offset
+= 4;
2775 htab
->srelgot
->reloc_count
++;
2776 loc
+= sizeof (Elf32_External_Rel
);
2777 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2783 local_got_offsets
[r_symndx
] |= 1;
2786 if (off
>= (bfd_vma
) -2)
2788 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
2790 relocation
= htab
->sgot
->output_offset
+ off
;
2791 if ((r_type
== R_386_TLS_IE
|| r_type
== R_386_TLS_GOTIE
)
2792 && tls_type
== GOT_TLS_IE_BOTH
)
2794 if (r_type
== R_386_TLS_IE
)
2795 relocation
+= htab
->sgot
->output_section
->vma
;
2796 unresolved_reloc
= FALSE
;
2800 unsigned int val
, type
;
2803 /* GD->IE transition. */
2804 BFD_ASSERT (rel
->r_offset
>= 2);
2805 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2806 BFD_ASSERT (type
== 0x8d || type
== 0x04);
2807 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->_raw_size
);
2808 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
2810 BFD_ASSERT (rel
+ 1 < relend
);
2811 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
2812 roff
= rel
->r_offset
- 3;
2813 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2816 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2818 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2819 BFD_ASSERT (rel
->r_offset
>= 3);
2820 BFD_ASSERT (bfd_get_8 (input_bfd
,
2821 contents
+ rel
->r_offset
- 3)
2823 BFD_ASSERT ((val
& 0xc7) == 0x05 && val
!= (4 << 3));
2828 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2830 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2831 BFD_ASSERT (rel
->r_offset
+ 10 <= input_section
->_raw_size
);
2832 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
2833 BFD_ASSERT (bfd_get_8 (input_bfd
,
2834 contents
+ rel
->r_offset
+ 9)
2836 roff
= rel
->r_offset
- 2;
2838 memcpy (contents
+ roff
,
2839 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2840 contents
[roff
+ 7] = 0x80 | (val
& 7);
2841 /* If foo is used only with foo@gotntpoff(%reg) and
2842 foo@indntpoff, but not with foo@gottpoff(%reg), change
2843 subl $foo@gottpoff(%reg), %eax
2845 addl $foo@gotntpoff(%reg), %eax. */
2846 if (r_type
== R_386_TLS_GOTIE
)
2848 contents
[roff
+ 6] = 0x03;
2849 if (tls_type
== GOT_TLS_IE_BOTH
)
2852 bfd_put_32 (output_bfd
, htab
->sgot
->output_offset
+ off
,
2853 contents
+ roff
+ 8);
2854 /* Skip R_386_PLT32. */
2865 /* LD->LE transition:
2867 leal foo(%reg), %eax; call ___tls_get_addr.
2869 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
2870 BFD_ASSERT (rel
->r_offset
>= 2);
2871 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2)
2873 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2874 BFD_ASSERT ((val
& 0xf8) == 0x80 && (val
& 7) != 4);
2875 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->_raw_size
);
2876 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
2878 BFD_ASSERT (rel
+ 1 < relend
);
2879 BFD_ASSERT (ELF32_R_TYPE (rel
[1].r_info
) == R_386_PLT32
);
2880 memcpy (contents
+ rel
->r_offset
- 2,
2881 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2882 /* Skip R_386_PLT32. */
2887 if (htab
->sgot
== NULL
)
2890 off
= htab
->tls_ldm_got
.offset
;
2895 Elf_Internal_Rela outrel
;
2898 if (htab
->srelgot
== NULL
)
2901 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2902 + htab
->sgot
->output_offset
+ off
);
2904 bfd_put_32 (output_bfd
, 0,
2905 htab
->sgot
->contents
+ off
);
2906 bfd_put_32 (output_bfd
, 0,
2907 htab
->sgot
->contents
+ off
+ 4);
2908 outrel
.r_info
= ELF32_R_INFO (0, R_386_TLS_DTPMOD32
);
2909 loc
= htab
->srelgot
->contents
;
2910 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2911 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2912 htab
->tls_ldm_got
.offset
|= 1;
2914 relocation
= htab
->sgot
->output_offset
+ off
;
2915 unresolved_reloc
= FALSE
;
2918 case R_386_TLS_LDO_32
:
2919 if (info
->shared
|| (input_section
->flags
& SEC_CODE
) == 0)
2920 relocation
-= dtpoff_base (info
);
2922 /* When converting LDO to LE, we must negate. */
2923 relocation
= -tpoff (info
, relocation
);
2926 case R_386_TLS_LE_32
:
2930 Elf_Internal_Rela outrel
;
2935 outrel
.r_offset
= rel
->r_offset
2936 + input_section
->output_section
->vma
2937 + input_section
->output_offset
;
2938 if (h
!= NULL
&& h
->dynindx
!= -1)
2942 if (r_type
== R_386_TLS_LE_32
)
2943 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF32
);
2945 outrel
.r_info
= ELF32_R_INFO (indx
, R_386_TLS_TPOFF
);
2946 sreloc
= elf_section_data (input_section
)->sreloc
;
2949 loc
= sreloc
->contents
;
2950 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
2951 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
2954 else if (r_type
== R_386_TLS_LE_32
)
2955 relocation
= dtpoff_base (info
) - relocation
;
2957 relocation
-= dtpoff_base (info
);
2959 else if (r_type
== R_386_TLS_LE_32
)
2960 relocation
= tpoff (info
, relocation
);
2962 relocation
= -tpoff (info
, relocation
);
2969 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2970 because such sections are not SEC_ALLOC and thus ld.so will
2971 not process them. */
2972 if (unresolved_reloc
2973 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2974 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
2976 (*_bfd_error_handler
)
2977 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2978 bfd_archive_filename (input_bfd
),
2979 bfd_get_section_name (input_bfd
, input_section
),
2980 (long) rel
->r_offset
,
2981 h
->root
.root
.string
);
2985 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2986 contents
, rel
->r_offset
,
2987 relocation
, (bfd_vma
) 0);
2989 if (r
!= bfd_reloc_ok
)
2994 name
= h
->root
.root
.string
;
2997 name
= bfd_elf_string_from_elf_section (input_bfd
,
2998 symtab_hdr
->sh_link
,
3003 name
= bfd_section_name (input_bfd
, sec
);
3006 if (r
== bfd_reloc_overflow
)
3008 if (! ((*info
->callbacks
->reloc_overflow
)
3009 (info
, name
, howto
->name
, (bfd_vma
) 0,
3010 input_bfd
, input_section
, rel
->r_offset
)))
3015 (*_bfd_error_handler
)
3016 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
3017 bfd_archive_filename (input_bfd
),
3018 bfd_get_section_name (input_bfd
, input_section
),
3019 (long) rel
->r_offset
, name
, (int) r
);
3028 /* Finish up dynamic symbol handling. We set the contents of various
3029 dynamic sections here. */
3032 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3034 struct bfd_link_info
*info
;
3035 struct elf_link_hash_entry
*h
;
3036 Elf_Internal_Sym
*sym
;
3038 struct elf_i386_link_hash_table
*htab
;
3040 htab
= elf_i386_hash_table (info
);
3042 if (h
->plt
.offset
!= (bfd_vma
) -1)
3046 Elf_Internal_Rela rel
;
3049 /* This symbol has an entry in the procedure linkage table. Set
3052 if (h
->dynindx
== -1
3053 || htab
->splt
== NULL
3054 || htab
->sgotplt
== NULL
3055 || htab
->srelplt
== NULL
)
3058 /* Get the index in the procedure linkage table which
3059 corresponds to this symbol. This is the index of this symbol
3060 in all the symbols for which we are making plt entries. The
3061 first entry in the procedure linkage table is reserved. */
3062 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3064 /* Get the offset into the .got table of the entry that
3065 corresponds to this function. Each .got entry is 4 bytes.
3066 The first three are reserved. */
3067 got_offset
= (plt_index
+ 3) * 4;
3069 /* Fill in the entry in the procedure linkage table. */
3072 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
3074 bfd_put_32 (output_bfd
,
3075 (htab
->sgotplt
->output_section
->vma
3076 + htab
->sgotplt
->output_offset
3078 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
3082 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
3084 bfd_put_32 (output_bfd
, got_offset
,
3085 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
3088 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
3089 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
3090 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
3091 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
3093 /* Fill in the entry in the global offset table. */
3094 bfd_put_32 (output_bfd
,
3095 (htab
->splt
->output_section
->vma
3096 + htab
->splt
->output_offset
3099 htab
->sgotplt
->contents
+ got_offset
);
3101 /* Fill in the entry in the .rel.plt section. */
3102 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
3103 + htab
->sgotplt
->output_offset
3105 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
3106 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3107 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3109 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3111 /* Mark the symbol as undefined, rather than as defined in
3112 the .plt section. Leave the value alone. This is a clue
3113 for the dynamic linker, to make function pointer
3114 comparisons work between an application and shared
3116 sym
->st_shndx
= SHN_UNDEF
;
3120 if (h
->got
.offset
!= (bfd_vma
) -1
3121 && elf_i386_hash_entry(h
)->tls_type
!= GOT_TLS_GD
3122 && (elf_i386_hash_entry(h
)->tls_type
& GOT_TLS_IE
) == 0)
3124 Elf_Internal_Rela rel
;
3127 /* This symbol has an entry in the global offset table. Set it
3130 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
3133 rel
.r_offset
= (htab
->sgot
->output_section
->vma
3134 + htab
->sgot
->output_offset
3135 + (h
->got
.offset
& ~(bfd_vma
) 1));
3137 /* If this is a static link, or it is a -Bsymbolic link and the
3138 symbol is defined locally or was forced to be local because
3139 of a version file, we just want to emit a RELATIVE reloc.
3140 The entry in the global offset table will already have been
3141 initialized in the relocate_section function. */
3145 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
3146 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3148 BFD_ASSERT((h
->got
.offset
& 1) != 0);
3149 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
3153 BFD_ASSERT((h
->got
.offset
& 1) == 0);
3154 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
3155 htab
->sgot
->contents
+ h
->got
.offset
);
3156 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
3159 loc
= htab
->srelgot
->contents
;
3160 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3161 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3164 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3166 Elf_Internal_Rela rel
;
3169 /* This symbol needs a copy reloc. Set it up. */
3171 if (h
->dynindx
== -1
3172 || (h
->root
.type
!= bfd_link_hash_defined
3173 && h
->root
.type
!= bfd_link_hash_defweak
)
3174 || htab
->srelbss
== NULL
)
3177 rel
.r_offset
= (h
->root
.u
.def
.value
3178 + h
->root
.u
.def
.section
->output_section
->vma
3179 + h
->root
.u
.def
.section
->output_offset
);
3180 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
3181 loc
= htab
->srelbss
->contents
;
3182 loc
+= htab
->srelbss
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3183 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3186 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3187 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3188 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3189 sym
->st_shndx
= SHN_ABS
;
3194 /* Used to decide how to sort relocs in an optimal manner for the
3195 dynamic linker, before writing them out. */
3197 static enum elf_reloc_type_class
3198 elf_i386_reloc_type_class (rela
)
3199 const Elf_Internal_Rela
*rela
;
3201 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3203 case R_386_RELATIVE
:
3204 return reloc_class_relative
;
3205 case R_386_JUMP_SLOT
:
3206 return reloc_class_plt
;
3208 return reloc_class_copy
;
3210 return reloc_class_normal
;
3214 /* Finish up the dynamic sections. */
3217 elf_i386_finish_dynamic_sections (output_bfd
, info
)
3219 struct bfd_link_info
*info
;
3221 struct elf_i386_link_hash_table
*htab
;
3225 htab
= elf_i386_hash_table (info
);
3226 dynobj
= htab
->elf
.dynobj
;
3227 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3229 if (htab
->elf
.dynamic_sections_created
)
3231 Elf32_External_Dyn
*dyncon
, *dynconend
;
3233 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
3236 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3237 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3238 for (; dyncon
< dynconend
; dyncon
++)
3240 Elf_Internal_Dyn dyn
;
3243 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3251 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
3256 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3261 dyn
.d_un
.d_val
= s
->_raw_size
;
3265 /* My reading of the SVR4 ABI indicates that the
3266 procedure linkage table relocs (DT_JMPREL) should be
3267 included in the overall relocs (DT_REL). This is
3268 what Solaris does. However, UnixWare can not handle
3269 that case. Therefore, we override the DT_RELSZ entry
3270 here to make it not include the JMPREL relocs. */
3274 dyn
.d_un
.d_val
-= s
->_raw_size
;
3278 /* We may not be using the standard ELF linker script.
3279 If .rel.plt is the first .rel section, we adjust
3280 DT_REL to not include it. */
3284 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
3286 dyn
.d_un
.d_ptr
+= s
->_raw_size
;
3290 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3293 /* Fill in the first entry in the procedure linkage table. */
3294 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
3297 memcpy (htab
->splt
->contents
,
3298 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
3301 memcpy (htab
->splt
->contents
,
3302 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
3303 bfd_put_32 (output_bfd
,
3304 (htab
->sgotplt
->output_section
->vma
3305 + htab
->sgotplt
->output_offset
3307 htab
->splt
->contents
+ 2);
3308 bfd_put_32 (output_bfd
,
3309 (htab
->sgotplt
->output_section
->vma
3310 + htab
->sgotplt
->output_offset
3312 htab
->splt
->contents
+ 8);
3315 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3316 really seem like the right value. */
3317 elf_section_data (htab
->splt
->output_section
)
3318 ->this_hdr
.sh_entsize
= 4;
3324 /* Fill in the first three entries in the global offset table. */
3325 if (htab
->sgotplt
->_raw_size
> 0)
3327 bfd_put_32 (output_bfd
,
3328 (sdyn
== NULL
? (bfd_vma
) 0
3329 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
3330 htab
->sgotplt
->contents
);
3331 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
3332 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
3335 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
3340 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3341 #define TARGET_LITTLE_NAME "elf32-i386"
3342 #define ELF_ARCH bfd_arch_i386
3343 #define ELF_MACHINE_CODE EM_386
3344 #define ELF_MAXPAGESIZE 0x1000
3346 #define elf_backend_can_gc_sections 1
3347 #define elf_backend_can_refcount 1
3348 #define elf_backend_want_got_plt 1
3349 #define elf_backend_plt_readonly 1
3350 #define elf_backend_want_plt_sym 0
3351 #define elf_backend_got_header_size 12
3352 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3354 #define elf_info_to_howto elf_i386_info_to_howto
3355 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3357 #define bfd_elf32_mkobject elf_i386_mkobject
3358 #define elf_backend_object_p elf_i386_object_p
3360 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3361 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3362 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3364 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3365 #define elf_backend_check_relocs elf_i386_check_relocs
3366 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
3367 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
3368 #define elf_backend_fake_sections elf_i386_fake_sections
3369 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3370 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3371 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3372 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
3373 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
3374 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
3375 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
3376 #define elf_backend_relocate_section elf_i386_relocate_section
3377 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
3379 #include "elf32-target.h"
3381 /* FreeBSD support. */
3383 #undef TARGET_LITTLE_SYM
3384 #define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
3385 #undef TARGET_LITTLE_NAME
3386 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
3388 /* The kernel recognizes executables as valid only if they carry a
3389 "FreeBSD" label in the ELF header. So we put this label on all
3390 executables and (for simplicity) also all other object files. */
3392 static void elf_i386_post_process_headers
3393 PARAMS ((bfd
*, struct bfd_link_info
*));
3396 elf_i386_post_process_headers (abfd
, link_info
)
3398 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
3400 Elf_Internal_Ehdr
*i_ehdrp
;
3402 i_ehdrp
= elf_elfheader (abfd
);
3404 /* Put an ABI label supported by FreeBSD >= 4.1. */
3405 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
3406 #ifdef OLD_FREEBSD_ABI_LABEL
3407 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
3408 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
3412 #undef elf_backend_post_process_headers
3413 #define elf_backend_post_process_headers elf_i386_post_process_headers
3415 #define elf32_bed elf32_i386_fbsd_bed
3417 #include "elf32-target.h"