1 /* Modified version of unexec for convex machines.
2 Copyright (C) 1985, 1986, 1988 Free Software Foundation, Inc.
4 This file is part of XEmacs.
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
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
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. */
21 /* Synched up with: FSF 19.31. */
24 /* modified for C-1 arch by jthomp@convex 871103 */
25 /* Corrected to support convex SOFF object file formats and thread specific
26 * regions. streepy@convex 890302
30 * unexec.c - Convert a running program into an a.out file.
32 * Author: Spencer W. Thomas
33 * Computer Science Dept.
35 * Date: Tue Mar 2 1982
36 * Modified heavily since then.
39 * unexec (new_name, a_name, data_start, bss_start, entry_address)
40 * char *new_name, *a_name;
41 * unsigned data_start, bss_start, entry_address;
43 * Takes a snapshot of the program and makes an a.out format file in the
44 * file named by the string argument new_name.
45 * If a_name is non-NULL, the symbol table will be taken from the given file.
46 * On some machines, an existing a_name file is required.
48 * The boundaries within the a.out file may be adjusted with the data_start
49 * and bss_start arguments. Either or both may be given as 0 for defaults.
51 * Data_start gives the boundary between the text segment and the data
52 * segment of the program. The text segment can contain shared, read-only
53 * program code and literal data, while the data segment is always unshared
54 * and unprotected. Data_start gives the lowest unprotected address.
55 * The value you specify may be rounded down to a suitable boundary
56 * as required by the machine you are using.
58 * Specifying zero for data_start means the boundary between text and data
59 * should not be the same as when the program was loaded.
60 * If NO_REMAP is defined, the argument data_start is ignored and the
61 * segment boundaries are never changed.
63 * Bss_start indicates how much of the data segment is to be saved in the
64 * a.out file and restored when the program is executed. It gives the lowest
65 * unsaved address, and is rounded up to a page boundary. The default when 0
66 * is given assumes that the entire data segment is to be stored, including
67 * the previous data and bss as well as any additional storage allocated with
70 * The new file is set up to start at entry_address.
72 * If you make improvements I'd like to get them too.
73 * harpo!utah-cs!thomas, thomas@Utah-20
77 /* There are several compilation parameters affecting unexec:
81 Define this if your system uses COFF for executables.
82 Otherwise we assume you use Berkeley format.
86 Define this if you do not want to try to save Emacs's pure data areas
87 as part of the text segment.
89 Saving them as text is good because it allows users to share more.
91 However, on machines that locate the text area far from the data area,
92 the boundary cannot feasibly be moved. Such machines require
95 Also, remapping can cause trouble with the built-in startup routine
96 /lib/crt0.o, which defines `environ' as an initialized variable.
97 Dumping `environ' as pure does not work! So, to use remapping,
98 you must write a startup routine for your machine in Emacs's crt0.c.
99 If NO_REMAP is defined, Emacs uses the system's crt0.o.
103 Some machines that use COFF executables require that each section
104 start on a certain boundary *in the COFF file*. Such machines should
105 define SECTION_ALIGNMENT to a mask of the low-order bits that must be
106 zero on such a boundary. This mask is used to control padding between
107 segments in the COFF file.
109 If SECTION_ALIGNMENT is not defined, the segments are written
110 consecutively with no attempt at alignment. This is right for
115 Some machines require that the beginnings and ends of segments
116 *in core* be on certain boundaries. For most machines, a page
117 boundary is sufficient. That is the default. When a larger
118 boundary is needed, define SEGMENT_MASK to a mask of
119 the bits that must be zero on such a boundary.
123 Some machines count the a.out header as part of the size of the text
124 segment (a_text); they may actually load the header into core as the
125 first data in the text segment. Some have additional padding between
126 the header and the real text of the program that is counted in a_text.
128 For these machines, define A_TEXT_OFFSET(HDR) to examine the header
129 structure HDR and return the number of bytes to add to `a_text'
130 before writing it (above and beyond the number of bytes of actual
131 program text). HDR's standard fields are already correct, except that
132 this adjustment to the `a_text' field has not yet been made;
133 thus, the amount of offset can depend on the data in the file.
137 If defined, this macro specifies the number of bytes to seek into the
138 a.out file before starting to write the text segment.a
142 For machines using COFF, this macro, if defined, is a value stored
143 into the magic number field of the output file.
147 This macro can be used to generate statements to adjust or
148 initialize nonstandard fields in the file header
152 Macro to correct an int which is the bit pattern of a pointer to a byte
153 into an int which is the number of a byte.
155 This macro has a default definition which is usually right.
156 This default definition is a no-op on most machines (where a
157 pointer looks like an int) but not on all machines.
162 #define PERROR(file) report_error (file, new)
165 /* Define getpagesize () if the system does not.
166 Note that this may depend on symbols defined in a.out.h
168 #include "getpagesize.h"
170 #include <sys/types.h>
172 #include <sys/stat.h>
175 extern char *start_of_text (); /* Start of text */
176 extern char *start_of_data (); /* Start of initialized data */
178 #include <machine/filehdr.h>
179 #include <machine/opthdr.h>
180 #include <machine/scnhdr.h>
181 #include <machine/pte.h>
183 static long block_copy_start; /* Old executable start point */
184 static struct filehdr f_hdr; /* File header */
185 static struct opthdr f_ohdr; /* Optional file header (a.out) */
186 long bias; /* Bias to add for growth */
187 #define SYMS_START block_copy_start
189 static long text_scnptr;
190 static long data_scnptr;
196 report_error (file, fd)
202 error ("Failure operating on %s", file);
205 #define ERROR0(msg) report_error_1 (new, msg, 0, 0); return -1
206 #define ERROR1(msg,x) report_error_1 (new, msg, x, 0); return -1
207 #define ERROR2(msg,x,y) report_error_1 (new, msg, x, y); return -1
210 report_error_1 (fd, msg, a1, a2)
219 /* ****************************************************************
224 unexec (new_name, a_name, data_start, bss_start, entry_address)
225 char *new_name, *a_name;
226 unsigned data_start, bss_start, entry_address;
230 if (a_name && (a_out = open (a_name, 0)) < 0) {
233 if ((new = creat (new_name, 0666)) < 0) {
237 if (make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name) < 0
238 || copy_text_and_data (new) < 0
239 || copy_sym (new, a_out, a_name, new_name) < 0 ) {
251 /* ****************************************************************
254 * Make the header in the new a.out from the header in core.
255 * Modify the text and data sizes.
258 struct scnhdr *stbl; /* Table of all scnhdr's */
259 struct scnhdr *f_thdr; /* Text section header */
260 struct scnhdr *f_dhdr; /* Data section header */
261 struct scnhdr *f_tdhdr; /* Thread Data section header */
262 struct scnhdr *f_bhdr; /* Bss section header */
263 struct scnhdr *f_tbhdr; /* Thread Bss section header */
266 make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name)
268 unsigned data_start, bss_start, entry_address;
273 unsigned int bss_end;
274 unsigned int eo_data; /* End of initialized data in new exec file */
275 int scntype; /* Section type */
276 int i; /* Var for sorting by vaddr */
277 struct scnhdr scntemp; /* For swapping entries in sort */
278 extern char *start_of_data();
280 pagemask = (pagesz = getpagesize()) - 1;
282 /* Adjust text/data boundary. */
284 data_start = (unsigned) start_of_data ();
286 data_start = data_start & ~pagemask; /* (Down) to page boundary. */
288 bss_end = (sbrk(0) + pagemask) & ~pagemask;
290 /* Adjust data/bss boundary. */
291 if (bss_start != 0) {
292 bss_start = (bss_start + pagemask) & ~pagemask;/* (Up) to page bdry. */
293 if (bss_start > bss_end) {
294 ERROR1 ("unexec: Specified bss_start (%x) is past end of program",
300 if (data_start > bss_start) { /* Can't have negative data size. */
301 ERROR2 ("unexec: data_start (%x) can't be greater than bss_start (%x)",
302 data_start, bss_start);
305 /* Salvage as much info from the existing file as possible */
307 ERROR0 ("can't build a COFF file from scratch yet");
311 if (read (a_out, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr)) {
314 block_copy_start += sizeof (f_hdr);
315 if (f_hdr.h_opthdr > 0) {
316 if (read (a_out, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr)) {
319 block_copy_start += sizeof (f_ohdr);
322 /* Allocate room for scn headers */
323 stbl = (struct scnhdr *)malloc( sizeof(struct scnhdr) * f_hdr.h_nscns );
325 ERROR0( "unexec: malloc of stbl failed" );
328 f_tdhdr = f_tbhdr = NULL;
330 /* Loop through section headers, copying them in */
331 for (scns = 0; scns < f_hdr.h_nscns; scns++) {
333 if( read( a_out, &stbl[scns], sizeof(*stbl)) != sizeof(*stbl)) {
337 scntype = stbl[scns].s_flags & S_TYPMASK; /* What type of section */
339 if( stbl[scns].s_scnptr > 0L) {
340 if( block_copy_start < stbl[scns].s_scnptr + stbl[scns].s_size )
341 block_copy_start = stbl[scns].s_scnptr + stbl[scns].s_size;
344 if( scntype == S_TEXT) {
345 f_thdr = &stbl[scns];
346 } else if( scntype == S_DATA) {
347 f_dhdr = &stbl[scns];
349 } else if( scntype == S_TDATA ) {
350 f_tdhdr = &stbl[scns];
351 } else if( scntype == S_TBSS ) {
352 f_tbhdr = &stbl[scns];
353 #endif /* S_TDATA (thread stuff) */
355 } else if( scntype == S_BSS) {
356 f_bhdr = &stbl[scns];
361 /* We will now convert TEXT and DATA into TEXT, BSS into DATA, and leave
362 * all thread stuff alone.
365 /* Now we alter the contents of all the f_*hdr variables
366 to correspond to what we want to dump. */
368 f_thdr->s_vaddr = (long) start_of_text ();
369 f_thdr->s_size = data_start - f_thdr->s_vaddr;
370 f_thdr->s_scnptr = pagesz;
371 f_thdr->s_relptr = 0;
374 eo_data = f_thdr->s_scnptr + f_thdr->s_size;
376 if( f_tdhdr ) { /* Process thread data */
378 f_tdhdr->s_vaddr = data_start;
379 f_tdhdr->s_size += f_dhdr->s_size - (data_start - f_dhdr->s_vaddr);
380 f_tdhdr->s_scnptr = eo_data;
381 f_tdhdr->s_relptr = 0;
384 eo_data += f_tdhdr->s_size;
386 /* And now for DATA */
388 f_dhdr->s_vaddr = f_bhdr->s_vaddr; /* Take BSS start address */
389 f_dhdr->s_size = bss_end - f_bhdr->s_vaddr;
390 f_dhdr->s_scnptr = eo_data;
391 f_dhdr->s_relptr = 0;
394 eo_data += f_dhdr->s_size;
398 f_dhdr->s_vaddr = data_start;
399 f_dhdr->s_size = bss_start - data_start;
400 f_dhdr->s_scnptr = eo_data;
401 f_dhdr->s_relptr = 0;
404 eo_data += f_dhdr->s_size;
408 f_bhdr->s_vaddr = bss_start;
409 f_bhdr->s_size = bss_end - bss_start + pagesz /* fudge */;
410 f_bhdr->s_scnptr = 0;
411 f_bhdr->s_relptr = 0;
414 text_scnptr = f_thdr->s_scnptr;
415 data_scnptr = f_dhdr->s_scnptr;
416 bias = eo_data - block_copy_start;
418 if (f_ohdr.o_symptr > 0L) {
419 f_ohdr.o_symptr += bias;
422 if (f_hdr.h_strptr > 0) {
423 f_hdr.h_strptr += bias;
426 if (write (new, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr)) {
430 if (write (new, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr)) {
434 for( scns = 0; scns < f_hdr.h_nscns; scns++ ) {
436 /* This is a cheesy little loop to write out the section headers
437 * in order of increasing virtual address. Dull but effective.
440 for( i = scns+1; i < f_hdr.h_nscns; i++ ) {
441 if( stbl[i].s_vaddr < stbl[scns].s_vaddr ) { /* Swap */
443 stbl[i] = stbl[scns];
444 stbl[scns] = scntemp;
450 for( scns = 0; scns < f_hdr.h_nscns; scns++ ) {
452 if( write( new, &stbl[scns], sizeof(*stbl)) != sizeof(*stbl)) {
462 /* ****************************************************************
465 * Copy the text and data segments from memory to the new a.out
468 copy_text_and_data (new)
473 for( scns = 0; scns < f_hdr.h_nscns; scns++ )
474 write_segment( new, &stbl[scns] );
479 write_segment( new, sptr )
489 if( sptr->s_scnptr == 0 )
490 return; /* Nothing to do */
492 if( lseek( new, (long) sptr->s_scnptr, 0 ) == -1 )
493 PERROR( "unexecing" );
495 memset (zeros, 0, sizeof zeros);
497 ptr = (char *) sptr->s_vaddr;
498 end = ptr + sptr->s_size;
502 /* distance to next multiple of 128. */
503 nwrite = (((int) ptr + 128) & -128) - (int) ptr;
504 /* But not beyond specified end. */
505 if (nwrite > end - ptr) nwrite = end - ptr;
506 ret = write (new, ptr, nwrite);
507 /* If write gets a page fault, it means we reached
508 a gap between the old text segment and the old data segment.
509 This gap has probably been remapped into part of the text segment.
510 So write zeros for it. */
511 if (ret == -1 && errno == EFAULT)
512 write (new, zeros, nwrite);
513 else if (nwrite != ret) {
515 "unexec write failure: addr 0x%x, fileno %d, size 0x%x, wrote 0x%x, errno %d",
516 ptr, new, nwrite, ret, errno);
523 /* ****************************************************************
526 * Copy the relocation information and symbol table from the a.out to the new
529 copy_sym (new, a_out, a_name, new_name)
531 char *a_name, *new_name;
539 if (SYMS_START == 0L)
542 lseek (a_out, SYMS_START, 0); /* Position a.out to symtab. */
543 lseek( new, (long)f_ohdr.o_symptr, 0 );
545 while ((n = read (a_out, page, sizeof page)) > 0) {
546 if (write (new, page, n) != n) {
556 /* ****************************************************************
559 * After successfully building the new a.out, mark it executable
567 int new = 0; /* for PERROR */
571 if (stat (name, &sbuf) == -1) {
574 sbuf.st_mode |= 0111 & ~um;
575 if (chmod (name, sbuf.st_mode) == -1)
579 /* Find the first pty letter. This is usually 'p', as in ptyp0, but
580 is sometimes configured down to 'm', 'n', or 'o' for some reason. */
588 for (c = 'o'; c >= 'a'; c--)
590 sprintf (pty_name, "/dev/pty%c0", c);
591 if (stat (pty_name, &buf) < 0)