home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / e20313sr.zip / emacs / 20.3.1 / src / unexaix.c < prev    next >
C/C++ Source or Header  |  1999-07-31  |  25KB  |  883 lines
  1. /* Modified by Andrew.Vignaux@comp.vuw.ac.nz to get it to work :-) */
  2.  
  3. /* Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
  4.  
  5. This file is part of GNU Emacs.
  6.  
  7. GNU Emacs is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11.  
  12. GNU Emacs is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU Emacs; see the file COPYING.  If not, write to
  19. the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20. Boston, MA 02111-1307, USA.
  21.  
  22. In other words, you are welcome to use, share and improve this program.
  23. You are forbidden to forbid anyone else to use, share and improve
  24. what you give them.   Help stamp out software-hoarding!  */
  25.  
  26.  
  27. /*
  28.  * unexec.c - Convert a running program into an a.out file.
  29.  *
  30.  * Author:    Spencer W. Thomas
  31.  *         Computer Science Dept.
  32.  *         University of Utah
  33.  * Date:    Tue Mar  2 1982
  34.  * Modified heavily since then.
  35.  *
  36.  * Updated for AIX 4.1.3 by Bill_Mann @ PraxisInt.com, Feb 1996
  37.  *   As of AIX 4.1, text, data, and bss are pre-relocated by the binder in
  38.  *   such a way that the file can be mapped with code in one segment and
  39.  *   data/bss in another segment, without reading or copying the file, by
  40.  *   the AIX exec loader.  Padding sections are omitted, nevertheless
  41.  *   small amounts of 'padding' still occurs between sections in the file.
  42.  *   As modified, this code handles both 3.2 and 4.1 conventions.
  43.  *
  44.  * Synopsis:
  45.  *    unexec (new_name, a_name, data_start, bss_start, entry_address)
  46.  *    char *new_name, *a_name;
  47.  *    unsigned data_start, bss_start, entry_address;
  48.  *
  49.  * Takes a snapshot of the program and makes an a.out format file in the
  50.  * file named by the string argument new_name.
  51.  * If a_name is non-NULL, the symbol table will be taken from the given file.
  52.  * On some machines, an existing a_name file is required.
  53.  *
  54.  * The boundaries within the a.out file may be adjusted with the data_start
  55.  * and bss_start arguments.  Either or both may be given as 0 for defaults.
  56.  *
  57.  * Data_start gives the boundary between the text segment and the data
  58.  * segment of the program.  The text segment can contain shared, read-only
  59.  * program code and literal data, while the data segment is always unshared
  60.  * and unprotected.  Data_start gives the lowest unprotected address.
  61.  * The value you specify may be rounded down to a suitable boundary
  62.  * as required by the machine you are using.
  63.  *
  64.  * Specifying zero for data_start means the boundary between text and data
  65.  * should not be the same as when the program was loaded.
  66.  * If NO_REMAP is defined, the argument data_start is ignored and the
  67.  * segment boundaries are never changed.
  68.  *
  69.  * Bss_start indicates how much of the data segment is to be saved in the
  70.  * a.out file and restored when the program is executed.  It gives the lowest
  71.  * unsaved address, and is rounded up to a page boundary.  The default when 0
  72.  * is given assumes that the entire data segment is to be stored, including
  73.  * the previous data and bss as well as any additional storage allocated with
  74.  * break (2).
  75.  *
  76.  * The new file is set up to start at entry_address.
  77.  *
  78.  * If you make improvements I'd like to get them too.
  79.  * harpo!utah-cs!thomas, thomas@Utah-20
  80.  *
  81.  */
  82.  
  83. /* There are several compilation parameters affecting unexec:
  84.  
  85. * COFF
  86.  
  87. Define this if your system uses COFF for executables.
  88. Otherwise we assume you use Berkeley format.
  89.  
  90. * NO_REMAP
  91.  
  92. Define this if you do not want to try to save Emacs's pure data areas
  93. as part of the text segment.
  94.  
  95. Saving them as text is good because it allows users to share more.
  96.  
  97. However, on machines that locate the text area far from the data area,
  98. the boundary cannot feasibly be moved.  Such machines require
  99. NO_REMAP.
  100.  
  101. Also, remapping can cause trouble with the built-in startup routine
  102. /lib/crt0.o, which defines `environ' as an initialized variable.
  103. Dumping `environ' as pure does not work!  So, to use remapping,
  104. you must write a startup routine for your machine in Emacs's crt0.c.
  105. If NO_REMAP is defined, Emacs uses the system's crt0.o.
  106.  
  107. * SECTION_ALIGNMENT
  108.  
  109. Some machines that use COFF executables require that each section
  110. start on a certain boundary *in the COFF file*.  Such machines should
  111. define SECTION_ALIGNMENT to a mask of the low-order bits that must be
  112. zero on such a boundary.  This mask is used to control padding between
  113. segments in the COFF file.
  114.  
  115. If SECTION_ALIGNMENT is not defined, the segments are written
  116. consecutively with no attempt at alignment.  This is right for
  117. unmodified system V.
  118.  
  119. * SEGMENT_MASK
  120.  
  121. Some machines require that the beginnings and ends of segments
  122. *in core* be on certain boundaries.  For most machines, a page
  123. boundary is sufficient.  That is the default.  When a larger
  124. boundary is needed, define SEGMENT_MASK to a mask of
  125. the bits that must be zero on such a boundary.
  126.  
  127. * A_TEXT_OFFSET(HDR)
  128.  
  129. Some machines count the a.out header as part of the size of the text
  130. segment (a_text); they may actually load the header into core as the
  131. first data in the text segment.  Some have additional padding between
  132. the header and the real text of the program that is counted in a_text.
  133.  
  134. For these machines, define A_TEXT_OFFSET(HDR) to examine the header
  135. structure HDR and return the number of bytes to add to `a_text'
  136. before writing it (above and beyond the number of bytes of actual
  137. program text).  HDR's standard fields are already correct, except that
  138. this adjustment to the `a_text' field has not yet been made;
  139. thus, the amount of offset can depend on the data in the file.
  140.   
  141. * A_TEXT_SEEK(HDR)
  142.  
  143. If defined, this macro specifies the number of bytes to seek into the
  144. a.out file before starting to write the text segment.a
  145.  
  146. * EXEC_MAGIC
  147.  
  148. For machines using COFF, this macro, if defined, is a value stored
  149. into the magic number field of the output file.
  150.  
  151. * ADJUST_EXEC_HEADER
  152.  
  153. This macro can be used to generate statements to adjust or
  154. initialize nonstandard fields in the file header
  155.  
  156. * ADDR_CORRECT(ADDR)
  157.  
  158. Macro to correct an int which is the bit pattern of a pointer to a byte
  159. into an int which is the number of a byte.
  160.  
  161. This macro has a default definition which is usually right.
  162. This default definition is a no-op on most machines (where a
  163. pointer looks like an int) but not on all machines.
  164.  
  165. */
  166.  
  167. #define XCOFF
  168. #define COFF
  169. #define NO_REMAP
  170.  
  171. #ifndef emacs
  172. #define PERROR(arg) perror (arg); return -1
  173. #else
  174. #include <config.h>
  175. #define PERROR(file) report_error (file, new)
  176. #endif
  177.  
  178. #include <a.out.h>
  179. /* Define getpagesize () if the system does not.
  180.    Note that this may depend on symbols defined in a.out.h
  181.  */
  182. #include "getpagesize.h"
  183.  
  184. #ifndef makedev            /* Try to detect types.h already loaded */
  185. #include <sys/types.h>
  186. #endif
  187. #include <stdio.h>
  188. #include <sys/stat.h>
  189. #include <errno.h>
  190.  
  191. extern char *start_of_text ();        /* Start of text */
  192. extern char *start_of_data ();        /* Start of initialized data */
  193.  
  194. extern int _data;
  195. extern int _edata;
  196. extern int _text;
  197. extern int _etext;
  198. extern int _end;
  199. #ifdef COFF
  200. #ifndef USG
  201. #ifndef STRIDE
  202. #ifndef UMAX
  203. #ifndef sun386
  204. /* I have a suspicion that these are turned off on all systems
  205.    and can be deleted.  Try it in version 19.  */
  206. #include <filehdr.h>
  207. #include <aouthdr.h>
  208. #include <scnhdr.h>
  209. #include <syms.h>
  210. #endif /* not sun386 */
  211. #endif /* not UMAX */
  212. #endif /* Not STRIDE */
  213. #endif /* not USG */
  214. static struct filehdr f_hdr;        /* File header */
  215. static struct aouthdr f_ohdr;        /* Optional file header (a.out) */
  216. long bias;            /* Bias to add for growth */
  217. long lnnoptr;            /* Pointer to line-number info within file */
  218.  
  219. static long text_scnptr;
  220. static long data_scnptr;
  221. #ifdef XCOFF
  222. #define ALIGN(val, pwr) (((val) + ((1L<<(pwr))-1)) & ~((1L<<(pwr))-1))
  223. static long load_scnptr;
  224. static long orig_load_scnptr;
  225. static long orig_data_scnptr;
  226. #endif
  227. static ulong data_st;                   /* start of data area written out */
  228.  
  229. #ifndef MAX_SECTIONS
  230. #define MAX_SECTIONS    10
  231. #endif
  232.  
  233. #endif /* COFF */
  234.  
  235. static int pagemask;
  236.  
  237. /* Correct an int which is the bit pattern of a pointer to a byte
  238.    into an int which is the number of a byte.
  239.    This is a no-op on ordinary machines, but not on all.  */
  240.  
  241. #ifndef ADDR_CORRECT   /* Let m-*.h files override this definition */
  242. #define ADDR_CORRECT(x) ((char *)(x) - (char*)0)
  243. #endif
  244.  
  245. #ifdef emacs
  246. #include "lisp.h"
  247.  
  248. static
  249. report_error (file, fd)
  250.      char *file;
  251.      int fd;
  252. {
  253.   if (fd)
  254.     close (fd);
  255.   report_file_error ("Cannot unexec", Fcons (build_string (file), Qnil));
  256. }
  257. #endif /* emacs */
  258.  
  259. #define ERROR0(msg) report_error_1 (new, msg, 0, 0); return -1
  260. #define ERROR1(msg,x) report_error_1 (new, msg, x, 0); return -1
  261. #define ERROR2(msg,x,y) report_error_1 (new, msg, x, y); return -1
  262.  
  263. static
  264. report_error_1 (fd, msg, a1, a2)
  265.      int fd;
  266.      char *msg;
  267.      int a1, a2;
  268. {
  269.   close (fd);
  270. #ifdef emacs
  271.   error (msg, a1, a2);
  272. #else
  273.   fprintf (stderr, msg, a1, a2);
  274.   fprintf (stderr, "\n");
  275. #endif
  276. }
  277.  
  278. static int make_hdr ();
  279. static void mark_x ();
  280. static int copy_text_and_data ();
  281. static int copy_sym ();
  282.  
  283. /* ****************************************************************
  284.  * unexec
  285.  *
  286.  * driving logic.
  287.  */
  288. unexec (new_name, a_name, data_start, bss_start, entry_address)
  289.      char *new_name, *a_name;
  290.      unsigned data_start, bss_start, entry_address;
  291. {
  292.   int new, a_out = -1;
  293.  
  294.   if (a_name && (a_out = open (a_name, 0)) < 0)
  295.     {
  296.       PERROR (a_name);
  297.     }
  298.   if ((new = creat (new_name, 0666)) < 0)
  299.     {
  300.       PERROR (new_name);
  301.     }
  302.   if (make_hdr (new,a_out,data_start,bss_start,entry_address,a_name,new_name) < 0
  303.       || copy_text_and_data (new) < 0
  304.       || copy_sym (new, a_out, a_name, new_name) < 0
  305. #ifdef COFF
  306.       || adjust_lnnoptrs (new, a_out, new_name) < 0
  307. #endif
  308. #ifdef XCOFF
  309.       || unrelocate_symbols (new, a_out, a_name, new_name) < 0
  310. #endif
  311.       )
  312.     {
  313.       close (new);
  314.       return -1;    
  315.     }
  316.  
  317.   close (new);
  318.   if (a_out >= 0)
  319.     close (a_out);
  320.   mark_x (new_name);
  321.   return 0;
  322. }
  323.  
  324. /* ****************************************************************
  325.  * make_hdr
  326.  *
  327.  * Make the header in the new a.out from the header in core.
  328.  * Modify the text and data sizes.
  329.  */
  330. static int
  331. make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name)
  332.      int new, a_out;
  333.      unsigned data_start, bss_start, entry_address;
  334.      char *a_name;
  335.      char *new_name;
  336. {
  337.   register int scns;
  338.   unsigned int bss_end;
  339.  
  340.   struct scnhdr section[MAX_SECTIONS];
  341.   struct scnhdr * f_thdr;        /* Text section header */
  342.   struct scnhdr * f_dhdr;        /* Data section header */
  343.   struct scnhdr * f_bhdr;        /* Bss section header */
  344.   struct scnhdr * f_lhdr;        /* Loader section header */
  345.   struct scnhdr * f_tchdr;        /* Typechk section header */
  346.   struct scnhdr * f_dbhdr;        /* Debug section header */
  347.   struct scnhdr * f_xhdr;        /* Except section header */
  348.  
  349.   load_scnptr = orig_load_scnptr = lnnoptr = 0;
  350.   pagemask = getpagesize () - 1;
  351.  
  352.   /* Adjust text/data boundary. */
  353. #ifdef NO_REMAP
  354.   data_start = (long) start_of_data ();
  355. #endif /*  NO_REMAP */
  356.   data_start = ADDR_CORRECT (data_start);
  357.  
  358. #ifdef SEGMENT_MASK
  359.   data_start = data_start & ~SEGMENT_MASK; /* (Down) to segment boundary. */
  360. #else
  361.   data_start = data_start & ~pagemask; /* (Down) to page boundary. */
  362. #endif
  363.  
  364.  
  365.   bss_end = ADDR_CORRECT (sbrk (0)) + pagemask;
  366.   bss_end &= ~ pagemask;
  367.   /* Adjust data/bss boundary. */
  368.   if (bss_start != 0)
  369.     {
  370.       bss_start = (ADDR_CORRECT (bss_start) + pagemask);
  371.       /* (Up) to page bdry. */
  372.       bss_start &= ~ pagemask;
  373.       if (bss_start > bss_end)
  374.     {
  375.       ERROR1 ("unexec: Specified bss_start (%u) is past end of program",
  376.           bss_start);
  377.     }
  378.     }
  379.   else
  380.     bss_start = bss_end;
  381.  
  382.   if (data_start > bss_start)    /* Can't have negative data size. */
  383.     {
  384.       ERROR2 ("unexec: data_start (%u) can't be greater than bss_start (%u)",
  385.           data_start, bss_start);
  386.     }
  387.  
  388. #ifdef COFF
  389.   /* Salvage as much info from the existing file as possible */
  390.   f_thdr = NULL; f_dhdr = NULL; f_bhdr = NULL;
  391.   f_lhdr = NULL; f_tchdr = NULL; f_dbhdr = NULL; f_xhdr = NULL;
  392.   if (a_out >= 0)
  393.     {
  394.       if (read (a_out, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
  395.     {
  396.       PERROR (a_name);
  397.     }
  398.       if (f_hdr.f_opthdr > 0)
  399.     {
  400.       if (read (a_out, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
  401.         {
  402.           PERROR (a_name);
  403.         }
  404.     }
  405.       if (f_hdr.f_nscns > MAX_SECTIONS)
  406.     {
  407.       ERROR0 ("unexec: too many section headers -- increase MAX_SECTIONS");
  408.     }
  409.       /* Loop through section headers */
  410.       for (scns = 0; scns < f_hdr.f_nscns; scns++) {
  411.     struct scnhdr *s = §ion[scns];
  412.     if (read (a_out, s, sizeof (*s)) != sizeof (*s))
  413.       {
  414.         PERROR (a_name);
  415.       }
  416.  
  417. #define CHECK_SCNHDR(ptr, name, flags) \
  418.   if (strcmp(s->s_name, name) == 0) { \
  419.     if (s->s_flags != flags) { \
  420.       fprintf(stderr, "unexec: %lx flags where %x expected in %s section.\n", \
  421.           (unsigned long)s->s_flags, flags, name); \
  422.     } \
  423.     if (ptr) { \
  424.       fprintf(stderr, "unexec: duplicate section header for section %s.\n", \
  425.           name); \
  426.     } \
  427.     ptr = s; \
  428.   }
  429.     CHECK_SCNHDR(f_thdr, _TEXT, STYP_TEXT);
  430.     CHECK_SCNHDR(f_dhdr, _DATA, STYP_DATA);
  431.     CHECK_SCNHDR(f_bhdr, _BSS, STYP_BSS);
  432.     CHECK_SCNHDR(f_lhdr, _LOADER, STYP_LOADER);
  433.     CHECK_SCNHDR(f_dbhdr, _DEBUG,  STYP_DEBUG);
  434.     CHECK_SCNHDR(f_tchdr, _TYPCHK,  STYP_TYPCHK);
  435.     CHECK_SCNHDR(f_xhdr, _EXCEPT,  STYP_EXCEPT);
  436.       }
  437.  
  438.       if (f_thdr == 0)
  439.     {
  440.       ERROR1 ("unexec: couldn't find \"%s\" section", _TEXT);
  441.     }
  442.       if (f_dhdr == 0)
  443.     {
  444.       ERROR1 ("unexec: couldn't find \"%s\" section", _DATA);
  445.     }
  446.       if (f_bhdr == 0)
  447.     {
  448.       ERROR1 ("unexec: couldn't find \"%s\" section", _BSS);
  449.     }
  450.     }
  451.   else
  452.     {
  453.       ERROR0 ("can't build a COFF file from scratch yet");
  454.     }
  455.   orig_data_scnptr = f_dhdr->s_scnptr;
  456.   orig_load_scnptr = f_lhdr ? f_lhdr->s_scnptr : 0;
  457.  
  458.   /* Now we alter the contents of all the f_*hdr variables
  459.      to correspond to what we want to dump.  */
  460.  
  461.   /* Indicate that the reloc information is no longer valid for ld (bind);
  462.      we only update it enough to fake out the exec-time loader.  */
  463.   f_hdr.f_flags |= (F_RELFLG | F_EXEC);
  464.  
  465. #ifdef EXEC_MAGIC
  466.   f_ohdr.magic = EXEC_MAGIC;
  467. #endif
  468. #ifndef NO_REMAP
  469.   f_ohdr.tsize = data_start - f_ohdr.text_start;
  470.   f_ohdr.text_start = (long) start_of_text ();
  471. #endif
  472.   data_st = f_ohdr.data_start ? f_ohdr.data_start : (ulong) &_data;
  473.   f_ohdr.dsize = bss_start - data_st;
  474.   f_ohdr.bsize = bss_end - bss_start;
  475.  
  476.   f_dhdr->s_size = f_ohdr.dsize;
  477.   f_bhdr->s_size = f_ohdr.bsize;
  478.   f_bhdr->s_paddr = f_ohdr.data_start + f_ohdr.dsize;
  479.   f_bhdr->s_vaddr = f_ohdr.data_start + f_ohdr.dsize;
  480.  
  481.   /* fix scnptr's */
  482.   {
  483.     ulong ptr = section[0].s_scnptr;
  484.  
  485.     bias = -1;
  486.     for (scns = 0; scns < f_hdr.f_nscns; scns++)
  487.       {
  488.     struct scnhdr *s = §ion[scns];
  489.  
  490.     if (s->s_flags & STYP_PAD)        /* .pad sections omitted in AIX 4.1 */
  491.       {
  492.         /*
  493.          * the text_start should probably be o_algntext but that doesn't
  494.          * seem to change
  495.          */
  496.         if (f_ohdr.text_start != 0) /* && scns != 0 */
  497.           {
  498.         s->s_size = 512 - (ptr % 512);
  499.         if (s->s_size == 512)
  500.           s->s_size = 0;
  501.           }
  502.         s->s_scnptr = ptr;
  503.       }
  504.     else if (s->s_flags & STYP_DATA)
  505.       s->s_scnptr = ptr;
  506.     else if (!(s->s_flags & (STYP_TEXT | STYP_BSS)))
  507.       {
  508.         if (bias == -1)                /* if first section after bss */
  509.           bias = ptr - s->s_scnptr;
  510.  
  511.         s->s_scnptr += bias;
  512.         ptr = s->s_scnptr;
  513.       }
  514.   
  515.     ptr = ptr + s->s_size;
  516.       }
  517.   }
  518.  
  519.   /* fix other pointers */
  520.   for (scns = 0; scns < f_hdr.f_nscns; scns++)
  521.     {
  522.       struct scnhdr *s = §ion[scns];
  523.  
  524.       if (s->s_relptr != 0)
  525.     {
  526.       s->s_relptr += bias;
  527.     }
  528.       if (s->s_lnnoptr != 0)
  529.     {
  530.       if (lnnoptr == 0) lnnoptr = s->s_lnnoptr;
  531.       s->s_lnnoptr += bias;
  532.     }
  533.     }
  534.  
  535.   if (f_hdr.f_symptr > 0L)
  536.     {
  537.       f_hdr.f_symptr += bias;
  538.     }
  539.  
  540.   text_scnptr = f_thdr->s_scnptr;
  541.   data_scnptr = f_dhdr->s_scnptr;
  542.   load_scnptr = f_lhdr ? f_lhdr->s_scnptr : 0;
  543.  
  544. #ifdef ADJUST_EXEC_HEADER
  545.   ADJUST_EXEC_HEADER
  546. #endif /* ADJUST_EXEC_HEADER */
  547.  
  548.   if (write (new, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
  549.     {
  550.       PERROR (new_name);
  551.     }
  552.  
  553.   if (f_hdr.f_opthdr > 0)
  554.     {
  555.       if (write (new, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
  556.     {
  557.       PERROR (new_name);
  558.     }
  559.     }
  560.  
  561.   for (scns = 0; scns < f_hdr.f_nscns; scns++) {
  562.     struct scnhdr *s = §ion[scns];
  563.     if (write (new, s, sizeof (*s)) != sizeof (*s))
  564.       {
  565.     PERROR (new_name);
  566.       }
  567.   }
  568.  
  569.   return (0);
  570.  
  571. #endif /* COFF */
  572. }
  573.  
  574. /* ****************************************************************
  575.  
  576.  *
  577.  * Copy the text and data segments from memory to the new a.out
  578.  */
  579. static int
  580. copy_text_and_data (new)
  581.      int new;
  582. {
  583.   register char *end;
  584.   register char *ptr;
  585.  
  586.   lseek (new, (long) text_scnptr, 0);
  587.   ptr = start_of_text () + text_scnptr;
  588.   end = ptr + f_ohdr.tsize;
  589.   write_segment (new, ptr, end);
  590.  
  591.   lseek (new, (long) data_scnptr, 0);
  592.   ptr = (char *) data_st;
  593.   end = ptr + f_ohdr.dsize;
  594.   write_segment (new, ptr, end);
  595.  
  596.   return 0;
  597. }
  598.  
  599. #define UnexBlockSz (1<<12)            /* read/write block size */
  600. write_segment (new, ptr, end)
  601.      int new;
  602.      register char *ptr, *end;
  603. {
  604.   register int i, nwrite, ret;
  605.   char buf[80];
  606.   extern int errno;
  607.   char zeros[UnexBlockSz];
  608.  
  609.   for (i = 0; ptr < end;)
  610.     {
  611.       /* distance to next block.  */
  612.       nwrite = (((int) ptr + UnexBlockSz) & -UnexBlockSz) - (int) ptr;
  613.       /* But not beyond specified end.  */
  614.       if (nwrite > end - ptr) nwrite = end - ptr;
  615.       ret = write (new, ptr, nwrite);
  616.       /* If write gets a page fault, it means we reached
  617.      a gap between the old text segment and the old data segment.
  618.      This gap has probably been remapped into part of the text segment.
  619.      So write zeros for it.  */
  620.       if (ret == -1 && errno == EFAULT)
  621.     {
  622.       bzero (zeros, nwrite);
  623.       write (new, zeros, nwrite);
  624.     }
  625.       else if (nwrite != ret)
  626.     {
  627.       sprintf (buf,
  628.            "unexec write failure: addr 0x%lx, fileno %d, size 0x%x, wrote 0x%x, errno %d",
  629.            (unsigned long)ptr, new, nwrite, ret, errno);
  630.       PERROR (buf);
  631.     }
  632.       i += nwrite;
  633.       ptr += nwrite;
  634.     }
  635. }
  636.  
  637. /* ****************************************************************
  638.  * copy_sym
  639.  *
  640.  * Copy the relocation information and symbol table from the a.out to the new
  641.  */
  642. static int
  643. copy_sym (new, a_out, a_name, new_name)
  644.      int new, a_out;
  645.      char *a_name, *new_name;
  646. {
  647.   char page[UnexBlockSz];
  648.   int n;
  649.  
  650.   if (a_out < 0)
  651.     return 0;
  652.  
  653.   if (orig_load_scnptr == 0L)
  654.     return 0;
  655.  
  656.   if (lnnoptr && lnnoptr < orig_load_scnptr) /* if there is line number info  */
  657.     lseek (a_out, lnnoptr, 0);  /* start copying from there */
  658.   else
  659.     lseek (a_out, orig_load_scnptr, 0); /* Position a.out to symtab. */
  660.  
  661.   while ((n = read (a_out, page, sizeof page)) > 0)
  662.     {
  663.       if (write (new, page, n) != n)
  664.     {
  665.       PERROR (new_name);
  666.     }
  667.     }
  668.   if (n < 0)
  669.     {
  670.       PERROR (a_name);
  671.     }
  672.   return 0;
  673. }
  674.  
  675. /* ****************************************************************
  676.  * mark_x
  677.  *
  678.  * After successfully building the new a.out, mark it executable
  679.  */
  680. static void
  681. mark_x (name)
  682.      char *name;
  683. {
  684.   struct stat sbuf;
  685.   int um;
  686.   int new = 0;  /* for PERROR */
  687.  
  688.   um = umask (777);
  689.   umask (um);
  690.   if (stat (name, &sbuf) == -1)
  691.     {
  692.       PERROR (name);
  693.     }
  694.   sbuf.st_mode |= 0111 & ~um;
  695.   if (chmod (name, sbuf.st_mode) == -1)
  696.     PERROR (name);
  697. }
  698.  
  699. /*
  700.  *    If the COFF file contains a symbol table and a line number section,
  701.  *    then any auxiliary entries that have values for x_lnnoptr must
  702.  *    be adjusted by the amount that the line number section has moved
  703.  *    in the file (bias computed in make_hdr).  The #@$%&* designers of
  704.  *    the auxiliary entry structures used the absolute file offsets for
  705.  *    the line number entry rather than an offset from the start of the
  706.  *    line number section!
  707.  *
  708.  *    When I figure out how to scan through the symbol table and pick out
  709.  *    the auxiliary entries that need adjustment, this routine will
  710.  *    be fixed.  As it is now, all such entries are wrong and sdb
  711.  *    will complain.   Fred Fish, UniSoft Systems Inc.
  712.  *
  713.  *      I believe this is now fixed correctly.  Bill Mann
  714.  */
  715.  
  716. #ifdef COFF
  717.  
  718. /* This function is probably very slow.  Instead of reopening the new
  719.    file for input and output it should copy from the old to the new
  720.    using the two descriptors already open (WRITEDESC and READDESC).
  721.    Instead of reading one small structure at a time it should use
  722.    a reasonable size buffer.  But I don't have time to work on such
  723.    things, so I am installing it as submitted to me.  -- RMS.  */
  724.  
  725. adjust_lnnoptrs (writedesc, readdesc, new_name)
  726.      int writedesc;
  727.      int readdesc;
  728.      char *new_name;
  729. {
  730.   register int nsyms;
  731.   register int naux;
  732.   register int new;
  733. #ifdef amdahl_uts
  734.   SYMENT symentry;
  735.   AUXENT auxentry;
  736. #else
  737.   struct syment symentry;
  738.   union auxent auxentry;
  739. #endif
  740.  
  741.   if (!lnnoptr || !f_hdr.f_symptr)
  742.     return 0;
  743.  
  744.   if ((new = open (new_name, 2)) < 0)
  745.     {
  746.       PERROR (new_name);
  747.       return -1;
  748.     }
  749.  
  750.   lseek (new, f_hdr.f_symptr, 0);
  751.   for (nsyms = 0; nsyms < f_hdr.f_nsyms; nsyms++)
  752.     {
  753.       read (new, &symentry, SYMESZ);
  754.       if (symentry.n_sclass == C_BINCL || symentry.n_sclass == C_EINCL)
  755.     {
  756.       symentry.n_value += bias;
  757.       lseek (new, -SYMESZ, 1);
  758.       write (new, &symentry, SYMESZ);
  759.     }
  760.  
  761.       for (naux = symentry.n_numaux; naux-- != 0; )
  762.     {
  763.       read (new, &auxentry, AUXESZ);
  764.       nsyms++;
  765.       if (naux != 0              /* skip csect auxentry (last entry) */
  766.               && (symentry.n_sclass == C_EXT || symentry.n_sclass == C_HIDEXT))
  767.             {
  768.               auxentry.x_sym.x_fcnary.x_fcn.x_lnnoptr += bias;
  769.               lseek (new, -AUXESZ, 1);
  770.               write (new, &auxentry, AUXESZ);
  771.             }
  772.     }
  773.     }
  774.   close (new);
  775. }
  776.  
  777. #endif /* COFF */
  778.  
  779. #ifdef XCOFF
  780.  
  781. /* It is probably a false economy to optimise this routine (it used to
  782.    read one LDREL and do do two lseeks per iteration) but the wrath of
  783.    RMS (see above :-) would be too much to bear */
  784.  
  785. unrelocate_symbols (new, a_out, a_name, new_name)
  786.      int new, a_out;
  787.      char *a_name, *new_name;
  788. {
  789.   register int i;
  790.   register int l;
  791.   register LDREL *ldrel;
  792.   LDHDR ldhdr;
  793.   LDREL ldrel_buf [20];
  794.   ulong t_reloc = (ulong) &_text - f_ohdr.text_start;
  795.   ulong d_reloc = (ulong) &_data - ALIGN(f_ohdr.data_start, 2);
  796.   int * p;
  797.  
  798.   if (load_scnptr == 0)
  799.     return 0;
  800.  
  801.   lseek (a_out, orig_load_scnptr, 0);
  802.   if (read (a_out, &ldhdr, sizeof (ldhdr)) != sizeof (ldhdr))
  803.     {
  804.       PERROR (new_name);
  805.     }
  806.  
  807. #define SYMNDX_TEXT    0
  808. #define SYMNDX_DATA    1
  809. #define SYMNDX_BSS    2
  810.   l = 0;
  811.   for (i = 0; i < ldhdr.l_nreloc; i++, l--, ldrel++)
  812.     {
  813.       if (l == 0) {
  814.     lseek (a_out,
  815.            orig_load_scnptr + LDHDRSZ + LDSYMSZ*ldhdr.l_nsyms + LDRELSZ*i,
  816.            0);
  817.  
  818.     l = ldhdr.l_nreloc - i;
  819.     if (l > sizeof (ldrel_buf) / LDRELSZ)
  820.       l = sizeof (ldrel_buf) / LDRELSZ;
  821.  
  822.     if (read (a_out, ldrel_buf, l * LDRELSZ) != l * LDRELSZ)
  823.       {
  824.         PERROR (a_name);
  825.       }
  826.     ldrel = ldrel_buf;
  827.       }
  828.  
  829.       /* move the BSS loader symbols to the DATA segment */
  830.       if (ldrel->l_symndx == SYMNDX_BSS)
  831.     {
  832.       ldrel->l_symndx = SYMNDX_DATA;
  833.  
  834.       lseek (new,
  835.          load_scnptr + LDHDRSZ + LDSYMSZ*ldhdr.l_nsyms + LDRELSZ*i,
  836.          0);
  837.  
  838.       if (write (new, ldrel, LDRELSZ) != LDRELSZ)
  839.         {
  840.           PERROR (new_name);
  841.         }
  842.     }
  843.  
  844.       if (ldrel->l_rsecnm == f_ohdr.o_sndata)
  845.     {
  846.       int orig_int;
  847.  
  848.       lseek (a_out,
  849.                  orig_data_scnptr + (ldrel->l_vaddr - f_ohdr.data_start), 0);
  850.  
  851.       if (read (a_out, (void *) &orig_int, sizeof (orig_int)) != sizeof (orig_int))
  852.         {
  853.           PERROR (a_name);
  854.         }
  855.  
  856.           p = (int *) (ldrel->l_vaddr + d_reloc);
  857.  
  858.       switch (ldrel->l_symndx) {
  859.       case SYMNDX_TEXT:
  860.         orig_int = * p - t_reloc;
  861.         break;
  862.  
  863.       case SYMNDX_DATA:
  864.       case SYMNDX_BSS:
  865.         orig_int = * p - d_reloc;
  866.         break;
  867.       }
  868.  
  869.           if (orig_int != * p)
  870.             {
  871.               lseek (new,
  872.                      data_scnptr + (ldrel->l_vaddr - f_ohdr.data_start), 0);
  873.               if (write (new, (void *) &orig_int, sizeof (orig_int))
  874.                   != sizeof (orig_int))
  875.                 {
  876.                   PERROR (new_name);
  877.                 }
  878.             }
  879.     }
  880.     }
  881. }
  882. #endif /* XCOFF */
  883.