src/unexec.c

   1 /* Copyright (C) 1985,86,87,88,92,93,94 Free Software Foundation, Inc.
   2
   3 This file is part of GNU Emacs.
   4
   5 GNU Emacs 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 2, or (at your option)
   8 any later version.
   9
  10 GNU Emacs is distributed in the hope that it will be useful,
  11 but 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 GNU Emacs; see the file COPYING.  If not, write to
  17 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18 Boston, MA 02111-1307, USA.  */
  19
  20
  21 /*
  22  * unexec.c - Convert a running program into an a.out file.
  23  *
  24  * Author:      Spencer W. Thomas
  25  *              Computer Science Dept.
  26  *              University of Utah
  27  * Date:        Tue Mar  2 1982
  28  * Modified heavily since then.
  29  *
  30  * Synopsis:
  31  *      unexec (new_name, a_name, data_start, bss_start, entry_address)
  32  *      char *new_name, *a_name;
  33  *      unsigned data_start, bss_start, entry_address;
  34  *
  35  * Takes a snapshot of the program and makes an a.out format file in the
  36  * file named by the string argument new_name.
  37  * If a_name is non-NULL, the symbol table will be taken from the given file.
  38  * On some machines, an existing a_name file is required.
  39  *
  40  * The boundaries within the a.out file may be adjusted with the data_start
  41  * and bss_start arguments.  Either or both may be given as 0 for defaults.
  42  *
  43  * Data_start gives the boundary between the text segment and the data
  44  * segment of the program.  The text segment can contain shared, read-only
  45  * program code and literal data, while the data segment is always unshared
  46  * and unprotected.  Data_start gives the lowest unprotected address.
  47  * The value you specify may be rounded down to a suitable boundary
  48  * as required by the machine you are using.
  49  *
  50  * Specifying zero for data_start means the boundary between text and data
  51  * should not be the same as when the program was loaded.
  52  * If NO_REMAP is defined, the argument data_start is ignored and the
  53  * segment boundaries are never changed.
  54  *
  55  * Bss_start indicates how much of the data segment is to be saved in the
  56  * a.out file and restored when the program is executed.  It gives the lowest
  57  * unsaved address, and is rounded up to a page boundary.  The default when 0
  58  * is given assumes that the entire data segment is to be stored, including
  59  * the previous data and bss as well as any additional storage allocated with
  60  * break (2).
  61  *
  62  * The new file is set up to start at entry_address.
  63  *
  64  * If you make improvements I'd like to get them too.
  65  * harpo!utah-cs!thomas, thomas@Utah-20
  66  *
  67  */
  68
  69 /* Modified to support SysVr3 shared libraries by James Van Artsdalen
  70  * of Dell Computer Corporation.  james@bigtex.cactus.org.
  71  */
  72
  73 /* There are several compilation parameters affecting unexec:
  74
  75 * COFF
  76
  77 Define this if your system uses COFF for executables.
  78
  79 * COFF_ENCAPSULATE
  80
  81 Define this if you are using the GNU coff encapsulated a.out format.
  82 This is closer to a.out than COFF. You should *not* define COFF if
  83 you define COFF_ENCAPSULATE
  84
  85 Otherwise we assume you use Berkeley format.
  86
  87 * NO_REMAP
  88
  89 Define this if you do not want to try to save Emacs's pure data areas
  90 as part of the text segment.
  91
  92 Saving them as text is good because it allows users to share more.
  93
  94 However, on machines that locate the text area far from the data area,
  95 the boundary cannot feasibly be moved.  Such machines require
  96 NO_REMAP.
  97
  98 Also, remapping can cause trouble with the built-in startup routine
  99 /lib/crt0.o, which defines `environ' as an initialized variable.
 100 Dumping `environ' as pure does not work!  So, to use remapping,
 101 you must write a startup routine for your machine in Emacs's crt0.c.
 102 If NO_REMAP is defined, Emacs uses the system's crt0.o.
 103
 104 * SECTION_ALIGNMENT
 105
 106 Some machines that use COFF executables require that each section
 107 start on a certain boundary *in the COFF file*.  Such machines should
 108 define SECTION_ALIGNMENT to a mask of the low-order bits that must be
 109 zero on such a boundary.  This mask is used to control padding between
 110 segments in the COFF file.
 111
 112 If SECTION_ALIGNMENT is not defined, the segments are written
 113 consecutively with no attempt at alignment.  This is right for
 114 unmodified system V.
 115
 116 * SEGMENT_MASK
 117
 118 Some machines require that the beginnings and ends of segments
 119 *in core* be on certain boundaries.  For most machines, a page
 120 boundary is sufficient.  That is the default.  When a larger
 121 boundary is needed, define SEGMENT_MASK to a mask of
 122 the bits that must be zero on such a boundary.
 123
 124 * A_TEXT_OFFSET(HDR)
 125
 126 Some machines count the a.out header as part of the size of the text
 127 segment (a_text); they may actually load the header into core as the
 128 first data in the text segment.  Some have additional padding between
 129 the header and the real text of the program that is counted in a_text.
 130
 131 For these machines, define A_TEXT_OFFSET(HDR) to examine the header
 132 structure HDR and return the number of bytes to add to `a_text'
 133 before writing it (above and beyond the number of bytes of actual
 134 program text).  HDR's standard fields are already correct, except that
 135 this adjustment to the `a_text' field has not yet been made;
 136 thus, the amount of offset can depend on the data in the file.
 137
 138 * A_TEXT_SEEK(HDR)
 139
 140 If defined, this macro specifies the number of bytes to seek into the
 141 a.out file before starting to write the text segment.
 142
 143 * EXEC_MAGIC
 144
 145 For machines using COFF, this macro, if defined, is a value stored
 146 into the magic number field of the output file.
 147
 148 * ADJUST_EXEC_HEADER
 149
 150 This macro can be used to generate statements to adjust or
 151 initialize nonstandard fields in the file header
 152
 153 * ADDR_CORRECT(ADDR)
 154
 155 Macro to correct an int which is the bit pattern of a pointer to a byte
 156 into an int which is the number of a byte.
 157
 158 This macro has a default definition which is usually right.
 159 This default definition is a no-op on most machines (where a
 160 pointer looks like an int) but not on all machines.
 161
 162 */
 163
 164 #ifndef emacs
 165 #define PERROR(arg) perror (arg); return -1
 166 #else
 167 #define IN_UNEXEC
 168 #include <config.h>
 169 #define PERROR(file) report_error (file, new)
 170 #endif
 171
 172 #ifndef CANNOT_DUMP  /* all rest of file!  */
 173
 174 #ifdef COFF_ENCAPSULATE
 175 int need_coff_header = 1;
 176 #include <coff-encap/a.out.encap.h> /* The location might be a poor assumption */
 177 #else
 178 #ifdef MSDOS
 179 #include <coff.h>
 180 #define filehdr external_filehdr
 181 #define scnhdr external_scnhdr
 182 #define syment external_syment
 183 #define auxent external_auxent
 184 #define n_numaux e_numaux
 185 #define n_type e_type
 186 struct aouthdr
 187 {
 188   unsigned short        magic;  /* type of file                         */
 189   unsigned short        vstamp; /* version stamp                        */
 190   unsigned long         tsize;  /* text size in bytes, padded to FW bdry*/
 191   unsigned long         dsize;  /* initialized data "  "                */
 192   unsigned long         bsize;  /* uninitialized data "   "             */
 193   unsigned long         entry;  /* entry pt.                            */
 194   unsigned long         text_start;/* base of text used for this file */
 195   unsigned long         data_start;/* base of data used for this file */
 196 };
 197
 198
 199 #else /* not MSDOS */
 200 #include <a.out.h>
 201 #endif /* not MSDOS */
 202 #endif
 203
 204 /* Define getpagesize if the system does not.
 205    Note that this may depend on symbols defined in a.out.h.  */
 206 #include "getpagesize.h"
 207
 208 #ifndef makedev                 /* Try to detect types.h already loaded */
 209 #include <sys/types.h>
 210 #endif /* makedev */
 211 #include <stdio.h>
 212 #include <sys/stat.h>
 213 #include <errno.h>
 214
 215 #include <sys/file.h>   /* Must be after sys/types.h for USG and BSD4_1*/
 216
 217 #ifdef USG5
 218 #include <fcntl.h>
 219 #endif
 220
 221 #ifndef O_RDONLY
 222 #define O_RDONLY 0
 223 #endif
 224 #ifndef O_RDWR
 225 #define O_RDWR 2
 226 #endif
 227
 228
 229 extern char *start_of_text ();          /* Start of text */
 230 extern char *start_of_data ();          /* Start of initialized data */
 231
 232 #ifdef COFF
 233 static long block_copy_start;           /* Old executable start point */
 234 static struct filehdr f_hdr;            /* File header */
 235 static struct aouthdr f_ohdr;           /* Optional file header (a.out) */
 236 long bias;                      /* Bias to add for growth */
 237 long lnnoptr;                   /* Pointer to line-number info within file */
 238 #define SYMS_START block_copy_start
 239
 240 static long text_scnptr;
 241 static long data_scnptr;
 242
 243 #else /* not COFF */
 244
 245 #ifdef HPUX
 246 extern void *sbrk ();
 247 #else
 248 #if 0
 249 /* Some systems with __STDC__ compilers still declare this `char *' in some
 250    header file, and our declaration conflicts.  The return value is always
 251    cast, so it should be harmless to leave it undefined.  Hopefully
 252    machines with different size pointers and ints declare sbrk in a header
 253    file.  */
 254 #ifdef __STDC__
 255 extern void *sbrk ();
 256 #else
 257 extern char *sbrk ();
 258 #endif /* __STDC__ */
 259 #endif
 260 #endif /* HPUX */
 261
 262 #define SYMS_START ((long) N_SYMOFF (ohdr))
 263
 264 /* Some machines override the structure name for an a.out header.  */
 265 #ifndef EXEC_HDR_TYPE
 266 #define EXEC_HDR_TYPE struct exec
 267 #endif
 268
 269 #ifdef HPUX
 270 #ifdef HP9000S200_ID
 271 #define MY_ID HP9000S200_ID
 272 #else
 273 #include <model.h>
 274 #define MY_ID MYSYS
 275 #endif /* no HP9000S200_ID */
 276 static MAGIC OLDMAGIC = {MY_ID, SHARE_MAGIC};
 277 static MAGIC NEWMAGIC = {MY_ID, DEMAND_MAGIC};
 278 #define N_TXTOFF(x) TEXT_OFFSET(x)
 279 #define N_SYMOFF(x) LESYM_OFFSET(x)
 280 static EXEC_HDR_TYPE hdr, ohdr;
 281
 282 #else /* not HPUX */
 283
 284 #if defined (USG) && !defined (IBMAIX) && !defined (IRIS) && !defined (COFF_ENCAPSULATE) && !defined (LINUX)
 285 static struct bhdr hdr, ohdr;
 286 #define a_magic fmagic
 287 #define a_text tsize
 288 #define a_data dsize
 289 #define a_bss bsize
 290 #define a_syms ssize
 291 #define a_trsize rtsize
 292 #define a_drsize rdsize
 293 #define a_entry entry
 294 #define N_BADMAG(x) \
 295     (((x).fmagic)!=OMAGIC && ((x).fmagic)!=NMAGIC &&\
 296      ((x).fmagic)!=FMAGIC && ((x).fmagic)!=IMAGIC)
 297 #define NEWMAGIC FMAGIC
 298 #else /* IRIS or IBMAIX or not USG */
 299 static EXEC_HDR_TYPE hdr, ohdr;
 300 #define NEWMAGIC ZMAGIC
 301 #endif /* IRIS or IBMAIX not USG */
 302 #endif /* not HPUX */
 303
 304 static int unexec_text_start;
 305 static int unexec_data_start;
 306
 307 #ifdef COFF_ENCAPSULATE
 308 /* coffheader is defined in the GNU a.out.encap.h file.  */
 309 struct coffheader coffheader;
 310 #endif
 311
 312 #endif /* not COFF */
 313
 314 static int pagemask;
 315
 316 /* Correct an int which is the bit pattern of a pointer to a byte
 317    into an int which is the number of a byte.
 318    This is a no-op on ordinary machines, but not on all.  */
 319
 320 #ifndef ADDR_CORRECT   /* Let m-*.h files override this definition */
 321 #define ADDR_CORRECT(x) ((char *)(x) - (char*)0)
 322 #endif
 323
 324 #ifdef emacs
 325
 326 #include "lisp.h"
 327
 328 static
 329 report_error (file, fd)
 330      char *file;
 331      int fd;
 332 {
 333   if (fd)
 334     close (fd);
 335   report_file_error ("Cannot unexec", Fcons (build_string (file), Qnil));
 336 }
 337 #endif /* emacs */
 338
 339 #define ERROR0(msg) report_error_1 (new, msg, 0, 0); return -1
 340 #define ERROR1(msg,x) report_error_1 (new, msg, x, 0); return -1
 341 #define ERROR2(msg,x,y) report_error_1 (new, msg, x, y); return -1
 342
 343 static
 344 report_error_1 (fd, msg, a1, a2)
 345      int fd;
 346      char *msg;
 347      int a1, a2;
 348 {
 349   close (fd);
 350 #ifdef emacs
 351   error (msg, a1, a2);
 352 #else
 353   fprintf (stderr, msg, a1, a2);
 354   fprintf (stderr, "\n");
 355 #endif
 356 }
 357 \f
 358 static int make_hdr ();
 359 static int copy_text_and_data ();
 360 static int copy_sym ();
 361 static void mark_x ();
 362
 363 /* ****************************************************************
 364  * unexec
 365  *
 366  * driving logic.
 367  */
 368 unexec (new_name, a_name, data_start, bss_start, entry_address)
 369      char *new_name, *a_name;
 370      unsigned data_start, bss_start, entry_address;
 371 {
 372   int new, a_out = -1;
 373
 374   if (a_name && (a_out = open (a_name, O_RDONLY)) < 0)
 375     {
 376       PERROR (a_name);
 377     }
 378   if ((new = creat (new_name, 0666)) < 0)
 379     {
 380       PERROR (new_name);
 381     }
 382
 383   if (make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name) < 0
 384       || copy_text_and_data (new, a_out) < 0
 385       || copy_sym (new, a_out, a_name, new_name) < 0
 386 #ifdef COFF
 387 #ifndef COFF_BSD_SYMBOLS
 388       || adjust_lnnoptrs (new, a_out, new_name) < 0
 389 #endif
 390 #endif
 391       )
 392     {
 393       close (new);
 394       /* unlink (new_name);             /* Failed, unlink new a.out */
 395       return -1;
 396     }
 397
 398   close (new);
 399   if (a_out >= 0)
 400     close (a_out);
 401   mark_x (new_name);
 402   return 0;
 403 }
 404
 405 /* ****************************************************************
 406  * make_hdr
 407  *
 408  * Make the header in the new a.out from the header in core.
 409  * Modify the text and data sizes.
 410  */
 411 static int
 412 make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name)
 413      int new, a_out;
 414      unsigned data_start, bss_start, entry_address;
 415      char *a_name;
 416      char *new_name;
 417 {
 418   int tem;
 419 #ifdef COFF
 420   auto struct scnhdr f_thdr;            /* Text section header */
 421   auto struct scnhdr f_dhdr;            /* Data section header */
 422   auto struct scnhdr f_bhdr;            /* Bss section header */
 423   auto struct scnhdr scntemp;           /* Temporary section header */
 424   register int scns;
 425 #endif /* COFF */
 426 #ifdef USG_SHARED_LIBRARIES
 427   extern unsigned int bss_end;
 428 #else
 429   unsigned int bss_end;
 430 #endif
 431
 432   pagemask = getpagesize () - 1;
 433
 434   /* Adjust text/data boundary. */
 435 #ifdef NO_REMAP
 436   data_start = (int) start_of_data ();
 437 #else /* not NO_REMAP */
 438   if (!data_start)
 439     data_start = (int) start_of_data ();
 440 #endif /* not NO_REMAP */
 441   data_start = ADDR_CORRECT (data_start);
 442
 443 #ifdef SEGMENT_MASK
 444   data_start = data_start & ~SEGMENT_MASK; /* (Down) to segment boundary. */
 445 #else
 446   data_start = data_start & ~pagemask; /* (Down) to page boundary. */
 447 #endif
 448
 449   bss_end = ADDR_CORRECT (sbrk (0)) + pagemask;
 450   bss_end &= ~ pagemask;
 451
 452   /* Adjust data/bss boundary. */
 453   if (bss_start != 0)
 454     {
 455       bss_start = (ADDR_CORRECT (bss_start) + pagemask);
 456       /* (Up) to page bdry. */
 457       bss_start &= ~ pagemask;
 458       if (bss_start > bss_end)
 459         {
 460           ERROR1 ("unexec: Specified bss_start (%u) is past end of program",
 461                   bss_start);
 462         }
 463     }
 464   else
 465     bss_start = bss_end;
 466
 467   if (data_start > bss_start)   /* Can't have negative data size. */
 468     {
 469       ERROR2 ("unexec: data_start (%u) can't be greater than bss_start (%u)",
 470               data_start, bss_start);
 471     }
 472
 473 #ifdef COFF
 474   /* Salvage as much info from the existing file as possible */
 475   if (a_out >= 0)
 476     {
 477       if (read (a_out, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
 478         {
 479           PERROR (a_name);
 480         }
 481       block_copy_start += sizeof (f_hdr);
 482       if (f_hdr.f_opthdr > 0)
 483         {
 484           if (read (a_out, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
 485             {
 486               PERROR (a_name);
 487             }
 488           block_copy_start += sizeof (f_ohdr);
 489         }
 490       /* Loop through section headers, copying them in */
 491       lseek (a_out, sizeof (f_hdr) + f_hdr.f_opthdr, 0);
 492       for (scns = f_hdr.f_nscns; scns > 0; scns--) {
 493         if (read (a_out, &scntemp, sizeof (scntemp)) != sizeof (scntemp))
 494           {
 495             PERROR (a_name);
 496           }
 497         if (scntemp.s_scnptr > 0L)
 498           {
 499             if (block_copy_start < scntemp.s_scnptr + scntemp.s_size)
 500               block_copy_start = scntemp.s_scnptr + scntemp.s_size;
 501           }
 502         if (strcmp (scntemp.s_name, ".text") == 0)
 503           {
 504             f_thdr = scntemp;
 505           }
 506         else if (strcmp (scntemp.s_name, ".data") == 0)
 507           {
 508             f_dhdr = scntemp;
 509           }
 510         else if (strcmp (scntemp.s_name, ".bss") == 0)
 511           {
 512             f_bhdr = scntemp;
 513           }
 514       }
 515     }
 516   else
 517     {
 518       ERROR0 ("can't build a COFF file from scratch yet");
 519     }
 520
 521   /* Now we alter the contents of all the f_*hdr variables
 522      to correspond to what we want to dump.  */
 523
 524 #ifdef USG_SHARED_LIBRARIES
 525
 526   /* The amount of data we're adding to the file is distance from the
 527    * end of the original .data space to the current end of the .data
 528    * space.
 529    */
 530
 531   bias = bss_start - (f_ohdr.data_start + f_dhdr.s_size);
 532
 533 #endif
 534
 535   f_hdr.f_flags |= (F_RELFLG | F_EXEC);
 536 #ifdef TPIX
 537   f_hdr.f_nscns = 3;
 538 #endif
 539 #ifdef EXEC_MAGIC
 540   f_ohdr.magic = EXEC_MAGIC;
 541 #endif
 542 #ifndef NO_REMAP
 543   f_ohdr.text_start = (long) start_of_text ();
 544   f_ohdr.tsize = data_start - f_ohdr.text_start;
 545   f_ohdr.data_start = data_start;
 546 #endif /* NO_REMAP */
 547   f_ohdr.dsize = bss_start - f_ohdr.data_start;
 548   f_ohdr.bsize = bss_end - bss_start;
 549 #ifndef KEEP_OLD_TEXT_SCNPTR
 550   /* On some machines, the old values are right.
 551      ??? Maybe on all machines with NO_REMAP.  */
 552   f_thdr.s_size = f_ohdr.tsize;
 553   f_thdr.s_scnptr = sizeof (f_hdr) + sizeof (f_ohdr);
 554   f_thdr.s_scnptr += (f_hdr.f_nscns) * (sizeof (f_thdr));
 555 #endif /* KEEP_OLD_TEXT_SCNPTR */
 556 #ifdef ADJUST_TEXT_SCNHDR_SIZE
 557   /* On some machines, `text size' includes all headers.  */
 558   f_thdr.s_size -= f_thdr.s_scnptr;
 559 #endif /* ADJUST_TEST_SCNHDR_SIZE */
 560   lnnoptr = f_thdr.s_lnnoptr;
 561 #ifdef SECTION_ALIGNMENT
 562   /* Some systems require special alignment
 563      of the sections in the file itself.  */
 564   f_thdr.s_scnptr
 565     = (f_thdr.s_scnptr + SECTION_ALIGNMENT) & ~SECTION_ALIGNMENT;
 566 #endif /* SECTION_ALIGNMENT */
 567 #ifdef TPIX
 568   f_thdr.s_scnptr = 0xd0;
 569 #endif
 570   text_scnptr = f_thdr.s_scnptr;
 571 #ifdef ADJUST_TEXTBASE
 572   text_scnptr = sizeof (f_hdr) + sizeof (f_ohdr) + (f_hdr.f_nscns) * (sizeof (f_thdr));
 573 #endif
 574 #ifndef KEEP_OLD_PADDR
 575   f_dhdr.s_paddr = f_ohdr.data_start;
 576 #endif /* KEEP_OLD_PADDR */
 577   f_dhdr.s_vaddr = f_ohdr.data_start;
 578   f_dhdr.s_size = f_ohdr.dsize;
 579   f_dhdr.s_scnptr = f_thdr.s_scnptr + f_thdr.s_size;
 580 #ifdef SECTION_ALIGNMENT
 581   /* Some systems require special alignment
 582      of the sections in the file itself.  */
 583   f_dhdr.s_scnptr
 584     = (f_dhdr.s_scnptr + SECTION_ALIGNMENT) & ~SECTION_ALIGNMENT;
 585 #endif /* SECTION_ALIGNMENT */
 586 #ifdef DATA_SECTION_ALIGNMENT
 587   /* Some systems require special alignment
 588      of the data section only.  */
 589   f_dhdr.s_scnptr
 590     = (f_dhdr.s_scnptr + DATA_SECTION_ALIGNMENT) & ~DATA_SECTION_ALIGNMENT;
 591 #endif /* DATA_SECTION_ALIGNMENT */
 592   data_scnptr = f_dhdr.s_scnptr;
 593 #ifndef KEEP_OLD_PADDR
 594   f_bhdr.s_paddr = f_ohdr.data_start + f_ohdr.dsize;
 595 #endif /* KEEP_OLD_PADDR */
 596   f_bhdr.s_vaddr = f_ohdr.data_start + f_ohdr.dsize;
 597   f_bhdr.s_size = f_ohdr.bsize;
 598   f_bhdr.s_scnptr = 0L;
 599 #ifndef USG_SHARED_LIBRARIES
 600   bias = f_dhdr.s_scnptr + f_dhdr.s_size - block_copy_start;
 601 #endif
 602
 603   if (f_hdr.f_symptr > 0L)
 604     {
 605       f_hdr.f_symptr += bias;
 606     }
 607
 608   if (f_thdr.s_lnnoptr > 0L)
 609     {
 610       f_thdr.s_lnnoptr += bias;
 611     }
 612
 613 #ifdef ADJUST_EXEC_HEADER
 614   ADJUST_EXEC_HEADER;
 615 #endif /* ADJUST_EXEC_HEADER */
 616
 617   if (write (new, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
 618     {
 619       PERROR (new_name);
 620     }
 621
 622   if (write (new, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
 623     {
 624       PERROR (new_name);
 625     }
 626
 627 #ifndef USG_SHARED_LIBRARIES
 628
 629   if (write (new, &f_thdr, sizeof (f_thdr)) != sizeof (f_thdr))
 630     {
 631       PERROR (new_name);
 632     }
 633
 634   if (write (new, &f_dhdr, sizeof (f_dhdr)) != sizeof (f_dhdr))
 635     {
 636       PERROR (new_name);
 637     }
 638
 639   if (write (new, &f_bhdr, sizeof (f_bhdr)) != sizeof (f_bhdr))
 640     {
 641       PERROR (new_name);
 642     }
 643
 644 #else /* USG_SHARED_LIBRARIES */
 645
 646   /* The purpose of this code is to write out the new file's section
 647    * header table.
 648    *
 649    * Scan through the original file's sections.  If the encountered
 650    * section is one we know (.text, .data or .bss), write out the
 651    * correct header.  If it is a section we do not know (such as
 652    * .lib), adjust the address of where the section data is in the
 653    * file, and write out the header.
 654    *
 655    * If any section precedes .text or .data in the file, this code
 656    * will not adjust the file pointer for that section correctly.
 657    */
 658
 659   /* This used to use sizeof (f_ohdr) instead of .f_opthdr.
 660      .f_opthdr is said to be right when there is no optional header.  */
 661   lseek (a_out, sizeof (f_hdr) + f_hdr.f_opthdr, 0);
 662
 663   for (scns = f_hdr.f_nscns; scns > 0; scns--)
 664     {
 665       if (read (a_out, &scntemp, sizeof (scntemp)) != sizeof (scntemp))
 666         PERROR (a_name);
 667
 668       if (!strcmp (scntemp.s_name, f_thdr.s_name))      /* .text */
 669         {
 670           if (write (new, &f_thdr, sizeof (f_thdr)) != sizeof (f_thdr))
 671             PERROR (new_name);
 672         }
 673       else if (!strcmp (scntemp.s_name, f_dhdr.s_name)) /* .data */
 674         {
 675           if (write (new, &f_dhdr, sizeof (f_dhdr)) != sizeof (f_dhdr))
 676             PERROR (new_name);
 677         }
 678       else if (!strcmp (scntemp.s_name, f_bhdr.s_name)) /* .bss */
 679         {
 680           if (write (new, &f_bhdr, sizeof (f_bhdr)) != sizeof (f_bhdr))
 681             PERROR (new_name);
 682         }
 683       else
 684         {
 685           if (scntemp.s_scnptr)
 686             scntemp.s_scnptr += bias;
 687           if (write (new, &scntemp, sizeof (scntemp)) != sizeof (scntemp))
 688             PERROR (new_name);
 689         }
 690     }
 691 #endif /* USG_SHARED_LIBRARIES */
 692
 693   return (0);
 694
 695 #else /* if not COFF */
 696
 697   /* Get symbol table info from header of a.out file if given one. */
 698   if (a_out >= 0)
 699     {
 700 #ifdef COFF_ENCAPSULATE
 701       if (read (a_out, &coffheader, sizeof coffheader) != sizeof coffheader)
 702         {
 703           PERROR(a_name);
 704         }
 705       if (coffheader.f_magic != COFF_MAGIC)
 706         {
 707           ERROR1("%s doesn't have legal coff magic number\n", a_name);
 708         }
 709 #endif
 710       if (read (a_out, &ohdr, sizeof hdr) != sizeof hdr)
 711         {
 712           PERROR (a_name);
 713         }
 714
 715       if (N_BADMAG (ohdr))
 716         {
 717           ERROR1 ("invalid magic number in %s", a_name);
 718         }
 719       hdr = ohdr;
 720     }
 721   else
 722     {
 723 #ifdef COFF_ENCAPSULATE
 724       /* We probably could without too much trouble. The code is in gld
 725        * but I don't have that much time or incentive.
 726        */
 727       ERROR0 ("can't build a COFF file from scratch yet");
 728 #else
 729 #ifdef MSDOS    /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
 730       bzero ((void *)&hdr, sizeof hdr);
 731 #else
 732       bzero (&hdr, sizeof hdr);
 733 #endif
 734 #endif
 735     }
 736
 737   unexec_text_start = (long) start_of_text ();
 738   unexec_data_start = data_start;
 739
 740   /* Machine-dependent fixup for header, or maybe for unexec_text_start */
 741 #ifdef ADJUST_EXEC_HEADER
 742   ADJUST_EXEC_HEADER;
 743 #endif /* ADJUST_EXEC_HEADER */
 744
 745   hdr.a_trsize = 0;
 746   hdr.a_drsize = 0;
 747   if (entry_address != 0)
 748     hdr.a_entry = entry_address;
 749
 750   hdr.a_bss = bss_end - bss_start;
 751   hdr.a_data = bss_start - data_start;
 752 #ifdef NO_REMAP
 753   hdr.a_text = ohdr.a_text;
 754 #else /* not NO_REMAP */
 755   hdr.a_text = data_start - unexec_text_start;
 756
 757 #ifdef A_TEXT_OFFSET
 758   hdr.a_text += A_TEXT_OFFSET (ohdr);
 759 #endif
 760
 761 #endif /* not NO_REMAP */
 762
 763 #ifdef COFF_ENCAPSULATE
 764   /* We are encapsulating BSD format within COFF format.  */
 765   {
 766     struct coffscn *tp, *dp, *bp;
 767     tp = &coffheader.scns[0];
 768     dp = &coffheader.scns[1];
 769     bp = &coffheader.scns[2];
 770     tp->s_size = hdr.a_text + sizeof(struct exec);
 771     dp->s_paddr = data_start;
 772     dp->s_vaddr = data_start;
 773     dp->s_size = hdr.a_data;
 774     bp->s_paddr = dp->s_vaddr + dp->s_size;
 775     bp->s_vaddr = bp->s_paddr;
 776     bp->s_size = hdr.a_bss;
 777     coffheader.tsize = tp->s_size;
 778     coffheader.dsize = dp->s_size;
 779     coffheader.bsize = bp->s_size;
 780     coffheader.text_start = tp->s_vaddr;
 781     coffheader.data_start = dp->s_vaddr;
 782   }
 783   if (write (new, &coffheader, sizeof coffheader) != sizeof coffheader)
 784     {
 785       PERROR(new_name);
 786     }
 787 #endif /* COFF_ENCAPSULATE */
 788
 789   if (write (new, &hdr, sizeof hdr) != sizeof hdr)
 790     {
 791       PERROR (new_name);
 792     }
 793
 794 #if 0 /* This #ifndef caused a bug on Linux when using QMAGIC.  */
 795   /* This adjustment was done above only #ifndef NO_REMAP,
 796      so only undo it now #ifndef NO_REMAP.  */
 797   /* #ifndef NO_REMAP  */
 798 #endif
 799 #ifdef A_TEXT_OFFSET
 800   hdr.a_text -= A_TEXT_OFFSET (ohdr);
 801 #endif
 802
 803   return 0;
 804
 805 #endif /* not COFF */
 806 }
 807 \f
 808 /* ****************************************************************
 809  * copy_text_and_data
 810  *
 811  * Copy the text and data segments from memory to the new a.out
 812  */
 813 static int
 814 copy_text_and_data (new, a_out)
 815      int new, a_out;
 816 {
 817   register char *end;
 818   register char *ptr;
 819
 820 #ifdef COFF
 821
 822 #ifdef USG_SHARED_LIBRARIES
 823
 824   int scns;
 825   struct scnhdr scntemp;                /* Temporary section header */
 826
 827   /* The purpose of this code is to write out the new file's section
 828    * contents.
 829    *
 830    * Step through the section table.  If we know the section (.text,
 831    * .data) do the appropriate thing.  Otherwise, if the section has
 832    * no allocated space in the file (.bss), do nothing.  Otherwise,
 833    * the section has space allocated in the file, and is not a section
 834    * we know.  So just copy it.
 835    */
 836
 837   lseek (a_out, sizeof (struct filehdr) + sizeof (struct aouthdr), 0);
 838
 839   for (scns = f_hdr.f_nscns; scns > 0; scns--)
 840     {
 841       if (read (a_out, &scntemp, sizeof (scntemp)) != sizeof (scntemp))
 842         PERROR ("temacs");
 843
 844       if (!strcmp (scntemp.s_name, ".text"))
 845         {
 846           lseek (new, (long) text_scnptr, 0);
 847           ptr = (char *) f_ohdr.text_start;
 848           end = ptr + f_ohdr.tsize;
 849           write_segment (new, ptr, end);
 850         }
 851       else if (!strcmp (scntemp.s_name, ".data"))
 852         {
 853           lseek (new, (long) data_scnptr, 0);
 854           ptr = (char *) f_ohdr.data_start;
 855           end = ptr + f_ohdr.dsize;
 856           write_segment (new, ptr, end);
 857         }
 858       else if (!scntemp.s_scnptr)
 859         ; /* do nothing - no data for this section */
 860       else
 861         {
 862           char page[BUFSIZ];
 863           int size, n;
 864           long old_a_out_ptr = lseek (a_out, 0, 1);
 865
 866           lseek (a_out, scntemp.s_scnptr, 0);
 867           for (size = scntemp.s_size; size > 0; size -= sizeof (page))
 868             {
 869               n = size > sizeof (page) ? sizeof (page) : size;
 870               if (read (a_out, page, n) != n || write (new, page, n) != n)
 871                 PERROR ("emacs");
 872             }
 873           lseek (a_out, old_a_out_ptr, 0);
 874         }
 875     }
 876
 877 #else /* COFF, but not USG_SHARED_LIBRARIES */
 878
 879   lseek (new, (long) text_scnptr, 0);
 880   ptr = (char *) f_ohdr.text_start;
 881 #ifdef HEADER_INCL_IN_TEXT
 882   /* For Gould UTX/32, text starts after headers */
 883   ptr = (char *) (ptr + text_scnptr);
 884 #endif /* HEADER_INCL_IN_TEXT */
 885   end = ptr + f_ohdr.tsize;
 886   write_segment (new, ptr, end);
 887
 888   lseek (new, (long) data_scnptr, 0);
 889   ptr = (char *) f_ohdr.data_start;
 890   end = ptr + f_ohdr.dsize;
 891   write_segment (new, ptr, end);
 892
 893 #endif /* USG_SHARED_LIBRARIES */
 894
 895 #else /* if not COFF */
 896
 897 /* Some machines count the header as part of the text segment.
 898    That is to say, the header appears in core
 899    just before the address that start_of_text returns.
 900    For them, N_TXTOFF is the place where the header goes.
 901    We must adjust the seek to the place after the header.
 902    Note that at this point hdr.a_text does *not* count
 903    the extra A_TEXT_OFFSET bytes, only the actual bytes of code.  */
 904
 905 #ifdef A_TEXT_SEEK
 906   lseek (new, (long) A_TEXT_SEEK (hdr), 0);
 907 #else
 908   lseek (new, (long) N_TXTOFF (hdr), 0);
 909 #endif /* no A_TEXT_SEEK */
 910
 911 #ifdef RISCiX
 912
 913   /* Acorn's RISC-iX has a wacky way of initialising the position of the heap.
 914    * There is a little table in crt0.o that is filled at link time with
 915    * the min and current brk positions, among other things.  When start
 916    * runs, it copies the table to where these parameters live during
 917    * execution.  This data is in text space, so it cannot be modified here
 918    * before saving the executable, so the data is written manually.  In
 919    * addition, the table does not have a label, and the nearest accessible
 920    * label (mcount) is not prefixed with a '_', thus making it inaccessible
 921    * from within C programs.  To overcome this, emacs's executable is passed
 922    * through the command 'nm %s | fgrep mcount' into a pipe, and the
 923    * resultant output is then used to find the address of 'mcount'.  As far as
 924    * is possible to determine, in RISC-iX releases prior to 1.2, the negative
 925    * offset of the table from mcount is 0x2c, whereas from 1.2 onwards it is
 926    * 0x30.  bss_end has been rounded up to page boundary.  This solution is
 927    * based on suggestions made by Kevin Welton and Steve Hunt of Acorn, and
 928    * avoids the need for a custom version of crt0.o for emacs which has its
 929    * table in data space.
 930    */
 931
 932   {
 933     char command[1024];
 934     char errbuf[1024];
 935     char address_text[32];
 936     int  proforma[4];
 937     FILE *pfile;
 938     char *temp_ptr;
 939     char c;
 940     int mcount_address, mcount_offset, count;
 941     extern char *_execname;
 942
 943
 944     /* The use of _execname is incompatible with RISCiX 1.1 */
 945     sprintf (command, "nm %s | fgrep mcount", _execname);
 946
 947     if ( (pfile = popen(command, "r")) == NULL)
 948     {
 949       sprintf (errbuf, "Could not open pipe");
 950       PERROR (errbuf);
 951     }
 952
 953     count=0;
 954     while ( ((c=getc(pfile)) != EOF) && (c != ' ') && (count < 31))
 955       address_text[count++]=c;
 956     address_text[count]=0;
 957
 958     if ((count == 0) || pclose(pfile) != NULL)
 959     {
 960       sprintf (errbuf, "Failed to execute the command '%s'\n", command);
 961       PERROR (errbuf);
 962     }
 963
 964     sscanf(address_text, "%x", &mcount_address);
 965     ptr = (char *) unexec_text_start;
 966     mcount_offset = (char *)mcount_address - ptr;
 967
 968 #ifdef RISCiX_1_1
 969 #define EDATA_OFFSET 0x2c
 970 #else
 971 #define EDATA_OFFSET 0x30
 972 #endif
 973
 974     end = ptr + mcount_offset - EDATA_OFFSET;
 975
 976     write_segment (new, ptr, end);
 977
 978     proforma[0] = bss_end;      /* becomes _edata */
 979     proforma[1] = bss_end;      /* becomes _end */
 980     proforma[2] = bss_end;      /* becomes _minbrk */
 981     proforma[3] = bss_end;      /* becomes _curbrk */
 982
 983     write (new, proforma, 16);
 984
 985     temp_ptr = ptr;
 986     ptr = end + 16;
 987     end = temp_ptr + hdr.a_text;
 988
 989     write_segment (new, ptr, end);
 990   }
 991
 992 #else /* !RISCiX */
 993   ptr = (char *) unexec_text_start;
 994   end = ptr + hdr.a_text;
 995   write_segment (new, ptr, end);
 996 #endif /* RISCiX */
 997
 998   ptr = (char *) unexec_data_start;
 999   end = ptr + hdr.a_data;
1000 /*  This lseek is certainly incorrect when A_TEXT_OFFSET
1001     and I believe it is a no-op otherwise.
1002     Let's see if its absence ever fails.  */
1003 /*  lseek (new, (long) N_TXTOFF (hdr) + hdr.a_text, 0); */
1004   write_segment (new, ptr, end);
1005
1006 #endif /* not COFF */
1007
1008   return 0;
1009 }
1010
1011 write_segment (new, ptr, end)
1012      int new;
1013      register char *ptr, *end;
1014 {
1015   register int i, nwrite, ret;
1016   char buf[80];
1017   extern int errno;
1018   /* This is the normal amount to write at once.
1019      It is the size of block that NFS uses.  */
1020   int writesize = 1 << 13;
1021   int pagesize = getpagesize ();
1022   char zeros[1 << 13];
1023
1024   bzero (zeros, sizeof (zeros));
1025
1026   for (i = 0; ptr < end;)
1027     {
1028       /* Distance to next multiple of writesize.  */
1029       nwrite = (((int) ptr + writesize) & -writesize) - (int) ptr;
1030       /* But not beyond specified end.  */
1031       if (nwrite > end - ptr) nwrite = end - ptr;
1032       ret = write (new, ptr, nwrite);
1033       /* If write gets a page fault, it means we reached
1034          a gap between the old text segment and the old data segment.
1035          This gap has probably been remapped into part of the text segment.
1036          So write zeros for it.  */
1037       if (ret == -1
1038 #ifdef EFAULT
1039           && errno == EFAULT
1040 #endif
1041           )
1042         {
1043           /* Write only a page of zeros at once,
1044              so that we we don't overshoot the start
1045              of the valid memory in the old data segment.  */
1046           if (nwrite > pagesize)
1047             nwrite = pagesize;
1048           write (new, zeros, nwrite);
1049         }
1050 #if 0 /* Now that we have can ask `write' to write more than a page,
1051          it is legit for write do less than the whole amount specified.  */
1052       else if (nwrite != ret)
1053         {
1054           sprintf (buf,
1055                    "unexec write failure: addr 0x%x, fileno %d, size 0x%x, wrote 0x%x, errno %d",
1056                    ptr, new, nwrite, ret, errno);
1057           PERROR (buf);
1058         }
1059 #endif
1060       i += nwrite;
1061       ptr += nwrite;
1062     }
1063 }
1064 \f
1065 /* ****************************************************************
1066  * copy_sym
1067  *
1068  * Copy the relocation information and symbol table from the a.out to the new
1069  */
1070 static int
1071 copy_sym (new, a_out, a_name, new_name)
1072      int new, a_out;
1073      char *a_name, *new_name;
1074 {
1075   char page[1024];
1076   int n;
1077
1078   if (a_out < 0)
1079     return 0;
1080
1081 #ifdef COFF
1082   if (SYMS_START == 0L)
1083     return 0;
1084 #endif  /* COFF */
1085
1086 #ifdef COFF
1087   if (lnnoptr)                  /* if there is line number info */
1088     lseek (a_out, lnnoptr, 0);  /* start copying from there */
1089   else
1090 #endif /* COFF */
1091     lseek (a_out, SYMS_START, 0);       /* Position a.out to symtab. */
1092
1093   while ((n = read (a_out, page, sizeof page)) > 0)
1094     {
1095       if (write (new, page, n) != n)
1096         {
1097           PERROR (new_name);
1098         }
1099     }
1100   if (n < 0)
1101     {
1102       PERROR (a_name);
1103     }
1104   return 0;
1105 }
1106 \f
1107 /* ****************************************************************
1108  * mark_x
1109  *
1110  * After successfully building the new a.out, mark it executable
1111  */
1112 static void
1113 mark_x (name)
1114      char *name;
1115 {
1116   struct stat sbuf;
1117   int um;
1118   int new = 0;  /* for PERROR */
1119
1120   um = umask (777);
1121   umask (um);
1122   if (stat (name, &sbuf) == -1)
1123     {
1124       PERROR (name);
1125     }
1126   sbuf.st_mode |= 0111 & ~um;
1127   if (chmod (name, sbuf.st_mode) == -1)
1128     PERROR (name);
1129 }
1130 \f
1131 #ifdef COFF
1132 #ifndef COFF_BSD_SYMBOLS
1133
1134 /*
1135  *      If the COFF file contains a symbol table and a line number section,
1136  *      then any auxiliary entries that have values for x_lnnoptr must
1137  *      be adjusted by the amount that the line number section has moved
1138  *      in the file (bias computed in make_hdr).  The #@$%&* designers of
1139  *      the auxiliary entry structures used the absolute file offsets for
1140  *      the line number entry rather than an offset from the start of the
1141  *      line number section!
1142  *
1143  *      When I figure out how to scan through the symbol table and pick out
1144  *      the auxiliary entries that need adjustment, this routine will
1145  *      be fixed.  As it is now, all such entries are wrong and sdb
1146  *      will complain.   Fred Fish, UniSoft Systems Inc.
1147  */
1148
1149 /* This function is probably very slow.  Instead of reopening the new
1150    file for input and output it should copy from the old to the new
1151    using the two descriptors already open (WRITEDESC and READDESC).
1152    Instead of reading one small structure at a time it should use
1153    a reasonable size buffer.  But I don't have time to work on such
1154    things, so I am installing it as submitted to me.  -- RMS.  */
1155
1156 adjust_lnnoptrs (writedesc, readdesc, new_name)
1157      int writedesc;
1158      int readdesc;
1159      char *new_name;
1160 {
1161   register int nsyms;
1162   register int new;
1163 #if defined (amdahl_uts) || defined (pfa)
1164   SYMENT symentry;
1165   AUXENT auxentry;
1166 #else
1167   struct syment symentry;
1168   union auxent auxentry;
1169 #endif
1170
1171   if (!lnnoptr || !f_hdr.f_symptr)
1172     return 0;
1173
1174 #ifdef MSDOS
1175   if ((new = writedesc) < 0)
1176 #else
1177   if ((new = open (new_name, O_RDWR)) < 0)
1178 #endif
1179     {
1180       PERROR (new_name);
1181       return -1;
1182     }
1183
1184   lseek (new, f_hdr.f_symptr, 0);
1185   for (nsyms = 0; nsyms < f_hdr.f_nsyms; nsyms++)
1186     {
1187       read (new, &symentry, SYMESZ);
1188       if (symentry.n_numaux)
1189         {
1190           read (new, &auxentry, AUXESZ);
1191           nsyms++;
1192           if (ISFCN (symentry.n_type) || symentry.n_type == 0x2400)
1193             {
1194               auxentry.x_sym.x_fcnary.x_fcn.x_lnnoptr += bias;
1195               lseek (new, -AUXESZ, 1);
1196               write (new, &auxentry, AUXESZ);
1197             }
1198         }
1199     }
1200 #ifndef MSDOS
1201   close (new);
1202 #endif
1203   return 0;
1204 }
1205
1206 #endif /* COFF_BSD_SYMBOLS */
1207
1208 #endif /* COFF */
1209
1210 #endif /* not CANNOT_DUMP */