src/unexelfsgi.c

   1 /* Copyright (C) 1985, 1986, 1987, 1988, 1990, 1992, 1999, 2000
   2    Free Software Foundation, Inc.
   3
   4    This file is part of XEmacs.
   5
   6    XEmacs is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    GNU Emacs is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    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; see the file COPYING.  If not, write to the
  18    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.
  20
  21    In other words, you are welcome to use, share and improve this
  22    program.  You are forbidden to forbid anyone else to use, share and
  23    improve what you give them.  Help stamp out software-hoarding!  */
  24
  25
  26 /*
  27  * unexec.c - Convert a running program into an a.out file.
  28  *
  29  * Author:      Spencer W. Thomas
  30  *              Computer Science Dept.
  31  *              University of Utah
  32  * Date:        Tue Mar  2 1982
  33  * Modified heavily since then.
  34  *
  35  * Synopsis:
  36  * void
  37  * unexec (char *new_name,
  38  *         char *old_name,
  39  *         uintptr_t data_start,
  40  *         uintptr_t bss_start,
  41  *         uintptr_t entry_address)
  42  *
  43  * The basic idea is that we start with an ELF file which contains
  44  * .bss (uninitialized global data) section which is normally not in
  45  * the file. As we load lisp the variables, which were first set to 0,
  46  * will change their values. We want to save those changed values into
  47  * another ELF file, which will become a new xemacs image. To do this,
  48  * we need to change several structures in the ELF file.
  49  *
  50  *   First of all, we need to change the programm header which tells
  51  *   the linker how to load stuff into memory so that data will come
  52  *   from the file and not from the /dev/zero. To do this, we find the
  53  *   segment, which is marked as loadable (type PT_LOAD) and which
  54  *   covers the old .bss section. We will next change the filesz and
  55  *   memsz for that segment to extend over the new data section.
  56  *
  57  *   Next we have to make sure that section header for the stuff which
  58  *   used to be uninitialized is changed to be initialized and to come
  59  *   from the file. To do this, we change the size and the type of the old
  60  *   .bss section (and all other section of the type SHT_NOBITS) to cover the
  61  *   new section and to be of type SHT_PROCBITS.
  62  *
  63  *   We also insert a new SHT_NOBITS section to keep some tools, which expect
  64  *   .bss happy.
  65  *
  66  *   Finally we need to patch up some references to the section
  67  *   indexes since we change the order and undo the relocation info to
  68  *   be the same as it was "before" because we actually used the data
  69  *   from the memory which were changed by the run-time linker.
  70  */
  71 \f
  72 #ifndef emacs
  73 #define fatal(a, b, c) fprintf (stderr, a, b, c), exit (1)
  74 #include <string.h>
  75 #else
  76 #include <config.h>
  77 extern void fatal (const char *, ...);
  78 #endif
  79
  80 #include <sys/types.h>
  81 #include <stdio.h>
  82 #include <sys/stat.h>
  83 #include <memory.h>
  84 #include <errno.h>
  85 #include <unistd.h>
  86 #include <fcntl.h>
  87 #ifdef HAVE_ELF_H
  88 #include <elf.h>
  89 #endif
  90 #include <sys/mman.h>
  91 #if defined (__sony_news) && defined (_SYSTYPE_SYSV)
  92 #include <sys/elf_mips.h>
  93 #include <sym.h>
  94 #endif /* __sony_news && _SYSTYPE_SYSV */
  95 #if __sgi
  96 #include <syms.h> /* for HDRR declaration */
  97 #endif /* __sgi */
  98
  99 #if __GNU_LIBRARY__ - 0 >= 6
 100 # include <link.h>      /* get ElfW etc */
 101 #endif
 102
 103 #ifndef ElfW
 104 # ifdef __STDC__
 105 #  define ElfBitsW(bits, type) Elf##bits##_##type
 106 # else
 107 #  define ElfBitsW(bits, type) Elf/**/bits/**/_/**/type
 108 # endif
 109 # ifdef _LP64
 110 #  define ELFSIZE 64
 111 # else
 112 #  define ELFSIZE 32
 113 # endif
 114   /* This macro expands `bits' before invoking ElfBitsW.  */
 115 # define ElfExpandBitsW(bits, type) ElfBitsW (bits, type)
 116 # define ElfW(type) ElfExpandBitsW (ELFSIZE, type)
 117 #endif
 118
 119 #ifndef ELF_BSS_SECTION_NAME
 120 #define ELF_BSS_SECTION_NAME ".bss"
 121 #endif
 122
 123 /* Get the address of a particular section or program header entry,
 124  * accounting for the size of the entries. */
 125
 126 #define OLD_SECTION_H(n) \
 127      (*(ElfW(Shdr) *) ((byte *) old_section_h + old_file_h->e_shentsize * (n)))
 128 #define NEW_SECTION_H(n) \
 129      (*(ElfW(Shdr) *) ((byte *) new_section_h + new_file_h->e_shentsize * (n)))
 130 #define OLD_PROGRAM_H(n) \
 131      (*(ElfW(Phdr) *) ((byte *) old_program_h + old_file_h->e_phentsize * (n)))
 132 #define NEW_PROGRAM_H(n) \
 133      (*(ElfW(Phdr) *) ((byte *) new_program_h + new_file_h->e_phentsize * (n)))
 134
 135 #define PATCH_INDEX(n) \
 136   do { \
 137          if ((int) (n) >= growme_index) \
 138            (n)++; } while (0)
 139
 140 typedef unsigned char byte;
 141
 142 /* Round X up to a multiple of Y.  */
 143
 144 static ElfW(Addr)
 145 round_up (ElfW(Addr) x, ElfW(Addr) y)
 146 {
 147   int rem = x % y;
 148   if (rem == 0)
 149     return x;
 150   return x - rem + y;
 151 }
 152
 153 /* Return the index of the section named NAME.
 154    SECTION_NAMES, FILE_NAME and FILE_H give information
 155    about the file we are looking in.
 156
 157    If we don't find the section NAME, that is a fatal error
 158    if NOERROR is 0; we return -1 if NOERROR is nonzero.  */
 159
 160 static int
 161 find_section (char *name,
 162               const char *section_names,
 163               char *file_name,
 164               ElfW(Ehdr) *old_file_h,
 165               ElfW(Shdr) *old_section_h,
 166               int noerror)
 167 {
 168   int idx;
 169
 170   for (idx = 1; idx < old_file_h->e_shnum; idx++)
 171     {
 172 #ifdef DEBUG
 173       fprintf (stderr, "Looking for %s - found %s\n", name,
 174                section_names + OLD_SECTION_H (idx).sh_name);
 175 #endif
 176       if (!strcmp (section_names + OLD_SECTION_H (idx).sh_name,
 177                    name))
 178           return idx;
 179     }
 180
 181   /* If we're here, we found nothing or return did not work */
 182   if ( ! noerror)
 183       fatal ("Can't find %s in %s.\n", name, file_name);
 184
 185   return -1;
 186 }
 187
 188 /* ****************************************************************
 189  * unexec
 190  *
 191  * driving logic.
 192  *
 193  * In ELF, this works by replacing the old .bss section with a new
 194  * .data section, and inserting an empty .bss immediately afterwards.
 195  *
 196  */
 197 void
 198 unexec (char *new_name,
 199         char *old_name,
 200         uintptr_t data_start,
 201         uintptr_t bss_start,
 202         uintptr_t entry_address)
 203 {
 204   int old_file;
 205
 206   struct stat stat_buf;
 207   caddr_t old_base, new_base;
 208
 209   ElfW(Ehdr) *old_file_h, * new_file_h;
 210   ElfW(Phdr) *old_program_h, * new_program_h;
 211   ElfW(Shdr) *old_section_h, * new_section_h;
 212   ElfW(Shdr) * growme = NULL, * grown = NULL;
 213   ElfW(Addr) old_bss_addr = 0,  new_data2_addr = 0;
 214
 215   int growme_index = -1;
 216   int n, nn;
 217   const char *old_section_names;
 218   int old_mdebug_index, old_data_index;
 219   int new_bss_addr, new_data2_size, new_data2_offset, new_file, new_file_size;
 220
 221   /* Open the old file */
 222   if ( (old_file = open (old_name, O_RDONLY)) < 0 )
 223       fatal ("Can't open %s for reading: errno %d\n", old_name, errno);
 224
 225   if (fstat (old_file, &stat_buf) == -1)
 226       fatal ("Can't fstat (%s): errno %d\n", old_name, errno);
 227
 228   /* map old file into the address space. */
 229   old_base = (caddr_t) mmap ((caddr_t) 0, stat_buf.st_size,
 230                              PROT_READ, MAP_SHARED, old_file, 0);
 231   if (old_base == (caddr_t) MAP_FAILED)
 232     fatal ("Can't mmap (%s): errno %d\n", old_name, errno);
 233
 234   old_file_h    = (ElfW(Ehdr) *) old_base;
 235   old_program_h = (ElfW(Phdr) *) ((byte *) old_base + old_file_h->e_phoff);
 236   old_section_h = (ElfW(Shdr) *) ((byte *) old_base + old_file_h->e_shoff);
 237   old_section_names = (const char *) old_base
 238       + OLD_SECTION_H (old_file_h->e_shstrndx).sh_offset;
 239
 240   /* Find a section which we will grow by looking for the SHT_NOBITS
 241    * section with ALLOCATE flag and with the biggest address. */
 242   for (n = 1; n < old_file_h->e_shnum; n++) {
 243       ElfW(Shdr) * sh = & OLD_SECTION_H(n);
 244
 245       if ((sh->sh_type == SHT_NOBITS) && (sh->sh_flags & SHF_ALLOC)) {
 246           if ( old_bss_addr < sh->sh_addr ) {
 247               growme = sh;
 248               growme_index = n;
 249               new_data2_addr = old_bss_addr =  sh->sh_addr;
 250           }
 251       }
 252   }
 253
 254   if (growme == NULL )
 255       fatal ("Can't find a section to grow\n", 0, 0);
 256
 257   old_data_index = find_section (".data", old_section_names,
 258                                  old_name, old_file_h, old_section_h, 0);
 259
 260   new_bss_addr = (ElfW(Addr)) sbrk (0);
 261   new_data2_size = new_bss_addr - old_bss_addr;
 262   new_data2_offset  = OLD_SECTION_H (old_data_index).sh_offset +
 263       (new_data2_addr - OLD_SECTION_H (old_data_index).sh_addr);
 264
 265   if ( new_bss_addr < old_bss_addr + growme->sh_size )
 266       fatal (".bss shrank when undumping???\n", 0, 0);
 267
 268   /* Set the output file to the right size and mmap it. */
 269   if ( (new_file = open (new_name, O_RDWR | O_CREAT, 0666)) < 0 )
 270       fatal ("Can't create (%s): errno %d\n", new_name, errno);
 271
 272   new_file_size = stat_buf.st_size +  old_file_h->e_shentsize + new_data2_size;
 273
 274   if (ftruncate (new_file, new_file_size))
 275       fatal ("Can't ftruncate (%s): errno %d\n", new_name, errno);
 276
 277   new_base = (caddr_t) mmap ((caddr_t) 0, new_file_size,
 278                              PROT_READ | PROT_WRITE,
 279 #ifdef UNEXEC_USE_MAP_PRIVATE
 280                              MAP_PRIVATE,
 281 #else
 282                              MAP_SHARED,
 283 #endif
 284                              new_file, 0);
 285
 286   if (new_base == (caddr_t) -1)
 287       fatal ("Can't mmap (%s): errno %d\n", new_name, errno);
 288
 289   new_file_h = (ElfW(Ehdr) *) new_base;
 290   new_program_h = (ElfW(Phdr) *) ((byte *) new_base + old_file_h->e_phoff);
 291   new_section_h = (ElfW(Shdr) *) ((byte *) new_base + old_file_h->e_shoff +
 292                                   new_data2_size);
 293
 294   /* Make our new file, program and section headers as copies of the
 295    * originals.  */
 296   memcpy (new_file_h, old_file_h, old_file_h->e_ehsize);
 297   memcpy (new_program_h, old_program_h,
 298           old_file_h->e_phnum * old_file_h->e_phentsize);
 299
 300   /* Modify the e_shstrndx if necessary. */
 301   PATCH_INDEX (new_file_h->e_shstrndx);
 302
 303   /* Fix up file header.  We'll add one section.  Section header is
 304    * further away now.  */
 305   new_file_h->e_shoff += new_data2_size;
 306   new_file_h->e_shnum += 1;
 307
 308   /* Fix up a new program header by extending the writable data
 309    * segment so that the bss area is covered too. Find that segment by
 310    * looking for one that starts before and ends after the .bss and is
 311    * PT_LOADable. */
 312   for (n = new_file_h->e_phnum - 1; n >= 0; n--) {
 313       ElfW(Phdr) * ph = & NEW_PROGRAM_H(n);
 314 #ifdef DEBUG
 315       printf ("%d @ %0x + %0x against %0x + %0x",
 316               n, ph->p_vaddr, ph->p_memsz,growme->sh_addr, growme->sh_size);
 317 #endif
 318       if ((ph->p_type == PT_LOAD) &&
 319           (ph->p_vaddr <= growme->sh_addr) &&
 320           ((ph->p_vaddr+ph->p_memsz) >= (growme->sh_addr + growme->sh_size))) {
 321           /* Make sure that the size includes any padding before the
 322            * old .bss section.  */
 323           ph->p_memsz = ph->p_filesz = new_bss_addr - ph->p_vaddr;
 324 #ifdef DEBUG
 325           puts (" That's the one!");
 326 #endif
 327           break;
 328       }
 329 #ifdef DEBUG
 330       putchar ('\n');
 331 #endif
 332   }
 333
 334   if (n < 0)
 335       fatal ("Couldn't find segment which covers %s",
 336              old_section_names + growme->sh_name);
 337
 338   /* Walk through all section headers, insert the new data2 section
 339    * right before the new bss section. */
 340   for (n = 1, nn = 1; n < (int) old_file_h->e_shnum;  n++, nn++) {
 341       ElfW(Shdr) * nsec = & NEW_SECTION_H(nn);
 342       ElfW(Shdr) * osec = & OLD_SECTION_H(n);
 343
 344       /* If this is the section we want to grow, insert the new data
 345        * section before it. */
 346       if ( osec == growme ) {
 347           /* Steal the data section header for this data2 section but
 348            * use the * 'grow' section's alignment. This * will assure
 349            * that the new section * always be placed in the same spot
 350            * * as the old section by any other * application. */
 351           ElfW(Shdr) * od = &OLD_SECTION_H(old_data_index);
 352
 353           memcpy (nsec, od, new_file_h->e_shentsize);
 354
 355           nsec->sh_addr = new_data2_addr;
 356           nsec->sh_offset =  new_data2_offset;
 357           nsec->sh_size = new_data2_size;
 358           nsec->sh_addralign = osec->sh_addralign;
 359
 360           /* Copy over what we have in memory now. */
 361           memcpy (nsec->sh_offset + new_base, (caddr_t) osec->sh_addr,
 362                   new_data2_size);
 363           nn++;
 364           grown = nsec++;
 365       }
 366
 367       memcpy (nsec, osec, old_file_h->e_shentsize);
 368
 369       if ( osec == growme ) {
 370           /* The new bss section's size is zero, and its file offset
 371            * and virtual address should be off by NEW_DATA2_SIZE.  */
 372           nsec->sh_offset = grown->sh_offset + new_data2_size;
 373           nsec->sh_addr = grown->sh_addr + new_data2_size;
 374
 375           /* Let the new bss section address alignment be the same as
 376            * the section address alignment followed the old bss
 377            * section, so this section will be placed in exactly the
 378            * same place. */
 379           nsec->sh_addralign = osec->sh_addralign;
 380           nsec->sh_size = 0;
 381       } else {
 382           /* Any section that was originally placed AFTER the bss
 383            * section should now be off by NEW_DATA2_SIZE. */
 384           if ( round_up (nsec->sh_offset, growme->sh_addralign) >=
 385                new_data2_offset)
 386               nsec->sh_offset += new_data2_size;
 387       }
 388
 389       /* Any section that was originally placed after the section *
 390        * header table should now be off by the size of one section
 391        * header table entry.  */
 392       if (nsec->sh_offset > new_file_h->e_shoff)
 393           nsec->sh_offset += new_file_h->e_shentsize;
 394
 395
 396       /* If any section hdr refers to the section after the new .data
 397        * section, make it refer to next one because we have inserted a
 398        * new section in between.  */
 399       PATCH_INDEX (nsec->sh_link);
 400
 401       /* For symbol tables, info is a symbol table index, so don't
 402        * change it.  */
 403       if (nsec->sh_type != SHT_SYMTAB && nsec->sh_type != SHT_DYNSYM)
 404           PATCH_INDEX (nsec->sh_info);
 405
 406       /* Any section which used to be NOBITS will now becomes PROGBITS
 407        * if it's ALLOC-atable, unless, of cause, it's not the one we
 408        * decided to grow */
 409       if ( (osec->sh_type == SHT_NOBITS) && (osec->sh_flags & SHF_ALLOC) &&
 410            (osec != growme ) ) {
 411           nsec->sh_type = SHT_PROGBITS;
 412       }
 413
 414       /* Now, start to copy the content of sections */
 415       if ( nsec->sh_type != SHT_NULL || nsec->sh_type != SHT_NOBITS ) {
 416
 417           /* Write out the sections. .data and .data1 (and data2,
 418            * called ".data" in the strings table) get copied from the
 419            * current process instead of the old file.  */
 420           caddr_t src =  old_base + osec->sh_offset;
 421           const char * secname = old_section_names + nsec->sh_name;
 422           const char * names[] = {
 423               ".data",".sdata", ".lit4", ".lit8", ".sdata1", ".data1",
 424               ".sbss", NULL};
 425           int i;
 426
 427           for ( i=0; names[i] != NULL; i++ ) {
 428               if ( ! strcmp (secname, names[i]) ) {
 429                   src = (caddr_t) osec->sh_addr;
 430                   break;
 431               }
 432           }
 433
 434           memcpy (nsec->sh_offset + new_base, src, nsec->sh_size);
 435       }
 436
 437       old_mdebug_index = find_section (".mdebug", old_section_names,
 438                                        old_name, old_file_h, old_section_h, 1);
 439
 440 #if defined (__sony_news) && defined (_SYSTYPE_SYSV)
 441       if (nsec->sh_type == SHT_MIPS_DEBUG && old_mdebug_index != -1) {
 442           int diff = nsec->sh_offset-OLD_SECTION_H(old_mdebug_index).sh_offset;
 443           HDRR *phdr = (HDRR *)(nsec->sh_offset + new_base);
 444
 445           if (diff) {
 446               phdr->cbLineOffset += diff;
 447               phdr->cbDnOffset   += diff;
 448               phdr->cbPdOffset   += diff;
 449               phdr->cbSymOffset  += diff;
 450               phdr->cbOptOffset  += diff;
 451               phdr->cbAuxOffset  += diff;
 452               phdr->cbSsOffset   += diff;
 453               phdr->cbSsExtOffset += diff;
 454               phdr->cbFdOffset   += diff;
 455               phdr->cbRfdOffset  += diff;
 456               phdr->cbExtOffset  += diff;
 457           }
 458       }
 459 #endif /* __sony_news && _SYSTYPE_SYSV */
 460
 461 #if __sgi
 462       /* Adjust the HDRR offsets in .mdebug and copy the line data if
 463        * it's in its usual 'hole' in the object.  Makes the new file
 464        * debuggable with dbx.  patches up two problems: the absolute
 465        * file offsets in the HDRR record of .mdebug (see
 466        * /usr/include/syms.h), and the ld bug that gets the line table
 467        * in a hole in the elf file rather than in the .mdebug section
 468        * proper.
 469        *
 470        * David Anderson. davea@sgi.com Jan 16,1994 */
 471 #define MDEBUGADJUST(__ct,__fileaddr)           \
 472   if (n_phdrr->__ct > 0)                        \
 473     {                                           \
 474       n_phdrr->__fileaddr += movement;          \
 475     }
 476
 477       if (n == old_mdebug_index) {
 478           HDRR * o_phdrr = (HDRR *)((byte *)old_base + osec->sh_offset);
 479           HDRR * n_phdrr = (HDRR *)((byte *)new_base + nsec->sh_offset);
 480           unsigned movement = new_data2_size;
 481
 482           MDEBUGADJUST (idnMax, cbDnOffset);
 483           MDEBUGADJUST (ipdMax, cbPdOffset);
 484           MDEBUGADJUST (isymMax, cbSymOffset);
 485           MDEBUGADJUST (ioptMax, cbOptOffset);
 486           MDEBUGADJUST (iauxMax, cbAuxOffset);
 487           MDEBUGADJUST (issMax, cbSsOffset);
 488           MDEBUGADJUST (issExtMax, cbSsExtOffset);
 489           MDEBUGADJUST (ifdMax, cbFdOffset);
 490           MDEBUGADJUST (crfd, cbRfdOffset);
 491           MDEBUGADJUST (iextMax, cbExtOffset);
 492
 493           /* The Line Section, being possible off in a hole of the
 494            * object, requires special handling.  */
 495           if (n_phdrr->cbLine > 0) {
 496               if (o_phdrr->cbLineOffset >
 497                   osec->sh_offset+ osec->sh_size){
 498                   /* line data is in a hole in elf. do special copy
 499                    * and adjust for this ld mistake.  */
 500                   n_phdrr->cbLineOffset += movement;
 501
 502                   memcpy (n_phdrr->cbLineOffset + new_base,
 503                           o_phdrr->cbLineOffset + old_base, n_phdrr->cbLine);
 504               } else {
 505                   /* somehow line data is in .mdebug as it is supposed
 506                    * to be.  */
 507                   MDEBUGADJUST (cbLine, cbLineOffset);
 508               }
 509           }
 510       }
 511 #endif /* __sgi */
 512       /* If it is the symbol table, its st_shndx field needs to be
 513        * patched.  */
 514       if (nsec->sh_type == SHT_SYMTAB || nsec->sh_type == SHT_DYNSYM) {
 515           unsigned int num = nsec->sh_size / nsec->sh_entsize;
 516           ElfW(Sym) * sym = (ElfW(Sym) *)(nsec->sh_offset + new_base);
 517           byte *symnames = ((byte *) new_base +
 518                             NEW_SECTION_H (nsec->sh_link).sh_offset);
 519
 520           for (; num--; sym++) {
 521               const char * symnam = (char *) (symnames + sym->st_name);
 522
 523               /* Update the symbol values of _edata and _end. */
 524               if (strcmp (symnam, "_end") == 0
 525                   || strcmp (symnam, "end") == 0
 526                   || strcmp (symnam, "_edata") == 0
 527                   || strcmp (symnam, "edata") == 0)
 528                   memcpy (&sym->st_value, &new_bss_addr,sizeof (new_bss_addr));
 529
 530
 531               if ((sym->st_shndx == SHN_UNDEF) || (sym->st_shndx == SHN_ABS)
 532                   || (sym->st_shndx == SHN_COMMON)
 533                   || (sym->st_shndx >= SHN_LOPROC &&
 534                       sym->st_shndx <= SHN_HIPROC))
 535                   continue;
 536
 537               PATCH_INDEX (sym->st_shndx);
 538           }
 539       }
 540   }
 541
 542   /* This loop seeks out relocation sections for the data section, so
 543    * that it can undo relocations performed by the runtime linker.  */
 544   for (n = new_file_h->e_shnum - 1; n; n--) {
 545       ElfW(Shdr) section = NEW_SECTION_H (n);
 546
 547       if ( section.sh_type == SHT_REL || section.sh_type == SHT_RELA ) {
 548           /* This code handles two different size structs, but there
 549            * should be no harm in that provided that r_offset is
 550            * always the first member.  */
 551           ElfW(Shdr) * info = & NEW_SECTION_H(section.sh_info);
 552           const char * nm = old_section_names + info->sh_name;
 553
 554           if (!strcmp (nm, ".data") || !strcmp (nm, ".sdata")
 555               || !strcmp (nm, ".lit4") || !strcmp (nm, ".lit8")
 556               || !strcmp (nm, ".sdata1") || !strcmp (nm, ".data1")) {
 557               ElfW(Addr) offset =  info->sh_addr - info->sh_offset;
 558               caddr_t end, reloc = old_base + section.sh_offset;
 559
 560               for (end = reloc + section.sh_size; reloc < end;
 561                    reloc += section.sh_entsize) {
 562                   ElfW(Addr) addr = ((ElfW(Rel) *) reloc)->r_offset - offset;
 563 #ifdef __alpha__
 564                   /* The Alpha ELF binutils currently have a bug that
 565                    * sometimes results in relocs that contain all
 566                    * zeroes.  Work around this for now...  */
 567                   if (((ElfW(Rel) *) reloc)->r_offset == 0)
 568                       continue;
 569 #endif
 570                   memcpy (new_base + addr, old_base + addr,
 571                           sizeof(ElfW(Addr)));
 572               }
 573           }
 574       }
 575   }
 576
 577 #ifdef UNEXEC_USE_MAP_PRIVATE
 578   if (lseek (new_file, 0, SEEK_SET) == -1)
 579       fatal ("Can't rewind (%s): errno %d\n", new_name, errno);
 580
 581   if (write (new_file, new_base, new_file_size) != new_file_size)
 582       fatal ("Can't write (%s): errno %d\n", new_name, errno);
 583 #endif
 584
 585   /* Close the files and make the new file executable.  */
 586   if (close (old_file))
 587       fatal ("Can't close (%s): errno %d\n", old_name, errno);
 588
 589   if (close (new_file))
 590       fatal ("Can't close (%s): errno %d\n", new_name, errno);
 591
 592   if (stat (new_name, &stat_buf) == -1)
 593       fatal ("Can't stat (%s): errno %d\n", new_name, errno);
 594
 595   n = umask (777);
 596   umask (n);
 597   stat_buf.st_mode |= 0111 & ~n;
 598   if (chmod (new_name, stat_buf.st_mode) == -1)
 599       fatal ("Can't chmod (%s): errno %d\n", new_name, errno);
 600 }