src/i386_ld.c

   1 /* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2008 Red Hat, Inc.
   2    This file is part of elfutils.
   3    Written by Ulrich Drepper <drepper@redhat.com>, 2001.
   4
   5    This file is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    elfutils is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #ifdef HAVE_CONFIG_H
  19 # include <config.h>
  20 #endif
  21
  22 #include <assert.h>
  23 #include <error.h>
  24 #include <libintl.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 // XXX For debugging
  29 #include <stdio.h>
  30
  31 #include <system.h>
  32 #include "ld.h"
  33 #include "list.h"
  34 /* x86 is little endian.  */
  35 #define UNALIGNED_ACCESS_CLASS LITTLE_ENDIAN
  36 #include "unaligned.h"
  37 #include "xelf.h"
  38
  39
  40 /* The old callbacks.  */
  41 static int (*old_open_outfile) (struct ld_state *, int, int, int);
  42
  43
  44 static int
  45 elf_i386_open_outfile (struct ld_state *statep,
  46                        int machine __attribute__ ((unused)),
  47                        int klass __attribute__ ((unused)),
  48                        int data __attribute__ ((unused)))
  49 {
  50   /* This backend only handles 32-bit object files.  */
  51   /* XXX For now just use the generic backend.  */
  52   return old_open_outfile (statep, EM_386, ELFCLASS32, ELFDATA2LSB);
  53 }
  54
  55
  56 /* Process relocations for the output in a relocatable file.  This
  57    only means adjusting offset and symbol indices.  */
  58 static void
  59 elf_i386_relocate_section (struct ld_state *statep __attribute__ ((unused)),
  60                            Elf_Scn *outscn, struct scninfo *firstp,
  61                            const Elf32_Word *dblindirect)
  62 {
  63   struct scninfo *runp;
  64   Elf_Data *data;
  65
  66   /* Iterate over all the input sections.  Appropriate data buffers in the
  67      output sections were already created.  */
  68   runp = firstp;
  69   data = NULL;
  70   do
  71     {
  72       Elf_Data *reltgtdata;
  73       Elf_Data *insymdata;
  74       Elf_Data *inxndxdata = NULL;
  75       size_t maxcnt;
  76       size_t cnt;
  77       const Elf32_Word *symindirect;
  78       struct symbol **symref;
  79       struct usedfiles *file = runp->fileinfo;
  80       XElf_Shdr *shdr = &SCNINFO_SHDR (runp->shdr);
  81
  82       /* Get the output section data buffer for this input section.  */
  83       data = elf_getdata (outscn, data);
  84       assert (data != NULL);
  85
  86       /* Get the data for section in the input file this relocation
  87          section is relocating.  Since these buffers are reused in the
  88          output modifying these buffers has the correct result.  */
  89       reltgtdata = elf_getdata (file->scninfo[shdr->sh_info].scn, NULL);
  90
  91       /* Get the data for the input section symbol table for this
  92          relocation section.  */
  93       insymdata = elf_getdata (file->scninfo[shdr->sh_link].scn, NULL);
  94       assert (insymdata != NULL);
  95
  96       /* And the extended section index table.  */
  97       inxndxdata = runp->fileinfo->xndxdata;
  98
  99       /* Number of relocations.  */
 100       maxcnt = shdr->sh_size / shdr->sh_entsize;
 101
 102       /* Array directing local symbol table offsets to output symbol
 103          table offsets.  */
 104       symindirect = file->symindirect;
 105
 106       /* References to the symbol records.  */
 107       symref = file->symref;
 108
 109       /* Iterate over all the relocations in the section.  */
 110       for (cnt = 0; cnt < maxcnt; ++cnt)
 111         {
 112           XElf_Rel_vardef (rel);
 113           Elf32_Word si;
 114           XElf_Sym_vardef (sym);
 115           Elf32_Word xndx;
 116
 117           /* Get the relocation data itself.  x86 uses Rel
 118              relocations.  In case we have to handle Rela as well the
 119              whole loop probably should be duplicated.  */
 120           xelf_getrel (data, cnt, rel);
 121           assert (rel != NULL);
 122
 123           /* Compute the symbol index in the output file.  */
 124           si = symindirect[XELF_R_SYM (rel->r_info)];
 125           if (si == 0)
 126             {
 127               /* This happens if the symbol is locally undefined or
 128                  superceded by some other definition.  */
 129               assert (symref[XELF_R_SYM (rel->r_info)] != NULL);
 130               si = symref[XELF_R_SYM (rel->r_info)]->outsymidx;
 131             }
 132           /* Take reordering performed to sort the symbol table into
 133              account.  */
 134           si = dblindirect[si];
 135
 136           /* Get the symbol table entry.  */
 137           xelf_getsymshndx (insymdata, inxndxdata, XELF_R_SYM (rel->r_info),
 138                             sym, xndx);
 139           if (sym->st_shndx != SHN_XINDEX)
 140             xndx = sym->st_shndx;
 141           assert (xndx < SHN_LORESERVE || xndx > SHN_HIRESERVE);
 142
 143           /* We fortunately don't have to do much.  The relocations
 144              mostly get only updates of the offset.  Only for a
 145              relocation referring to a section do we have to do
 146              something.  In this case the reference to the sections
 147              has no direct equivalent since the part the input section
 148              contributes need not start at the same offset as in the
 149              input file.  Therefore we have to adjust the addend which
 150              in the case of Rel relocations is in the target section
 151              itself.  */
 152           if (XELF_ST_TYPE (sym->st_info) == STT_SECTION)
 153             {
 154               /* We expect here only R_386_32 relocations.  */
 155               assert (XELF_R_TYPE (rel->r_info) == R_386_32);
 156
 157               /* Avoid writing to the section memory if this is
 158                  effectively a no-op since it might save a
 159                  copy-on-write operation.  */
 160               Elf32_Word toadd = file->scninfo[xndx].offset;
 161               if (toadd != 0)
 162                 add_4ubyte_unaligned (reltgtdata->d_buf + rel->r_offset,
 163                                       toadd);
 164             }
 165
 166           /* Adjust the offset for the position of the input section
 167              content in the output section.  */
 168           rel->r_offset += file->scninfo[shdr->sh_info].offset;
 169
 170           /* And finally adjust the index of the symbol in the output
 171              symbol table.  */
 172           rel->r_info = XELF_R_INFO (si, XELF_R_TYPE (rel->r_info));
 173
 174           /* Store the result.  */
 175           (void) xelf_update_rel (data, cnt, rel);
 176         }
 177
 178       runp = runp->next;
 179     }
 180   while (runp != firstp);
 181 }
 182
 183
 184 /* Each PLT entry has 16 bytes.  We need one entry as overhead for
 185    the code to set up the call into the runtime relocation.  */
 186 #define PLT_ENTRY_SIZE 16
 187
 188 static void
 189 elf_i386_initialize_plt (struct ld_state *statep, Elf_Scn *scn)
 190 {
 191   Elf_Data *data;
 192   XElf_Shdr_vardef (shdr);
 193
 194   /* Change the entry size in the section header.  */
 195   xelf_getshdr (scn, shdr);
 196   assert (shdr != NULL);
 197   shdr->sh_entsize = PLT_ENTRY_SIZE;
 198   (void) xelf_update_shdr (scn, shdr);
 199
 200   data = elf_newdata (scn);
 201   if (data == NULL)
 202     error (EXIT_FAILURE, 0, gettext ("cannot allocate PLT section: %s"),
 203            elf_errmsg (-1));
 204
 205   /* We need one special PLT entry (performing the jump to the runtime
 206      relocation routines) and one for each function we call in a DSO.  */
 207   data->d_size = (1 + statep->nplt) * PLT_ENTRY_SIZE;
 208   data->d_buf = xcalloc (1, data->d_size);
 209   assert (data->d_type == ELF_T_BYTE);
 210   data->d_off = 0;
 211   data->d_align = 8;
 212
 213   statep->nplt_used = 1;
 214 }
 215
 216
 217 static void
 218 elf_i386_initialize_pltrel (struct ld_state *statep, Elf_Scn *scn)
 219 {
 220   Elf_Data *data;
 221
 222   data = elf_newdata (scn);
 223   if (data == NULL)
 224     error (EXIT_FAILURE, 0, gettext ("cannot allocate PLTREL section: %s"),
 225            elf_errmsg (-1));
 226
 227   /* One relocation per PLT entry.  */
 228   size_t size = statep->nplt * sizeof (Elf32_Rel);
 229   data->d_buf = xcalloc (1, size);
 230   data->d_type = ELF_T_REL;
 231   data->d_size = size;
 232   data->d_align = 4;
 233   data->d_off = 0;
 234 }
 235
 236
 237 static void
 238 elf_i386_initialize_got (struct ld_state *statep, Elf_Scn *scn)
 239 {
 240   /* If we come here we better need a GOT.  */
 241   assert (statep->ngot != 0);
 242
 243   Elf_Data *data = elf_newdata (scn);
 244   if (data == NULL)
 245     error (EXIT_FAILURE, 0, gettext ("cannot allocate GOT section: %s"),
 246            elf_errmsg (-1));
 247
 248   /* Just a single word per GOT entry is needed.  */
 249   size_t size = statep->ngot * sizeof (Elf32_Addr);
 250   data->d_buf = xcalloc (1, size);
 251   data->d_size = size;
 252   data->d_type = ELF_T_WORD;
 253   data->d_off = 0;
 254   data->d_align = sizeof (Elf32_Addr);
 255 }
 256
 257
 258 static void
 259 elf_i386_initialize_gotplt (struct ld_state *statep, Elf_Scn *scn)
 260 {
 261   /* If we come here we better need a PLT.  */
 262   assert (statep->nplt != 0);
 263
 264   Elf_Data *data = elf_newdata (scn);
 265   if (data == NULL)
 266     error (EXIT_FAILURE, 0, gettext ("cannot allocate GOTPLT section: %s"),
 267            elf_errmsg (-1));
 268
 269   /* We construct the .got.plt section in pieces.  Here we only add the data
 270      structures which are used by the PLT.  This includes three reserved
 271      entries at the beginning (the first will contain a pointer to the
 272      .dynamic section), and one word for each PLT entry.  */
 273   size_t size = (3 + statep->nplt) * sizeof (Elf32_Addr);
 274   data->d_buf = xcalloc (1, size);
 275   data->d_type = ELF_T_WORD;
 276   data->d_size = size;
 277   data->d_off = 0;
 278   data->d_align = sizeof (Elf32_Addr);
 279 }
 280
 281
 282 /* The first entry in an absolute procedure linkage table looks like
 283    this.  See the SVR4 ABI i386 supplement to see how this works.  */
 284 static const unsigned char elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
 285 {
 286   0xff, 0x35,   /* pushl contents of address */
 287   0, 0, 0, 0,   /* replaced with address of .got + 4.  */
 288   0xff, 0x25,   /* jmp indirect */
 289   0, 0, 0, 0,   /* replaced with address of .got + 8.  */
 290   0x0f, 0x0b,   /* ud2a, to prevent further decoding.  */
 291   0, 0          /* pad out to 16 bytes.  */
 292 };
 293
 294 /* Type describing the first PLT entry in non-PIC.  */
 295 struct plt0_entry
 296 {
 297   /* First a 'push' of the second GOT entry.  */
 298   unsigned char push_instr[2];
 299   uint32_t gotp4_addr;
 300   /* Second, a 'jmp indirect' to the third GOT entry.  */
 301   unsigned char jmp_instr[2];
 302   uint32_t gotp8_addr;
 303   /* Padding.  */
 304   unsigned char padding[4];
 305 } __attribute__ ((packed));
 306
 307 /* The first entry in a PIC procedure linkage table look like this.  */
 308 static const unsigned char elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
 309 {
 310   0xff, 0xb3, 4, 0, 0, 0,       /* pushl 4(%ebx) */
 311   0xff, 0xa3, 8, 0, 0, 0,       /* jmp *8(%ebx) */
 312   0x0f, 0x0b,                   /* ud2a, to prevent further decoding.  */
 313   0, 0                          /* pad out to 16 bytes.  */
 314 };
 315
 316 /* Contents of all but the first PLT entry in executable.  */
 317 static const unsigned char elf_i386_plt_entry[PLT_ENTRY_SIZE] =
 318 {
 319   0xff, 0x25,   /* jmp indirect */
 320   0, 0, 0, 0,   /* replaced with address of this symbol in .got.  */
 321   0x68,         /* pushl immediate */
 322   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 323   0xe9,         /* jmp relative */
 324   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 325 };
 326
 327 /* Contents of all but the first PLT entry in DSOs.  */
 328 static const unsigned char elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
 329 {
 330   0xff, 0xa3,   /* jmp *offset(%ebx) */
 331   0, 0, 0, 0,   /* replaced with offset of this symbol in .got.  */
 332   0x68,         /* pushl immediate */
 333   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 334   0xe9,         /* jmp relative */
 335   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 336 };
 337
 338 /* Type describing a PLT entry.  */
 339 struct plt_entry
 340 {
 341   /* The first instruction is 'jmp indirect' or 'jmp *offset(%ebs)'.  */
 342   unsigned char jmp_instr[2];
 343   uint32_t offset_got;
 344   /* The second instruction is 'push immediate'.  */
 345   unsigned char push_instr;
 346   uint32_t push_imm;
 347   /* Finally a 'jmp relative'.  */
 348   unsigned char jmp_instr2;
 349   uint32_t plt0_offset;
 350 } __attribute__ ((packed));
 351
 352
 353 static void
 354 elf_i386_finalize_plt (struct ld_state *statep, size_t nsym,
 355                        size_t nsym_local, struct symbol **ndxtosym)
 356 {
 357   if (unlikely (statep->nplt + statep->ngot == 0))
 358     /* Nothing to be done.  */
 359     return;
 360
 361   Elf_Scn *scn;
 362   XElf_Shdr_vardef (shdr);
 363   Elf_Data *data;
 364   const bool build_dso = statep->file_type == dso_file_type;
 365
 366   /* Get the address of the .got.plt section.  */
 367   scn = elf_getscn (statep->outelf, statep->gotpltscnidx);
 368   xelf_getshdr (scn, shdr);
 369   data = elf_getdata (scn, NULL);
 370   assert (shdr != NULL && data != NULL);
 371   /* The address points to the .got.plt section, not the .got section.  */
 372   Elf32_Addr gotaddr = shdr->sh_addr;
 373
 374   /* Now create the initial values for the .got.plt section.  The
 375      first word contains the address of the .dynamic section.  The
 376      second and third entry are left empty for use by the dynamic
 377      linker.  The following entries are pointers to the instructions
 378      following the initial jmp instruction in the corresponding PLT
 379      entry.  */
 380   xelf_getshdr (elf_getscn (statep->outelf, statep->dynamicscnidx), shdr);
 381   assert (shdr != NULL);
 382   ((Elf32_Word *) data->d_buf)[0] = shdr->sh_addr;
 383
 384   /* The PLT contains code which a user of a function jumps to.  The first
 385      PLT entry is special, so the first used one has the index 1.  */
 386   scn = elf_getscn (statep->outelf, statep->pltscnidx);
 387   XElf_Shdr_vardef (pltshdr);
 388   xelf_getshdr (scn, pltshdr);
 389   assert (pltshdr != NULL);
 390
 391   Elf_Data *dynsymdata = elf_getdata (elf_getscn (statep->outelf,
 392                                                   statep->dynsymscnidx), NULL);
 393   assert (dynsymdata != NULL);
 394
 395   Elf_Data *symdata = NULL;
 396   if (statep->symscnidx != 0)
 397     {
 398       symdata = elf_getdata (elf_getscn (statep->outelf, statep->symscnidx),
 399                              NULL);
 400       assert (symdata != NULL);
 401     }
 402
 403   /* Create the .plt section.  */
 404   scn = elf_getscn (statep->outelf, statep->pltscnidx);
 405   Elf_Data *pltdata = elf_getdata (scn, NULL);
 406   assert (pltdata != NULL);
 407
 408   /* Also create the .rel.plt section data.  It simply means relocations
 409      addressing the corresponding entry in the .got.plt section.  The
 410      section name is misleading.  */
 411   scn = elf_getscn (statep->outelf, statep->pltrelscnidx);
 412   xelf_getshdr (scn, shdr);
 413   Elf_Data *reldata = elf_getdata (scn, NULL);
 414   assert (shdr != NULL && reldata != NULL);
 415
 416   /* Update the sh_link to point to the section being modified.  We
 417      point it here (correctly) to the .got.plt section.  Some linkers
 418      (e.g., the GNU binutils linker) point to the .plt section.  This
 419      is wrong since the .plt section isn't modified even though the
 420      name .rel.plt suggests that this is correct.  */
 421   shdr->sh_link = statep->dynsymscnidx;
 422   shdr->sh_info = statep->gotpltscnidx;
 423   (void) xelf_update_shdr (scn, shdr);
 424
 425   /* Create the first entry of the .plt section.  */
 426   assert (pltdata->d_size >= PLT_ENTRY_SIZE);
 427   if (build_dso)
 428     /* Copy the entry.  It's complete, no relocation needed.  */
 429     memcpy (pltdata->d_buf, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
 430   else
 431     {
 432       /* Copy the skeleton.  */
 433       memcpy (pltdata->d_buf, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
 434
 435       /* And fill in the addresses.  */
 436       struct plt0_entry *addr = (struct plt0_entry *) pltdata->d_buf;
 437       addr->gotp4_addr = target_bswap_32 (gotaddr + 4);
 438       addr->gotp8_addr = target_bswap_32 (gotaddr + 8);
 439     }
 440
 441   /* For DSOs we need GOT offsets, otherwise the GOT address.  */
 442   Elf32_Addr gotaddr_off = build_dso ? 0 : gotaddr;
 443
 444   /* Create the remaining entries.  */
 445   const unsigned char *plt_template
 446     = build_dso ? elf_i386_pic_plt_entry : elf_i386_plt_entry;
 447
 448   for (size_t idx = nsym_local; idx < nsym; ++idx)
 449     {
 450       struct symbol *symbol = ndxtosym[idx];
 451       if (symbol == NULL || symbol->type != STT_FUNC
 452           || ndxtosym[idx]->outdynsymidx == 0
 453           // XXX is the following test correct?
 454           || ! ndxtosym[idx]->in_dso)
 455         continue;
 456
 457       size_t pltidx = symbol->merge.value;
 458
 459       assert (pltidx > 0);
 460       assert ((3 + pltidx) * sizeof (Elf32_Word) <= data->d_size);
 461
 462       /* Address in the PLT.  */
 463       Elf32_Addr pltentryaddr = (pltshdr->sh_addr + pltidx * PLT_ENTRY_SIZE);
 464
 465       /* Point the GOT entry at the PLT entry, after the initial jmp.  */
 466       ((Elf32_Word *) data->d_buf)[2 + pltidx] = pltentryaddr + 6;
 467
 468       /* If the symbol is defined, adjust the address.  */
 469       if (((Elf32_Sym *) dynsymdata->d_buf)[ndxtosym[idx]->outdynsymidx].st_shndx != SHN_UNDEF)
 470         {
 471           /* The value of the symbol is the address of the corresponding PLT
 472              entry.  Store the address, also for the normal symbol table if
 473              this is necessary.  */
 474           ((Elf32_Sym *) dynsymdata->d_buf)[pltidx].st_value = pltentryaddr;
 475
 476           if (symdata != NULL)
 477  {
 478    assert(nsym - statep->nplt + (pltidx - 1) == idx);
 479             ((Elf32_Sym *) symdata->d_buf)[nsym - statep->nplt
 480                                            + (pltidx - 1)].st_value
 481               = pltentryaddr;
 482  }
 483         }
 484
 485       /* Copy the PLT entry template.  */
 486       assert (pltdata->d_size >= (1 + pltidx) * PLT_ENTRY_SIZE);
 487       struct plt_entry *addr = (struct plt_entry *) ((char *) pltdata->d_buf
 488                                                      + (pltidx
 489                                                         * PLT_ENTRY_SIZE));
 490       memcpy (addr, plt_template, PLT_ENTRY_SIZE);
 491
 492       /* And once more, fill in the addresses.  First the address of
 493          this symbol in .got.  */
 494       addr->offset_got = target_bswap_32 (gotaddr_off
 495                                           + (2 + pltidx) * sizeof (Elf32_Addr));
 496       /* Offset into relocation table.  */
 497       addr->push_imm = target_bswap_32 ((pltidx - 1) * sizeof (Elf32_Rel));
 498       /* Offset to start of .plt.  */
 499       addr->plt0_offset = target_bswap_32 (-(1 + pltidx) * PLT_ENTRY_SIZE);
 500
 501
 502       XElf_Rel_vardef (rel);
 503       assert (pltidx * sizeof (Elf32_Rel) <= reldata->d_size);
 504       xelf_getrel_ptr (reldata, pltidx - 1, rel);
 505       rel->r_offset = gotaddr + (2 + pltidx) * sizeof (Elf32_Addr);
 506       /* The symbol table entries for the functions from DSOs are at
 507          the beginning of the symbol table.  */
 508       rel->r_info = XELF_R_INFO (ndxtosym[idx]->outdynsymidx, R_386_JMP_SLOT);
 509       (void) xelf_update_rel (reldata, pltidx - 1, rel);
 510     }
 511 }
 512
 513
 514 static int
 515 elf_i386_rel_type (struct ld_state *statep __attribute__ ((__unused__)))
 516 {
 517   /* ELF/i386 uses REL.  */
 518   return DT_REL;
 519 }
 520
 521
 522 static void
 523 elf_i386_count_relocations (struct ld_state *statep, struct scninfo *scninfo)
 524 {
 525   /* We go through the list of input sections and count those relocations
 526      which are not handled by the linker.  At the same time we have to
 527      see how many GOT entries we need and how much .bss space is needed
 528      for copy relocations.  */
 529   Elf_Data *data = elf_getdata (scninfo->scn, NULL);
 530   XElf_Shdr *shdr = &SCNINFO_SHDR (scninfo->shdr);
 531   size_t maxcnt = shdr->sh_size / shdr->sh_entsize;
 532   size_t relsize = 0;
 533   size_t cnt;
 534   struct symbol *sym;
 535
 536   assert (shdr->sh_type == SHT_REL);
 537
 538   for (cnt = 0; cnt < maxcnt; ++cnt)
 539     {
 540       XElf_Rel_vardef (rel);
 541
 542       xelf_getrel (data, cnt, rel);
 543       /* XXX Should we complain about failing accesses?  */
 544       if (rel != NULL)
 545         {
 546           Elf32_Word r_sym = XELF_R_SYM (rel->r_info);
 547
 548           /* Symbols in COMDAT group sections which are discarded do
 549              not have to be relocated.  */
 550           if (r_sym >= scninfo->fileinfo->nlocalsymbols
 551               && unlikely (scninfo->fileinfo->symref[r_sym] == NULL))
 552             continue;
 553
 554           switch (XELF_R_TYPE (rel->r_info))
 555             {
 556             case R_386_GOT32:
 557               if (! scninfo->fileinfo->symref[r_sym]->defined
 558                   || scninfo->fileinfo->symref[r_sym]->in_dso
 559                   || statep->file_type == dso_file_type)
 560                 {
 561                   relsize += sizeof (Elf32_Rel);
 562                   ++statep->nrel_got;
 563                 }
 564
 565               /* Even if this relocation is not emitted in the output
 566                  file it requires a GOT entry.  */
 567               ++statep->ngot;
 568
 569               /* FALLTHROUGH */
 570
 571             case R_386_GOTOFF:
 572             case R_386_GOTPC:
 573               statep->need_got = true;
 574               break;
 575
 576             case R_386_32:
 577             case R_386_PC32:
 578               /* These relocations cause text relocations in DSOs.  */
 579               if (linked_from_dso_p (scninfo, r_sym))
 580                 {
 581                   if (statep->file_type == dso_file_type)
 582                     {
 583                       relsize += sizeof (Elf32_Rel);
 584                       // XXX Do we have to check whether the target
 585                       // XXX section is read-only first?
 586                       statep->dt_flags |= DF_TEXTREL;
 587                     }
 588                   else
 589                     {
 590                       /* Non-function objects from a DSO need to get a
 591                          copy relocation.  */
 592                       sym = scninfo->fileinfo->symref[r_sym];
 593
 594                       /* Only do this if we have not requested a copy
 595                          relocation already.  */
 596                       if (unlikely (sym->type != STT_FUNC) && ! sym->need_copy)
 597                         {
 598                           sym->need_copy = 1;
 599                           ++statep->ncopy;
 600                           relsize += sizeof (Elf32_Rel);
 601                         }
 602                     }
 603                 }
 604               else if (statep->file_type == dso_file_type
 605                        && XELF_R_TYPE (rel->r_info) == R_386_32)
 606                 relsize += sizeof (Elf32_Rel);
 607
 608               break;
 609
 610             case R_386_PLT32:
 611               /* We might need a PLT entry.  But we cannot say for sure
 612                  here since one of the symbols might turn up being
 613                  defined in the executable (if we create such a thing).
 614                  If a DSO is created we still might use a local
 615                  definition.
 616
 617                  If the symbol is not defined and we are not creating
 618                  a statically linked binary, then we need in any case
 619                  a PLT entry.  */
 620               if (! scninfo->fileinfo->symref[r_sym]->defined
 621                   && !statep->statically)
 622                 {
 623                   sym = scninfo->fileinfo->symref[r_sym];
 624                   sym->type = STT_FUNC;
 625                   sym->in_dso = 1;
 626                   sym->defined = 1;
 627
 628                   /* Remove from the list of unresolved symbols.  */
 629                   --statep->nunresolved;
 630                   if (! sym->weak)
 631                     --statep->nunresolved_nonweak;
 632                   CDBL_LIST_DEL (statep->unresolved, sym);
 633
 634                   /* Add to the list of symbols we expect from a DSO.  */
 635                   ++statep->nplt;
 636                   ++statep->nfrom_dso;
 637                   CDBL_LIST_ADD_REAR (statep->from_dso, sym);
 638                 }
 639               break;
 640
 641             case R_386_TLS_LDO_32:
 642               if (statep->file_type != executable_file_type)
 643                 abort ();
 644               /* We do not need a relocation in the output file.  */
 645               break;
 646
 647             case R_386_TLS_LE:
 648               /* We never need a relocation in the output file.  */
 649               break;
 650
 651             case R_386_TLS_IE:
 652               if (statep->file_type == dso_file_type)
 653                 error (EXIT_FAILURE, 0, gettext ("initial-executable TLS relocation cannot be used "));
 654               if (!scninfo->fileinfo->symref[r_sym]->defined
 655                   || scninfo->fileinfo->symref[r_sym]->in_dso)
 656                 {
 657                   abort ();
 658                 }
 659               break;
 660
 661             case R_386_TLS_GD:
 662               if (statep->file_type != executable_file_type
 663                   || !scninfo->fileinfo->symref[r_sym]->defined
 664                   || scninfo->fileinfo->symref[r_sym]->in_dso)
 665                 {
 666                   abort ();
 667                 }
 668               break;
 669
 670             case R_386_TLS_GOTIE:
 671             case R_386_TLS_LDM:
 672             case R_386_TLS_GD_32:
 673             case R_386_TLS_GD_PUSH:
 674             case R_386_TLS_GD_CALL:
 675             case R_386_TLS_GD_POP:
 676             case R_386_TLS_LDM_32:
 677             case R_386_TLS_LDM_PUSH:
 678             case R_386_TLS_LDM_CALL:
 679             case R_386_TLS_LDM_POP:
 680             case R_386_TLS_IE_32:
 681             case R_386_TLS_LE_32:
 682               /* XXX */
 683               abort ();
 684               break;
 685
 686             case R_386_NONE:
 687               /* Nothing to be done.  */
 688               break;
 689
 690               /* These relocation should never be generated by an
 691                  assembler.  */
 692             case R_386_COPY:
 693             case R_386_GLOB_DAT:
 694             case R_386_JMP_SLOT:
 695             case R_386_RELATIVE:
 696             case R_386_TLS_DTPMOD32:
 697             case R_386_TLS_DTPOFF32:
 698             case R_386_TLS_TPOFF32:
 699               /* Unknown relocation.  */
 700             default:
 701               abort ();
 702             }
 703         }
 704     }
 705
 706   scninfo->relsize = relsize;
 707 }
 708
 709
 710 static void
 711 elf_i386_create_relocations (struct ld_state *statep,
 712                              const Elf32_Word *dblindirect __attribute__ ((unused)))
 713 {
 714   /* Get the address of the got section.  */
 715   Elf_Scn *pltscn = elf_getscn (statep->outelf, statep->pltscnidx);
 716   Elf32_Shdr *shdr = elf32_getshdr (pltscn);
 717   assert (shdr != NULL);
 718   Elf32_Addr pltaddr = shdr->sh_addr;
 719
 720   Elf_Scn *gotscn = elf_getscn (statep->outelf, statep->gotscnidx);
 721   // XXX Adjust the address, if necessary, for relro
 722   Elf_Data *gotdata = NULL;
 723   if (statep->need_got)
 724     {
 725       gotdata = elf_getdata (gotscn, NULL);
 726       assert (gotdata != NULL);
 727     }
 728
 729   Elf_Scn *gotpltscn = elf_getscn (statep->outelf, statep->gotpltscnidx);
 730   shdr = elf32_getshdr (gotpltscn);
 731   assert (shdr != NULL);
 732   Elf32_Addr gotaddr = shdr->sh_addr;
 733
 734   Elf_Scn *reldynscn = elf_getscn (statep->outelf, statep->reldynscnidx);
 735   Elf_Data *reldyndata = elf_getdata (reldynscn, NULL);
 736   assert (reldyndata != NULL);
 737
 738   size_t nreldyn = 0;
 739   size_t ngotconst = statep->nrel_got;
 740
 741   struct scninfo *first = statep->rellist->next;
 742   struct scninfo *runp = first;
 743   do
 744     {
 745       XElf_Shdr *rshdr = &SCNINFO_SHDR (runp->shdr);
 746       Elf_Data *reldata = elf_getdata (runp->scn, NULL);
 747       int nrels = rshdr->sh_size / rshdr->sh_entsize;
 748
 749       /* We will need the following values a couple of times.  Help
 750          the compiler and improve readability.  */
 751       struct symbol **symref = runp->fileinfo->symref;
 752       struct scninfo *scninfo = runp->fileinfo->scninfo;
 753
 754       /* This is the offset of the input section we are looking at in
 755          the output file.  */
 756       XElf_Addr inscnoffset = scninfo[rshdr->sh_info].offset;
 757
 758       /* The target section.  We use the data from the input file.  */
 759       Elf_Data *data = elf_getdata (scninfo[rshdr->sh_info].scn, NULL);
 760
 761       /* We cannot handle relocations against merge-able sections.  */
 762       assert ((SCNINFO_SHDR (scninfo[rshdr->sh_link].shdr).sh_flags
 763                & SHF_MERGE) == 0);
 764
 765       /* Cache the access to the symbol table data.  */
 766       Elf_Data *symdata = elf_getdata (scninfo[rshdr->sh_link].scn, NULL);
 767
 768       for (int cnt = 0; cnt < nrels; ++cnt)
 769         {
 770           XElf_Rel_vardef (rel);
 771           XElf_Rel *rel2;
 772           xelf_getrel (reldata, cnt, rel);
 773           assert (rel != NULL);
 774           XElf_Addr reladdr = inscnoffset + rel->r_offset;
 775           XElf_Addr value;
 776
 777           size_t idx = XELF_R_SYM (rel->r_info);
 778           if (idx < runp->fileinfo->nlocalsymbols)
 779             {
 780               XElf_Sym_vardef (sym);
 781               xelf_getsym (symdata, idx, sym);
 782
 783               /* The value only depends on the position of the referenced
 784                  section in the output file and the addend.  */
 785               value = scninfo[sym->st_shndx].offset + sym->st_value;
 786             }
 787           else
 788             {
 789               if (symref[idx] == NULL)
 790                 /* Symbol in ignored COMDAT group section.  */
 791                 continue;
 792
 793               value = symref[idx]->merge.value;
 794               if (symref[idx]->in_dso)
 795                 {
 796                   /* MERGE.VALUE contains the PLT index.  If this is not for
 797                      a function the actual value will be computed later.  */
 798                   assert (value != 0 || symref[idx]->type != STT_FUNC);
 799                   value = pltaddr + value * PLT_ENTRY_SIZE;
 800                 }
 801             }
 802
 803           /* Address of the relocated memory in the data buffer.  */
 804           unsigned char *relloc = (unsigned char *) data->d_buf + rel->r_offset;
 805
 806           uint32_t thisgotidx;
 807           switch (XELF_R_TYPE (rel->r_info))
 808             {
 809               /* These three cases can be handled together since the
 810                  symbol associated with the R_386_GOTPC relocation is
 811                  _GLOBAL_OFFSET_TABLE_ which has a value corresponding
 812                  to the address of the GOT and the address of the PLT
 813                  entry required for R_386_PLT32 is computed above.  */
 814             case R_386_PC32:
 815             case R_386_GOTPC:
 816             case R_386_PLT32:
 817               value -= reladdr;
 818               /* FALLTHROUGH */
 819
 820             case R_386_32:
 821               if (linked_from_dso_p (scninfo, idx)
 822                   && statep->file_type != dso_file_type
 823                   && symref[idx]->type != STT_FUNC)
 824                 {
 825                   value = (ld_state.copy_section->offset
 826                            + symref[idx]->merge.value);
 827
 828                   if (unlikely (symref[idx]->need_copy))
 829                     {
 830                       /* Add a relocation to initialize the GOT entry.  */
 831                       assert (symref[idx]->outdynsymidx != 0);
 832 #if NATIVE_ELF != 0
 833                       xelf_getrel_ptr (reldyndata, nreldyn, rel2);
 834 #else
 835                       rel2 = &rel_mem;
 836 #endif
 837                       rel2->r_offset = value;
 838                       rel2->r_info
 839                         = XELF_R_INFO (symref[idx]->outdynsymidx, R_386_COPY);
 840                       (void) xelf_update_rel (reldyndata, nreldyn, rel2);
 841                       ++nreldyn;
 842                       assert (nreldyn <= statep->nrel_got);
 843
 844                       /* Update the symbol table record for the new
 845                          address.  */
 846                       Elf32_Word symidx = symref[idx]->outdynsymidx;
 847                       Elf_Scn *symscn = elf_getscn (statep->outelf,
 848                                                     statep->dynsymscnidx);
 849                       Elf_Data *outsymdata = elf_getdata (symscn, NULL);
 850                       assert (outsymdata != NULL);
 851                       XElf_Sym_vardef (sym);
 852                       xelf_getsym (outsymdata, symidx, sym);
 853                       sym->st_value = value;
 854                       sym->st_shndx = statep->copy_section->outscnndx;
 855                       (void) xelf_update_sym (outsymdata, symidx, sym);
 856
 857                       symidx = symref[idx]->outsymidx;
 858                       if (symidx != 0)
 859                         {
 860                           symidx = statep->dblindirect[symidx];
 861                           symscn = elf_getscn (statep->outelf,
 862                                                statep->symscnidx);
 863                           outsymdata = elf_getdata (symscn, NULL);
 864                           assert (outsymdata != NULL);
 865                           xelf_getsym (outsymdata, symidx, sym);
 866                           sym->st_value = value;
 867                           sym->st_shndx = statep->copy_section->outscnndx;
 868                           (void) xelf_update_sym (outsymdata, symidx, sym);
 869                         }
 870
 871                       /* Remember that we set up the copy relocation.  */
 872                       symref[idx]->need_copy = 0;
 873                     }
 874                 }
 875               else if (statep->file_type == dso_file_type
 876                        && XELF_R_TYPE (rel->r_info) == R_386_32)
 877                 {
 878 #if NATIVE_ELF != 0
 879                   xelf_getrel_ptr (reldyndata, nreldyn, rel2);
 880 #else
 881                   rel2 = &rel_mem;
 882 #endif
 883                   rel2->r_offset = value;
 884
 885                   /* For symbols we do not export we generate a relative
 886                      relocation.  */
 887                   if (idx < SCNINFO_SHDR (scninfo[rshdr->sh_link].shdr).sh_info
 888                       || symref[idx]->outdynsymidx == 0)
 889                     rel2->r_info = XELF_R_INFO (0, R_386_RELATIVE);
 890                   else
 891                     rel2->r_info
 892                       = XELF_R_INFO (symref[idx]->outdynsymidx, R_386_32);
 893                   (void) xelf_update_rel (reldyndata, nreldyn, rel2);
 894                   ++nreldyn;
 895                   assert (nreldyn <= statep->nrel_got);
 896
 897                   value = 0;
 898                 }
 899               add_4ubyte_unaligned (relloc, value);
 900               break;
 901
 902             case R_386_GOT32:
 903               if (! symref[idx]->defined || symref[idx]->in_dso)
 904                 {
 905                   thisgotidx = nreldyn++;
 906                   assert (thisgotidx < statep->nrel_got);
 907
 908                   /* Add a relocation to initialize the GOT entry.  */
 909 #if NATIVE_ELF != 0
 910                   xelf_getrel_ptr (reldyndata, thisgotidx, rel2);
 911 #else
 912                   rel2 = &rel_mem;
 913 #endif
 914                   rel2->r_offset = gotaddr + ((thisgotidx - statep->ngot)
 915                                               * sizeof (Elf32_Addr));
 916                   rel2->r_info
 917                     = XELF_R_INFO (symref[idx]->outdynsymidx, R_386_GLOB_DAT);
 918                   (void) xelf_update_rel (reldyndata, thisgotidx, rel2);
 919                 }
 920               else if (statep->file_type != dso_file_type)
 921                 {
 922                   thisgotidx = ngotconst++;
 923                   assert (thisgotidx < statep->ngot);
 924
 925                   /* We have to use a GOT since the generated code
 926                      requires it but we know the address and therefore
 927                      do not need a relocation.  */
 928                   ((uint32_t *) gotdata->d_buf)[thisgotidx] = value;
 929                 }
 930               else
 931                 {
 932                   thisgotidx = nreldyn++;
 933                   assert (thisgotidx < statep->nrel_got);
 934
 935                   // XXX generate a relative relocation.
 936                   abort ();
 937                 }
 938
 939               store_4ubyte_unaligned (relloc,
 940                                       (thisgotidx - statep->ngot)
 941                                       * sizeof (Elf32_Addr));
 942               break;
 943
 944             case R_386_GOTOFF:
 945               add_4ubyte_unaligned (relloc, value - gotaddr);
 946               break;
 947
 948             case R_386_TLS_LE:
 949               value = symref[idx]->merge.value - ld_state.tls_tcb;
 950               store_4ubyte_unaligned (relloc, value);
 951               break;
 952
 953             case R_386_TLS_IE:
 954               if (symref[idx]->defined && !symref[idx]->in_dso)
 955                 {
 956                   /* The symbol is defined in the executable.
 957                      Perform the IE->LE optimization.
 958                      There are multiple versions, though.
 959
 960                      First version: mov ADDR,REG.  */
 961                   if (relloc[-2] == 0x8b
 962                       && ((relloc[-1] & 0xc7) == 0x05))
 963                     {
 964                       relloc[-2] = 0xc7;
 965                       relloc[-1] = 0xc0 | ((relloc[-1] >> 3) & 7);
 966                       store_4ubyte_unaligned (relloc, (symref[idx]->merge.value
 967                                                        - ld_state.tls_tcb));
 968                     }
 969                   else
 970                     {
 971                       abort ();
 972                     }
 973                 }
 974               else
 975                 {
 976                   abort ();
 977                 }
 978               break;
 979
 980             case R_386_TLS_LDO_32:
 981               value = symref[idx]->merge.value - ld_state.tls_start;
 982               store_4ubyte_unaligned (relloc, value);
 983               break;
 984
 985             case R_386_TLS_GD:
 986               if (ld_state.file_type == executable_file_type)
 987                 {
 988                   if (symref[idx]->defined && !symref[idx]->in_dso)
 989                     {
 990                       /* The symbol is defined in the executable.
 991                          Perform the GD->LE optimization.  */
 992                       static const char gd_to_le[] =
 993                         {
 994                           /* mov %gs:0x0,%eax */
 995                           0x65, 0xa1, 0x00, 0x00, 0x00, 0x00,
 996                           /* sub $OFFSET,%eax */
 997                           0x81, 0xe8
 998                         };
 999 #ifndef NDEBUG
1000                       static const char gd_text[] =
1001                         {
1002                           /* lea 0x0(,%ebx,1),%eax */
1003                           0x8d, 0x04, 0x1d, 0x00, 0x00, 0x00, 0x00,
1004                           /* call ___tls_get_addr */
1005                           0xe8
1006                         };
1007                       assert (memcmp (relloc - 3, gd_text, sizeof (gd_text))
1008                               == 0);
1009 #endif
1010                       relloc = mempcpy (relloc - 3, gd_to_le,
1011                                         sizeof (gd_to_le));
1012                       value = ld_state.tls_tcb- symref[idx]->merge.value;
1013                       store_4ubyte_unaligned (relloc, value);
1014
1015                       /* We have to skip over the next relocation which is
1016                          the matching R_i386_PLT32 for __tls_get_addr.  */
1017                       ++cnt;
1018 #ifndef NDEBUG
1019                       assert (cnt < nrels);
1020                       XElf_Off old_offset = rel->r_offset;
1021                       xelf_getrel (reldata, cnt, rel);
1022                       assert (rel != NULL);
1023                       assert (XELF_R_TYPE (rel->r_info) == R_386_PLT32);
1024                       idx = XELF_R_SYM (rel->r_info);
1025                       assert (strcmp (symref[idx]->name, "___tls_get_addr")
1026                               == 0);
1027                       assert (old_offset + 5 == rel->r_offset);
1028 #endif
1029
1030                       break;
1031                     }
1032                 }
1033               abort ();
1034               break;
1035
1036             case R_386_32PLT:
1037             case R_386_TLS_TPOFF:
1038             case R_386_TLS_GOTIE:
1039             case R_386_TLS_LDM:
1040             case R_386_16:
1041             case R_386_PC16:
1042             case R_386_8:
1043             case R_386_PC8:
1044             case R_386_TLS_GD_32:
1045             case R_386_TLS_GD_PUSH:
1046             case R_386_TLS_GD_CALL:
1047             case R_386_TLS_GD_POP:
1048             case R_386_TLS_LDM_32:
1049             case R_386_TLS_LDM_PUSH:
1050             case R_386_TLS_LDM_CALL:
1051             case R_386_TLS_LDM_POP:
1052             case R_386_TLS_IE_32:
1053             case R_386_TLS_LE_32:
1054               // XXX For now fall through
1055               break;
1056
1057             case R_386_NONE:
1058               /* Nothing to do.  */
1059               break;
1060
1061             case R_386_COPY:
1062             case R_386_JMP_SLOT:
1063             case R_386_RELATIVE:
1064             case R_386_GLOB_DAT:
1065             case R_386_TLS_DTPMOD32:
1066             case R_386_TLS_DTPOFF32:
1067             case R_386_TLS_TPOFF32:
1068             default:
1069               /* Should not happen.  */
1070               abort ();
1071             }
1072         }
1073     }
1074   while ((runp = runp->next) != first);
1075 }
1076
1077
1078 int
1079 elf_i386_ld_init (struct ld_state *statep)
1080 {
1081   /* We have a few callbacks available.  */
1082   old_open_outfile = statep->callbacks.open_outfile;
1083   statep->callbacks.open_outfile = elf_i386_open_outfile;
1084
1085   statep->callbacks.relocate_section  = elf_i386_relocate_section;
1086
1087   statep->callbacks.initialize_plt = elf_i386_initialize_plt;
1088   statep->callbacks.initialize_pltrel = elf_i386_initialize_pltrel;
1089
1090   statep->callbacks.initialize_got = elf_i386_initialize_got;
1091   statep->callbacks.initialize_gotplt = elf_i386_initialize_gotplt;
1092
1093   statep->callbacks.finalize_plt = elf_i386_finalize_plt;
1094
1095   statep->callbacks.rel_type = elf_i386_rel_type;
1096
1097   statep->callbacks.count_relocations = elf_i386_count_relocations;
1098
1099   statep->callbacks.create_relocations = elf_i386_create_relocations;
1100
1101   return 0;
1102 }