src/unexelf.c

   1 /* Copyright (C) 1985-1988, 1990, 1992, 1999-2018 Free Software
   2    Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs 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 3 of the License, or (at
   9 your option) any later version.
  10
  11 GNU Emacs 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 GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
  18
  19 /*
  20 In other words, you are welcome to use, share and improve this program.
  21 You are forbidden to forbid anyone else to use, share and improve
  22 what you give them.   Help stamp out software-hoarding!  */
  23
  24
  25 /*
  26  * unexec.c - Convert a running program into an a.out file.
  27  *
  28  * Author:      Spencer W. Thomas
  29  *              Computer Science Dept.
  30  *              University of Utah
  31  * Date:        Tue Mar  2 1982
  32  * Modified heavily since then.
  33  *
  34  * Synopsis:
  35  *      unexec (const char *new_name, const char *old_name);
  36  *
  37  * Takes a snapshot of the program and makes an a.out format file in the
  38  * file named by the string argument new_name.
  39  * If old_name is non-NULL, the symbol table will be taken from the given file.
  40  * On some machines, an existing old_name file is required.
  41  *
  42  */
  43 \f
  44 /* We do not use mmap because that fails with NFS.
  45    Instead we read the whole file, modify it, and write it out.  */
  46
  47 #include <config.h>
  48 #include "unexec.h"
  49 #include "lisp.h"
  50
  51 #include <errno.h>
  52 #include <fcntl.h>
  53 #include <limits.h>
  54 #include <memory.h>
  55 #include <stdint.h>
  56 #include <stdio.h>
  57 #include <sys/stat.h>
  58 #include <sys/types.h>
  59 #include <unistd.h>
  60
  61 #ifdef __QNX__
  62 # include <sys/elf.h>
  63 #elif !defined __NetBSD__ && !defined __OpenBSD__
  64 # include <elf.h>
  65 #endif
  66 #include <sys/mman.h>
  67 #if defined (_SYSTYPE_SYSV)
  68 #include <sys/elf_mips.h>
  69 #include <sym.h>
  70 #endif /* _SYSTYPE_SYSV */
  71
  72 #ifndef MAP_ANON
  73 #ifdef MAP_ANONYMOUS
  74 #define MAP_ANON MAP_ANONYMOUS
  75 #else
  76 #define MAP_ANON 0
  77 #endif
  78 #endif
  79
  80 #ifndef MAP_FAILED
  81 #define MAP_FAILED ((void *) -1)
  82 #endif
  83
  84 #if defined (__alpha__) && !defined (__NetBSD__) && !defined (__OpenBSD__)
  85 /* Declare COFF debugging symbol table.  This used to be in
  86    /usr/include/sym.h, but this file is no longer included in Red Hat
  87    5.0 and presumably in any other glibc 2.x based distribution.  */
  88 typedef struct {
  89         short magic;
  90         short vstamp;
  91         int ilineMax;
  92         int idnMax;
  93         int ipdMax;
  94         int isymMax;
  95         int ioptMax;
  96         int iauxMax;
  97         int issMax;
  98         int issExtMax;
  99         int ifdMax;
 100         int crfd;
 101         int iextMax;
 102         long cbLine;
 103         long cbLineOffset;
 104         long cbDnOffset;
 105         long cbPdOffset;
 106         long cbSymOffset;
 107         long cbOptOffset;
 108         long cbAuxOffset;
 109         long cbSsOffset;
 110         long cbSsExtOffset;
 111         long cbFdOffset;
 112         long cbRfdOffset;
 113         long cbExtOffset;
 114 } HDRR, *pHDRR;
 115 #define cbHDRR sizeof (HDRR)
 116 #define hdrNil ((pHDRR)0)
 117 #endif
 118
 119 #ifdef __NetBSD__
 120 /*
 121  * NetBSD does not have normal-looking user-land ELF support.
 122  */
 123 # if defined __alpha__ || defined __sparc_v9__ || defined _LP64
 124 #  define ELFSIZE       64
 125 # else
 126 #  define ELFSIZE       32
 127 # endif
 128 # include <sys/exec_elf.h>
 129
 130 # ifndef PT_LOAD
 131 #  define PT_LOAD       Elf_pt_load
 132 #  if 0                                         /* was in pkgsrc patches for 20.7 */
 133 #   define SHT_PROGBITS Elf_sht_progbits
 134 #  endif
 135 #  define SHT_SYMTAB    Elf_sht_symtab
 136 #  define SHT_DYNSYM    Elf_sht_dynsym
 137 #  define SHT_NULL      Elf_sht_null
 138 #  define SHT_NOBITS    Elf_sht_nobits
 139 #  define SHT_REL       Elf_sht_rel
 140 #  define SHT_RELA      Elf_sht_rela
 141
 142 #  define SHN_UNDEF     Elf_eshn_undefined
 143 #  define SHN_ABS       Elf_eshn_absolute
 144 #  define SHN_COMMON    Elf_eshn_common
 145 # endif /* !PT_LOAD */
 146
 147 # ifdef __alpha__
 148 #  include <sys/exec_ecoff.h>
 149 #  define HDRR          struct ecoff_symhdr
 150 #  define pHDRR         HDRR *
 151 # endif /* __alpha__ */
 152
 153 #ifdef __mips__                 /* was in pkgsrc patches for 20.7 */
 154 # define SHT_MIPS_DEBUG DT_MIPS_FLAGS
 155 # define HDRR           struct Elf_Shdr
 156 #endif /* __mips__ */
 157 #endif /* __NetBSD__ */
 158
 159 #ifdef __OpenBSD__
 160 # include <sys/exec_elf.h>
 161 #endif
 162
 163 #if __GNU_LIBRARY__ - 0 >= 6
 164 # include <link.h>      /* get ElfW etc */
 165 #endif
 166
 167 #ifndef ElfW
 168 # define ElfBitsW(bits, type) Elf##bits##_##type
 169 # ifndef ELFSIZE
 170 #  ifdef _LP64
 171 #   define ELFSIZE 64
 172 #  else
 173 #   define ELFSIZE 32
 174 #  endif
 175 # endif
 176   /* This macro expands `bits' before invoking ElfBitsW.  */
 177 # define ElfExpandBitsW(bits, type) ElfBitsW (bits, type)
 178 # define ElfW(type) ElfExpandBitsW (ELFSIZE, type)
 179 #endif
 180
 181 /* The code often converts ElfW (Half) values like e_shentsize to ptrdiff_t;
 182    check that this doesn't lose information.  */
 183 #include <intprops.h>
 184 #include <verify.h>
 185 verify ((! TYPE_SIGNED (ElfW (Half))
 186          || PTRDIFF_MIN <= TYPE_MINIMUM (ElfW (Half)))
 187         && TYPE_MAXIMUM (ElfW (Half)) <= PTRDIFF_MAX);
 188
 189 #ifdef UNEXELF_DEBUG
 190 # define DEBUG_LOG(expr) fprintf (stderr, #expr " 0x%jx\n", (uintmax_t) (expr))
 191 #endif
 192
 193 /* Get the address of a particular section or program header entry,
 194  * accounting for the size of the entries.
 195  */
 196
 197 static void *
 198 entry_address (void *section_h, ptrdiff_t idx, ptrdiff_t entsize)
 199 {
 200   char *h = section_h;
 201   return h + idx * entsize;
 202 }
 203
 204 #define OLD_SECTION_H(n) \
 205   (*(ElfW (Shdr) *) entry_address (old_section_h, n, old_file_h->e_shentsize))
 206 #define NEW_SECTION_H(n) \
 207   (*(ElfW (Shdr) *) entry_address (new_section_h, n, new_file_h->e_shentsize))
 208 #define OLD_PROGRAM_H(n) \
 209   (*(ElfW (Phdr) *) entry_address (old_program_h, n, old_file_h->e_phentsize))
 210
 211 typedef unsigned char byte;
 212
 213 /* ****************************************************************
 214  * unexec
 215  *
 216  * driving logic.
 217  *
 218  * In ELF, this works by replacing the old bss SHT_NOBITS section with
 219  * a new, larger, SHT_PROGBITS section.
 220  *
 221  */
 222 void
 223 unexec (const char *new_name, const char *old_name)
 224 {
 225   int new_file, old_file;
 226   off_t new_file_size;
 227
 228   /* Pointers to the base of the image of the two files.  */
 229   caddr_t old_base, new_base;
 230
 231 #if MAP_ANON == 0
 232   int mmap_fd;
 233 #else
 234 # define mmap_fd -1
 235 #endif
 236
 237   /* Pointers to the file, program and section headers for the old and
 238      new files.  */
 239   ElfW (Ehdr) *old_file_h, *new_file_h;
 240   ElfW (Phdr) *old_program_h, *new_program_h;
 241   ElfW (Shdr) *old_section_h, *new_section_h;
 242
 243   /* Point to the section name table.  */
 244   char *old_section_names, *new_section_names;
 245
 246   ElfW (Phdr) *old_bss_seg, *new_bss_seg;
 247   ElfW (Addr) old_bss_addr, new_bss_addr;
 248   ElfW (Word) old_bss_size, bss_size_growth, new_data2_size;
 249   ElfW (Off) old_bss_offset, new_data2_offset;
 250
 251   ptrdiff_t n;
 252   ptrdiff_t old_bss_index;
 253   struct stat stat_buf;
 254   off_t old_file_size;
 255
 256   /* Open the old file, allocate a buffer of the right size, and read
 257      in the file contents.  */
 258
 259   old_file = emacs_open (old_name, O_RDONLY, 0);
 260
 261   if (old_file < 0)
 262     fatal ("Can't open %s for reading: %s", old_name, strerror (errno));
 263
 264   if (fstat (old_file, &stat_buf) != 0)
 265     fatal ("Can't fstat (%s): %s", old_name, strerror (errno));
 266
 267 #if MAP_ANON == 0
 268   mmap_fd = emacs_open ("/dev/zero", O_RDONLY, 0);
 269   if (mmap_fd < 0)
 270     fatal ("Can't open /dev/zero for reading: %s", strerror (errno));
 271 #endif
 272
 273   /* We cannot use malloc here because that may use sbrk.  If it does,
 274      we'd dump our temporary buffers with Emacs, and we'd have to be
 275      extra careful to use the correct value of sbrk(0) after
 276      allocating all buffers in the code below, which we aren't.  */
 277   old_file_size = stat_buf.st_size;
 278   if (! (0 <= old_file_size && old_file_size <= SIZE_MAX))
 279     fatal ("File size out of range");
 280   old_base = mmap (NULL, old_file_size, PROT_READ | PROT_WRITE,
 281                    MAP_ANON | MAP_PRIVATE, mmap_fd, 0);
 282   if (old_base == MAP_FAILED)
 283     fatal ("Can't allocate buffer for %s: %s", old_name, strerror (errno));
 284
 285   if (read (old_file, old_base, old_file_size) != old_file_size)
 286     fatal ("Didn't read all of %s: %s", old_name, strerror (errno));
 287
 288   /* Get pointers to headers & section names */
 289
 290   old_file_h = (ElfW (Ehdr) *) old_base;
 291   old_program_h = (ElfW (Phdr) *) ((byte *) old_base + old_file_h->e_phoff);
 292   old_section_h = (ElfW (Shdr) *) ((byte *) old_base + old_file_h->e_shoff);
 293   old_section_names = (char *) old_base
 294     + OLD_SECTION_H (old_file_h->e_shstrndx).sh_offset;
 295
 296   /* Find the PT_LOAD header covering the highest address.  This
 297      segment will be where bss sections are located, past p_filesz.  */
 298   old_bss_seg = 0;
 299   for (n = old_file_h->e_phnum; --n >= 0; )
 300     {
 301       ElfW (Phdr) *seg = &OLD_PROGRAM_H (n);
 302       if (seg->p_type == PT_LOAD
 303           && (old_bss_seg == 0
 304               || seg->p_vaddr > old_bss_seg->p_vaddr))
 305         old_bss_seg = seg;
 306     }
 307
 308   /* Note that old_bss_addr may be lower than the first bss section
 309      address, since the section may need aligning.  */
 310   old_bss_addr = old_bss_seg->p_vaddr + old_bss_seg->p_filesz;
 311   old_bss_offset = old_bss_seg->p_offset + old_bss_seg->p_filesz;
 312   old_bss_size = old_bss_seg->p_memsz - old_bss_seg->p_filesz;
 313
 314   /* Find the last bss style section in the bss segment range.  */
 315   old_bss_index = -1;
 316   for (n = old_file_h->e_shnum; --n > 0; )
 317     {
 318       ElfW (Shdr) *shdr = &OLD_SECTION_H (n);
 319       if (shdr->sh_type == SHT_NOBITS
 320           && shdr->sh_addr >= old_bss_addr
 321           && shdr->sh_addr + shdr->sh_size <= old_bss_addr + old_bss_size
 322           && (old_bss_index == -1
 323               || OLD_SECTION_H (old_bss_index).sh_addr < shdr->sh_addr))
 324         old_bss_index = n;
 325     }
 326
 327   if (old_bss_index == -1)
 328     fatal ("no bss section found");
 329
 330   void *no_break = (void *) (intptr_t) -1;
 331   void *new_break = no_break;
 332 #ifdef HAVE_SBRK
 333   new_break = sbrk (0);
 334 #endif
 335   if (new_break == no_break)
 336     new_break = (byte *) old_bss_addr + old_bss_size;
 337   new_bss_addr = (ElfW (Addr)) new_break;
 338   bss_size_growth = new_bss_addr - old_bss_addr;
 339   new_data2_size = bss_size_growth;
 340   new_data2_size += alignof (ElfW (Shdr)) - 1;
 341   new_data2_size -= new_data2_size % alignof (ElfW (Shdr));
 342
 343   new_data2_offset = old_bss_offset;
 344
 345 #ifdef UNEXELF_DEBUG
 346   fprintf (stderr, "old_bss_index %td\n", old_bss_index);
 347   DEBUG_LOG (old_bss_addr);
 348   DEBUG_LOG (old_bss_size);
 349   DEBUG_LOG (old_bss_offset);
 350   DEBUG_LOG (new_bss_addr);
 351   DEBUG_LOG (new_data2_size);
 352   DEBUG_LOG (new_data2_offset);
 353 #endif
 354
 355   if (new_bss_addr < old_bss_addr + old_bss_size)
 356     fatal (".bss shrank when undumping");
 357
 358   /* Set the output file to the right size.  Allocate a buffer to hold
 359      the image of the new file.  Set pointers to various interesting
 360      objects.  */
 361
 362   new_file = emacs_open (new_name, O_RDWR | O_CREAT, 0777);
 363   if (new_file < 0)
 364     fatal ("Can't creat (%s): %s", new_name, strerror (errno));
 365
 366   new_file_size = old_file_size + new_data2_size;
 367
 368   if (ftruncate (new_file, new_file_size))
 369     fatal ("Can't ftruncate (%s): %s", new_name, strerror (errno));
 370
 371   new_base = mmap (NULL, new_file_size, PROT_READ | PROT_WRITE,
 372                    MAP_ANON | MAP_PRIVATE, mmap_fd, 0);
 373   if (new_base == MAP_FAILED)
 374     fatal ("Can't allocate buffer for %s: %s", old_name, strerror (errno));
 375
 376   /* Make our new file, program and section headers as copies of the
 377      originals.  */
 378
 379   new_file_h = (ElfW (Ehdr) *) new_base;
 380   memcpy (new_file_h, old_file_h, old_file_h->e_ehsize);
 381
 382   /* Fix up file header.  Section header is further away now.  */
 383
 384   if (new_file_h->e_shoff >= old_bss_offset)
 385     new_file_h->e_shoff += new_data2_size;
 386
 387   new_program_h = (ElfW (Phdr) *) ((byte *) new_base + new_file_h->e_phoff);
 388   new_section_h = (ElfW (Shdr) *) ((byte *) new_base + new_file_h->e_shoff);
 389
 390   memcpy (new_program_h, old_program_h,
 391           old_file_h->e_phnum * old_file_h->e_phentsize);
 392   memcpy (new_section_h, old_section_h,
 393           old_file_h->e_shnum * old_file_h->e_shentsize);
 394
 395 #ifdef UNEXELF_DEBUG
 396   DEBUG_LOG (old_file_h->e_shoff);
 397   fprintf (stderr, "Old section count %td\n", (ptrdiff_t) old_file_h->e_shnum);
 398   DEBUG_LOG (new_file_h->e_shoff);
 399   fprintf (stderr, "New section count %td\n", (ptrdiff_t) new_file_h->e_shnum);
 400 #endif
 401
 402   /* Fix up program header.  Extend the writable data segment so
 403      that the bss area is covered too.  */
 404
 405   new_bss_seg = new_program_h + (old_bss_seg - old_program_h);
 406   new_bss_seg->p_filesz = new_bss_addr - new_bss_seg->p_vaddr;
 407   new_bss_seg->p_memsz = new_bss_seg->p_filesz;
 408
 409   /* Copy over what we have in memory now for the bss area. */
 410   memcpy (new_base + new_data2_offset, (caddr_t) old_bss_addr,
 411           bss_size_growth);
 412
 413   /* Walk through all section headers, copying data and updating.  */
 414   for (n = 1; n < old_file_h->e_shnum; n++)
 415     {
 416       caddr_t src;
 417       ElfW (Shdr) *old_shdr = &OLD_SECTION_H (n);
 418       ElfW (Shdr) *new_shdr = &NEW_SECTION_H (n);
 419
 420       if (new_shdr->sh_type == SHT_NOBITS
 421           && new_shdr->sh_addr >= old_bss_addr
 422           && (new_shdr->sh_addr + new_shdr->sh_size
 423               <= old_bss_addr + old_bss_size))
 424         {
 425           /* This section now has file backing.  */
 426           new_shdr->sh_type = SHT_PROGBITS;
 427
 428           /* SHT_NOBITS sections do not need a valid sh_offset, so it
 429              might be incorrect.  Write the correct value.  */
 430           new_shdr->sh_offset = (new_shdr->sh_addr - new_bss_seg->p_vaddr
 431                                  + new_bss_seg->p_offset);
 432
 433           /* If this is was a SHT_NOBITS .plt section, then it is
 434              probably a PowerPC PLT.  If it is PowerPC64 ELFv1 then
 435              glibc ld.so doesn't initialize the toc pointer word.  A
 436              non-zero toc pointer word can defeat Power7 thread safety
 437              during lazy update of a PLT entry.  This only matters if
 438              emacs becomes multi-threaded.  */
 439           if (strcmp (old_section_names + new_shdr->sh_name, ".plt") == 0)
 440             memset (new_shdr->sh_offset + new_base, 0, new_shdr->sh_size);
 441
 442           /* Extend the size of the last bss section to cover dumped
 443              data.  */
 444           if (n == old_bss_index)
 445             new_shdr->sh_size = new_bss_addr - new_shdr->sh_addr;
 446
 447           /* We have already copied this section from the current
 448              process.  */
 449           continue;
 450         }
 451
 452       /* Any section that was originally placed after the .bss
 453          section should now be offset by NEW_DATA2_SIZE.  */
 454       if (new_shdr->sh_offset >= old_bss_offset)
 455         new_shdr->sh_offset += new_data2_size;
 456
 457       /* Now, start to copy the content of sections.  */
 458       if (new_shdr->sh_type == SHT_NULL
 459           || new_shdr->sh_type == SHT_NOBITS)
 460         continue;
 461
 462       /* Some sections are copied from the current process instead of
 463          the old file.  */
 464       if (!strcmp (old_section_names + new_shdr->sh_name, ".data")
 465           || !strcmp (old_section_names + new_shdr->sh_name, ".sdata")
 466           || !strcmp (old_section_names + new_shdr->sh_name, ".lit4")
 467           || !strcmp (old_section_names + new_shdr->sh_name, ".lit8")
 468           || !strcmp (old_section_names + new_shdr->sh_name, ".sdata1")
 469           || !strcmp (old_section_names + new_shdr->sh_name, ".data1"))
 470         src = (caddr_t) old_shdr->sh_addr;
 471       else
 472         src = old_base + old_shdr->sh_offset;
 473
 474       memcpy (new_shdr->sh_offset + new_base, src, new_shdr->sh_size);
 475
 476 #if (defined __alpha__ && !defined __OpenBSD__) || defined _SYSTYPE_SYSV
 477       /* Update Alpha and MIPS COFF debug symbol table.  */
 478       if (strcmp (old_section_names + new_shdr->sh_name, ".mdebug") == 0
 479           && new_shdr->sh_offset - old_shdr->sh_offset != 0
 480 #if defined _SYSTYPE_SYSV
 481           && new_shdr->sh_type == SHT_MIPS_DEBUG
 482 #endif
 483           )
 484         {
 485           ptrdiff_t diff = new_shdr->sh_offset - old_shdr->sh_offset;
 486           HDRR *phdr = (HDRR *) (new_shdr->sh_offset + new_base);
 487
 488           phdr->cbLineOffset += diff;
 489           phdr->cbDnOffset += diff;
 490           phdr->cbPdOffset += diff;
 491           phdr->cbSymOffset += diff;
 492           phdr->cbOptOffset += diff;
 493           phdr->cbAuxOffset += diff;
 494           phdr->cbSsOffset += diff;
 495           phdr->cbSsExtOffset += diff;
 496           phdr->cbFdOffset += diff;
 497           phdr->cbRfdOffset += diff;
 498           phdr->cbExtOffset += diff;
 499         }
 500 #endif /* __alpha__ || _SYSTYPE_SYSV */
 501     }
 502
 503   /* Update the symbol values of _edata and _end.  */
 504   for (n = new_file_h->e_shnum; 0 < --n; )
 505     {
 506       byte *symnames;
 507       ElfW (Sym) *symp, *symendp;
 508       ElfW (Shdr) *sym_shdr = &NEW_SECTION_H (n);
 509
 510       if (sym_shdr->sh_type != SHT_DYNSYM
 511           && sym_shdr->sh_type != SHT_SYMTAB)
 512         continue;
 513
 514       symnames = ((byte *) new_base
 515                   + NEW_SECTION_H (sym_shdr->sh_link).sh_offset);
 516       symp = (ElfW (Sym) *) (sym_shdr->sh_offset + new_base);
 517       symendp = (ElfW (Sym) *) ((byte *) symp + sym_shdr->sh_size);
 518
 519       for (; symp < symendp; symp ++)
 520         {
 521           if (strcmp ((char *) (symnames + symp->st_name), "_end") == 0
 522               || strcmp ((char *) (symnames + symp->st_name), "end") == 0
 523               || strcmp ((char *) (symnames + symp->st_name), "_edata") == 0
 524               || strcmp ((char *) (symnames + symp->st_name), "edata") == 0)
 525             memcpy (&symp->st_value, &new_bss_addr, sizeof (new_bss_addr));
 526
 527           /* Strictly speaking, #ifdef below is not necessary.  But we
 528              keep it to indicate that this kind of change may also be
 529              necessary for other unexecs to support GNUstep.  */
 530 #ifdef NS_IMPL_GNUSTEP
 531           /* ObjC runtime modifies the values of some data structures
 532              such as classes and selectors in the .data section after
 533              loading.  As the dump process copies the .data section
 534              from the current process, that causes problems when the
 535              modified classes are reinitialized in the dumped
 536              executable.  We copy such data from the old file, not
 537              from the current process.  */
 538           if (strncmp ((char *) (symnames + symp->st_name),
 539                        "_OBJC_", sizeof ("_OBJC_") - 1) == 0)
 540             {
 541               ElfW (Shdr) *new_shdr = &NEW_SECTION_H (symp->st_shndx);
 542               if (new_shdr->sh_type != SHT_NOBITS)
 543                 {
 544                   ElfW (Shdr) *old_shdr = &OLD_SECTION_H (symp->st_shndx);
 545                   ptrdiff_t reladdr = symp->st_value - new_shdr->sh_addr;
 546                   ptrdiff_t newoff = reladdr + new_shdr->sh_offset;
 547
 548                   if (old_shdr->sh_type == SHT_NOBITS)
 549                     memset (new_base + newoff, 0, symp->st_size);
 550                   else
 551                     {
 552                       ptrdiff_t oldoff = reladdr + old_shdr->sh_offset;
 553                       memcpy (new_base + newoff, old_base + oldoff,
 554                               symp->st_size);
 555                     }
 556                 }
 557             }
 558 #endif
 559         }
 560     }
 561
 562   /* Modify the names of sections we changed from SHT_NOBITS to
 563      SHT_PROGBITS.  This is really just cosmetic, but some tools that
 564      (wrongly) operate on section names rather than types might be
 565      confused by a SHT_PROGBITS .bss section.  */
 566   new_section_names = ((char *) new_base
 567                        + NEW_SECTION_H (new_file_h->e_shstrndx).sh_offset);
 568   for (n = new_file_h->e_shnum; 0 < --n; )
 569     {
 570       ElfW (Shdr) *old_shdr = &OLD_SECTION_H (n);
 571       ElfW (Shdr) *new_shdr = &NEW_SECTION_H (n);
 572
 573       /* Replace the leading '.' with ','.  When .shstrtab is string
 574          merged this will rename both .bss and .rela.bss to ,bss and
 575          .rela,bss.  */
 576       if (old_shdr->sh_type == SHT_NOBITS
 577           && new_shdr->sh_type == SHT_PROGBITS)
 578         *(new_section_names + new_shdr->sh_name) = ',';
 579     }
 580
 581   /* This loop seeks out relocation sections for the data section, so
 582      that it can undo relocations performed by the runtime loader.
 583
 584      The following approach does not work on x86 platforms that use
 585      the GNU Gold linker, which can generate .rel.dyn relocation
 586      sections containing R_386_32 entries that the following code does
 587      not grok.  Emacs works around this problem by avoiding C
 588      constructs that generate such entries, which is horrible hack.
 589
 590      FIXME: Presumably more problems like this will crop up as linkers
 591      get fancier.  We really need to stop assuming that Emacs can grok
 592      arbitrary linker output.  See Bug#27248.  */
 593   for (n = new_file_h->e_shnum; 0 < --n; )
 594     {
 595       ElfW (Shdr) *rel_shdr = &NEW_SECTION_H (n);
 596       ElfW (Shdr) *shdr;
 597
 598       switch (rel_shdr->sh_type)
 599         {
 600         default:
 601           break;
 602         case SHT_REL:
 603         case SHT_RELA:
 604           /* This code handles two different size structs, but there should
 605              be no harm in that provided that r_offset is always the first
 606              member.  */
 607           shdr = &NEW_SECTION_H (rel_shdr->sh_info);
 608           if (!strcmp (old_section_names + shdr->sh_name, ".data")
 609               || !strcmp (old_section_names + shdr->sh_name, ".sdata")
 610               || !strcmp (old_section_names + shdr->sh_name, ".lit4")
 611               || !strcmp (old_section_names + shdr->sh_name, ".lit8")
 612               || !strcmp (old_section_names + shdr->sh_name, ".sdata1")
 613               || !strcmp (old_section_names + shdr->sh_name, ".data1"))
 614             {
 615               ElfW (Addr) offset = shdr->sh_addr - shdr->sh_offset;
 616               caddr_t reloc = old_base + rel_shdr->sh_offset, end;
 617               for (end = reloc + rel_shdr->sh_size;
 618                    reloc < end;
 619                    reloc += rel_shdr->sh_entsize)
 620                 {
 621                   ElfW (Addr) addr = ((ElfW (Rel) *) reloc)->r_offset - offset;
 622                   /* Ignore R_*_NONE relocs.  */
 623                   if (((ElfW (Rel) *) reloc)->r_offset == 0)
 624                     continue;
 625                   /* Assume reloc applies to a word.
 626                      ??? This is not always true, eg. TLS module/index
 627                      pair in .got which occupies two words.  */
 628                   memcpy (new_base + addr, old_base + addr,
 629                           sizeof (ElfW (Addr)));
 630                 }
 631             }
 632           break;
 633         }
 634     }
 635
 636   /* Write out new_file, and free the buffers.  */
 637
 638   if (write (new_file, new_base, new_file_size) != new_file_size)
 639     fatal ("Didn't write %lu bytes to %s: %s",
 640            (unsigned long) new_file_size, new_name, strerror (errno));
 641   munmap (old_base, old_file_size);
 642   munmap (new_base, new_file_size);
 643
 644   /* Close the files and make the new file executable.  */
 645
 646 #if MAP_ANON == 0
 647   emacs_close (mmap_fd);
 648 #endif
 649
 650   if (emacs_close (old_file) != 0)
 651     fatal ("Can't close (%s): %s", old_name, strerror (errno));
 652
 653   if (emacs_close (new_file) != 0)
 654     fatal ("Can't close (%s): %s", new_name, strerror (errno));
 655 }