bfd/elf32-i386.c

   1 /* Intel 80386/80486-specific support for 32-bit ELF
   2    Copyright 1993, 1994, 1995 Free Software Foundation, Inc.
   3
   4 This file is part of BFD, the Binary File Descriptor library.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "bfdlink.h"
  23 #include "libbfd.h"
  24 #include "libelf.h"
  25
  26 static reloc_howto_type *elf_i386_reloc_type_lookup
  27   PARAMS ((bfd *, bfd_reloc_code_real_type));
  28 static void elf_i386_info_to_howto
  29   PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
  30 static void elf_i386_info_to_howto_rel
  31   PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
  32 static boolean elf_i386_check_relocs
  33   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  34            const Elf_Internal_Rela *));
  35 static boolean elf_i386_adjust_dynamic_symbol
  36   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  37 static boolean elf_i386_size_dynamic_sections
  38   PARAMS ((bfd *, struct bfd_link_info *));
  39 static boolean elf_i386_relocate_section
  40   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  41            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  42 static boolean elf_i386_finish_dynamic_symbol
  43   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  44            Elf_Internal_Sym *));
  45 static boolean elf_i386_finish_dynamic_sections
  46   PARAMS ((bfd *, struct bfd_link_info *));
  47
  48 #define USE_REL 1               /* 386 uses REL relocations instead of RELA */
  49
  50 enum reloc_type
  51   {
  52     R_386_NONE = 0,
  53     R_386_32,
  54     R_386_PC32,
  55     R_386_GOT32,
  56     R_386_PLT32,
  57     R_386_COPY,
  58     R_386_GLOB_DAT,
  59     R_386_JUMP_SLOT,
  60     R_386_RELATIVE,
  61     R_386_GOTOFF,
  62     R_386_GOTPC,
  63     R_386_max
  64   };
  65
  66 #if 0
  67 static CONST char *CONST reloc_type_names[] =
  68 {
  69   "R_386_NONE",
  70   "R_386_32",
  71   "R_386_PC32",
  72   "R_386_GOT32",
  73   "R_386_PLT32",
  74   "R_386_COPY",
  75   "R_386_GLOB_DAT",
  76   "R_386_JUMP_SLOT",
  77   "R_386_RELATIVE",
  78   "R_386_GOTOFF",
  79   "R_386_GOTPC",
  80 };
  81 #endif
  82
  83 static reloc_howto_type elf_howto_table[]=
  84 {
  85   HOWTO(R_386_NONE,      0,0, 0,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_NONE",     true,0x00000000,0x00000000,false),
  86   HOWTO(R_386_32,        0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_32",       true,0xffffffff,0xffffffff,false),
  87   HOWTO(R_386_PC32,      0,2,32,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC32",     true,0xffffffff,0xffffffff,true),
  88   HOWTO(R_386_GOT32,     0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOT32",    true,0xffffffff,0xffffffff,false),
  89   HOWTO(R_386_PLT32,     0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PLT32",    true,0xffffffff,0xffffffff,true),
  90   HOWTO(R_386_COPY,      0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_COPY",     true,0xffffffff,0xffffffff,false),
  91   HOWTO(R_386_GLOB_DAT,  0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GLOB_DAT", true,0xffffffff,0xffffffff,false),
  92   HOWTO(R_386_JUMP_SLOT, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_JUMP_SLOT",true,0xffffffff,0xffffffff,false),
  93   HOWTO(R_386_RELATIVE,  0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_RELATIVE", true,0xffffffff,0xffffffff,false),
  94   HOWTO(R_386_GOTOFF,    0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTOFF",   true,0xffffffff,0xffffffff,false),
  95   HOWTO(R_386_GOTPC,     0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTPC",    true,0xffffffff,0xffffffff,true),
  96 };
  97
  98 #ifdef DEBUG_GEN_RELOC
  99 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
 100 #else
 101 #define TRACE(str)
 102 #endif
 103
 104 static reloc_howto_type *
 105 elf_i386_reloc_type_lookup (abfd, code)
 106      bfd *abfd;
 107      bfd_reloc_code_real_type code;
 108 {
 109   switch (code)
 110     {
 111     case BFD_RELOC_NONE:
 112       TRACE ("BFD_RELOC_NONE");
 113       return &elf_howto_table[ (int)R_386_NONE ];
 114
 115     case BFD_RELOC_32:
 116       TRACE ("BFD_RELOC_32");
 117       return &elf_howto_table[ (int)R_386_32 ];
 118
 119     case BFD_RELOC_32_PCREL:
 120       TRACE ("BFD_RELOC_PC32");
 121       return &elf_howto_table[ (int)R_386_PC32 ];
 122
 123     case BFD_RELOC_386_GOT32:
 124       TRACE ("BFD_RELOC_386_GOT32");
 125       return &elf_howto_table[ (int)R_386_GOT32 ];
 126
 127     case BFD_RELOC_386_PLT32:
 128       TRACE ("BFD_RELOC_386_PLT32");
 129       return &elf_howto_table[ (int)R_386_PLT32 ];
 130
 131     case BFD_RELOC_386_COPY:
 132       TRACE ("BFD_RELOC_386_COPY");
 133       return &elf_howto_table[ (int)R_386_COPY ];
 134
 135     case BFD_RELOC_386_GLOB_DAT:
 136       TRACE ("BFD_RELOC_386_GLOB_DAT");
 137       return &elf_howto_table[ (int)R_386_GLOB_DAT ];
 138
 139     case BFD_RELOC_386_JUMP_SLOT:
 140       TRACE ("BFD_RELOC_386_JUMP_SLOT");
 141       return &elf_howto_table[ (int)R_386_JUMP_SLOT ];
 142
 143     case BFD_RELOC_386_RELATIVE:
 144       TRACE ("BFD_RELOC_386_RELATIVE");
 145       return &elf_howto_table[ (int)R_386_RELATIVE ];
 146
 147     case BFD_RELOC_386_GOTOFF:
 148       TRACE ("BFD_RELOC_386_GOTOFF");
 149       return &elf_howto_table[ (int)R_386_GOTOFF ];
 150
 151     case BFD_RELOC_386_GOTPC:
 152       TRACE ("BFD_RELOC_386_GOTPC");
 153       return &elf_howto_table[ (int)R_386_GOTPC ];
 154
 155     default:
 156       break;
 157     }
 158
 159   TRACE ("Unknown");
 160   return 0;
 161 }
 162
 163 static void
 164 elf_i386_info_to_howto (abfd, cache_ptr, dst)
 165      bfd                *abfd;
 166      arelent            *cache_ptr;
 167      Elf32_Internal_Rela *dst;
 168 {
 169   BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_386_max);
 170
 171   cache_ptr->howto = &elf_howto_table[ELF32_R_TYPE(dst->r_info)];
 172 }
 173
 174 static void
 175 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
 176      bfd                *abfd;
 177      arelent            *cache_ptr;
 178      Elf32_Internal_Rel *dst;
 179 {
 180   BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_386_max);
 181
 182   cache_ptr->howto = &elf_howto_table[ELF32_R_TYPE(dst->r_info)];
 183 }
 184 \f
 185 /* Functions for the i386 ELF linker.  */
 186
 187 /* The name of the dynamic interpreter.  This is put in the .interp
 188    section.  */
 189
 190 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
 191
 192 /* The size in bytes of an entry in the procedure linkage table.  */
 193
 194 #define PLT_ENTRY_SIZE 16
 195
 196 /* The first entry in an absolute procedure linkage table looks like
 197    this.  See the SVR4 ABI i386 supplement to see how this works.  */
 198
 199 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
 200 {
 201   0xff, 0x35,   /* pushl contents of address */
 202   0, 0, 0, 0,   /* replaced with address of .got + 4.  */
 203   0xff, 0x25,   /* jmp indirect */
 204   0, 0, 0, 0,   /* replaced with address of .got + 8.  */
 205   0, 0, 0, 0    /* pad out to 16 bytes.  */
 206 };
 207
 208 /* Subsequent entries in an absolute procedure linkage table look like
 209    this.  */
 210
 211 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
 212 {
 213   0xff, 0x25,   /* jmp indirect */
 214   0, 0, 0, 0,   /* replaced with address of this symbol in .got.  */
 215   0x68,         /* pushl immediate */
 216   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 217   0xe9,         /* jmp relative */
 218   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 219 };
 220
 221 /* The first entry in a PIC procedure linkage table look like this.  */
 222
 223 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
 224 {
 225   0xff, 0xb3, 4, 0, 0, 0,       /* pushl 4(%ebx) */
 226   0xff, 0xa3, 8, 0, 0, 0,       /* jmp *8(%ebx) */
 227   0, 0, 0, 0                    /* pad out to 16 bytes.  */
 228 };
 229
 230 /* Subsequent entries in a PIC procedure linkage table look like this.  */
 231
 232 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
 233 {
 234   0xff, 0xa3,   /* jmp *offset(%ebx) */
 235   0, 0, 0, 0,   /* replaced with offset of this symbol in .got.  */
 236   0x68,         /* pushl immediate */
 237   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 238   0xe9,         /* jmp relative */
 239   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 240 };
 241
 242 /* Look through the relocs for a section during the first phase, and
 243    allocate space in the global offset table or procedure linkage
 244    table.  */
 245
 246 static boolean
 247 elf_i386_check_relocs (abfd, info, sec, relocs)
 248      bfd *abfd;
 249      struct bfd_link_info *info;
 250      asection *sec;
 251      const Elf_Internal_Rela *relocs;
 252 {
 253   bfd *dynobj;
 254   Elf_Internal_Shdr *symtab_hdr;
 255   struct elf_link_hash_entry **sym_hashes;
 256   bfd_vma *local_got_offsets;
 257   const Elf_Internal_Rela *rel;
 258   const Elf_Internal_Rela *rel_end;
 259   asection *sgot;
 260   asection *srelgot;
 261   asection *sreloc;
 262
 263   if (info->relocateable)
 264     return true;
 265
 266   dynobj = elf_hash_table (info)->dynobj;
 267   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 268   sym_hashes = elf_sym_hashes (abfd);
 269   local_got_offsets = elf_local_got_offsets (abfd);
 270
 271   sgot = NULL;
 272   srelgot = NULL;
 273   sreloc = NULL;
 274
 275   rel_end = relocs + sec->reloc_count;
 276   for (rel = relocs; rel < rel_end; rel++)
 277     {
 278       long r_symndx;
 279       struct elf_link_hash_entry *h;
 280
 281       r_symndx = ELF32_R_SYM (rel->r_info);
 282
 283       if (r_symndx < symtab_hdr->sh_info)
 284         h = NULL;
 285       else
 286         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 287
 288       /* Some relocs require a global offset table.  */
 289       if (dynobj == NULL)
 290         {
 291           switch (ELF32_R_TYPE (rel->r_info))
 292             {
 293             case R_386_GOT32:
 294             case R_386_GOTOFF:
 295             case R_386_GOTPC:
 296               elf_hash_table (info)->dynobj = dynobj = abfd;
 297               if (! _bfd_elf_create_got_section (dynobj, info))
 298                 return false;
 299               break;
 300
 301             default:
 302               break;
 303             }
 304         }
 305
 306       switch (ELF32_R_TYPE (rel->r_info))
 307         {
 308         case R_386_GOT32:
 309           /* This symbol requires a global offset table entry.  */
 310
 311           if (sgot == NULL)
 312             {
 313               sgot = bfd_get_section_by_name (dynobj, ".got");
 314               BFD_ASSERT (sgot != NULL);
 315             }
 316
 317           if (srelgot == NULL
 318               && (h != NULL || info->shared))
 319             {
 320               srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
 321               if (srelgot == NULL)
 322                 {
 323                   srelgot = bfd_make_section (dynobj, ".rel.got");
 324                   if (srelgot == NULL
 325                       || ! bfd_set_section_flags (dynobj, srelgot,
 326                                                   (SEC_ALLOC
 327                                                    | SEC_LOAD
 328                                                    | SEC_HAS_CONTENTS
 329                                                    | SEC_IN_MEMORY
 330                                                    | SEC_READONLY))
 331                       || ! bfd_set_section_alignment (dynobj, srelgot, 2))
 332                     return false;
 333                 }
 334             }
 335
 336           if (h != NULL)
 337             {
 338               if (h->got_offset != (bfd_vma) -1)
 339                 {
 340                   /* We have already allocated space in the .got.  */
 341                   break;
 342                 }
 343               h->got_offset = sgot->_raw_size;
 344
 345               /* Make sure this symbol is output as a dynamic symbol.  */
 346               if (h->dynindx == -1)
 347                 {
 348                   if (! bfd_elf32_link_record_dynamic_symbol (info, h))
 349                     return false;
 350                 }
 351
 352               srelgot->_raw_size += sizeof (Elf32_External_Rel);
 353             }
 354           else
 355             {
 356               /* This is a global offset table entry for a local
 357                  symbol.  */
 358               if (local_got_offsets == NULL)
 359                 {
 360                   size_t size;
 361                   register int i;
 362
 363                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
 364                   local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
 365                   if (local_got_offsets == NULL)
 366                     {
 367                       bfd_set_error (bfd_error_no_memory);
 368                       return false;
 369                     }
 370                   elf_local_got_offsets (abfd) = local_got_offsets;
 371                   for (i = 0; i < symtab_hdr->sh_info; i++)
 372                     local_got_offsets[i] = (bfd_vma) -1;
 373                 }
 374               if (local_got_offsets[r_symndx] != (bfd_vma) -1)
 375                 {
 376                   /* We have already allocated space in the .got.  */
 377                   break;
 378                 }
 379               local_got_offsets[r_symndx] = sgot->_raw_size;
 380
 381               if (info->shared)
 382                 {
 383                   /* If we are generating a shared object, we need to
 384                      output a R_386_RELATIVE reloc so that the dynamic
 385                      linker can adjust this GOT entry.  */
 386                   srelgot->_raw_size += sizeof (Elf32_External_Rel);
 387                 }
 388             }
 389
 390           sgot->_raw_size += 4;
 391
 392           break;
 393
 394         case R_386_PLT32:
 395           /* This symbol requires a procedure linkage table entry.  We
 396              actually build the entry in adjust_dynamic_symbol,
 397              because this might be a case of linking PIC code without
 398              linking in any dynamic objects, in which case we don't
 399              need to generate a procedure linkage table after all.  */
 400
 401           /* If this is a local symbol, we resolve it directly without
 402              creating a procedure linkage table entry.  */
 403           if (h == NULL)
 404             continue;
 405
 406           /* Make sure this symbol is output as a dynamic symbol.  */
 407           if (h->dynindx == -1)
 408             {
 409               if (! bfd_elf32_link_record_dynamic_symbol (info, h))
 410                 return false;
 411             }
 412
 413           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 414
 415           break;
 416
 417         case R_386_32:
 418         case R_386_PC32:
 419           if (info->shared
 420               && (sec->flags & SEC_ALLOC) != 0)
 421             {
 422               /* When creating a shared object, we must copy these
 423                  reloc types into the output file.  We create a reloc
 424                  section in dynobj and make room for this reloc.  */
 425               if (sreloc == NULL)
 426                 {
 427                   const char *name;
 428
 429                   name = (bfd_elf_string_from_elf_section
 430                           (abfd,
 431                            elf_elfheader (abfd)->e_shstrndx,
 432                            elf_section_data (sec)->rel_hdr.sh_name));
 433                   if (name == NULL)
 434                     return false;
 435
 436                   BFD_ASSERT (strncmp (name, ".rel", 4) == 0
 437                               && strcmp (bfd_get_section_name (abfd, sec),
 438                                          name + 4) == 0);
 439
 440                   sreloc = bfd_get_section_by_name (dynobj, name);
 441                   if (sreloc == NULL)
 442                     {
 443                       sreloc = bfd_make_section (dynobj, name);
 444                       if (sreloc == NULL
 445                           || ! bfd_set_section_flags (dynobj, sreloc,
 446                                                       (SEC_ALLOC
 447                                                        | SEC_LOAD
 448                                                        | SEC_HAS_CONTENTS
 449                                                        | SEC_IN_MEMORY
 450                                                        | SEC_READONLY))
 451                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
 452                         return false;
 453                     }
 454                 }
 455
 456               sreloc->_raw_size += sizeof (Elf32_External_Rel);
 457             }
 458
 459           break;
 460
 461         default:
 462           break;
 463         }
 464     }
 465
 466   return true;
 467 }
 468
 469 /* Adjust a symbol defined by a dynamic object and referenced by a
 470    regular object.  The current definition is in some section of the
 471    dynamic object, but we're not including those sections.  We have to
 472    change the definition to something the rest of the link can
 473    understand.  */
 474
 475 static boolean
 476 elf_i386_adjust_dynamic_symbol (info, h)
 477      struct bfd_link_info *info;
 478      struct elf_link_hash_entry *h;
 479 {
 480   bfd *dynobj;
 481   asection *s;
 482   unsigned int power_of_two;
 483
 484   dynobj = elf_hash_table (info)->dynobj;
 485
 486   /* Make sure we know what is going on here.  */
 487   BFD_ASSERT (dynobj != NULL
 488               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
 489                   || ((h->elf_link_hash_flags
 490                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
 491                       && (h->elf_link_hash_flags
 492                           & ELF_LINK_HASH_REF_REGULAR) != 0
 493                       && (h->elf_link_hash_flags
 494                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
 495
 496   /* If this is a function, put it in the procedure linkage table.  We
 497      will fill in the contents of the procedure linkage table later,
 498      when we know the address of the .got section.  */
 499   if (h->type == STT_FUNC
 500       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
 501     {
 502       if (! elf_hash_table (info)->dynamic_sections_created)
 503         {
 504           /* This case can occur if we saw a PLT32 reloc in an input
 505              file, but none of the input files were dynamic objects.
 506              In such a case, we don't actually need to build a
 507              procedure linkage table, and we can just do a PC32 reloc
 508              instead.  */
 509           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
 510           return true;
 511         }
 512
 513       s = bfd_get_section_by_name (dynobj, ".plt");
 514       BFD_ASSERT (s != NULL);
 515
 516       /* If this is the first .plt entry, make room for the special
 517          first entry.  */
 518       if (s->_raw_size == 0)
 519         s->_raw_size += PLT_ENTRY_SIZE;
 520
 521       /* If this symbol is not defined in a regular file, and we are
 522          not generating a shared library, then set the symbol to this
 523          location in the .plt.  This is required to make function
 524          pointers compare as equal between the normal executable and
 525          the shared library.  */
 526       if (! info->shared
 527           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
 528         {
 529           h->root.u.def.section = s;
 530           h->root.u.def.value = s->_raw_size;
 531         }
 532
 533       h->plt_offset = s->_raw_size;
 534
 535       /* Make room for this entry.  */
 536       s->_raw_size += PLT_ENTRY_SIZE;
 537
 538       /* We also need to make an entry in the .got.plt section, which
 539          will be placed in the .got section by the linker script.  */
 540
 541       s = bfd_get_section_by_name (dynobj, ".got.plt");
 542       BFD_ASSERT (s != NULL);
 543       s->_raw_size += 4;
 544
 545       /* We also need to make an entry in the .rel.plt section.  */
 546
 547       s = bfd_get_section_by_name (dynobj, ".rel.plt");
 548       BFD_ASSERT (s != NULL);
 549       s->_raw_size += sizeof (Elf32_External_Rel);
 550
 551       return true;
 552     }
 553
 554   /* If this is a weak symbol, and there is a real definition, the
 555      processor independent code will have arranged for us to see the
 556      real definition first, and we can just use the same value.  */
 557   if (h->weakdef != NULL)
 558     {
 559       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
 560                   || h->weakdef->root.type == bfd_link_hash_defweak);
 561       h->root.u.def.section = h->weakdef->root.u.def.section;
 562       h->root.u.def.value = h->weakdef->root.u.def.value;
 563       return true;
 564     }
 565
 566   /* This is a reference to a symbol defined by a dynamic object which
 567      is not a function.  */
 568
 569   /* If we are creating a shared library, we must presume that the
 570      only references to the symbol are via the global offset table.
 571      For such cases we need not do anything here; the relocations will
 572      be handled correctly by relocate_section.  */
 573   if (info->shared)
 574     return true;
 575
 576   /* We must allocate the symbol in our .dynbss section, which will
 577      become part of the .bss section of the executable.  There will be
 578      an entry for this symbol in the .dynsym section.  The dynamic
 579      object will contain position independent code, so all references
 580      from the dynamic object to this symbol will go through the global
 581      offset table.  The dynamic linker will use the .dynsym entry to
 582      determine the address it must put in the global offset table, so
 583      both the dynamic object and the regular object will refer to the
 584      same memory location for the variable.  */
 585
 586   s = bfd_get_section_by_name (dynobj, ".dynbss");
 587   BFD_ASSERT (s != NULL);
 588
 589   /* If the symbol is currently defined in the .bss section of the
 590      dynamic object, then it is OK to simply initialize it to zero.
 591      If the symbol is in some other section, we must generate a
 592      R_386_COPY reloc to tell the dynamic linker to copy the initial
 593      value out of the dynamic object and into the runtime process
 594      image.  We need to remember the offset into the .rel.bss section
 595      we are going to use.  */
 596   if ((h->root.u.def.section->flags & SEC_LOAD) != 0)
 597     {
 598       asection *srel;
 599
 600       srel = bfd_get_section_by_name (dynobj, ".rel.bss");
 601       BFD_ASSERT (srel != NULL);
 602       srel->_raw_size += sizeof (Elf32_External_Rel);
 603       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
 604     }
 605
 606   /* We need to figure out the alignment required for this symbol.  I
 607      have no idea how ELF linkers handle this.  */
 608   power_of_two = bfd_log2 (h->size);
 609   if (power_of_two > 3)
 610     power_of_two = 3;
 611
 612   /* Apply the required alignment.  */
 613   s->_raw_size = BFD_ALIGN (s->_raw_size,
 614                             (bfd_size_type) (1 << power_of_two));
 615   if (power_of_two > bfd_get_section_alignment (dynobj, s))
 616     {
 617       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
 618         return false;
 619     }
 620
 621   /* Define the symbol as being at this point in the section.  */
 622   h->root.u.def.section = s;
 623   h->root.u.def.value = s->_raw_size;
 624
 625   /* Increment the section size to make room for the symbol.  */
 626   s->_raw_size += h->size;
 627
 628   return true;
 629 }
 630
 631 /* Set the sizes of the dynamic sections.  */
 632
 633 static boolean
 634 elf_i386_size_dynamic_sections (output_bfd, info)
 635      bfd *output_bfd;
 636      struct bfd_link_info *info;
 637 {
 638   bfd *dynobj;
 639   asection *s;
 640   boolean plt;
 641   boolean relocs;
 642   boolean reltext;
 643
 644   dynobj = elf_hash_table (info)->dynobj;
 645   BFD_ASSERT (dynobj != NULL);
 646
 647   if (elf_hash_table (info)->dynamic_sections_created)
 648     {
 649       /* Set the contents of the .interp section to the interpreter.  */
 650       if (! info->shared)
 651         {
 652           s = bfd_get_section_by_name (dynobj, ".interp");
 653           BFD_ASSERT (s != NULL);
 654           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
 655           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
 656         }
 657     }
 658   else
 659     {
 660       /* We may have created entries in the .rel.got section.
 661          However, if we are not creating the dynamic sections, we will
 662          not actually use these entries.  Reset the size of .rel.got,
 663          which will cause it to get stripped from the output file
 664          below.  */
 665       s = bfd_get_section_by_name (dynobj, ".rel.got");
 666       if (s != NULL)
 667         s->_raw_size = 0;
 668     }
 669
 670   /* The check_relocs and adjust_dynamic_symbol entry points have
 671      determined the sizes of the various dynamic sections.  Allocate
 672      memory for them.  */
 673   plt = false;
 674   relocs = false;
 675   reltext = false;
 676   for (s = dynobj->sections; s != NULL; s = s->next)
 677     {
 678       const char *name;
 679       boolean strip;
 680
 681       if ((s->flags & SEC_IN_MEMORY) == 0)
 682         continue;
 683
 684       /* It's OK to base decisions on the section name, because none
 685          of the dynobj section names depend upon the input files.  */
 686       name = bfd_get_section_name (dynobj, s);
 687
 688       strip = false;
 689
 690       if (strcmp (name, ".plt") == 0)
 691         {
 692           if (s->_raw_size == 0)
 693             {
 694               /* Strip this section if we don't need it; see the
 695                  comment below.  */
 696               strip = true;
 697             }
 698           else
 699             {
 700               /* Remember whether there is a PLT.  */
 701               plt = true;
 702             }
 703         }
 704       else if (strncmp (name, ".rel", 4) == 0)
 705         {
 706           if (s->_raw_size == 0)
 707             {
 708               /* If we don't need this section, strip it from the
 709                  output file.  This is mostly to handle .rel.bss and
 710                  .rel.plt.  We must create both sections in
 711                  create_dynamic_sections, because they must be created
 712                  before the linker maps input sections to output
 713                  sections.  The linker does that before
 714                  adjust_dynamic_symbol is called, and it is that
 715                  function which decides whether anything needs to go
 716                  into these sections.  */
 717               strip = true;
 718             }
 719           else
 720             {
 721               asection *target;
 722
 723               /* Remember whether there are any reloc sections other
 724                  than .rel.plt.  */
 725               if (strcmp (name, ".rel.plt") != 0)
 726                 relocs = true;
 727
 728               /* If this relocation section applies to a read only
 729                  section, then we probably need a DT_TEXTREL entry.  */
 730               target = bfd_get_section_by_name (output_bfd, name + 4);
 731               if (target != NULL
 732                   && (target->flags & SEC_READONLY) != 0)
 733                 reltext = true;
 734
 735               /* We use the reloc_count field as a counter if we need
 736                  to copy relocs into the output file.  */
 737               s->reloc_count = 0;
 738             }
 739         }
 740       else if (strncmp (name, ".got", 4) != 0)
 741         {
 742           /* It's not one of our sections, so don't allocate space.  */
 743           continue;
 744         }
 745
 746       if (strip)
 747         {
 748           asection **spp;
 749
 750           for (spp = &s->output_section->owner->sections;
 751                *spp != s->output_section;
 752                spp = &(*spp)->next)
 753             ;
 754           *spp = s->output_section->next;
 755           --s->output_section->owner->section_count;
 756
 757           continue;
 758         }
 759
 760       /* Allocate memory for the section contents.  */
 761       s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
 762       if (s->contents == NULL && s->_raw_size != 0)
 763         {
 764           bfd_set_error (bfd_error_no_memory);
 765           return false;
 766         }
 767     }
 768
 769   if (elf_hash_table (info)->dynamic_sections_created)
 770     {
 771       /* Add some entries to the .dynamic section.  We fill in the
 772          values later, in elf_i386_finish_dynamic_sections, but we
 773          must add the entries now so that we get the correct size for
 774          the .dynamic section.  The DT_DEBUG entry is filled in by the
 775          dynamic linker and used by the debugger.  */
 776       if (! info->shared)
 777         {
 778           if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
 779             return false;
 780         }
 781
 782       if (plt)
 783         {
 784           if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
 785               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
 786               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
 787               || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
 788             return false;
 789         }
 790
 791       if (relocs)
 792         {
 793           if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
 794               || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
 795               || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
 796                                                 sizeof (Elf32_External_Rel)))
 797             return false;
 798         }
 799
 800       if (reltext)
 801         {
 802           if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
 803             return false;
 804         }
 805     }
 806
 807   return true;
 808 }
 809
 810 /* Relocate an i386 ELF section.  */
 811
 812 static boolean
 813 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
 814                            contents, relocs, local_syms, local_sections)
 815      bfd *output_bfd;
 816      struct bfd_link_info *info;
 817      bfd *input_bfd;
 818      asection *input_section;
 819      bfd_byte *contents;
 820      Elf_Internal_Rela *relocs;
 821      Elf_Internal_Sym *local_syms;
 822      asection **local_sections;
 823 {
 824   bfd *dynobj;
 825   Elf_Internal_Shdr *symtab_hdr;
 826   struct elf_link_hash_entry **sym_hashes;
 827   bfd_vma *local_got_offsets;
 828   asection *sgot;
 829   asection *splt;
 830   asection *sreloc;
 831   Elf_Internal_Rela *rel;
 832   Elf_Internal_Rela *relend;
 833
 834   dynobj = elf_hash_table (info)->dynobj;
 835   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 836   sym_hashes = elf_sym_hashes (input_bfd);
 837   local_got_offsets = elf_local_got_offsets (input_bfd);
 838
 839   sgot = NULL;
 840   splt = NULL;
 841   sreloc = NULL;
 842
 843   rel = relocs;
 844   relend = relocs + input_section->reloc_count;
 845   for (; rel < relend; rel++)
 846     {
 847       int r_type;
 848       reloc_howto_type *howto;
 849       long r_symndx;
 850       struct elf_link_hash_entry *h;
 851       Elf_Internal_Sym *sym;
 852       asection *sec;
 853       bfd_vma relocation;
 854       bfd_reloc_status_type r;
 855
 856       r_type = ELF32_R_TYPE (rel->r_info);
 857       if (r_type < 0 || r_type >= (int) R_386_max)
 858         {
 859           bfd_set_error (bfd_error_bad_value);
 860           return false;
 861         }
 862       howto = elf_howto_table + r_type;
 863
 864       r_symndx = ELF32_R_SYM (rel->r_info);
 865
 866       if (info->relocateable)
 867         {
 868           /* This is a relocateable link.  We don't have to change
 869              anything, unless the reloc is against a section symbol,
 870              in which case we have to adjust according to where the
 871              section symbol winds up in the output section.  */
 872           if (r_symndx < symtab_hdr->sh_info)
 873             {
 874               sym = local_syms + r_symndx;
 875               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
 876                 {
 877                   bfd_vma val;
 878
 879                   sec = local_sections[r_symndx];
 880                   val = bfd_get_32 (input_bfd, contents + rel->r_offset);
 881                   val += sec->output_offset + sym->st_value;
 882                   bfd_put_32 (input_bfd, val, contents + rel->r_offset);
 883                 }
 884             }
 885
 886           continue;
 887         }
 888
 889       /* This is a final link.  */
 890       h = NULL;
 891       sym = NULL;
 892       sec = NULL;
 893       if (r_symndx < symtab_hdr->sh_info)
 894         {
 895           sym = local_syms + r_symndx;
 896           sec = local_sections[r_symndx];
 897           relocation = (sec->output_section->vma
 898                         + sec->output_offset
 899                         + sym->st_value);
 900         }
 901       else
 902         {
 903           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 904           if (h->root.type == bfd_link_hash_defined
 905               || h->root.type == bfd_link_hash_defweak)
 906             {
 907               sec = h->root.u.def.section;
 908               if (r_type == R_386_GOTPC
 909                   || (r_type == R_386_PLT32
 910                       && h->plt_offset != (bfd_vma) -1)
 911                   || (r_type == R_386_GOT32
 912                       && elf_hash_table (info)->dynamic_sections_created)
 913                   || (info->shared
 914                       && (r_type == R_386_32
 915                           || r_type == R_386_PC32)
 916                       && (input_section->flags & SEC_ALLOC) != 0))
 917                 {
 918                   /* In these cases, we don't need the relocation
 919                      value.  We check specially because in some
 920                      obscure cases sec->output_section will be NULL.  */
 921                   relocation = 0;
 922                 }
 923               else
 924                 relocation = (h->root.u.def.value
 925                               + sec->output_section->vma
 926                               + sec->output_offset);
 927             }
 928           else if (h->root.type == bfd_link_hash_undefweak)
 929             relocation = 0;
 930           else if (info->shared)
 931             relocation = 0;
 932           else
 933             {
 934               if (! ((*info->callbacks->undefined_symbol)
 935                      (info, h->root.root.string, input_bfd,
 936                       input_section, rel->r_offset)))
 937                 return false;
 938               relocation = 0;
 939             }
 940         }
 941
 942       switch (r_type)
 943         {
 944         case R_386_GOT32:
 945           /* Relocation is to the entry for this symbol in the global
 946              offset table.  */
 947           if (sgot == NULL)
 948             {
 949               sgot = bfd_get_section_by_name (dynobj, ".got");
 950               BFD_ASSERT (sgot != NULL);
 951             }
 952
 953           if (h != NULL)
 954             {
 955               bfd_vma off;
 956
 957               off = h->got_offset;
 958               BFD_ASSERT (off != (bfd_vma) -1);
 959
 960               if (! elf_hash_table (info)->dynamic_sections_created)
 961                 {
 962                   /* This is actually a static link.  We must
 963                      initialize this entry in the global offset table.
 964                      Since the offset must always be a multiple of 4,
 965                      we use the least significant bit to record
 966                      whether we have initialized it already.
 967
 968                      When doing a dynamic link, we create a .rel.got
 969                      relocation entry to initialize the value.  This
 970                      is done in the finish_dynamic_symbol routine.  */
 971                   if ((off & 1) != 0)
 972                     off &= ~1;
 973                   else
 974                     {
 975                       bfd_put_32 (output_bfd, relocation,
 976                                   sgot->contents + off);
 977                       h->got_offset |= 1;
 978                     }
 979                 }
 980
 981               relocation = sgot->output_offset + off;
 982             }
 983           else
 984             {
 985               bfd_vma off;
 986
 987               BFD_ASSERT (local_got_offsets != NULL
 988                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
 989
 990               off = local_got_offsets[r_symndx];
 991
 992               /* The offset must always be a multiple of 4.  We use
 993                  the least significant bit to record whether we have
 994                  already generated the necessary reloc.  */
 995               if ((off & 1) != 0)
 996                 off &= ~1;
 997               else
 998                 {
 999                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1000
1001                   if (info->shared)
1002                     {
1003                       asection *srelgot;
1004                       Elf_Internal_Rel outrel;
1005
1006                       srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1007                       BFD_ASSERT (srelgot != NULL);
1008
1009                       outrel.r_offset = (sgot->output_section->vma
1010                                          + sgot->output_offset
1011                                          + off);
1012                       outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1013                       bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1014                                                 (((Elf32_External_Rel *)
1015                                                   srelgot->contents)
1016                                                  + srelgot->reloc_count));
1017                       ++srelgot->reloc_count;
1018                     }
1019
1020                   local_got_offsets[r_symndx] |= 1;
1021                 }
1022
1023               relocation = sgot->output_offset + off;
1024             }
1025
1026           break;
1027
1028         case R_386_GOTOFF:
1029           /* Relocation is relative to the start of the global offset
1030              table.  */
1031
1032           if (sgot == NULL)
1033             {
1034               sgot = bfd_get_section_by_name (dynobj, ".got");
1035               BFD_ASSERT (sgot != NULL);
1036             }
1037
1038           /* Note that sgot->output_offset is not involved in this
1039              calculation.  We always want the start of .got.  If we
1040              defined _GLOBAL_OFFSET_TABLE in a different way, as is
1041              permitted by the ABI, we might have to change this
1042              calculation.  */
1043           relocation -= sgot->output_section->vma;
1044
1045           break;
1046
1047         case R_386_GOTPC:
1048           /* Use global offset table as symbol value.  */
1049
1050           if (sgot == NULL)
1051             {
1052               sgot = bfd_get_section_by_name (dynobj, ".got");
1053               BFD_ASSERT (sgot != NULL);
1054             }
1055
1056           relocation = sgot->output_section->vma;
1057
1058           break;
1059
1060         case R_386_PLT32:
1061           /* Relocation is to the entry for this symbol in the
1062              procedure linkage table.  */
1063
1064           /* Resolve a PLT32 reloc again a local symbol directly,
1065              without using the procedure linkage table.  */
1066           if (h == NULL)
1067             break;
1068
1069           if (h->plt_offset == (bfd_vma) -1)
1070             {
1071               /* We didn't make a PLT entry for this symbol.  This
1072                  happens when statically linking PIC code.  */
1073               break;
1074             }
1075
1076           if (splt == NULL)
1077             {
1078               splt = bfd_get_section_by_name (dynobj, ".plt");
1079               BFD_ASSERT (splt != NULL);
1080             }
1081
1082           relocation = (splt->output_section->vma
1083                         + splt->output_offset
1084                         + h->plt_offset);
1085
1086           break;
1087
1088         case R_386_32:
1089         case R_386_PC32:
1090           if (info->shared
1091               && (input_section->flags & SEC_ALLOC) != 0
1092               && (r_type != R_386_PC32 || h != NULL))
1093             {
1094               Elf_Internal_Rel outrel;
1095
1096               /* When generating a shared object, these relocations
1097                  are copied into the output file to be resolved at run
1098                  time.  */
1099
1100               if (sreloc == NULL)
1101                 {
1102                   const char *name;
1103
1104                   name = (bfd_elf_string_from_elf_section
1105                           (input_bfd,
1106                            elf_elfheader (input_bfd)->e_shstrndx,
1107                            elf_section_data (input_section)->rel_hdr.sh_name));
1108                   if (name == NULL)
1109                     return false;
1110
1111                   BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1112                               && strcmp (bfd_get_section_name (input_bfd,
1113                                                                input_section),
1114                                          name + 4) == 0);
1115
1116                   sreloc = bfd_get_section_by_name (dynobj, name);
1117                   BFD_ASSERT (sreloc != NULL);
1118                 }
1119
1120               outrel.r_offset = (rel->r_offset
1121                                  + input_section->output_section->vma
1122                                  + input_section->output_offset);
1123               if (r_type == R_386_PC32)
1124                 {
1125                   BFD_ASSERT (h != NULL && h->dynindx != -1);
1126                   outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
1127                 }
1128               else
1129                 {
1130                   if (h == NULL)
1131                     outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1132                   else
1133                     {
1134                       BFD_ASSERT (h->dynindx != (bfd_vma) -1);
1135                       outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1136                     }
1137                 }
1138
1139               bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1140                                         (((Elf32_External_Rel *)
1141                                           sreloc->contents)
1142                                          + sreloc->reloc_count));
1143               ++sreloc->reloc_count;
1144
1145               /* If this reloc is against an external symbol, we do
1146                  not want to fiddle with the addend.  Otherwise, we
1147                  need to include the symbol value so that it becomes
1148                  an addend for the dynamic reloc.  */
1149               if (h != NULL)
1150                 continue;
1151             }
1152
1153           break;
1154
1155         default:
1156           break;
1157         }
1158
1159       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1160                                     contents, rel->r_offset,
1161                                     relocation, (bfd_vma) 0);
1162
1163       if (r != bfd_reloc_ok)
1164         {
1165           switch (r)
1166             {
1167             default:
1168             case bfd_reloc_outofrange:
1169               abort ();
1170             case bfd_reloc_overflow:
1171               {
1172                 const char *name;
1173
1174                 if (h != NULL)
1175                   name = h->root.root.string;
1176                 else
1177                   {
1178                     name = bfd_elf_string_from_elf_section (input_bfd,
1179                                                             symtab_hdr->sh_link,
1180                                                             sym->st_name);
1181                     if (name == NULL)
1182                       return false;
1183                     if (*name == '\0')
1184                       name = bfd_section_name (input_bfd, sec);
1185                   }
1186                 if (! ((*info->callbacks->reloc_overflow)
1187                        (info, name, howto->name, (bfd_vma) 0,
1188                         input_bfd, input_section, rel->r_offset)))
1189                   return false;
1190               }
1191               break;
1192             }
1193         }
1194     }
1195
1196   return true;
1197 }
1198
1199 /* Finish up dynamic symbol handling.  We set the contents of various
1200    dynamic sections here.  */
1201
1202 static boolean
1203 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1204      bfd *output_bfd;
1205      struct bfd_link_info *info;
1206      struct elf_link_hash_entry *h;
1207      Elf_Internal_Sym *sym;
1208 {
1209   bfd *dynobj;
1210
1211   dynobj = elf_hash_table (info)->dynobj;
1212
1213   if (h->plt_offset != (bfd_vma) -1)
1214     {
1215       asection *splt;
1216       asection *sgot;
1217       asection *srel;
1218       bfd_vma plt_index;
1219       bfd_vma got_offset;
1220       Elf_Internal_Rel rel;
1221
1222       /* This symbol has an entry in the procedure linkage table.  Set
1223          it up.  */
1224
1225       BFD_ASSERT (h->dynindx != -1);
1226
1227       splt = bfd_get_section_by_name (dynobj, ".plt");
1228       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1229       srel = bfd_get_section_by_name (dynobj, ".rel.plt");
1230       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1231
1232       /* Get the index in the procedure linkage table which
1233          corresponds to this symbol.  This is the index of this symbol
1234          in all the symbols for which we are making plt entries.  The
1235          first entry in the procedure linkage table is reserved.  */
1236       plt_index = h->plt_offset / PLT_ENTRY_SIZE - 1;
1237
1238       /* Get the offset into the .got table of the entry that
1239          corresponds to this function.  Each .got entry is 4 bytes.
1240          The first three are reserved.  */
1241       got_offset = (plt_index + 3) * 4;
1242
1243       /* Fill in the entry in the procedure linkage table.  */
1244       if (! info->shared)
1245         {
1246           memcpy (splt->contents + h->plt_offset, elf_i386_plt_entry,
1247                   PLT_ENTRY_SIZE);
1248           bfd_put_32 (output_bfd,
1249                       (sgot->output_section->vma
1250                        + sgot->output_offset
1251                        + got_offset),
1252                       splt->contents + h->plt_offset + 2);
1253         }
1254       else
1255         {
1256           memcpy (splt->contents + h->plt_offset, elf_i386_pic_plt_entry,
1257                   PLT_ENTRY_SIZE);
1258           bfd_put_32 (output_bfd, got_offset,
1259                       splt->contents + h->plt_offset + 2);
1260         }
1261
1262       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1263                   splt->contents + h->plt_offset + 7);
1264       bfd_put_32 (output_bfd, - (h->plt_offset + PLT_ENTRY_SIZE),
1265                   splt->contents + h->plt_offset + 12);
1266
1267       /* Fill in the entry in the global offset table.  */
1268       bfd_put_32 (output_bfd,
1269                   (splt->output_section->vma
1270                    + splt->output_offset
1271                    + h->plt_offset
1272                    + 6),
1273                   sgot->contents + got_offset);
1274
1275       /* Fill in the entry in the .rel.plt section.  */
1276       rel.r_offset = (sgot->output_section->vma
1277                       + sgot->output_offset
1278                       + got_offset);
1279       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1280       bfd_elf32_swap_reloc_out (output_bfd, &rel,
1281                                 ((Elf32_External_Rel *) srel->contents
1282                                  + plt_index));
1283
1284       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1285         {
1286           /* Mark the symbol as undefined, rather than as defined in
1287              the .plt section.  Leave the value alone.  */
1288           sym->st_shndx = SHN_UNDEF;
1289         }
1290     }
1291
1292   if (h->got_offset != (bfd_vma) -1)
1293     {
1294       asection *sgot;
1295       asection *srel;
1296       Elf_Internal_Rel rel;
1297
1298       /* This symbol has an entry in the global offset table.  Set it
1299          up.  */
1300
1301       BFD_ASSERT (h->dynindx != -1);
1302
1303       sgot = bfd_get_section_by_name (dynobj, ".got");
1304       srel = bfd_get_section_by_name (dynobj, ".rel.got");
1305       BFD_ASSERT (sgot != NULL && srel != NULL);
1306
1307       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset);
1308
1309       rel.r_offset = (sgot->output_section->vma
1310                       + sgot->output_offset
1311                       + h->got_offset);
1312       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1313       bfd_elf32_swap_reloc_out (output_bfd, &rel,
1314                                 ((Elf32_External_Rel *) srel->contents
1315                                  + srel->reloc_count));
1316       ++srel->reloc_count;
1317     }
1318
1319   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1320     {
1321       asection *s;
1322       Elf_Internal_Rel rel;
1323
1324       /* This symbol needs a copy reloc.  Set it up.  */
1325
1326       BFD_ASSERT (h->dynindx != -1
1327                   && (h->root.type == bfd_link_hash_defined
1328                       || h->root.type == bfd_link_hash_defweak));
1329
1330       s = bfd_get_section_by_name (h->root.u.def.section->owner,
1331                                    ".rel.bss");
1332       BFD_ASSERT (s != NULL);
1333
1334       rel.r_offset = (h->root.u.def.value
1335                       + h->root.u.def.section->output_section->vma
1336                       + h->root.u.def.section->output_offset);
1337       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
1338       bfd_elf32_swap_reloc_out (output_bfd, &rel,
1339                                 ((Elf32_External_Rel *) s->contents
1340                                  + s->reloc_count));
1341       ++s->reloc_count;
1342     }
1343
1344   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
1345   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1346       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1347     sym->st_shndx = SHN_ABS;
1348
1349   return true;
1350 }
1351
1352 /* Finish up the dynamic sections.  */
1353
1354 static boolean
1355 elf_i386_finish_dynamic_sections (output_bfd, info)
1356      bfd *output_bfd;
1357      struct bfd_link_info *info;
1358 {
1359   bfd *dynobj;
1360   asection *sgot;
1361   asection *sdyn;
1362
1363   dynobj = elf_hash_table (info)->dynobj;
1364
1365   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1366   BFD_ASSERT (sgot != NULL);
1367   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1368
1369   if (elf_hash_table (info)->dynamic_sections_created)
1370     {
1371       asection *splt;
1372       Elf32_External_Dyn *dyncon, *dynconend;
1373
1374       splt = bfd_get_section_by_name (dynobj, ".plt");
1375       BFD_ASSERT (splt != NULL && sdyn != NULL);
1376
1377       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1378       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1379       for (; dyncon < dynconend; dyncon++)
1380         {
1381           Elf_Internal_Dyn dyn;
1382           const char *name;
1383           asection *s;
1384
1385           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1386
1387           switch (dyn.d_tag)
1388             {
1389             default:
1390               break;
1391
1392             case DT_PLTGOT:
1393               name = ".got";
1394               goto get_vma;
1395             case DT_JMPREL:
1396               name = ".rel.plt";
1397             get_vma:
1398               s = bfd_get_section_by_name (output_bfd, name);
1399               BFD_ASSERT (s != NULL);
1400               dyn.d_un.d_ptr = s->vma;
1401               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1402               break;
1403
1404             case DT_PLTRELSZ:
1405               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1406               BFD_ASSERT (s != NULL);
1407               if (s->_cooked_size != 0)
1408                 dyn.d_un.d_val = s->_cooked_size;
1409               else
1410                 dyn.d_un.d_val = s->_raw_size;
1411               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1412               break;
1413
1414             case DT_RELSZ:
1415               /* My reading of the SVR4 ABI indicates that the
1416                  procedure linkage table relocs (DT_JMPREL) should be
1417                  included in the overall relocs (DT_REL).  This is
1418                  what Solaris does.  However, UnixWare can not handle
1419                  that case.  Therefore, we override the DT_RELSZ entry
1420                  here to make it not include the JMPREL relocs.  Since
1421                  the linker script arranges for .rel.plt to follow all
1422                  other relocation sections, we don't have to worry
1423                  about changing the DT_REL entry.  */
1424               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1425               if (s != NULL)
1426                 {
1427                   if (s->_cooked_size != 0)
1428                     dyn.d_un.d_val -= s->_cooked_size;
1429                   else
1430                     dyn.d_un.d_val -= s->_raw_size;
1431                 }
1432               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1433               break;
1434             }
1435         }
1436
1437       /* Fill in the first entry in the procedure linkage table.  */
1438       if (splt->_raw_size > 0)
1439         {
1440           if (info->shared)
1441             memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
1442           else
1443             {
1444               memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
1445               bfd_put_32 (output_bfd,
1446                           sgot->output_section->vma + sgot->output_offset + 4,
1447                           splt->contents + 2);
1448               bfd_put_32 (output_bfd,
1449                           sgot->output_section->vma + sgot->output_offset + 8,
1450                           splt->contents + 8);
1451             }
1452         }
1453
1454       /* UnixWare sets the entsize of .plt to 4, although that doesn't
1455          really seem like the right value.  */
1456       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
1457     }
1458
1459   /* Fill in the first three entries in the global offset table.  */
1460   if (sgot->_raw_size > 0)
1461     {
1462       if (sdyn == NULL)
1463         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1464       else
1465         bfd_put_32 (output_bfd,
1466                     sdyn->output_section->vma + sdyn->output_offset,
1467                     sgot->contents);
1468       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1469       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1470     }
1471
1472   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1473
1474   return true;
1475 }
1476
1477 #define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
1478 #define TARGET_LITTLE_NAME              "elf32-i386"
1479 #define ELF_ARCH                        bfd_arch_i386
1480 #define ELF_MACHINE_CODE                EM_386
1481 #define elf_info_to_howto               elf_i386_info_to_howto
1482 #define elf_info_to_howto_rel           elf_i386_info_to_howto_rel
1483 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
1484 #define ELF_MAXPAGESIZE                 0x1000
1485 #define elf_backend_create_dynamic_sections \
1486                                         _bfd_elf_create_dynamic_sections
1487 #define elf_backend_check_relocs        elf_i386_check_relocs
1488 #define elf_backend_adjust_dynamic_symbol \
1489                                         elf_i386_adjust_dynamic_symbol
1490 #define elf_backend_size_dynamic_sections \
1491                                         elf_i386_size_dynamic_sections
1492 #define elf_backend_relocate_section    elf_i386_relocate_section
1493 #define elf_backend_finish_dynamic_symbol \
1494                                         elf_i386_finish_dynamic_symbol
1495 #define elf_backend_finish_dynamic_sections \
1496                                         elf_i386_finish_dynamic_sections
1497 #define elf_backend_want_got_plt 1
1498 #define elf_backend_plt_readonly 0
1499 #define elf_backend_want_plt_sym 0
1500
1501 #include "elf32-target.h"