* elf-eh-frame.c (_bfd_elf_discard_section_eh_frame): Enable
[external/binutils.git] / bfd / elf32-i386.c
1 /* Intel 80386/80486-specific support for 32-bit ELF
2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3    Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
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.
11
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.
16
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.  */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "bfdlink.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26
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 *, Elf32_Internal_Rela *));
31 static void elf_i386_info_to_howto_rel
32   PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
33 static boolean elf_i386_is_local_label_name
34   PARAMS ((bfd *, const char *));
35 static boolean elf_i386_grok_prstatus
36   PARAMS ((bfd *abfd, Elf_Internal_Note *note));
37 static 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
42   PARAMS ((bfd *));
43 static boolean create_got_section
44   PARAMS((bfd *, struct bfd_link_info *));
45 static 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_link_hash_entry *, struct elf_link_hash_entry *));
49 static boolean elf_i386_check_relocs
50   PARAMS ((bfd *, struct bfd_link_info *, asection *,
51            const Elf_Internal_Rela *));
52 static asection *elf_i386_gc_mark_hook
53   PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
54            struct elf_link_hash_entry *, Elf_Internal_Sym *));
55 static boolean elf_i386_gc_sweep_hook
56   PARAMS ((bfd *, struct bfd_link_info *, asection *,
57            const Elf_Internal_Rela *));
58 static boolean elf_i386_adjust_dynamic_symbol
59   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
60 static boolean allocate_dynrelocs
61   PARAMS ((struct elf_link_hash_entry *, PTR));
62 static boolean readonly_dynrelocs
63   PARAMS ((struct elf_link_hash_entry *, PTR));
64 static boolean elf_i386_fake_sections
65   PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *));
66 static boolean elf_i386_size_dynamic_sections
67   PARAMS ((bfd *, struct bfd_link_info *));
68 static boolean elf_i386_relocate_section
69   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
70            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
71 static boolean elf_i386_finish_dynamic_symbol
72   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
73            Elf_Internal_Sym *));
74 static enum elf_reloc_type_class elf_i386_reloc_type_class
75   PARAMS ((const Elf_Internal_Rela *));
76 static boolean elf_i386_finish_dynamic_sections
77   PARAMS ((bfd *, struct bfd_link_info *));
78
79 #define USE_REL 1               /* 386 uses REL relocations instead of RELA */
80
81 #include "elf/i386.h"
82
83 static reloc_howto_type elf_howto_table[]=
84 {
85   HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
86         bfd_elf_generic_reloc, "R_386_NONE",
87         true, 0x00000000, 0x00000000, false),
88   HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
89         bfd_elf_generic_reloc, "R_386_32",
90         true, 0xffffffff, 0xffffffff, false),
91   HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
92         bfd_elf_generic_reloc, "R_386_PC32",
93         true, 0xffffffff, 0xffffffff, true),
94   HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
95         bfd_elf_generic_reloc, "R_386_GOT32",
96         true, 0xffffffff, 0xffffffff, false),
97   HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
98         bfd_elf_generic_reloc, "R_386_PLT32",
99         true, 0xffffffff, 0xffffffff, true),
100   HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
101         bfd_elf_generic_reloc, "R_386_COPY",
102         true, 0xffffffff, 0xffffffff, false),
103   HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
104         bfd_elf_generic_reloc, "R_386_GLOB_DAT",
105         true, 0xffffffff, 0xffffffff, false),
106   HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
107         bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
108         true, 0xffffffff, 0xffffffff, false),
109   HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
110         bfd_elf_generic_reloc, "R_386_RELATIVE",
111         true, 0xffffffff, 0xffffffff, false),
112   HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
113         bfd_elf_generic_reloc, "R_386_GOTOFF",
114         true, 0xffffffff, 0xffffffff, false),
115   HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
116         bfd_elf_generic_reloc, "R_386_GOTPC",
117         true, 0xffffffff, 0xffffffff, true),
118
119   /* We have a gap in the reloc numbers here.
120      R_386_standard counts the number up to this point, and
121      R_386_ext_offset is the value to subtract from a reloc type of
122      R_386_16 thru R_386_PC8 to form an index into this table.  */
123 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
124 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
125
126   /* The remaining relocs are a GNU extension.  */
127   HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
128         bfd_elf_generic_reloc, "R_386_16",
129         true, 0xffff, 0xffff, false),
130   HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
131         bfd_elf_generic_reloc, "R_386_PC16",
132         true, 0xffff, 0xffff, true),
133   HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
134         bfd_elf_generic_reloc, "R_386_8",
135         true, 0xff, 0xff, false),
136   HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
137         bfd_elf_generic_reloc, "R_386_PC8",
138         true, 0xff, 0xff, true),
139
140   /* Another gap.  */
141 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
142 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
143
144 /* GNU extension to record C++ vtable hierarchy.  */
145   HOWTO (R_386_GNU_VTINHERIT,   /* type */
146          0,                     /* rightshift */
147          2,                     /* size (0 = byte, 1 = short, 2 = long) */
148          0,                     /* bitsize */
149          false,                 /* pc_relative */
150          0,                     /* bitpos */
151          complain_overflow_dont, /* complain_on_overflow */
152          NULL,                  /* special_function */
153          "R_386_GNU_VTINHERIT", /* name */
154          false,                 /* partial_inplace */
155          0,                     /* src_mask */
156          0,                     /* dst_mask */
157          false),
158
159 /* GNU extension to record C++ vtable member usage.  */
160   HOWTO (R_386_GNU_VTENTRY,     /* type */
161          0,                     /* rightshift */
162          2,                     /* size (0 = byte, 1 = short, 2 = long) */
163          0,                     /* bitsize */
164          false,                 /* pc_relative */
165          0,                     /* bitpos */
166          complain_overflow_dont, /* complain_on_overflow */
167          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
168          "R_386_GNU_VTENTRY",   /* name */
169          false,                 /* partial_inplace */
170          0,                     /* src_mask */
171          0,                     /* dst_mask */
172          false)
173
174 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
175
176 };
177
178 #ifdef DEBUG_GEN_RELOC
179 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
180 #else
181 #define TRACE(str)
182 #endif
183
184 static reloc_howto_type *
185 elf_i386_reloc_type_lookup (abfd, code)
186      bfd *abfd ATTRIBUTE_UNUSED;
187      bfd_reloc_code_real_type code;
188 {
189   switch (code)
190     {
191     case BFD_RELOC_NONE:
192       TRACE ("BFD_RELOC_NONE");
193       return &elf_howto_table[(unsigned int) R_386_NONE ];
194
195     case BFD_RELOC_32:
196       TRACE ("BFD_RELOC_32");
197       return &elf_howto_table[(unsigned int) R_386_32 ];
198
199     case BFD_RELOC_CTOR:
200       TRACE ("BFD_RELOC_CTOR");
201       return &elf_howto_table[(unsigned int) R_386_32 ];
202
203     case BFD_RELOC_32_PCREL:
204       TRACE ("BFD_RELOC_PC32");
205       return &elf_howto_table[(unsigned int) R_386_PC32 ];
206
207     case BFD_RELOC_386_GOT32:
208       TRACE ("BFD_RELOC_386_GOT32");
209       return &elf_howto_table[(unsigned int) R_386_GOT32 ];
210
211     case BFD_RELOC_386_PLT32:
212       TRACE ("BFD_RELOC_386_PLT32");
213       return &elf_howto_table[(unsigned int) R_386_PLT32 ];
214
215     case BFD_RELOC_386_COPY:
216       TRACE ("BFD_RELOC_386_COPY");
217       return &elf_howto_table[(unsigned int) R_386_COPY ];
218
219     case BFD_RELOC_386_GLOB_DAT:
220       TRACE ("BFD_RELOC_386_GLOB_DAT");
221       return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
222
223     case BFD_RELOC_386_JUMP_SLOT:
224       TRACE ("BFD_RELOC_386_JUMP_SLOT");
225       return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
226
227     case BFD_RELOC_386_RELATIVE:
228       TRACE ("BFD_RELOC_386_RELATIVE");
229       return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
230
231     case BFD_RELOC_386_GOTOFF:
232       TRACE ("BFD_RELOC_386_GOTOFF");
233       return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
234
235     case BFD_RELOC_386_GOTPC:
236       TRACE ("BFD_RELOC_386_GOTPC");
237       return &elf_howto_table[(unsigned int) R_386_GOTPC ];
238
239       /* The remaining relocs are a GNU extension.  */
240     case BFD_RELOC_16:
241       TRACE ("BFD_RELOC_16");
242       return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
243
244     case BFD_RELOC_16_PCREL:
245       TRACE ("BFD_RELOC_16_PCREL");
246       return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
247
248     case BFD_RELOC_8:
249       TRACE ("BFD_RELOC_8");
250       return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
251
252     case BFD_RELOC_8_PCREL:
253       TRACE ("BFD_RELOC_8_PCREL");
254       return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
255
256     case BFD_RELOC_VTABLE_INHERIT:
257       TRACE ("BFD_RELOC_VTABLE_INHERIT");
258       return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
259                              - R_386_vt_offset];
260
261     case BFD_RELOC_VTABLE_ENTRY:
262       TRACE ("BFD_RELOC_VTABLE_ENTRY");
263       return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
264                              - R_386_vt_offset];
265
266     default:
267       break;
268     }
269
270   TRACE ("Unknown");
271   return 0;
272 }
273
274 static void
275 elf_i386_info_to_howto (abfd, cache_ptr, dst)
276      bfd                *abfd ATTRIBUTE_UNUSED;
277      arelent            *cache_ptr ATTRIBUTE_UNUSED;
278      Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;
279 {
280   abort ();
281 }
282
283 static void
284 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
285      bfd *abfd ATTRIBUTE_UNUSED;
286      arelent *cache_ptr;
287      Elf32_Internal_Rel *dst;
288 {
289   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
290   unsigned int indx;
291
292   if ((indx = r_type) >= R_386_standard
293       && ((indx = r_type - R_386_ext_offset) - R_386_standard
294           >= R_386_ext - R_386_standard)
295       && ((indx = r_type - R_386_vt_offset) - R_386_ext
296           >= R_386_vt - R_386_ext))
297     {
298       (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
299                              bfd_archive_filename (abfd), (int) r_type);
300       indx = (unsigned int) R_386_NONE;
301     }
302   cache_ptr->howto = &elf_howto_table[indx];
303 }
304
305 /* Return whether a symbol name implies a local label.  The UnixWare
306    2.1 cc generates temporary symbols that start with .X, so we
307    recognize them here.  FIXME: do other SVR4 compilers also use .X?.
308    If so, we should move the .X recognition into
309    _bfd_elf_is_local_label_name.  */
310
311 static boolean
312 elf_i386_is_local_label_name (abfd, name)
313      bfd *abfd;
314      const char *name;
315 {
316   if (name[0] == '.' && name[1] == 'X')
317     return true;
318
319   return _bfd_elf_is_local_label_name (abfd, name);
320 }
321 \f
322 /* Support for core dump NOTE sections.  */
323 static boolean
324 elf_i386_grok_prstatus (abfd, note)
325      bfd *abfd;
326      Elf_Internal_Note *note;
327 {
328   int offset;
329   size_t raw_size;
330
331   switch (note->descsz)
332     {
333       default:
334         return false;
335
336       case 144:         /* Linux/i386 */
337         /* pr_cursig */
338         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
339
340         /* pr_pid */
341         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
342
343         /* pr_reg */
344         offset = 72;
345         raw_size = 68;
346
347         break;
348     }
349
350   /* Make a ".reg/999" section.  */
351   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
352                                           raw_size, note->descpos + offset);
353 }
354
355 static boolean
356 elf_i386_grok_psinfo (abfd, note)
357      bfd *abfd;
358      Elf_Internal_Note *note;
359 {
360   switch (note->descsz)
361     {
362       default:
363         return false;
364
365       case 124:         /* Linux/i386 elf_prpsinfo */
366         elf_tdata (abfd)->core_program
367          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
368         elf_tdata (abfd)->core_command
369          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
370     }
371
372   /* Note that for some reason, a spurious space is tacked
373      onto the end of the args in some (at least one anyway)
374      implementations, so strip it off if it exists.  */
375
376   {
377     char *command = elf_tdata (abfd)->core_command;
378     int n = strlen (command);
379
380     if (0 < n && command[n - 1] == ' ')
381       command[n - 1] = '\0';
382   }
383
384   return true;
385 }
386 \f
387 /* Functions for the i386 ELF linker.
388
389    In order to gain some understanding of code in this file without
390    knowing all the intricate details of the linker, note the
391    following:
392
393    Functions named elf_i386_* are called by external routines, other
394    functions are only called locally.  elf_i386_* functions appear
395    in this file more or less in the order in which they are called
396    from external routines.  eg. elf_i386_check_relocs is called
397    early in the link process, elf_i386_finish_dynamic_sections is
398    one of the last functions.  */
399
400
401 /* The name of the dynamic interpreter.  This is put in the .interp
402    section.  */
403
404 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
405
406 /* The size in bytes of an entry in the procedure linkage table.  */
407
408 #define PLT_ENTRY_SIZE 16
409
410 /* The first entry in an absolute procedure linkage table looks like
411    this.  See the SVR4 ABI i386 supplement to see how this works.  */
412
413 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
414 {
415   0xff, 0x35,   /* pushl contents of address */
416   0, 0, 0, 0,   /* replaced with address of .got + 4.  */
417   0xff, 0x25,   /* jmp indirect */
418   0, 0, 0, 0,   /* replaced with address of .got + 8.  */
419   0, 0, 0, 0    /* pad out to 16 bytes.  */
420 };
421
422 /* Subsequent entries in an absolute procedure linkage table look like
423    this.  */
424
425 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
426 {
427   0xff, 0x25,   /* jmp indirect */
428   0, 0, 0, 0,   /* replaced with address of this symbol in .got.  */
429   0x68,         /* pushl immediate */
430   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
431   0xe9,         /* jmp relative */
432   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
433 };
434
435 /* The first entry in a PIC procedure linkage table look like this.  */
436
437 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
438 {
439   0xff, 0xb3, 4, 0, 0, 0,       /* pushl 4(%ebx) */
440   0xff, 0xa3, 8, 0, 0, 0,       /* jmp *8(%ebx) */
441   0, 0, 0, 0                    /* pad out to 16 bytes.  */
442 };
443
444 /* Subsequent entries in a PIC procedure linkage table look like this.  */
445
446 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
447 {
448   0xff, 0xa3,   /* jmp *offset(%ebx) */
449   0, 0, 0, 0,   /* replaced with offset of this symbol in .got.  */
450   0x68,         /* pushl immediate */
451   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
452   0xe9,         /* jmp relative */
453   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
454 };
455
456 /* The i386 linker needs to keep track of the number of relocs that it
457    decides to copy as dynamic relocs in check_relocs for each symbol.
458    This is so that it can later discard them if they are found to be
459    unnecessary.  We store the information in a field extending the
460    regular ELF linker hash table.  */
461
462 struct elf_i386_dyn_relocs
463 {
464   struct elf_i386_dyn_relocs *next;
465
466   /* The input section of the reloc.  */
467   asection *sec;
468
469   /* Total number of relocs copied for the input section.  */
470   bfd_size_type count;
471
472   /* Number of pc-relative relocs copied for the input section.  */
473   bfd_size_type pc_count;
474 };
475
476 /* i386 ELF linker hash entry.  */
477
478 struct elf_i386_link_hash_entry
479 {
480   struct elf_link_hash_entry elf;
481
482   /* Track dynamic relocs copied for this symbol.  */
483   struct elf_i386_dyn_relocs *dyn_relocs;
484 };
485
486 /* i386 ELF linker hash table.  */
487
488 struct elf_i386_link_hash_table
489 {
490   struct elf_link_hash_table elf;
491
492   /* Short-cuts to get to dynamic linker sections.  */
493   asection *sgot;
494   asection *sgotplt;
495   asection *srelgot;
496   asection *splt;
497   asection *srelplt;
498   asection *sdynbss;
499   asection *srelbss;
500
501   /* Small local sym to section mapping cache.  */
502   struct sym_sec_cache sym_sec;
503 };
504
505 /* Get the i386 ELF linker hash table from a link_info structure.  */
506
507 #define elf_i386_hash_table(p) \
508   ((struct elf_i386_link_hash_table *) ((p)->hash))
509
510 /* Create an entry in an i386 ELF linker hash table.  */
511
512 static struct bfd_hash_entry *
513 link_hash_newfunc (entry, table, string)
514      struct bfd_hash_entry *entry;
515      struct bfd_hash_table *table;
516      const char *string;
517 {
518   /* Allocate the structure if it has not already been allocated by a
519      subclass.  */
520   if (entry == NULL)
521     {
522       entry = bfd_hash_allocate (table,
523                                  sizeof (struct elf_i386_link_hash_entry));
524       if (entry == NULL)
525         return entry;
526     }
527
528   /* Call the allocation method of the superclass.  */
529   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
530   if (entry != NULL)
531     {
532       struct elf_i386_link_hash_entry *eh;
533
534       eh = (struct elf_i386_link_hash_entry *) entry;
535       eh->dyn_relocs = NULL;
536     }
537
538   return entry;
539 }
540
541 /* Create an i386 ELF linker hash table.  */
542
543 static struct bfd_link_hash_table *
544 elf_i386_link_hash_table_create (abfd)
545      bfd *abfd;
546 {
547   struct elf_i386_link_hash_table *ret;
548   bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
549
550   ret = (struct elf_i386_link_hash_table *) bfd_alloc (abfd, amt);
551   if (ret == NULL)
552     return NULL;
553
554   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
555     {
556       bfd_release (abfd, ret);
557       return NULL;
558     }
559
560   ret->sgot = NULL;
561   ret->sgotplt = NULL;
562   ret->srelgot = NULL;
563   ret->splt = NULL;
564   ret->srelplt = NULL;
565   ret->sdynbss = NULL;
566   ret->srelbss = NULL;
567   ret->sym_sec.abfd = NULL;
568
569   return &ret->elf.root;
570 }
571
572 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
573    shortcuts to them in our hash table.  */
574
575 static boolean
576 create_got_section (dynobj, info)
577      bfd *dynobj;
578      struct bfd_link_info *info;
579 {
580   struct elf_i386_link_hash_table *htab;
581
582   if (! _bfd_elf_create_got_section (dynobj, info))
583     return false;
584
585   htab = elf_i386_hash_table (info);
586   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
587   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
588   if (!htab->sgot || !htab->sgotplt)
589     abort ();
590
591   htab->srelgot = bfd_make_section (dynobj, ".rel.got");
592   if (htab->srelgot == NULL
593       || ! bfd_set_section_flags (dynobj, htab->srelgot,
594                                   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
595                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
596                                    | SEC_READONLY))
597       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
598     return false;
599   return true;
600 }
601
602 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
603    .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
604    hash table.  */
605
606 static boolean
607 elf_i386_create_dynamic_sections (dynobj, info)
608      bfd *dynobj;
609      struct bfd_link_info *info;
610 {
611   struct elf_i386_link_hash_table *htab;
612
613   htab = elf_i386_hash_table (info);
614   if (!htab->sgot && !create_got_section (dynobj, info))
615     return false;
616
617   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
618     return false;
619
620   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
621   htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
622   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
623   if (!info->shared)
624     htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
625
626   if (!htab->splt || !htab->srelplt || !htab->sdynbss
627       || (!info->shared && !htab->srelbss))
628     abort ();
629
630   return true;
631 }
632
633 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
634
635 static void
636 elf_i386_copy_indirect_symbol (dir, ind)
637      struct elf_link_hash_entry *dir, *ind;
638 {
639   struct elf_i386_link_hash_entry *edir, *eind;
640
641   edir = (struct elf_i386_link_hash_entry *) dir;
642   eind = (struct elf_i386_link_hash_entry *) ind;
643
644   if (eind->dyn_relocs != NULL)
645     {
646       if (edir->dyn_relocs != NULL)
647         {
648           struct elf_i386_dyn_relocs **pp;
649           struct elf_i386_dyn_relocs *p;
650
651           if (ind->root.type == bfd_link_hash_indirect)
652             abort ();
653
654           /* Add reloc counts against the weak sym to the strong sym
655              list.  Merge any entries against the same section.  */
656           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
657             {
658               struct elf_i386_dyn_relocs *q;
659
660               for (q = edir->dyn_relocs; q != NULL; q = q->next)
661                 if (q->sec == p->sec)
662                   {
663                     q->pc_count += p->pc_count;
664                     q->count += p->count;
665                     *pp = p->next;
666                     break;
667                   }
668               if (q == NULL)
669                 pp = &p->next;
670             }
671           *pp = edir->dyn_relocs;
672         }
673
674       edir->dyn_relocs = eind->dyn_relocs;
675       eind->dyn_relocs = NULL;
676     }
677
678   _bfd_elf_link_hash_copy_indirect (dir, ind);
679 }
680
681 /* Look through the relocs for a section during the first phase, and
682    calculate needed space in the global offset table, procedure linkage
683    table, and dynamic reloc sections.  */
684
685 static boolean
686 elf_i386_check_relocs (abfd, info, sec, relocs)
687      bfd *abfd;
688      struct bfd_link_info *info;
689      asection *sec;
690      const Elf_Internal_Rela *relocs;
691 {
692   struct elf_i386_link_hash_table *htab;
693   Elf_Internal_Shdr *symtab_hdr;
694   struct elf_link_hash_entry **sym_hashes;
695   const Elf_Internal_Rela *rel;
696   const Elf_Internal_Rela *rel_end;
697   asection *sreloc;
698
699   if (info->relocateable)
700     return true;
701
702   htab = elf_i386_hash_table (info);
703   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
704   sym_hashes = elf_sym_hashes (abfd);
705
706   sreloc = NULL;
707
708   rel_end = relocs + sec->reloc_count;
709   for (rel = relocs; rel < rel_end; rel++)
710     {
711       unsigned long r_symndx;
712       struct elf_link_hash_entry *h;
713
714       r_symndx = ELF32_R_SYM (rel->r_info);
715
716       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
717         {
718           (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
719                                  bfd_archive_filename (abfd),
720                                  r_symndx);
721           return false;
722         }
723
724       if (r_symndx < symtab_hdr->sh_info)
725         h = NULL;
726       else
727         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
728
729       switch (ELF32_R_TYPE (rel->r_info))
730         {
731         case R_386_GOT32:
732           /* This symbol requires a global offset table entry.  */
733           if (h != NULL)
734             {
735               h->got.refcount += 1;
736             }
737           else
738             {
739               bfd_signed_vma *local_got_refcounts;
740
741               /* This is a global offset table entry for a local symbol.  */
742               local_got_refcounts = elf_local_got_refcounts (abfd);
743               if (local_got_refcounts == NULL)
744                 {
745                   bfd_size_type size;
746
747                   size = symtab_hdr->sh_info;
748                   size *= sizeof (bfd_signed_vma);
749                   local_got_refcounts = ((bfd_signed_vma *)
750                                          bfd_zalloc (abfd, size));
751                   if (local_got_refcounts == NULL)
752                     return false;
753                   elf_local_got_refcounts (abfd) = local_got_refcounts;
754                 }
755               local_got_refcounts[r_symndx] += 1;
756             }
757           /* Fall through */
758
759         case R_386_GOTOFF:
760         case R_386_GOTPC:
761           if (htab->sgot == NULL)
762             {
763               if (htab->elf.dynobj == NULL)
764                 htab->elf.dynobj = abfd;
765               if (!create_got_section (htab->elf.dynobj, info))
766                 return false;
767             }
768           break;
769
770         case R_386_PLT32:
771           /* This symbol requires a procedure linkage table entry.  We
772              actually build the entry in adjust_dynamic_symbol,
773              because this might be a case of linking PIC code which is
774              never referenced by a dynamic object, in which case we
775              don't need to generate a procedure linkage table entry
776              after all.  */
777
778           /* If this is a local symbol, we resolve it directly without
779              creating a procedure linkage table entry.  */
780           if (h == NULL)
781             continue;
782
783           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
784           h->plt.refcount += 1;
785           break;
786
787         case R_386_32:
788         case R_386_PC32:
789           if (h != NULL && !info->shared)
790             {
791               /* If this reloc is in a read-only section, we might
792                  need a copy reloc.  We can't check reliably at this
793                  stage whether the section is read-only, as input
794                  sections have not yet been mapped to output sections.
795                  Tentatively set the flag for now, and correct in
796                  adjust_dynamic_symbol.  */
797               h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
798
799               /* We may need a .plt entry if the function this reloc
800                  refers to is in a shared lib.  */
801               h->plt.refcount += 1;
802             }
803
804           /* If we are creating a shared library, and this is a reloc
805              against a global symbol, or a non PC relative reloc
806              against a local symbol, then we need to copy the reloc
807              into the shared library.  However, if we are linking with
808              -Bsymbolic, we do not need to copy a reloc against a
809              global symbol which is defined in an object we are
810              including in the link (i.e., DEF_REGULAR is set).  At
811              this point we have not seen all the input files, so it is
812              possible that DEF_REGULAR is not set now but will be set
813              later (it is never cleared).  In case of a weak definition,
814              DEF_REGULAR may be cleared later by a strong definition in
815              a shared library.  We account for that possibility below by
816              storing information in the relocs_copied field of the hash
817              table entry.  A similar situation occurs when creating
818              shared libraries and symbol visibility changes render the
819              symbol local.
820
821              If on the other hand, we are creating an executable, we
822              may need to keep relocations for symbols satisfied by a
823              dynamic library if we manage to avoid copy relocs for the
824              symbol.  */
825           if ((info->shared
826                && (sec->flags & SEC_ALLOC) != 0
827                && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
828                    || (h != NULL
829                        && (! info->symbolic
830                            || h->root.type == bfd_link_hash_defweak
831                            || (h->elf_link_hash_flags
832                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
833               || (!info->shared
834                   && (sec->flags & SEC_ALLOC) != 0
835                   && h != NULL
836                   && (h->root.type == bfd_link_hash_defweak
837                       || (h->elf_link_hash_flags
838                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
839             {
840               struct elf_i386_dyn_relocs *p;
841               struct elf_i386_dyn_relocs **head;
842
843               /* We must copy these reloc types into the output file.
844                  Create a reloc section in dynobj and make room for
845                  this reloc.  */
846               if (sreloc == NULL)
847                 {
848                   const char *name;
849                   bfd *dynobj;
850
851                   name = (bfd_elf_string_from_elf_section
852                           (abfd,
853                            elf_elfheader (abfd)->e_shstrndx,
854                            elf_section_data (sec)->rel_hdr.sh_name));
855                   if (name == NULL)
856                     return false;
857
858                   if (strncmp (name, ".rel", 4) != 0
859                       || strcmp (bfd_get_section_name (abfd, sec),
860                                  name + 4) != 0)
861                     {
862                       (*_bfd_error_handler)
863                         (_("%s: bad relocation section name `%s\'"),
864                          bfd_archive_filename (abfd), name);
865                     }
866
867                   if (htab->elf.dynobj == NULL)
868                     htab->elf.dynobj = abfd;
869
870                   dynobj = htab->elf.dynobj;
871                   sreloc = bfd_get_section_by_name (dynobj, name);
872                   if (sreloc == NULL)
873                     {
874                       flagword flags;
875
876                       sreloc = bfd_make_section (dynobj, name);
877                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
878                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
879                       if ((sec->flags & SEC_ALLOC) != 0)
880                         flags |= SEC_ALLOC | SEC_LOAD;
881                       if (sreloc == NULL
882                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
883                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
884                         return false;
885                     }
886                   elf_section_data (sec)->sreloc = sreloc;
887                 }
888
889               /* If this is a global symbol, we count the number of
890                  relocations we need for this symbol.  */
891               if (h != NULL)
892                 {
893                   head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
894                 }
895               else
896                 {
897                   /* Track dynamic relocs needed for local syms too.
898                      We really need local syms available to do this
899                      easily.  Oh well.  */
900
901                   asection *s;
902                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
903                                                  sec, r_symndx);
904                   if (s == NULL)
905                     return false;
906
907                   head = ((struct elf_i386_dyn_relocs **)
908                           &elf_section_data (s)->local_dynrel);
909                 }
910
911               p = *head;
912               if (p == NULL || p->sec != sec)
913                 {
914                   bfd_size_type amt = sizeof *p;
915                   p = ((struct elf_i386_dyn_relocs *)
916                        bfd_alloc (htab->elf.dynobj, amt));
917                   if (p == NULL)
918                     return false;
919                   p->next = *head;
920                   *head = p;
921                   p->sec = sec;
922                   p->count = 0;
923                   p->pc_count = 0;
924                 }
925
926               p->count += 1;
927               if (ELF32_R_TYPE (rel->r_info) == R_386_PC32)
928                 p->pc_count += 1;
929             }
930           break;
931
932           /* This relocation describes the C++ object vtable hierarchy.
933              Reconstruct it for later use during GC.  */
934         case R_386_GNU_VTINHERIT:
935           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
936             return false;
937           break;
938
939           /* This relocation describes which C++ vtable entries are actually
940              used.  Record for later use during GC.  */
941         case R_386_GNU_VTENTRY:
942           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
943             return false;
944           break;
945
946         default:
947           break;
948         }
949     }
950
951   return true;
952 }
953
954 /* Return the section that should be marked against GC for a given
955    relocation.  */
956
957 static asection *
958 elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
959      bfd *abfd;
960      struct bfd_link_info *info ATTRIBUTE_UNUSED;
961      Elf_Internal_Rela *rel;
962      struct elf_link_hash_entry *h;
963      Elf_Internal_Sym *sym;
964 {
965   if (h != NULL)
966     {
967       switch (ELF32_R_TYPE (rel->r_info))
968         {
969         case R_386_GNU_VTINHERIT:
970         case R_386_GNU_VTENTRY:
971           break;
972
973         default:
974           switch (h->root.type)
975             {
976             case bfd_link_hash_defined:
977             case bfd_link_hash_defweak:
978               return h->root.u.def.section;
979
980             case bfd_link_hash_common:
981               return h->root.u.c.p->section;
982
983             default:
984               break;
985             }
986         }
987     }
988   else
989     {
990       return bfd_section_from_elf_index (abfd, sym->st_shndx);
991     }
992
993   return NULL;
994 }
995
996 /* Update the got entry reference counts for the section being removed.  */
997
998 static boolean
999 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
1000      bfd *abfd;
1001      struct bfd_link_info *info;
1002      asection *sec;
1003      const Elf_Internal_Rela *relocs;
1004 {
1005   Elf_Internal_Shdr *symtab_hdr;
1006   struct elf_link_hash_entry **sym_hashes;
1007   bfd_signed_vma *local_got_refcounts;
1008   const Elf_Internal_Rela *rel, *relend;
1009   unsigned long r_symndx;
1010   struct elf_link_hash_entry *h;
1011
1012   elf_section_data (sec)->local_dynrel = NULL;
1013
1014   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1015   sym_hashes = elf_sym_hashes (abfd);
1016   local_got_refcounts = elf_local_got_refcounts (abfd);
1017
1018   relend = relocs + sec->reloc_count;
1019   for (rel = relocs; rel < relend; rel++)
1020     switch (ELF32_R_TYPE (rel->r_info))
1021       {
1022       case R_386_GOT32:
1023       case R_386_GOTOFF:
1024       case R_386_GOTPC:
1025         r_symndx = ELF32_R_SYM (rel->r_info);
1026         if (r_symndx >= symtab_hdr->sh_info)
1027           {
1028             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1029             if (h->got.refcount > 0)
1030               h->got.refcount -= 1;
1031           }
1032         else if (local_got_refcounts != NULL)
1033           {
1034             if (local_got_refcounts[r_symndx] > 0)
1035               local_got_refcounts[r_symndx] -= 1;
1036           }
1037         break;
1038
1039       case R_386_32:
1040       case R_386_PC32:
1041         r_symndx = ELF32_R_SYM (rel->r_info);
1042         if (r_symndx >= symtab_hdr->sh_info)
1043           {
1044             struct elf_i386_link_hash_entry *eh;
1045             struct elf_i386_dyn_relocs **pp;
1046             struct elf_i386_dyn_relocs *p;
1047
1048             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1049
1050             if (!info->shared && h->plt.refcount > 0)
1051               h->plt.refcount -= 1;
1052
1053             eh = (struct elf_i386_link_hash_entry *) h;
1054
1055             for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1056               if (p->sec == sec)
1057                 {
1058                   if (ELF32_R_TYPE (rel->r_info) == R_386_PC32)
1059                     p->pc_count -= 1;
1060                   p->count -= 1;
1061                   if (p->count == 0)
1062                     *pp = p->next;
1063                   break;
1064                 }
1065           }
1066         break;
1067
1068       case R_386_PLT32:
1069         r_symndx = ELF32_R_SYM (rel->r_info);
1070         if (r_symndx >= symtab_hdr->sh_info)
1071           {
1072             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1073             if (h->plt.refcount > 0)
1074               h->plt.refcount -= 1;
1075           }
1076         break;
1077
1078       default:
1079         break;
1080       }
1081
1082   return true;
1083 }
1084
1085 /* Adjust a symbol defined by a dynamic object and referenced by a
1086    regular object.  The current definition is in some section of the
1087    dynamic object, but we're not including those sections.  We have to
1088    change the definition to something the rest of the link can
1089    understand.  */
1090
1091 static boolean
1092 elf_i386_adjust_dynamic_symbol (info, h)
1093      struct bfd_link_info *info;
1094      struct elf_link_hash_entry *h;
1095 {
1096   struct elf_i386_link_hash_table *htab;
1097   struct elf_i386_link_hash_entry * eh;
1098   struct elf_i386_dyn_relocs *p;
1099   asection *s;
1100   unsigned int power_of_two;
1101
1102   /* If this is a function, put it in the procedure linkage table.  We
1103      will fill in the contents of the procedure linkage table later,
1104      when we know the address of the .got section.  */
1105   if (h->type == STT_FUNC
1106       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1107     {
1108       if (h->plt.refcount <= 0
1109           || (! info->shared
1110               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1111               && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1112               && h->root.type != bfd_link_hash_undefweak
1113               && h->root.type != bfd_link_hash_undefined))
1114         {
1115           /* This case can occur if we saw a PLT32 reloc in an input
1116              file, but the symbol was never referred to by a dynamic
1117              object, or if all references were garbage collected.  In
1118              such a case, we don't actually need to build a procedure
1119              linkage table, and we can just do a PC32 reloc instead.  */
1120           h->plt.offset = (bfd_vma) -1;
1121           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1122         }
1123
1124       return true;
1125     }
1126   else
1127     /* It's possible that we incorrectly decided a .plt reloc was
1128        needed for an R_386_PC32 reloc to a non-function sym in
1129        check_relocs.  We can't decide accurately between function and
1130        non-function syms in check-relocs;  Objects loaded later in
1131        the link may change h->type.  So fix it now.  */
1132     h->plt.offset = (bfd_vma) -1;
1133
1134   /* If this is a weak symbol, and there is a real definition, the
1135      processor independent code will have arranged for us to see the
1136      real definition first, and we can just use the same value.  */
1137   if (h->weakdef != NULL)
1138     {
1139       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1140                   || h->weakdef->root.type == bfd_link_hash_defweak);
1141       h->root.u.def.section = h->weakdef->root.u.def.section;
1142       h->root.u.def.value = h->weakdef->root.u.def.value;
1143       return true;
1144     }
1145
1146   /* This is a reference to a symbol defined by a dynamic object which
1147      is not a function.  */
1148
1149   /* If we are creating a shared library, we must presume that the
1150      only references to the symbol are via the global offset table.
1151      For such cases we need not do anything here; the relocations will
1152      be handled correctly by relocate_section.  */
1153   if (info->shared)
1154     return true;
1155
1156   /* If there are no references to this symbol that do not use the
1157      GOT, we don't need to generate a copy reloc.  */
1158   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1159     return true;
1160
1161   /* If -z nocopyreloc was given, we won't generate them either.  */
1162   if (info->nocopyreloc)
1163     {
1164       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1165       return true;
1166     }
1167
1168   eh = (struct elf_i386_link_hash_entry *) h;
1169   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1170     {
1171       s = p->sec->output_section;
1172       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1173         break;
1174     }
1175
1176   /* If we didn't find any dynamic relocs in read-only sections, then
1177      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */ 
1178   if (p == NULL)
1179     {
1180       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1181       return true;
1182     }
1183
1184   /* We must allocate the symbol in our .dynbss section, which will
1185      become part of the .bss section of the executable.  There will be
1186      an entry for this symbol in the .dynsym section.  The dynamic
1187      object will contain position independent code, so all references
1188      from the dynamic object to this symbol will go through the global
1189      offset table.  The dynamic linker will use the .dynsym entry to
1190      determine the address it must put in the global offset table, so
1191      both the dynamic object and the regular object will refer to the
1192      same memory location for the variable.  */
1193
1194   htab = elf_i386_hash_table (info);
1195
1196   /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1197      copy the initial value out of the dynamic object and into the
1198      runtime process image.  */
1199   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1200     {
1201       htab->srelbss->_raw_size += sizeof (Elf32_External_Rel);
1202       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1203     }
1204
1205   /* We need to figure out the alignment required for this symbol.  I
1206      have no idea how ELF linkers handle this.  */
1207   power_of_two = bfd_log2 (h->size);
1208   if (power_of_two > 3)
1209     power_of_two = 3;
1210
1211   /* Apply the required alignment.  */
1212   s = htab->sdynbss;
1213   s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1214   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1215     {
1216       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1217         return false;
1218     }
1219
1220   /* Define the symbol as being at this point in the section.  */
1221   h->root.u.def.section = s;
1222   h->root.u.def.value = s->_raw_size;
1223
1224   /* Increment the section size to make room for the symbol.  */
1225   s->_raw_size += h->size;
1226
1227   return true;
1228 }
1229
1230 /* This is the condition under which elf_i386_finish_dynamic_symbol
1231    will be called from elflink.h.  If elflink.h doesn't call our
1232    finish_dynamic_symbol routine, we'll need to do something about
1233    initializing any .plt and .got entries in elf_i386_relocate_section.  */
1234 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1235   ((DYN)                                                                \
1236    && ((INFO)->shared                                                   \
1237        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
1238    && ((H)->dynindx != -1                                               \
1239        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1240
1241 /* Allocate space in .plt, .got and associated reloc sections for
1242    dynamic relocs.  */
1243
1244 static boolean
1245 allocate_dynrelocs (h, inf)
1246      struct elf_link_hash_entry *h;
1247      PTR inf;
1248 {
1249   struct bfd_link_info *info;
1250   struct elf_i386_link_hash_table *htab;
1251   struct elf_i386_link_hash_entry *eh;
1252   struct elf_i386_dyn_relocs *p;
1253
1254   if (h->root.type == bfd_link_hash_indirect
1255       || h->root.type == bfd_link_hash_warning)
1256     return true;
1257
1258   info = (struct bfd_link_info *) inf;
1259   htab = elf_i386_hash_table (info);
1260
1261   if (htab->elf.dynamic_sections_created
1262       && h->plt.refcount > 0)
1263     {
1264       /* Make sure this symbol is output as a dynamic symbol.
1265          Undefined weak syms won't yet be marked as dynamic.  */
1266       if (h->dynindx == -1
1267           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1268         {
1269           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1270             return false;
1271         }
1272
1273       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1274         {
1275           asection *s = htab->splt;
1276
1277           /* If this is the first .plt entry, make room for the special
1278              first entry.  */
1279           if (s->_raw_size == 0)
1280             s->_raw_size += PLT_ENTRY_SIZE;
1281
1282           h->plt.offset = s->_raw_size;
1283
1284           /* If this symbol is not defined in a regular file, and we are
1285              not generating a shared library, then set the symbol to this
1286              location in the .plt.  This is required to make function
1287              pointers compare as equal between the normal executable and
1288              the shared library.  */
1289           if (! info->shared
1290               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1291             {
1292               h->root.u.def.section = s;
1293               h->root.u.def.value = h->plt.offset;
1294             }
1295
1296           /* Make room for this entry.  */
1297           s->_raw_size += PLT_ENTRY_SIZE;
1298
1299           /* We also need to make an entry in the .got.plt section, which
1300              will be placed in the .got section by the linker script.  */
1301           htab->sgotplt->_raw_size += 4;
1302
1303           /* We also need to make an entry in the .rel.plt section.  */
1304           htab->srelplt->_raw_size += sizeof (Elf32_External_Rel);
1305         }
1306       else
1307         {
1308           h->plt.offset = (bfd_vma) -1;
1309           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1310         }
1311     }
1312   else
1313     {
1314       h->plt.offset = (bfd_vma) -1;
1315       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1316     }
1317
1318   if (h->got.refcount > 0)
1319     {
1320       asection *s;
1321       boolean dyn;
1322
1323       /* Make sure this symbol is output as a dynamic symbol.
1324          Undefined weak syms won't yet be marked as dynamic.  */
1325       if (h->dynindx == -1
1326           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1327         {
1328           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1329             return false;
1330         }
1331
1332       s = htab->sgot;
1333       h->got.offset = s->_raw_size;
1334       s->_raw_size += 4;
1335       dyn = htab->elf.dynamic_sections_created;
1336       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1337         htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1338     }
1339   else
1340     h->got.offset = (bfd_vma) -1;
1341
1342   eh = (struct elf_i386_link_hash_entry *) h;
1343   if (eh->dyn_relocs == NULL)
1344     return true;
1345
1346   /* In the shared -Bsymbolic case, discard space allocated for
1347      dynamic pc-relative relocs against symbols which turn out to be
1348      defined in regular objects.  For the normal shared case, discard
1349      space for pc-relative relocs that have become local due to symbol
1350      visibility changes.  */
1351
1352   if (info->shared)
1353     {
1354       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1355           && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1356               || info->symbolic))
1357         {
1358           struct elf_i386_dyn_relocs **pp;
1359
1360           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1361             {
1362               p->count -= p->pc_count;
1363               p->pc_count = 0;
1364               if (p->count == 0)
1365                 *pp = p->next;
1366               else
1367                 pp = &p->next;
1368             }
1369         }
1370     }
1371   else
1372     {
1373       /* For the non-shared case, discard space for relocs against
1374          symbols which turn out to need copy relocs or are not
1375          dynamic.  */
1376
1377       if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1378           && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1379                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1380               || (htab->elf.dynamic_sections_created
1381                   && (h->root.type == bfd_link_hash_undefweak
1382                       || h->root.type == bfd_link_hash_undefined))))
1383         {
1384           /* Make sure this symbol is output as a dynamic symbol.
1385              Undefined weak syms won't yet be marked as dynamic.  */
1386           if (h->dynindx == -1
1387               && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1388             {
1389               if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1390                 return false;
1391             }
1392
1393           /* If that succeeded, we know we'll be keeping all the
1394              relocs.  */
1395           if (h->dynindx != -1)
1396             goto keep;
1397         }
1398
1399       eh->dyn_relocs = NULL;
1400
1401     keep: ;
1402     }
1403
1404   /* Finally, allocate space.  */
1405   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1406     {
1407       asection *sreloc = elf_section_data (p->sec)->sreloc;
1408       sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
1409     }
1410
1411   return true;
1412 }
1413
1414 /* Find any dynamic relocs that apply to read-only sections.  */
1415
1416 static boolean
1417 readonly_dynrelocs (h, inf)
1418      struct elf_link_hash_entry *h;
1419      PTR inf;
1420 {
1421   struct elf_i386_link_hash_entry *eh;
1422   struct elf_i386_dyn_relocs *p;
1423
1424   eh = (struct elf_i386_link_hash_entry *) h;
1425   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1426     {
1427       asection *s = p->sec->output_section;
1428
1429       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1430         {
1431           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1432
1433           info->flags |= DF_TEXTREL;
1434
1435           /* Not an error, just cut short the traversal.  */
1436           return false;
1437         }
1438     }
1439   return true;
1440 }
1441
1442 /* Set the sizes of the dynamic sections.  */
1443
1444 static boolean
1445 elf_i386_size_dynamic_sections (output_bfd, info)
1446      bfd *output_bfd ATTRIBUTE_UNUSED;
1447      struct bfd_link_info *info;
1448 {
1449   struct elf_i386_link_hash_table *htab;
1450   bfd *dynobj;
1451   asection *s;
1452   boolean relocs;
1453   bfd *ibfd;
1454
1455   htab = elf_i386_hash_table (info);
1456   dynobj = htab->elf.dynobj;
1457   if (dynobj == NULL)
1458     abort ();
1459
1460   if (htab->elf.dynamic_sections_created)
1461     {
1462       /* Set the contents of the .interp section to the interpreter.  */
1463       if (! info->shared)
1464         {
1465           s = bfd_get_section_by_name (dynobj, ".interp");
1466           if (s == NULL)
1467             abort ();
1468           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1469           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1470         }
1471     }
1472
1473   /* Set up .got offsets for local syms, and space for local dynamic
1474      relocs.  */
1475   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1476     {
1477       bfd_signed_vma *local_got;
1478       bfd_signed_vma *end_local_got;
1479       bfd_size_type locsymcount;
1480       Elf_Internal_Shdr *symtab_hdr;
1481       asection *srel;
1482
1483       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1484         continue;
1485
1486       for (s = ibfd->sections; s != NULL; s = s->next)
1487         {
1488           struct elf_i386_dyn_relocs *p;
1489
1490           for (p = *((struct elf_i386_dyn_relocs **)
1491                      &elf_section_data (s)->local_dynrel);
1492                p != NULL;
1493                p = p->next)
1494             {
1495               if (!bfd_is_abs_section (p->sec)
1496                   && bfd_is_abs_section (p->sec->output_section))
1497                 {
1498                   /* Input section has been discarded, either because
1499                      it is a copy of a linkonce section or due to
1500                      linker script /DISCARD/, so we'll be discarding
1501                      the relocs too.  */
1502                 }
1503               else if (p->count != 0)
1504                 {
1505                   srel = elf_section_data (p->sec)->sreloc;
1506                   srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
1507                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1508                     info->flags |= DF_TEXTREL;
1509                 }
1510             }
1511         }
1512
1513       local_got = elf_local_got_refcounts (ibfd);
1514       if (!local_got)
1515         continue;
1516
1517       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1518       locsymcount = symtab_hdr->sh_info;
1519       end_local_got = local_got + locsymcount;
1520       s = htab->sgot;
1521       srel = htab->srelgot;
1522       for (; local_got < end_local_got; ++local_got)
1523         {
1524           if (*local_got > 0)
1525             {
1526               *local_got = s->_raw_size;
1527               s->_raw_size += 4;
1528               if (info->shared)
1529                 srel->_raw_size += sizeof (Elf32_External_Rel);
1530             }
1531           else
1532             *local_got = (bfd_vma) -1;
1533         }
1534     }
1535
1536   /* Allocate global sym .plt and .got entries, and space for global
1537      sym dynamic relocs.  */
1538   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1539
1540   /* We now have determined the sizes of the various dynamic sections.
1541      Allocate memory for them.  */
1542   relocs = false;
1543   for (s = dynobj->sections; s != NULL; s = s->next)
1544     {
1545       if ((s->flags & SEC_LINKER_CREATED) == 0)
1546         continue;
1547
1548       if (s == htab->splt
1549           || s == htab->sgot
1550           || s == htab->sgotplt)
1551         {
1552           /* Strip this section if we don't need it; see the
1553              comment below.  */
1554         }
1555       else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1556         {
1557           if (s->_raw_size != 0 && s != htab->srelplt)
1558             relocs = true;
1559
1560           /* We use the reloc_count field as a counter if we need
1561              to copy relocs into the output file.  */
1562           s->reloc_count = 0;
1563         }
1564       else
1565         {
1566           /* It's not one of our sections, so don't allocate space.  */
1567           continue;
1568         }
1569
1570       if (s->_raw_size == 0)
1571         {
1572           /* If we don't need this section, strip it from the
1573              output file.  This is mostly to handle .rel.bss and
1574              .rel.plt.  We must create both sections in
1575              create_dynamic_sections, because they must be created
1576              before the linker maps input sections to output
1577              sections.  The linker does that before
1578              adjust_dynamic_symbol is called, and it is that
1579              function which decides whether anything needs to go
1580              into these sections.  */
1581
1582           _bfd_strip_section_from_output (info, s);
1583           continue;
1584         }
1585
1586       /* Allocate memory for the section contents.  We use bfd_zalloc
1587          here in case unused entries are not reclaimed before the
1588          section's contents are written out.  This should not happen,
1589          but this way if it does, we get a R_386_NONE reloc instead
1590          of garbage.  */
1591       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1592       if (s->contents == NULL)
1593         return false;
1594     }
1595
1596   if (htab->elf.dynamic_sections_created)
1597     {
1598       /* Add some entries to the .dynamic section.  We fill in the
1599          values later, in elf_i386_finish_dynamic_sections, but we
1600          must add the entries now so that we get the correct size for
1601          the .dynamic section.  The DT_DEBUG entry is filled in by the
1602          dynamic linker and used by the debugger.  */
1603 #define add_dynamic_entry(TAG, VAL) \
1604   bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1605
1606       if (! info->shared)
1607         {
1608           if (!add_dynamic_entry (DT_DEBUG, 0))
1609             return false;
1610         }
1611
1612       if (htab->splt->_raw_size != 0)
1613         {
1614           if (!add_dynamic_entry (DT_PLTGOT, 0)
1615               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1616               || !add_dynamic_entry (DT_PLTREL, DT_REL)
1617               || !add_dynamic_entry (DT_JMPREL, 0))
1618             return false;
1619         }
1620
1621       if (relocs)
1622         {
1623           if (!add_dynamic_entry (DT_REL, 0)
1624               || !add_dynamic_entry (DT_RELSZ, 0)
1625               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
1626             return false;
1627
1628           /* If any dynamic relocs apply to a read-only section,
1629              then we need a DT_TEXTREL entry.  */
1630           if ((info->flags & DF_TEXTREL) == 0)
1631             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1632                                     (PTR) info);
1633
1634           if ((info->flags & DF_TEXTREL) != 0)
1635             {
1636               if (!add_dynamic_entry (DT_TEXTREL, 0))
1637                 return false;
1638             }
1639         }
1640     }
1641 #undef add_dynamic_entry
1642
1643   return true;
1644 }
1645
1646 /* Set the correct type for an x86 ELF section.  We do this by the
1647    section name, which is a hack, but ought to work.  */
1648
1649 static boolean
1650 elf_i386_fake_sections (abfd, hdr, sec)
1651      bfd *abfd ATTRIBUTE_UNUSED;
1652      Elf32_Internal_Shdr *hdr;
1653      asection *sec;
1654 {
1655   register const char *name;
1656
1657   name = bfd_get_section_name (abfd, sec);
1658
1659   /* This is an ugly, but unfortunately necessary hack that is
1660      needed when producing EFI binaries on x86. It tells
1661      elf.c:elf_fake_sections() not to consider ".reloc" as a section
1662      containing ELF relocation info.  We need this hack in order to
1663      be able to generate ELF binaries that can be translated into
1664      EFI applications (which are essentially COFF objects).  Those
1665      files contain a COFF ".reloc" section inside an ELFNN object,
1666      which would normally cause BFD to segfault because it would
1667      attempt to interpret this section as containing relocation
1668      entries for section "oc".  With this hack enabled, ".reloc"
1669      will be treated as a normal data section, which will avoid the
1670      segfault.  However, you won't be able to create an ELFNN binary
1671      with a section named "oc" that needs relocations, but that's
1672      the kind of ugly side-effects you get when detecting section
1673      types based on their names...  In practice, this limitation is
1674      unlikely to bite.  */
1675   if (strcmp (name, ".reloc") == 0)
1676     hdr->sh_type = SHT_PROGBITS;
1677
1678   return true;
1679 }
1680
1681 /* Relocate an i386 ELF section.  */
1682
1683 static boolean
1684 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1685                            contents, relocs, local_syms, local_sections)
1686      bfd *output_bfd;
1687      struct bfd_link_info *info;
1688      bfd *input_bfd;
1689      asection *input_section;
1690      bfd_byte *contents;
1691      Elf_Internal_Rela *relocs;
1692      Elf_Internal_Sym *local_syms;
1693      asection **local_sections;
1694 {
1695   struct elf_i386_link_hash_table *htab;
1696   Elf_Internal_Shdr *symtab_hdr;
1697   struct elf_link_hash_entry **sym_hashes;
1698   bfd_vma *local_got_offsets;
1699   Elf_Internal_Rela *rel;
1700   Elf_Internal_Rela *relend;
1701
1702   htab = elf_i386_hash_table (info);
1703   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1704   sym_hashes = elf_sym_hashes (input_bfd);
1705   local_got_offsets = elf_local_got_offsets (input_bfd);
1706
1707   rel = relocs;
1708   relend = relocs + input_section->reloc_count;
1709   for (; rel < relend; rel++)
1710     {
1711       int r_type;
1712       reloc_howto_type *howto;
1713       unsigned long r_symndx;
1714       struct elf_link_hash_entry *h;
1715       Elf_Internal_Sym *sym;
1716       asection *sec;
1717       bfd_vma off;
1718       bfd_vma relocation;
1719       boolean unresolved_reloc;
1720       bfd_reloc_status_type r;
1721       unsigned int indx;
1722
1723       r_type = ELF32_R_TYPE (rel->r_info);
1724       if (r_type == (int) R_386_GNU_VTINHERIT
1725           || r_type == (int) R_386_GNU_VTENTRY)
1726         continue;
1727
1728       if ((indx = (unsigned) r_type) >= R_386_standard
1729           && ((indx = (unsigned) r_type - R_386_ext_offset) - R_386_standard
1730               >= R_386_ext - R_386_standard))
1731         {
1732           bfd_set_error (bfd_error_bad_value);
1733           return false;
1734         }
1735       howto = elf_howto_table + indx;
1736
1737       r_symndx = ELF32_R_SYM (rel->r_info);
1738
1739       if (info->relocateable)
1740         {
1741           /* This is a relocatable link.  We don't have to change
1742              anything, unless the reloc is against a section symbol,
1743              in which case we have to adjust according to where the
1744              section symbol winds up in the output section.  */
1745           if (r_symndx < symtab_hdr->sh_info)
1746             {
1747               sym = local_syms + r_symndx;
1748               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1749                 {
1750                   bfd_vma val;
1751
1752                   sec = local_sections[r_symndx];
1753                   val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1754                   val += sec->output_offset + sym->st_value;
1755                   bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1756                 }
1757             }
1758           continue;
1759         }
1760
1761       /* This is a final link.  */
1762       h = NULL;
1763       sym = NULL;
1764       sec = NULL;
1765       unresolved_reloc = false;
1766       if (r_symndx < symtab_hdr->sh_info)
1767         {
1768           sym = local_syms + r_symndx;
1769           sec = local_sections[r_symndx];
1770           relocation = (sec->output_section->vma
1771                         + sec->output_offset
1772                         + sym->st_value);
1773           if ((sec->flags & SEC_MERGE)
1774               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1775             {
1776               asection *msec;
1777               bfd_vma addend;
1778
1779               if (howto->src_mask != 0xffffffff)
1780                 {
1781                   (*_bfd_error_handler)
1782                     (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
1783                      bfd_archive_filename (input_bfd),
1784                      bfd_get_section_name (input_bfd, input_section),
1785                      (long) rel->r_offset, howto->name);
1786                   return false;
1787                 }
1788
1789               addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
1790               msec = sec;
1791               addend =
1792                 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
1793                 - relocation;
1794               addend += msec->output_section->vma + msec->output_offset;
1795               bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
1796             }
1797         }
1798       else
1799         {
1800           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1801           while (h->root.type == bfd_link_hash_indirect
1802                  || h->root.type == bfd_link_hash_warning)
1803             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1804
1805           relocation = 0;
1806           if (h->root.type == bfd_link_hash_defined
1807               || h->root.type == bfd_link_hash_defweak)
1808             {
1809               sec = h->root.u.def.section;
1810               if (sec->output_section == NULL)
1811                 /* Set a flag that will be cleared later if we find a
1812                    relocation value for this symbol.  output_section
1813                    is typically NULL for symbols satisfied by a shared
1814                    library.  */
1815                 unresolved_reloc = true;
1816               else
1817                 relocation = (h->root.u.def.value
1818                               + sec->output_section->vma
1819                               + sec->output_offset);
1820             }
1821           else if (h->root.type == bfd_link_hash_undefweak)
1822             ;
1823           else if (info->shared
1824                    && (!info->symbolic || info->allow_shlib_undefined)
1825                    && !info->no_undefined
1826                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1827             ;
1828           else
1829             {
1830               if (! ((*info->callbacks->undefined_symbol)
1831                      (info, h->root.root.string, input_bfd,
1832                       input_section, rel->r_offset,
1833                       (!info->shared || info->no_undefined
1834                        || ELF_ST_VISIBILITY (h->other)))))
1835                 return false;
1836             }
1837         }
1838
1839       switch (r_type)
1840         {
1841         case R_386_GOT32:
1842           /* Relocation is to the entry for this symbol in the global
1843              offset table.  */
1844           if (htab->sgot == NULL)
1845             abort ();
1846
1847           if (h != NULL)
1848             {
1849               boolean dyn;
1850
1851               off = h->got.offset;
1852               dyn = htab->elf.dynamic_sections_created;
1853               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
1854                   || (info->shared
1855                       && (info->symbolic
1856                           || h->dynindx == -1
1857                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1858                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1859                 {
1860                   /* This is actually a static link, or it is a
1861                      -Bsymbolic link and the symbol is defined
1862                      locally, or the symbol was forced to be local
1863                      because of a version file.  We must initialize
1864                      this entry in the global offset table.  Since the
1865                      offset must always be a multiple of 4, we use the
1866                      least significant bit to record whether we have
1867                      initialized it already.
1868
1869                      When doing a dynamic link, we create a .rel.got
1870                      relocation entry to initialize the value.  This
1871                      is done in the finish_dynamic_symbol routine.  */
1872                   if ((off & 1) != 0)
1873                     off &= ~1;
1874                   else
1875                     {
1876                       bfd_put_32 (output_bfd, relocation,
1877                                   htab->sgot->contents + off);
1878                       h->got.offset |= 1;
1879                     }
1880                 }
1881               else
1882                 unresolved_reloc = false;
1883             }
1884           else
1885             {
1886               if (local_got_offsets == NULL)
1887                 abort ();
1888
1889               off = local_got_offsets[r_symndx];
1890
1891               /* The offset must always be a multiple of 4.  We use
1892                  the least significant bit to record whether we have
1893                  already generated the necessary reloc.  */
1894               if ((off & 1) != 0)
1895                 off &= ~1;
1896               else
1897                 {
1898                   bfd_put_32 (output_bfd, relocation,
1899                               htab->sgot->contents + off);
1900
1901                   if (info->shared)
1902                     {
1903                       asection *srelgot;
1904                       Elf_Internal_Rel outrel;
1905                       Elf32_External_Rel *loc;
1906
1907                       srelgot = htab->srelgot;
1908                       if (srelgot == NULL)
1909                         abort ();
1910
1911                       outrel.r_offset = (htab->sgot->output_section->vma
1912                                          + htab->sgot->output_offset
1913                                          + off);
1914                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1915                       loc = (Elf32_External_Rel *) srelgot->contents;
1916                       loc += srelgot->reloc_count++;
1917                       bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
1918                     }
1919
1920                   local_got_offsets[r_symndx] |= 1;
1921                 }
1922             }
1923
1924           if (off >= (bfd_vma) -2)
1925             abort ();
1926
1927           relocation = htab->sgot->output_offset + off;
1928           break;
1929
1930         case R_386_GOTOFF:
1931           /* Relocation is relative to the start of the global offset
1932              table.  */
1933
1934           /* Note that sgot->output_offset is not involved in this
1935              calculation.  We always want the start of .got.  If we
1936              defined _GLOBAL_OFFSET_TABLE in a different way, as is
1937              permitted by the ABI, we might have to change this
1938              calculation.  */
1939           relocation -= htab->sgot->output_section->vma;
1940           break;
1941
1942         case R_386_GOTPC:
1943           /* Use global offset table as symbol value.  */
1944           relocation = htab->sgot->output_section->vma;
1945           unresolved_reloc = false;
1946           break;
1947
1948         case R_386_PLT32:
1949           /* Relocation is to the entry for this symbol in the
1950              procedure linkage table.  */
1951
1952           /* Resolve a PLT32 reloc against a local symbol directly,
1953              without using the procedure linkage table.  */
1954           if (h == NULL)
1955             break;
1956
1957           if (h->plt.offset == (bfd_vma) -1
1958               || htab->splt == NULL)
1959             {
1960               /* We didn't make a PLT entry for this symbol.  This
1961                  happens when statically linking PIC code, or when
1962                  using -Bsymbolic.  */
1963               break;
1964             }
1965
1966           relocation = (htab->splt->output_section->vma
1967                         + htab->splt->output_offset
1968                         + h->plt.offset);
1969           unresolved_reloc = false;
1970           break;
1971
1972         case R_386_32:
1973         case R_386_PC32:
1974           /* r_symndx will be zero only for relocs against symbols
1975              from removed linkonce sections, or sections discarded by
1976              a linker script.  */
1977           if (r_symndx == 0
1978               || (input_section->flags & SEC_ALLOC) == 0)
1979             break;
1980
1981           if ((info->shared
1982                && (r_type != R_386_PC32
1983                    || (h != NULL
1984                        && h->dynindx != -1
1985                        && (! info->symbolic
1986                            || (h->elf_link_hash_flags
1987                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1988               || (!info->shared
1989                   && h != NULL
1990                   && h->dynindx != -1
1991                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1992                   && (((h->elf_link_hash_flags
1993                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1994                        && (h->elf_link_hash_flags
1995                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
1996                       || h->root.type == bfd_link_hash_undefweak
1997                       || h->root.type == bfd_link_hash_undefined)))
1998             {
1999               Elf_Internal_Rel outrel;
2000               boolean skip, relocate;
2001               asection *sreloc;
2002               Elf32_External_Rel *loc;
2003
2004               /* When generating a shared object, these relocations
2005                  are copied into the output file to be resolved at run
2006                  time.  */
2007
2008               skip = false;
2009               relocate = false;
2010
2011               outrel.r_offset =
2012                 _bfd_elf_section_offset (output_bfd, info, input_section,
2013                                          rel->r_offset);
2014               if (outrel.r_offset == (bfd_vma) -1)
2015                 skip = true;
2016               else if (outrel.r_offset == (bfd_vma) -2)
2017                 skip = true, relocate = true;
2018               outrel.r_offset += (input_section->output_section->vma
2019                                   + input_section->output_offset);
2020
2021               if (skip)
2022                 memset (&outrel, 0, sizeof outrel);
2023               else if (h != NULL
2024                        && h->dynindx != -1
2025                        && (r_type == R_386_PC32
2026                            || !info->shared
2027                            || !info->symbolic
2028                            || (h->elf_link_hash_flags
2029                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
2030                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2031               else
2032                 {
2033                   /* This symbol is local, or marked to become local.  */
2034                   relocate = true;
2035                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2036                 }
2037
2038               sreloc = elf_section_data (input_section)->sreloc;
2039               if (sreloc == NULL)
2040                 abort ();
2041
2042               loc = (Elf32_External_Rel *) sreloc->contents;
2043               loc += sreloc->reloc_count++;
2044               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2045
2046               /* If this reloc is against an external symbol, we do
2047                  not want to fiddle with the addend.  Otherwise, we
2048                  need to include the symbol value so that it becomes
2049                  an addend for the dynamic reloc.  */
2050               if (! relocate)
2051                 continue;
2052             }
2053           break;
2054
2055         default:
2056           break;
2057         }
2058
2059       /* FIXME: Why do we allow debugging sections to escape this error?
2060          More importantly, why do we not emit dynamic relocs for
2061          R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
2062          If we had emitted the dynamic reloc, we could remove the
2063          fudge here.  */
2064       if (unresolved_reloc
2065           && !(info->shared
2066                && (input_section->flags & SEC_DEBUGGING) != 0
2067                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2068         (*_bfd_error_handler)
2069           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2070            bfd_archive_filename (input_bfd),
2071            bfd_get_section_name (input_bfd, input_section),
2072            (long) rel->r_offset,
2073            h->root.root.string);
2074
2075       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2076                                     contents, rel->r_offset,
2077                                     relocation, (bfd_vma) 0);
2078
2079       if (r != bfd_reloc_ok)
2080         {
2081           const char *name;
2082
2083           if (h != NULL)
2084             name = h->root.root.string;
2085           else
2086             {
2087               name = bfd_elf_string_from_elf_section (input_bfd,
2088                                                       symtab_hdr->sh_link,
2089                                                       sym->st_name);
2090               if (name == NULL)
2091                 return false;
2092               if (*name == '\0')
2093                 name = bfd_section_name (input_bfd, sec);
2094             }
2095
2096           if (r == bfd_reloc_overflow)
2097             {
2098
2099               if (! ((*info->callbacks->reloc_overflow)
2100                      (info, name, howto->name, (bfd_vma) 0,
2101                       input_bfd, input_section, rel->r_offset)))
2102                 return false;
2103             }
2104           else
2105             {
2106               (*_bfd_error_handler)
2107                 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2108                  bfd_archive_filename (input_bfd),
2109                  bfd_get_section_name (input_bfd, input_section),
2110                  (long) rel->r_offset, name, (int) r);
2111               return false;
2112             }
2113         }
2114     }
2115
2116   return true;
2117 }
2118
2119 /* Finish up dynamic symbol handling.  We set the contents of various
2120    dynamic sections here.  */
2121
2122 static boolean
2123 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
2124      bfd *output_bfd;
2125      struct bfd_link_info *info;
2126      struct elf_link_hash_entry *h;
2127      Elf_Internal_Sym *sym;
2128 {
2129   struct elf_i386_link_hash_table *htab;
2130
2131   htab = elf_i386_hash_table (info);
2132
2133   if (h->plt.offset != (bfd_vma) -1)
2134     {
2135       bfd_vma plt_index;
2136       bfd_vma got_offset;
2137       Elf_Internal_Rel rel;
2138       Elf32_External_Rel *loc;
2139
2140       /* This symbol has an entry in the procedure linkage table.  Set
2141          it up.  */
2142
2143       if (h->dynindx == -1
2144           || htab->splt == NULL
2145           || htab->sgotplt == NULL
2146           || htab->srelplt == NULL)
2147         abort ();
2148
2149       /* Get the index in the procedure linkage table which
2150          corresponds to this symbol.  This is the index of this symbol
2151          in all the symbols for which we are making plt entries.  The
2152          first entry in the procedure linkage table is reserved.  */
2153       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2154
2155       /* Get the offset into the .got table of the entry that
2156          corresponds to this function.  Each .got entry is 4 bytes.
2157          The first three are reserved.  */
2158       got_offset = (plt_index + 3) * 4;
2159
2160       /* Fill in the entry in the procedure linkage table.  */
2161       if (! info->shared)
2162         {
2163           memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
2164                   PLT_ENTRY_SIZE);
2165           bfd_put_32 (output_bfd,
2166                       (htab->sgotplt->output_section->vma
2167                        + htab->sgotplt->output_offset
2168                        + got_offset),
2169                       htab->splt->contents + h->plt.offset + 2);
2170         }
2171       else
2172         {
2173           memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
2174                   PLT_ENTRY_SIZE);
2175           bfd_put_32 (output_bfd, got_offset,
2176                       htab->splt->contents + h->plt.offset + 2);
2177         }
2178
2179       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
2180                   htab->splt->contents + h->plt.offset + 7);
2181       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
2182                   htab->splt->contents + h->plt.offset + 12);
2183
2184       /* Fill in the entry in the global offset table.  */
2185       bfd_put_32 (output_bfd,
2186                   (htab->splt->output_section->vma
2187                    + htab->splt->output_offset
2188                    + h->plt.offset
2189                    + 6),
2190                   htab->sgotplt->contents + got_offset);
2191
2192       /* Fill in the entry in the .rel.plt section.  */
2193       rel.r_offset = (htab->sgotplt->output_section->vma
2194                       + htab->sgotplt->output_offset
2195                       + got_offset);
2196       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
2197       loc = (Elf32_External_Rel *) htab->srelplt->contents + plt_index;
2198       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2199
2200       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2201         {
2202           /* Mark the symbol as undefined, rather than as defined in
2203              the .plt section.  Leave the value alone.  This is a clue
2204              for the dynamic linker, to make function pointer
2205              comparisons work between an application and shared
2206              library.  */  
2207           sym->st_shndx = SHN_UNDEF;
2208         }
2209     }
2210
2211   if (h->got.offset != (bfd_vma) -1)
2212     {
2213       Elf_Internal_Rel rel;
2214       Elf32_External_Rel *loc;
2215
2216       /* This symbol has an entry in the global offset table.  Set it
2217          up.  */
2218
2219       if (htab->sgot == NULL || htab->srelgot == NULL)
2220         abort ();
2221
2222       rel.r_offset = (htab->sgot->output_section->vma
2223                       + htab->sgot->output_offset
2224                       + (h->got.offset & ~(bfd_vma) 1));
2225
2226       /* If this is a static link, or it is a -Bsymbolic link and the
2227          symbol is defined locally or was forced to be local because
2228          of a version file, we just want to emit a RELATIVE reloc.
2229          The entry in the global offset table will already have been
2230          initialized in the relocate_section function.  */
2231       if (info->shared
2232           && (info->symbolic
2233               || h->dynindx == -1
2234               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2235           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2236         {
2237           BFD_ASSERT((h->got.offset & 1) != 0);
2238           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2239         }
2240       else
2241         {
2242           BFD_ASSERT((h->got.offset & 1) == 0);
2243           bfd_put_32 (output_bfd, (bfd_vma) 0,
2244                       htab->sgot->contents + h->got.offset);
2245           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
2246         }
2247
2248       loc = (Elf32_External_Rel *) htab->srelgot->contents;
2249       loc += htab->srelgot->reloc_count++;
2250       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2251     }
2252
2253   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2254     {
2255       Elf_Internal_Rel rel;
2256       Elf32_External_Rel *loc;
2257
2258       /* This symbol needs a copy reloc.  Set it up.  */
2259
2260       if (h->dynindx == -1
2261           || (h->root.type != bfd_link_hash_defined
2262               && h->root.type != bfd_link_hash_defweak)
2263           || htab->srelbss == NULL)
2264         abort ();
2265
2266       rel.r_offset = (h->root.u.def.value
2267                       + h->root.u.def.section->output_section->vma
2268                       + h->root.u.def.section->output_offset);
2269       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
2270       loc = (Elf32_External_Rel *) htab->srelbss->contents;
2271       loc += htab->srelbss->reloc_count++;
2272       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2273     }
2274
2275   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2276   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2277       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2278     sym->st_shndx = SHN_ABS;
2279
2280   return true;
2281 }
2282
2283 /* Used to decide how to sort relocs in an optimal manner for the
2284    dynamic linker, before writing them out.  */
2285
2286 static enum elf_reloc_type_class
2287 elf_i386_reloc_type_class (rela)
2288      const Elf_Internal_Rela *rela;
2289 {
2290   switch ((int) ELF32_R_TYPE (rela->r_info))
2291     {
2292     case R_386_RELATIVE:
2293       return reloc_class_relative;
2294     case R_386_JUMP_SLOT:
2295       return reloc_class_plt;
2296     case R_386_COPY:
2297       return reloc_class_copy;
2298     default:
2299       return reloc_class_normal;
2300     }
2301 }
2302
2303 /* Finish up the dynamic sections.  */
2304
2305 static boolean
2306 elf_i386_finish_dynamic_sections (output_bfd, info)
2307      bfd *output_bfd;
2308      struct bfd_link_info *info;
2309 {
2310   struct elf_i386_link_hash_table *htab;
2311   bfd *dynobj;
2312   asection *sdyn;
2313
2314   htab = elf_i386_hash_table (info);
2315   dynobj = htab->elf.dynobj;
2316   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2317
2318   if (htab->elf.dynamic_sections_created)
2319     {
2320       Elf32_External_Dyn *dyncon, *dynconend;
2321
2322       if (sdyn == NULL || htab->sgot == NULL)
2323         abort ();
2324
2325       dyncon = (Elf32_External_Dyn *) sdyn->contents;
2326       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2327       for (; dyncon < dynconend; dyncon++)
2328         {
2329           Elf_Internal_Dyn dyn;
2330           asection *s;
2331
2332           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2333
2334           switch (dyn.d_tag)
2335             {
2336             default:
2337               continue;
2338
2339             case DT_PLTGOT:
2340               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
2341               break;
2342
2343             case DT_JMPREL:
2344               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
2345               break;
2346
2347             case DT_PLTRELSZ:
2348               s = htab->srelplt->output_section;
2349               if (s->_cooked_size != 0)
2350                 dyn.d_un.d_val = s->_cooked_size;
2351               else
2352                 dyn.d_un.d_val = s->_raw_size;
2353               break;
2354
2355             case DT_RELSZ:
2356               /* My reading of the SVR4 ABI indicates that the
2357                  procedure linkage table relocs (DT_JMPREL) should be
2358                  included in the overall relocs (DT_REL).  This is
2359                  what Solaris does.  However, UnixWare can not handle
2360                  that case.  Therefore, we override the DT_RELSZ entry
2361                  here to make it not include the JMPREL relocs.  Since
2362                  the linker script arranges for .rel.plt to follow all
2363                  other relocation sections, we don't have to worry
2364                  about changing the DT_REL entry.  */
2365               if (htab->srelplt != NULL)
2366                 {
2367                   s = htab->srelplt->output_section;
2368                   if (s->_cooked_size != 0)
2369                     dyn.d_un.d_val -= s->_cooked_size;
2370                   else
2371                     dyn.d_un.d_val -= s->_raw_size;
2372                 }
2373               break;
2374             }
2375
2376           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2377         }
2378
2379       /* Fill in the first entry in the procedure linkage table.  */
2380       if (htab->splt && htab->splt->_raw_size > 0)
2381         {
2382           if (info->shared)
2383             memcpy (htab->splt->contents,
2384                     elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
2385           else
2386             {
2387               memcpy (htab->splt->contents,
2388                       elf_i386_plt0_entry, PLT_ENTRY_SIZE);
2389               bfd_put_32 (output_bfd,
2390                           (htab->sgotplt->output_section->vma
2391                            + htab->sgotplt->output_offset
2392                            + 4),
2393                           htab->splt->contents + 2);
2394               bfd_put_32 (output_bfd,
2395                           (htab->sgotplt->output_section->vma
2396                            + htab->sgotplt->output_offset
2397                            + 8),
2398                           htab->splt->contents + 8);
2399             }
2400
2401           /* UnixWare sets the entsize of .plt to 4, although that doesn't
2402              really seem like the right value.  */
2403           elf_section_data (htab->splt->output_section)
2404             ->this_hdr.sh_entsize = 4;
2405         }
2406     }
2407
2408   if (htab->sgotplt)
2409     {
2410       /* Fill in the first three entries in the global offset table.  */
2411       if (htab->sgotplt->_raw_size > 0)
2412         {
2413           bfd_put_32 (output_bfd,
2414                       (sdyn == NULL ? (bfd_vma) 0
2415                        : sdyn->output_section->vma + sdyn->output_offset),
2416                       htab->sgotplt->contents);
2417           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
2418           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
2419         }
2420
2421       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
2422     }
2423   return true;
2424 }
2425
2426 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
2427 #define TARGET_LITTLE_NAME              "elf32-i386"
2428 #define ELF_ARCH                        bfd_arch_i386
2429 #define ELF_MACHINE_CODE                EM_386
2430 #define ELF_MAXPAGESIZE                 0x1000
2431
2432 #define elf_backend_can_gc_sections     1
2433 #define elf_backend_can_refcount        1
2434 #define elf_backend_want_got_plt        1
2435 #define elf_backend_plt_readonly        1
2436 #define elf_backend_want_plt_sym        0
2437 #define elf_backend_got_header_size     12
2438 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
2439
2440 #define elf_info_to_howto                     elf_i386_info_to_howto
2441 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
2442
2443 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
2444 #define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
2445 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
2446
2447 #define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
2448 #define elf_backend_check_relocs              elf_i386_check_relocs
2449 #define elf_backend_copy_indirect_symbol      elf_i386_copy_indirect_symbol
2450 #define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
2451 #define elf_backend_fake_sections             elf_i386_fake_sections
2452 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
2453 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
2454 #define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
2455 #define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
2456 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
2457 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
2458 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
2459 #define elf_backend_relocate_section          elf_i386_relocate_section
2460 #define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
2461
2462 #include "elf32-target.h"