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