![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to unexec.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / src|
Return to unexec.c CVS log | Up to [Apple XNU] / GNUtools / emacs / src |
1.1 root 1: /* Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
2:
3: This program is free software; you can redistribute it and/or modify
4: it under the terms of the GNU General Public License as published by
5: the Free Software Foundation; either version 1, or (at your option)
6: any later version.
7:
8: This program is distributed in the hope that it will be useful,
9: but WITHOUT ANY WARRANTY; without even the implied warranty of
10: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11: GNU General Public License for more details.
12:
13: You should have received a copy of the GNU General Public License
14: along with this program; if not, write to the Free Software
15: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
16:
17: In other words, you are welcome to use, share and improve this program.
18: You are forbidden to forbid anyone else to use, share and improve
19: what you give them. Help stamp out software-hoarding! */
20:
21:
22: /*
23: * unexec.c - Convert a running program into an a.out file.
24: *
25: * Author: Spencer W. Thomas
26: * Computer Science Dept.
27: * University of Utah
28: * Date: Tue Mar 2 1982
29: * Modified heavily since then.
30: *
31: * Synopsis:
32: * unexec (new_name, a_name, data_start, bss_start, entry_address)
33: * char *new_name, *a_name;
34: * unsigned data_start, bss_start, entry_address;
35: *
36: * Takes a snapshot of the program and makes an a.out format file in the
37: * file named by the string argument new_name.
38: * If a_name is non-NULL, the symbol table will be taken from the given file.
39: * On some machines, an existing a_name file is required.
40: *
41: * The boundaries within the a.out file may be adjusted with the data_start
42: * and bss_start arguments. Either or both may be given as 0 for defaults.
43: *
44: * Data_start gives the boundary between the text segment and the data
45: * segment of the program. The text segment can contain shared, read-only
46: * program code and literal data, while the data segment is always unshared
47: * and unprotected. Data_start gives the lowest unprotected address.
48: * The value you specify may be rounded down to a suitable boundary
49: * as required by the machine you are using.
50: *
51: * Specifying zero for data_start means the boundary between text and data
52: * should not be the same as when the program was loaded.
53: * If NO_REMAP is defined, the argument data_start is ignored and the
54: * segment boundaries are never changed.
55: *
56: * Bss_start indicates how much of the data segment is to be saved in the
57: * a.out file and restored when the program is executed. It gives the lowest
58: * unsaved address, and is rounded up to a page boundary. The default when 0
59: * is given assumes that the entire data segment is to be stored, including
60: * the previous data and bss as well as any additional storage allocated with
61: * break (2).
62: *
63: * The new file is set up to start at entry_address.
64: *
65: * If you make improvements I'd like to get them too.
66: * harpo!utah-cs!thomas, thomas@Utah-20
67: *
68: */
69:
70: /* Modified to support SysVr3 shared libraries by James Van Artsdalen
71: * of Dell Computer Corporation. [email protected].
72: */
73:
74: /* There are several compilation parameters affecting unexec:
75:
76: * COFF
77:
78: Define this if your system uses COFF for executables.
79: Otherwise we assume you use Berkeley format.
80:
81: * NO_REMAP
82:
83: Define this if you do not want to try to save Emacs's pure data areas
84: as part of the text segment.
85:
86: Saving them as text is good because it allows users to share more.
87:
88: However, on machines that locate the text area far from the data area,
89: the boundary cannot feasibly be moved. Such machines require
90: NO_REMAP.
91:
92: Also, remapping can cause trouble with the built-in startup routine
93: /lib/crt0.o, which defines `environ' as an initialized variable.
94: Dumping `environ' as pure does not work! So, to use remapping,
95: you must write a startup routine for your machine in Emacs's crt0.c.
96: If NO_REMAP is defined, Emacs uses the system's crt0.o.
97:
98: * SECTION_ALIGNMENT
99:
100: Some machines that use COFF executables require that each section
101: start on a certain boundary *in the COFF file*. Such machines should
102: define SECTION_ALIGNMENT to a mask of the low-order bits that must be
103: zero on such a boundary. This mask is used to control padding between
104: segments in the COFF file.
105:
106: If SECTION_ALIGNMENT is not defined, the segments are written
107: consecutively with no attempt at alignment. This is right for
108: unmodified system V.
109:
110: * SEGMENT_MASK
111:
112: Some machines require that the beginnings and ends of segments
113: *in core* be on certain boundaries. For most machines, a page
114: boundary is sufficient. That is the default. When a larger
115: boundary is needed, define SEGMENT_MASK to a mask of
116: the bits that must be zero on such a boundary.
117:
118: * A_TEXT_OFFSET(HDR)
119:
120: Some machines count the a.out header as part of the size of the text
121: segment (a_text); they may actually load the header into core as the
122: first data in the text segment. Some have additional padding between
123: the header and the real text of the program that is counted in a_text.
124:
125: For these machines, define A_TEXT_OFFSET(HDR) to examine the header
126: structure HDR and return the number of bytes to add to `a_text'
127: before writing it (above and beyond the number of bytes of actual
128: program text). HDR's standard fields are already correct, except that
129: this adjustment to the `a_text' field has not yet been made;
130: thus, the amount of offset can depend on the data in the file.
131:
132: * A_TEXT_SEEK(HDR)
133:
134: If defined, this macro specifies the number of bytes to seek into the
135: a.out file before starting to write the text segment.a
136:
137: * EXEC_MAGIC
138:
139: For machines using COFF, this macro, if defined, is a value stored
140: into the magic number field of the output file.
141:
142: * ADJUST_EXEC_HEADER
143:
144: This macro can be used to generate statements to adjust or
145: initialize nonstandard fields in the file header
146:
147: * ADDR_CORRECT(ADDR)
148:
149: Macro to correct an int which is the bit pattern of a pointer to a byte
150: into an int which is the number of a byte.
151:
152: This macro has a default definition which is usually right.
153: This default definition is a no-op on most machines (where a
154: pointer looks like an int) but not on all machines.
155:
156: */
157:
158: #ifndef emacs
159: #define PERROR(arg) perror (arg); return -1
160: #else
161: #include "config.h"
162: #define PERROR(file) report_error (file, new)
163: #endif
164:
165: #ifndef CANNOT_DUMP /* all rest of file! */
166:
167: #ifndef CANNOT_UNEXEC /* most of rest of file */
168:
169: #include <a.out.h>
170: /* Define getpagesize () if the system does not.
171: Note that this may depend on symbols defined in a.out.h
172: */
173: #include "getpagesize.h"
174:
175: #ifndef makedev /* Try to detect types.h already loaded */
176: #include <sys/types.h>
177: #endif
178: #include <stdio.h>
179: #include <sys/stat.h>
180: #include <errno.h>
181:
182: extern char *start_of_text (); /* Start of text */
183: extern char *start_of_data (); /* Start of initialized data */
184:
185: static int make_hdr (), copy_text_and_data (), copy_sym ();
186: static int mark_x ();
187:
188: #ifdef COFF
189: #ifndef USG
190: #ifndef STRIDE
191: #ifndef UMAX
192: #ifndef sun386
193: /* I have a suspicion that these are turned off on all systems
194: and can be deleted. Try it in version 19. */
195: #include <filehdr.h>
196: #include <aouthdr.h>
197: #include <scnhdr.h>
198: #include <syms.h>
199: #endif /* not sun386 */
200: #endif /* not UMAX */
201: #endif /* Not STRIDE */
202: #endif /* not USG */
203: static long block_copy_start; /* Old executable start point */
204: static struct filehdr f_hdr; /* File header */
205: static struct aouthdr f_ohdr; /* Optional file header (a.out) */
206: long bias; /* Bias to add for growth */
207: long lnnoptr; /* Pointer to line-number info within file */
208: #define SYMS_START block_copy_start
209:
210: static long text_scnptr;
211: static long data_scnptr;
212:
213: #else /* not COFF */
214:
215: #define SYMS_START ((long) N_SYMOFF (ohdr))
216:
217: /* Some machines override the structure name for an a.out header. */
218: #ifndef EXEC_HDR_TYPE
219: #define EXEC_HDR_TYPE struct exec
220: #endif
221:
222: #ifdef HPUX
223: #ifdef HP9000S200_ID
224: #define MY_ID HP9000S200_ID
225: #else
226: #include <model.h>
227: #define MY_ID MYSYS
228: #endif /* no HP9000S200_ID */
229: static MAGIC OLDMAGIC = {MY_ID, SHARE_MAGIC};
230: static MAGIC NEWMAGIC = {MY_ID, DEMAND_MAGIC};
231: #define N_TXTOFF(x) TEXT_OFFSET(x)
232: #define N_SYMOFF(x) LESYM_OFFSET(x)
233: static EXEC_HDR_TYPE hdr, ohdr;
234:
235: #else /* not HPUX */
236:
237: extern char *sbrk ();
238:
239: #if defined (USG) && !defined (IBMRTAIX) && !defined (IRIS)
240: static struct bhdr hdr, ohdr;
241: #define a_magic fmagic
242: #define a_text tsize
243: #define a_data dsize
244: #define a_bss bsize
245: #define a_syms ssize
246: #define a_trsize rtsize
247: #define a_drsize rdsize
248: #define a_entry entry
249: #define N_BADMAG(x) \
250: (((x).fmagic)!=OMAGIC && ((x).fmagic)!=NMAGIC &&\
251: ((x).fmagic)!=FMAGIC && ((x).fmagic)!=IMAGIC)
252: #define NEWMAGIC FMAGIC
253: #else /* IRIS or IBMRTAIX or not USG */
254: static EXEC_HDR_TYPE hdr, ohdr;
255: #define NEWMAGIC ZMAGIC
256: #endif /* IRIS or IBMRTAIX not USG */
257: #endif /* not HPUX */
258:
259: static int unexec_text_start;
260: static int unexec_data_start;
261:
262: #endif /* not COFF */
263:
264: static int pagemask;
265:
266: /* Correct an int which is the bit pattern of a pointer to a byte
267: into an int which is the number of a byte.
268: This is a no-op on ordinary machines, but not on all. */
269:
270: #ifndef ADDR_CORRECT /* Let m-*.h files override this definition */
271: #define ADDR_CORRECT(x) ((char *)(x) - (char*)0)
272: #endif
273:
274: #ifdef emacs
275:
276: static
277: report_error (file, fd)
278: char *file;
279: int fd;
280: {
281: if (fd)
282: close (fd);
283: error ("Failure operating on %s", file);
284: }
285: #endif /* emacs */
286:
287: #define ERROR0(msg) report_error_1 (new, msg, 0, 0); return -1
288: #define ERROR1(msg,x) report_error_1 (new, msg, x, 0); return -1
289: #define ERROR2(msg,x,y) report_error_1 (new, msg, x, y); return -1
290:
291: static
292: report_error_1 (fd, msg, a1, a2)
293: int fd;
294: char *msg;
295: int a1, a2;
296: {
297: close (fd);
298: #ifdef emacs
299: error (msg, a1, a2);
300: #else
301: fprintf (stderr, msg, a1, a2);
302: fprintf (stderr, "\n");
303: #endif
304: }
305:
306: /* ****************************************************************
307: * unexec
308: *
309: * driving logic.
310: */
311: unexec (new_name, a_name, data_start, bss_start, entry_address)
312: char *new_name, *a_name;
313: unsigned data_start, bss_start, entry_address;
314: {
315: int new, a_out = -1;
316:
317: if (a_name && (a_out = open (a_name, 0)) < 0)
318: {
319: PERROR (a_name);
320: }
321: if ((new = creat (new_name, 0666)) < 0)
322: {
323: PERROR (new_name);
324: }
325:
326: if (make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name) < 0
327: || copy_text_and_data (new, a_out) < 0
328: || copy_sym (new, a_out, a_name, new_name) < 0
329: #ifdef COFF
330: || adjust_lnnoptrs (new, a_out, new_name) < 0
331: #endif
332: )
333: {
334: close (new);
335: /* unlink (new_name); /* Failed, unlink new a.out */
336: return -1;
337: }
338:
339: close (new);
340: if (a_out >= 0)
341: close (a_out);
342: return mark_x (new_name);
343: }
344:
345: /* ****************************************************************
346: * make_hdr
347: *
348: * Make the header in the new a.out from the header in core.
349: * Modify the text and data sizes.
350: */
351: static int
352: make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name)
353: int new, a_out;
354: unsigned data_start, bss_start, entry_address;
355: char *a_name;
356: char *new_name;
357: {
358: int tem;
359: #ifdef COFF
360: auto struct scnhdr f_thdr; /* Text section header */
361: auto struct scnhdr f_dhdr; /* Data section header */
362: auto struct scnhdr f_bhdr; /* Bss section header */
363: auto struct scnhdr scntemp; /* Temporary section header */
364: register int scns;
365: #endif /* COFF */
366: #ifdef USG_SHARED_LIBRARIES
367: extern unsigned int bss_end;
368: #else
369: unsigned int bss_end;
370: #endif
371:
372: pagemask = getpagesize () - 1;
373:
374: /* Adjust text/data boundary. */
375: #ifdef NO_REMAP
376: data_start = (int) start_of_data ();
377: #else /* not NO_REMAP */
378: if (!data_start)
379: data_start = (int) start_of_data ();
380: #endif /* not NO_REMAP */
381: data_start = ADDR_CORRECT (data_start);
382:
383: #ifdef SEGMENT_MASK
384: data_start = data_start & ~SEGMENT_MASK; /* (Down) to segment boundary. */
385: #else
386: data_start = data_start & ~pagemask; /* (Down) to page boundary. */
387: #endif
388:
389: bss_end = ADDR_CORRECT (sbrk (0)) + pagemask;
390: bss_end &= ~ pagemask;
391:
392: /* Adjust data/bss boundary. */
393: if (bss_start != 0)
394: {
395: bss_start = (ADDR_CORRECT (bss_start) + pagemask);
396: /* (Up) to page bdry. */
397: bss_start &= ~ pagemask;
398: if (bss_start > bss_end)
399: {
400: ERROR1 ("unexec: Specified bss_start (%u) is past end of program",
401: bss_start);
402: }
403: }
404: else
405: bss_start = bss_end;
406:
407: if (data_start > bss_start) /* Can't have negative data size. */
408: {
409: ERROR2 ("unexec: data_start (%u) can't be greater than bss_start (%u)",
410: data_start, bss_start);
411: }
412:
413: #ifdef COFF
414: /* Salvage as much info from the existing file as possible */
415: if (a_out >= 0)
416: {
417: if (read (a_out, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
418: {
419: PERROR (a_name);
420: }
421: block_copy_start += sizeof (f_hdr);
422: if (f_hdr.f_opthdr > 0)
423: {
424: if (read (a_out, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
425: {
426: PERROR (a_name);
427: }
428: block_copy_start += sizeof (f_ohdr);
429: }
430: /* Loop through section headers, copying them in */
431: for (scns = f_hdr.f_nscns; scns > 0; scns--) {
432: if (read (a_out, &scntemp, sizeof (scntemp)) != sizeof (scntemp))
433: {
434: PERROR (a_name);
435: }
436: if (scntemp.s_scnptr > 0L)
437: {
438: if (block_copy_start < scntemp.s_scnptr + scntemp.s_size)
439: block_copy_start = scntemp.s_scnptr + scntemp.s_size;
440: }
441: if (strcmp (scntemp.s_name, ".text") == 0)
442: {
443: f_thdr = scntemp;
444: }
445: else if (strcmp (scntemp.s_name, ".data") == 0)
446: {
447: f_dhdr = scntemp;
448: }
449: else if (strcmp (scntemp.s_name, ".bss") == 0)
450: {
451: f_bhdr = scntemp;
452: }
453: }
454: }
455: else
456: {
457: ERROR0 ("can't build a COFF file from scratch yet");
458: }
459:
460: /* Now we alter the contents of all the f_*hdr variables
461: to correspond to what we want to dump. */
462:
463: #ifdef USG_SHARED_LIBRARIES
464:
465: /* The amount of data we're adding to the file is distance from the
466: * end of the original .data space to the current end of the .data
467: * space.
468: */
469:
470: bias = bss_end - (f_ohdr.data_start + f_dhdr.s_size);
471:
472: #endif
473:
474: f_hdr.f_flags |= (F_RELFLG | F_EXEC);
475: #ifdef TPIX
476: f_hdr.f_nscns = 3;
477: #endif
478: #ifdef EXEC_MAGIC
479: f_ohdr.magic = EXEC_MAGIC;
480: #endif
481: #ifndef NO_REMAP
482: f_ohdr.text_start = (long) start_of_text ();
483: f_ohdr.tsize = data_start - f_ohdr.text_start;
484: f_ohdr.data_start = data_start;
485: #endif /* NO_REMAP */
486: f_ohdr.dsize = bss_start - f_ohdr.data_start;
487: f_ohdr.bsize = bss_end - bss_start;
488: f_thdr.s_size = f_ohdr.tsize;
489: f_thdr.s_scnptr = sizeof (f_hdr) + sizeof (f_ohdr);
490: f_thdr.s_scnptr += (f_hdr.f_nscns) * (sizeof (f_thdr));
491: lnnoptr = f_thdr.s_lnnoptr;
492: #ifdef SECTION_ALIGNMENT
493: /* Some systems require special alignment
494: of the sections in the file itself. */
495: f_thdr.s_scnptr
496: = (f_thdr.s_scnptr + SECTION_ALIGNMENT) & ~SECTION_ALIGNMENT;
497: #endif /* SECTION_ALIGNMENT */
498: #ifdef TPIX
499: f_thdr.s_scnptr = 0xd0;
500: #endif
501: text_scnptr = f_thdr.s_scnptr;
502: f_dhdr.s_paddr = f_ohdr.data_start;
503: f_dhdr.s_vaddr = f_ohdr.data_start;
504: f_dhdr.s_size = f_ohdr.dsize;
505: f_dhdr.s_scnptr = f_thdr.s_scnptr + f_thdr.s_size;
506: #ifdef SECTION_ALIGNMENT
507: /* Some systems require special alignment
508: of the sections in the file itself. */
509: f_dhdr.s_scnptr
510: = (f_dhdr.s_scnptr + SECTION_ALIGNMENT) & ~SECTION_ALIGNMENT;
511: #endif /* SECTION_ALIGNMENT */
512: #ifdef DATA_SECTION_ALIGNMENT
513: /* Some systems require special alignment
514: of the data section only. */
515: f_dhdr.s_scnptr
516: = (f_dhdr.s_scnptr + DATA_SECTION_ALIGNMENT) & ~DATA_SECTION_ALIGNMENT;
517: #endif /* DATA_SECTION_ALIGNMENT */
518: data_scnptr = f_dhdr.s_scnptr;
519: f_bhdr.s_paddr = f_ohdr.data_start + f_ohdr.dsize;
520: f_bhdr.s_vaddr = f_ohdr.data_start + f_ohdr.dsize;
521: f_bhdr.s_size = f_ohdr.bsize;
522: f_bhdr.s_scnptr = 0L;
523: #ifndef USG_SHARED_LIBRARIES
524: bias = f_dhdr.s_scnptr + f_dhdr.s_size - block_copy_start;
525: #endif
526:
527: if (f_hdr.f_symptr > 0L)
528: {
529: f_hdr.f_symptr += bias;
530: }
531:
532: if (f_thdr.s_lnnoptr > 0L)
533: {
534: f_thdr.s_lnnoptr += bias;
535: }
536:
537: #ifdef ADJUST_EXEC_HEADER
538: ADJUST_EXEC_HEADER
539: #endif /* ADJUST_EXEC_HEADER */
540:
541: if (write (new, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
542: {
543: PERROR (new_name);
544: }
545:
546: if (write (new, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
547: {
548: PERROR (new_name);
549: }
550:
551: #ifndef USG_SHARED_LIBRARIES
552:
553: if (write (new, &f_thdr, sizeof (f_thdr)) != sizeof (f_thdr))
554: {
555: PERROR (new_name);
556: }
557:
558: if (write (new, &f_dhdr, sizeof (f_dhdr)) != sizeof (f_dhdr))
559: {
560: PERROR (new_name);
561: }
562:
563: if (write (new, &f_bhdr, sizeof (f_bhdr)) != sizeof (f_bhdr))
564: {
565: PERROR (new_name);
566: }
567:
568: #else /* USG_SHARED_LIBRARIES */
569:
570: /* The purpose of this code is to write out the new file's section
571: * header table.
572: *
573: * Scan through the original file's sections. If the encountered
574: * section is one we know (.text, .data or .bss), write out the
575: * correct header. If it is a section we do not know (such as
576: * .lib), adjust the address of where the section data is in the
577: * file, and write out the header.
578: *
579: * If any section preceeds .text or .data in the file, this code
580: * will not adjust the file pointer for that section correctly.
581: */
582:
583: lseek (a_out, sizeof (f_hdr) + sizeof (f_ohdr), 0);
584:
585: for (scns = f_hdr.f_nscns; scns > 0; scns--)
586: {
587: if (read (a_out, &scntemp, sizeof (scntemp)) != sizeof (scntemp))
588: PERROR (a_name);
589:
590: if (!strcmp (scntemp.s_name, f_thdr.s_name)) /* .text */
591: {
592: if (write (new, &f_thdr, sizeof (f_thdr)) != sizeof (f_thdr))
593: PERROR (new_name);
594: }
595: else if (!strcmp (scntemp.s_name, f_dhdr.s_name)) /* .data */
596: {
597: if (write (new, &f_dhdr, sizeof (f_dhdr)) != sizeof (f_dhdr))
598: PERROR (new_name);
599: }
600: else if (!strcmp (scntemp.s_name, f_bhdr.s_name)) /* .bss */
601: {
602: if (write (new, &f_bhdr, sizeof (f_bhdr)) != sizeof (f_bhdr))
603: PERROR (new_name);
604: }
605: else
606: {
607: if (scntemp.s_scnptr)
608: scntemp.s_scnptr += bias;
609: if (write (new, &scntemp, sizeof (scntemp)) != sizeof (scntemp))
610: PERROR (new_name);
611: }
612: }
613: #endif /* USG_SHARED_LIBRARIES */
614:
615: return (0);
616:
617: #else /* if not COFF */
618:
619: /* Get symbol table info from header of a.out file if given one. */
620: if (a_out >= 0)
621: {
622: if (read (a_out, &ohdr, sizeof hdr) != sizeof hdr)
623: {
624: PERROR (a_name);
625: }
626:
627: if (N_BADMAG (ohdr))
628: {
629: ERROR1 ("invalid magic number in %s", a_name);
630: }
631: hdr = ohdr;
632: }
633: else
634: {
635: bzero (hdr, sizeof hdr);
636: }
637:
638: unexec_text_start = (long) start_of_text ();
639: unexec_data_start = data_start;
640:
641: /* Machine-dependent fixup for header, or maybe for unexec_text_start */
642: #ifdef ADJUST_EXEC_HEADER
643: ADJUST_EXEC_HEADER;
644: #endif /* ADJUST_EXEC_HEADER */
645:
646: hdr.a_trsize = 0;
647: hdr.a_drsize = 0;
648: if (entry_address != 0)
649: hdr.a_entry = entry_address;
650:
651: hdr.a_bss = bss_end - bss_start;
652: hdr.a_data = bss_start - data_start;
653: #ifdef NO_REMAP
654: hdr.a_text = ohdr.a_text;
655: #else /* not NO_REMAP */
656: hdr.a_text = data_start - unexec_text_start;
657:
658: #ifdef A_TEXT_OFFSET
659: hdr.a_text += A_TEXT_OFFSET (ohdr);
660: #endif
661:
662: #endif /* not NO_REMAP */
663:
664: if (write (new, &hdr, sizeof hdr) != sizeof hdr)
665: {
666: PERROR (new_name);
667: }
668:
669: #ifdef A_TEXT_OFFSET
670: hdr.a_text -= A_TEXT_OFFSET (ohdr);
671: #endif
672:
673: return 0;
674:
675: #endif /* not COFF */
676: }
677:
678: /* ****************************************************************
679: * copy_text_and_data
680: *
681: * Copy the text and data segments from memory to the new a.out
682: */
683: static int
684: copy_text_and_data (new, a_out)
685: int new, a_out;
686: {
687: register char *end;
688: register char *ptr;
689:
690: #ifdef COFF
691:
692: #ifdef USG_SHARED_LIBRARIES
693:
694: int scns;
695: struct scnhdr scntemp; /* Temporary section header */
696:
697: /* The purpose of this code is to write out the new file's section
698: * contents.
699: *
700: * Step through the section table. If we know the section (.text,
701: * .data) do the appropriate thing. Otherwise, if the section has
702: * no allocated space in the file (.bss), do nothing. Otherwise,
703: * the section has space allocated in the file, and is not a section
704: * we know. So just copy it.
705: */
706:
707: lseek (a_out, sizeof (struct filehdr) + sizeof (struct aouthdr), 0);
708:
709: for (scns = f_hdr.f_nscns; scns > 0; scns--)
710: {
711: if (read (a_out, &scntemp, sizeof (scntemp)) != sizeof (scntemp))
712: PERROR ("temacs");
713:
714: if (!strcmp (scntemp.s_name, ".text"))
715: {
716: lseek (new, (long) text_scnptr, 0);
717: ptr = (char *) f_ohdr.text_start;
718: end = ptr + f_ohdr.tsize;
719: write_segment (new, ptr, end);
720: }
721: else if (!strcmp (scntemp.s_name, ".data"))
722: {
723: lseek (new, (long) data_scnptr, 0);
724: ptr = (char *) f_ohdr.data_start;
725: end = ptr + f_ohdr.dsize;
726: write_segment (new, ptr, end);
727: }
728: else if (!scntemp.s_scnptr)
729: ; /* do nothing - no data for this section */
730: else
731: {
732: char page[BUFSIZ];
733: int size, n;
734: long old_a_out_ptr = lseek (a_out, 0, 1);
735:
736: lseek (a_out, scntemp.s_scnptr, 0);
737: for (size = scntemp.s_size; size > 0; size -= sizeof (page))
738: {
739: n = size > sizeof (page) ? sizeof (page) : size;
740: if (read (a_out, page, n) != n || write (new, page, n) != n)
741: PERROR ("xemacs");
742: }
743: lseek (a_out, old_a_out_ptr, 0);
744: }
745: }
746:
747: #else /* COFF, but not USG_SHARED_LIBRARIES */
748:
749: lseek (new, (long) text_scnptr, 0);
750: ptr = (char *) f_ohdr.text_start;
751: end = ptr + f_ohdr.tsize;
752: write_segment (new, ptr, end);
753:
754: lseek (new, (long) data_scnptr, 0);
755: ptr = (char *) f_ohdr.data_start;
756: end = ptr + f_ohdr.dsize;
757: write_segment (new, ptr, end);
758:
759: #endif /* USG_SHARED_LIBRARIES */
760:
761: #else /* if not COFF */
762:
763: /* Some machines count the header as part of the text segment.
764: That is to say, the header appears in core
765: just before the address that start_of_text () returns.
766: For them, N_TXTOFF is the place where the header goes.
767: We must adjust the seek to the place after the header.
768: Note that at this point hdr.a_text does *not* count
769: the extra A_TEXT_OFFSET bytes, only the actual bytes of code. */
770:
771: #ifdef A_TEXT_SEEK
772: lseek (new, (long) A_TEXT_SEEK (hdr), 0);
773: #else
774: #ifdef A_TEXT_OFFSET
775: /* Note that on the Sequent machine A_TEXT_OFFSET != sizeof (hdr)
776: and sizeof (hdr) is the correct amount to add here. */
777: /* In version 19, eliminate this case and use A_TEXT_SEEK whenever
778: N_TXTOFF is not right. */
779: lseek (new, (long) N_TXTOFF (hdr) + sizeof (hdr), 0);
780: #else
781: lseek (new, (long) N_TXTOFF (hdr), 0);
782: #endif /* no A_TEXT_OFFSET */
783: #endif /* no A_TEXT_SEEK */
784:
785: ptr = (char *) unexec_text_start;
786: end = ptr + hdr.a_text;
787: write_segment (new, ptr, end);
788:
789: ptr = (char *) unexec_data_start;
790: end = ptr + hdr.a_data;
791: /* This lseek is certainly incorrect when A_TEXT_OFFSET
792: and I believe it is a no-op otherwise.
793: Let's see if its absence ever fails. */
794: /* lseek (new, (long) N_TXTOFF (hdr) + hdr.a_text, 0); */
795: write_segment (new, ptr, end);
796:
797: #endif /* not COFF */
798:
799: return 0;
800: }
801:
802: write_segment (new, ptr, end)
803: int new;
804: register char *ptr, *end;
805: {
806: register int i, nwrite, ret;
807: char buf[80];
808: extern int errno;
809: char zeros[128];
810:
811: bzero (zeros, sizeof zeros);
812:
813: for (i = 0; ptr < end;)
814: {
815: /* distance to next multiple of 128. */
816: nwrite = (((int) ptr + 128) & -128) - (int) ptr;
817: /* But not beyond specified end. */
818: if (nwrite > end - ptr) nwrite = end - ptr;
819: ret = write (new, ptr, nwrite);
820: /* If write gets a page fault, it means we reached
821: a gap between the old text segment and the old data segment.
822: This gap has probably been remapped into part of the text segment.
823: So write zeros for it. */
824: if (ret == -1 && errno == EFAULT)
825: write (new, zeros, nwrite);
826: else if (nwrite != ret)
827: {
828: sprintf (buf,
829: "unexec write failure: addr 0x%x, fileno %d, size 0x%x, wrote 0x%x, errno %d",
830: ptr, new, nwrite, ret, errno);
831: PERROR (buf);
832: }
833: i += nwrite;
834: ptr += nwrite;
835: }
836: }
837:
838: /* ****************************************************************
839: * copy_sym
840: *
841: * Copy the relocation information and symbol table from the a.out to the new
842: */
843: static int
844: copy_sym (new, a_out, a_name, new_name)
845: int new, a_out;
846: char *a_name, *new_name;
847: {
848: char page[1024];
849: int n;
850:
851: if (a_out < 0)
852: return 0;
853:
854: #ifdef COFF
855: if (SYMS_START == 0L)
856: return 0;
857: #endif /* COFF */
858:
859: #ifdef COFF
860: if (lnnoptr) /* if there is line number info */
861: lseek (a_out, lnnoptr, 0); /* start copying from there */
862: else
863: #endif /* COFF */
864: lseek (a_out, SYMS_START, 0); /* Position a.out to symtab. */
865:
866: while ((n = read (a_out, page, sizeof page)) > 0)
867: {
868: if (write (new, page, n) != n)
869: {
870: PERROR (new_name);
871: }
872: }
873: if (n < 0)
874: {
875: PERROR (a_name);
876: }
877: return 0;
878: }
879:
880: /* ****************************************************************
881: * mark_x
882: *
883: * After succesfully building the new a.out, mark it executable
884: */
885: static int
886: mark_x (name)
887: char *name;
888: {
889: struct stat sbuf;
890: int um;
891: int new = 0; /* for PERROR */
892:
893: um = umask (777);
894: umask (um);
895: if (stat (name, &sbuf) == -1)
896: {
897: PERROR (name);
898: }
899: sbuf.st_mode |= 0111 & ~um;
900: if (chmod (name, sbuf.st_mode) == -1)
901: PERROR (name);
902: return 0;
903: }
904:
905: /*
906: * If the COFF file contains a symbol table and a line number section,
907: * then any auxiliary entries that have values for x_lnnoptr must
908: * be adjusted by the amount that the line number section has moved
909: * in the file (bias computed in make_hdr). The #@$%&* designers of
910: * the auxiliary entry structures used the absolute file offsets for
911: * the line number entry rather than an offset from the start of the
912: * line number section!
913: *
914: * When I figure out how to scan through the symbol table and pick out
915: * the auxiliary entries that need adjustment, this routine will
916: * be fixed. As it is now, all such entries are wrong and sdb
917: * will complain. Fred Fish, UniSoft Systems Inc.
918: */
919:
920: #ifdef COFF
921:
922: /* This function is probably very slow. Instead of reopening the new
923: file for input and output it should copy from the old to the new
924: using the two descriptors already open (WRITEDESC and READDESC).
925: Instead of reading one small structure at a time it should use
926: a reasonable size buffer. But I don't have time to work on such
927: things, so I am installing it as submitted to me. -- RMS. */
928:
929: adjust_lnnoptrs (writedesc, readdesc, new_name)
930: int writedesc;
931: int readdesc;
932: char *new_name;
933: {
934: register int nsyms;
935: register int new;
936: #if defined (amdahl_uts) || defined (pfa)
937: SYMENT symentry;
938: AUXENT auxentry;
939: #else
940: struct syment symentry;
941: union auxent auxentry;
942: #endif
943:
944: if (!lnnoptr || !f_hdr.f_symptr)
945: return 0;
946:
947: if ((new = open (new_name, 2)) < 0)
948: {
949: PERROR (new_name);
950: return -1;
951: }
952:
953: lseek (new, f_hdr.f_symptr, 0);
954: for (nsyms = 0; nsyms < f_hdr.f_nsyms; nsyms++)
955: {
956: read (new, &symentry, SYMESZ);
957: if (symentry.n_numaux)
958: {
959: read (new, &auxentry, AUXESZ);
960: nsyms++;
961: if (ISFCN (symentry.n_type)) {
962: auxentry.x_sym.x_fcnary.x_fcn.x_lnnoptr += bias;
963: lseek (new, -AUXESZ, 1);
964: write (new, &auxentry, AUXESZ);
965: }
966: }
967: }
968: close (new);
969: }
970:
971: #endif /* COFF */
972:
973: #endif /* not CANNOT_UNEXEC */
974:
975: #endif /* not CANNOT_DUMP */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.