![[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 [CSRG BSD Unix] / 43BSD / contrib / emacs / src|
Return to unexec.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / src |
1.1 root 1: /* Copyright (C) 1985 Free Software Foundation, Inc.
2:
3: This file is part of GNU Emacs.
4:
5: GNU Emacs is distributed in the hope that it will be useful,
6: but WITHOUT ANY WARRANTY. No author or distributor
7: accepts responsibility to anyone for the consequences of using it
8: or for whether it serves any particular purpose or works at all,
9: unless he says so in writing. Refer to the GNU Emacs General Public
10: License for full details.
11:
12: Everyone is granted permission to copy, modify and redistribute
13: GNU Emacs, but only under the conditions described in the
14: GNU Emacs General Public License. A copy of this license is
15: supposed to have been given to you along with GNU Emacs so you
16: can know your rights and responsibilities. It should be in a
17: file named COPYING. Among other things, the copyright notice
18: and this notice must be preserved on all copies. */
19:
20:
21: /*
22: * unexec.c - Convert a running program into an a.out file.
23: *
24: * Author: Spencer W. Thomas
25: * Computer Science Dept.
26: * University of Utah
27: * Date: Tue Mar 2 1982
28: * Modified heavily since then.
29: *
30: * Synopsis:
31: * unexec (new_name, a_name, data_start, bss_start, entry_address)
32: * char *new_name, *a_name;
33: * unsigned data_start, bss_start, entry_address;
34: *
35: * Takes a snapshot of the program and makes an a.out format file in the
36: * file named by the string argument new_name.
37: * If a_name is non-NULL, the symbol table will be taken from the given file.
38: *
39: * The boundaries within the a.out file may be adjusted with the data_start
40: * and bss_start arguments. Either or both may be given as 0 for defaults.
41: *
42: * Data_start gives the boundary between the text segment and the data
43: * segment of the program. The text segment can contain shared, read-only
44: * program code and literal data, while the data segment is always unshared
45: * and unprotected. Data_start gives the lowest unprotected address. Since
46: * the granularity of write-protection is on 1k page boundaries on the VAX, a
47: * given data_start value which is not on a page boundary is rounded down to
48: * the beginning of the page it is on. The default when 0 is given leaves the
49: * number of protected pages the same as it was before.
50: *
51: * Bss_start indicates how much of the data segment is to be saved in the
52: * a.out file and restored when the program is executed. It gives the lowest
53: * unsaved address, and is rounded up to a page boundary. The default when 0
54: * is given assumes that the entire data segment is to be stored, including
55: * the previous data and bss as well as any additional storage allocated with
56: * break (2).
57: *
58: * The new file is set up to start at entry_address.
59: *
60: * If you make improvements I'd like to get them too.
61: * harpo!utah-cs!thomas, thomas@Utah-20
62: *
63: */
64:
65: #ifndef emacs
66: #define PERROR(arg) perror (arg); return -1
67: #else
68: #include "config.h"
69: #define PERROR(file) report_error (file, new)
70: #endif
71:
72: #ifndef CANNOT_DUMP /* all rest of file! */
73:
74: #include <sys/param.h>
75: #ifndef makedev /* Try to detect types.h already loaded */
76: #include <sys/types.h>
77: #endif
78: #include <stdio.h>
79: #include <sys/stat.h>
80: #include <errno.h>
81:
82: extern char *start_of_text (); /* Start of text */
83: extern char *start_of_data (); /* Start of initialized data */
84:
85: #ifdef COFF
86: #include <filehdr.h>
87: #include <aouthdr.h>
88: #include <scnhdr.h>
89: #include <syms.h>
90: static long block_copy_start; /* Old executable start point */
91: static struct filehdr f_hdr; /* File header */
92: static struct aouthdr f_ohdr; /* Optional file header (a.out) */
93: long bias; /* Bias to add for growth */
94: long lnnoptr; /* Pointer to line-number info within file */
95: #define SYMS_START block_copy_start
96:
97: static int text_scnptr;
98:
99: #else /* not COFF */
100:
101: extern char *sbrk ();
102:
103: #include <a.out.h>
104: #define SYMS_START ((long) N_SYMOFF (ohdr))
105:
106: #ifdef HPUX
107: #ifdef hp9000s200
108: #define MY_ID HP9000S200_ID
109: #else
110: #include <model.h>
111: #define MY_ID MYSYS
112: #endif /* not hp9000s200 */
113: static MAGIC OLDMAGIC = {MY_ID, SHARE_MAGIC};
114: static MAGIC NEWMAGIC = {MY_ID, DEMAND_MAGIC};
115: #define N_TXTOFF(x) TEXT_OFFSET(x)
116: #define N_SYMOFF(x) LESYM_OFFSET(x)
117: static struct exec hdr, ohdr;
118:
119: #else /* not HPUX */
120:
121: #ifdef USG
122: static struct bhdr hdr, ohdr;
123: #define a_magic fmagic
124: #define a_text tsize
125: #define a_data dsize
126: #define a_bss bsize
127: #define a_syms ssize
128: #define a_trsize rtsize
129: #define a_drsize rdsize
130: #define a_entry entry
131: #define N_BADMAG(x) \
132: (((x).fmagic)!=OMAGIC && ((x).fmagic)!=NMAGIC &&\
133: ((x).fmagic)!=FMAGIC && ((x).fmagic)!=IMAGIC)
134: #define NEWMAGIC FMAGIC
135: #else /* not USG */
136: static struct exec hdr, ohdr;
137: #define NEWMAGIC ZMAGIC
138: #endif /* not USG */
139: #endif /* not HPUX */
140:
141: #endif /* not COFF */
142:
143: static int pagemask;
144:
145: #if defined (BSD4_1) || defined (USG)
146: #ifdef EXEC_PAGESIZE
147: #define getpagesize() EXEC_PAGESIZE
148: #else
149: #ifdef NBPG
150: #define getpagesize() NBPG * CLSIZE
151: #ifndef CLSIZE
152: #define CLSIZE 1
153: #endif /* no CLSIZE */
154: #else /* no NBPG */
155: #define getpagesize() NBPC
156: #endif /* no NBPG */
157: #endif /* no EXEC_PAGESIZE */
158: #endif /* BSD4_1 or USG */
159:
160: /* Correct an int which is the bit pattern of a pointer to a byte
161: into an int which is the number of a byte.
162: This is a no-op on ordinary machines, but not on all. */
163:
164: #ifndef ADDR_CORRECT /* Let m-*.h files override this definition */
165: #define ADDR_CORRECT(x) ((char *)(x) - (char*)0)
166: #endif
167:
168: #ifdef emacs
169:
170: static
171: report_error (file, fd)
172: char *file;
173: int fd;
174: {
175: if (fd)
176: close (fd);
177: error ("Failure operating on %s", file);
178: }
179: #endif /* emacs */
180:
181: #define ERROR0(msg) report_error_1 (new, msg, 0, 0); return -1
182: #define ERROR1(msg,x) report_error_1 (new, msg, x, 0); return -1
183: #define ERROR2(msg,x,y) report_error_1 (new, msg, x, y); return -1
184:
185: static
186: report_error_1 (fd, msg, a1, a2)
187: int fd;
188: char *msg;
189: int a1, a2;
190: {
191: close (fd);
192: #ifdef emacs
193: error (msg, a1, a2);
194: #else
195: fprintf (stderr, msg, a1, a2);
196: fprintf (stderr, "\n");
197: #endif
198: }
199:
200: /* ****************************************************************
201: * unexec
202: *
203: * driving logic.
204: */
205: unexec (new_name, a_name, data_start, bss_start, entry_address)
206: char *new_name, *a_name;
207: unsigned data_start, bss_start, entry_address;
208: {
209: int new, a_out = -1;
210:
211: if (a_name && (a_out = open (a_name, 0)) < 0)
212: {
213: PERROR (a_name);
214: }
215: if ((new = creat (new_name, 0666)) < 0)
216: {
217: PERROR (new_name);
218: }
219: if (make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name) < 0
220: || copy_text_and_data (new) < 0
221: || copy_sym (new, a_out, a_name, new_name) < 0
222: #ifdef COFF
223: || adjust_lnnoptrs (new, a_out, new_name) < 0
224: #endif
225: )
226: {
227: close (new);
228: /* unlink (new_name); /* Failed, unlink new a.out */
229: return -1;
230: }
231:
232: close (new);
233: if (a_out >= 0)
234: close (a_out);
235: mark_x (new_name);
236: return 0;
237: }
238:
239: /* ****************************************************************
240: * make_hdr
241: *
242: * Make the header in the new a.out from the header in core.
243: * Modify the text and data sizes.
244: */
245: static int
246: make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name)
247: int new, a_out;
248: unsigned data_start, bss_start, entry_address;
249: char *a_name;
250: char *new_name;
251: {
252: int tem;
253: #ifdef COFF
254: auto struct scnhdr f_thdr; /* Text section header */
255: auto struct scnhdr f_dhdr; /* Data section header */
256: auto struct scnhdr f_bhdr; /* Bss section header */
257: auto struct scnhdr scntemp; /* Temporary section header */
258: register int scns;
259:
260: /* Salvage as much info from the existing file as possible */
261: if (a_out >= 0)
262: {
263: if (read (a_out, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
264: {
265: PERROR (a_name);
266: }
267: block_copy_start += sizeof (f_hdr);
268: if (f_hdr.f_opthdr > 0)
269: {
270: if (read (a_out, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
271: {
272: PERROR (a_name);
273: }
274: block_copy_start += sizeof (f_ohdr);
275: }
276: /* Loop through section headers, copying them in */
277: for (scns = f_hdr.f_nscns; scns > 0; scns--) {
278: if (read (a_out, &scntemp, sizeof (scntemp)) != sizeof (scntemp))
279: {
280: PERROR (a_name);
281: }
282: block_copy_start += sizeof (scntemp);
283: if (scntemp.s_scnptr > 0L)
284: {
285: block_copy_start += scntemp.s_size;
286: }
287: if (strcmp (scntemp.s_name, ".text") == 0)
288: {
289: f_thdr = scntemp;
290: }
291: else if (strcmp (scntemp.s_name, ".data") == 0)
292: {
293: f_dhdr = scntemp;
294: }
295: else if (strcmp (scntemp.s_name, ".bss") == 0)
296: {
297: f_bhdr = scntemp;
298: }
299: }
300: }
301: else
302: {
303: ERROR0 ("can't build a COFF file from scratch yet");
304: }
305:
306: pagemask = getpagesize () - 1;
307:
308: #ifdef NO_REMAP
309: data_start = (int) start_of_data ();
310: #else /* not NO_REMAP */
311: if (!data_start)
312: data_start = (int) start_of_data ();
313: #endif /* not NO_REMAP */
314: data_start = ADDR_CORRECT (data_start);
315: data_start = data_start & ~pagemask; /* down to a page boundary */
316:
317: f_hdr.f_flags |= (F_RELFLG | F_EXEC);
318: #ifdef EXEC_MAGIC
319: f_ohdr.magic = EXEC_MAGIC;
320: #endif
321: f_ohdr.text_start = (long) start_of_text ();
322: f_ohdr.tsize = data_start - f_ohdr.text_start;
323: f_ohdr.data_start = data_start;
324: f_ohdr.dsize = (long) sbrk (0) - f_ohdr.data_start;
325: f_ohdr.bsize = 0;
326: f_thdr.s_size = f_ohdr.tsize;
327: f_thdr.s_scnptr = sizeof (f_hdr) + sizeof (f_ohdr);
328: f_thdr.s_scnptr += (f_hdr.f_nscns) * (sizeof (f_thdr));
329: lnnoptr = f_thdr.s_lnnoptr;
330: #ifdef UMAX
331: /* Umax is bsd using coff; it has restrictions on alignment
332: of the sections in the file itself. */
333: f_thdr.s_scnptr = (f_thdr.s_scnptr + pagemask) & ~pagemask; /* round up */
334: #endif /* UMAX */
335: text_scnptr = f_thdr.s_scnptr;
336: f_dhdr.s_paddr = f_ohdr.data_start;
337: f_dhdr.s_vaddr = f_ohdr.data_start;
338: f_dhdr.s_size = f_ohdr.dsize;
339: f_dhdr.s_scnptr = f_thdr.s_scnptr + f_thdr.s_size;
340: #ifdef UMAX
341: f_dhdr.s_scnptr &= ~pagemask; /* round down to page boundary */
342: #endif /* UMAX */
343: f_bhdr.s_paddr = f_ohdr.data_start + f_ohdr.dsize;
344: f_bhdr.s_vaddr = f_ohdr.data_start + f_ohdr.dsize;
345: f_bhdr.s_size = f_ohdr.bsize;
346: f_bhdr.s_scnptr = 0L;
347: bias = f_dhdr.s_scnptr + f_dhdr.s_size - block_copy_start;
348:
349: if (f_hdr.f_symptr > 0L)
350: {
351: f_hdr.f_symptr += bias;
352: }
353:
354: if (f_thdr.s_lnnoptr > 0L)
355: {
356: f_thdr.s_lnnoptr += bias;
357: }
358:
359: if (write (new, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
360: {
361: PERROR (new_name);
362: }
363:
364: if (write (new, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
365: {
366: PERROR (new_name);
367: }
368:
369: if (write (new, &f_thdr, sizeof (f_thdr)) != sizeof (f_thdr))
370: {
371: PERROR (new_name);
372: }
373:
374: if (write (new, &f_dhdr, sizeof (f_dhdr)) != sizeof (f_dhdr))
375: {
376: PERROR (new_name);
377: }
378:
379: if (write (new, &f_bhdr, sizeof (f_bhdr)) != sizeof (f_bhdr))
380: {
381: PERROR (new_name);
382: }
383: return (0);
384:
385: #else /* if not COFF */
386:
387: /* Get symbol table info from header of a.out file if given one. */
388: if (a_out >= 0)
389: {
390: if (read (a_out, &ohdr, sizeof hdr) != sizeof hdr)
391: {
392: PERROR (a_name);
393: }
394:
395: if N_BADMAG (ohdr)
396: {
397: ERROR1 ("invalid magic number in %s", a_name);
398: }
399: #ifdef celerity
400: hdr.a_scovrfl = ohdr.a_scovrfl;
401: #endif
402: #ifdef HPUX
403: hdr.a_lesyms = ohdr.a_lesyms;
404: hdr.a_sltsize = ohdr.a_sltsize;
405: hdr.a_dnttsize = ohdr.a_dnttsize;
406: hdr.a_vtsize = ohdr.a_vtsize;
407: #else /* not HPUX */
408: hdr.a_syms = ohdr.a_syms;
409: #endif /* not HPUX */
410: }
411: else
412: {
413: #ifdef celerity
414: hdr.a_scovrfl = 0;
415: #endif
416: #ifdef HPUX
417: hdr.a_lesyms = 0;
418: hdr.a_sltsize = 0;
419: hdr.a_dnttsize = 0;
420: hdr.a_vtsize = 0;
421: #else /* not HPUX */
422: hdr.a_syms = 0; /* No a.out, so no symbol info. */
423: #endif /* not HPUX */
424: }
425:
426: /* Construct header from user structure. */
427: #ifdef HPUX
428: /* (((MAGIC) ohdr.a_magic) == ((MAGIC) OLDMAGIC)) This does not work */
429: hdr.a_magic = ((ohdr.a_magic.file_type == OLDMAGIC.file_type) ?
430: NEWMAGIC : ohdr.a_magic);
431: #else /* not HPUX */
432: /* hdr.a_magic = NEWMAGIC; */
433: hdr.a_magic = ohdr.a_magic;
434: #endif /* not HPUX */
435:
436: #ifdef sun3
437: hdr.a_machtype = ohdr.a_machtype;
438: #endif /* sun3 */
439: hdr.a_trsize = 0;
440: hdr.a_drsize = 0;
441: hdr.a_entry = entry_address;
442:
443: pagemask = getpagesize () - 1;
444:
445: /* Adjust data/bss boundary. */
446: if (bss_start != 0)
447: {
448: bss_start = (ADDR_CORRECT (bss_start) + pagemask) & ~pagemask; /* (Up) to page bdry. */
449: if (bss_start > ADDR_CORRECT (sbrk (0)))
450: {
451: ERROR1 ("unexec: Specified bss_start (%u) is past end of program",
452: bss_start);
453: }
454: }
455: else
456: {
457: bss_start = ADDR_CORRECT (sbrk (0));
458: bss_start = (bss_start + pagemask) & ~pagemask;
459: }
460:
461: /* Adjust text/data boundary. */
462: #ifdef NO_REMAP
463: data_start = (int) start_of_data ();
464: #else /* not NO_REMAP */
465: if (!data_start)
466: data_start = (int) start_of_data ();
467: #endif /* not NO_REMAP */
468: data_start = ADDR_CORRECT (data_start);
469:
470: #ifdef sun
471: data_start = data_start & ~(SEGSIZ - 1); /* (Down) to segment boundary. */
472: #else
473: data_start = data_start & ~pagemask; /* (Down) to page boundary. */
474: #endif
475:
476: if (data_start > bss_start) /* Can't have negative data size. */
477: {
478: ERROR2 ("unexec: data_start (%u) can't be greater than bss_start (%u)",
479: data_start, bss_start);
480: }
481:
482: tem = ADDR_CORRECT (sbrk (0));
483: hdr.a_bss = tem - bss_start;
484: if (tem < bss_start) /* Note a_bss is unsigned on some systems */
485: hdr.a_bss = 0;
486: hdr.a_data = bss_start - data_start;
487: #if defined(sequent)
488: hdr.a_text = data_start - (long) start_of_text () + sizeof(hdr) + N_ADDRADJ(ohdr);
489: #else
490: hdr.a_text = data_start - (long) start_of_text ();
491: #endif /* not sequent */
492:
493: if (write (new, &hdr, sizeof hdr) != sizeof hdr)
494: {
495: PERROR (new_name);
496: }
497: return 0;
498:
499: #endif /* not COFF */
500: }
501:
502: /* ****************************************************************
503: * copy_text_and_data
504: *
505: * Copy the text and data segments from memory to the new a.out
506: */
507: static int
508: copy_text_and_data (new)
509: int new;
510: {
511: register int nwrite, ret;
512: register char *end;
513: int i;
514: register char *ptr;
515: char buf[80];
516: extern int errno;
517:
518: #ifdef COFF
519: lseek (new, (long) text_scnptr, 0);
520: ptr = (char *) f_ohdr.text_start;
521: end = ptr + f_ohdr.tsize + f_ohdr.dsize;
522: while (ptr < end)
523: {
524: nwrite = 128;
525: if (nwrite > end - ptr) nwrite = end - ptr;
526: ret = write (new, ptr, nwrite);
527: if (nwrite != ret)
528: {
529: sprintf (buf,
530: "unexec write failure: addr 0x%x, fileno %d, size 0x%x, wrote 0x%x, errno %d",
531: ptr, new, nwrite, ret, errno);
532: PERROR (buf);
533: }
534: ptr += nwrite;
535: }
536: return (0);
537:
538: #else /* if not COFF */
539:
540: #if defined(sun3) || defined(sequent)
541: lseek (new, (long) (N_TXTOFF (hdr) + sizeof (hdr)), 0);
542: #else
543: lseek (new, (long) N_TXTOFF (hdr), 0);
544: #endif
545:
546: ptr = start_of_text ();
547: end = ptr + hdr.a_text + hdr.a_data;
548: #if defined(sequent)
549: end -= (sizeof(hdr) + N_ADDRADJ(hdr));
550: #endif
551: for (i = 0; ptr < end;)
552: {
553: nwrite = 128;
554: if (nwrite > end - ptr) nwrite = end - ptr;
555: ret = write (new, ptr, nwrite);
556: if (ret == -1 && errno == EFAULT)
557: {
558: /* BZS - again, see above about N_TXTOFF on a SUN */
559: #if defined(sun3) || defined(sequent)
560: lseek (new, (long) (N_TXTOFF (hdr) + i + nwrite + sizeof (hdr)), 0);
561: #else
562: lseek (new, (long) (N_TXTOFF (hdr) + i + nwrite), 0);
563: #endif
564: }
565: else if (nwrite != ret)
566: {
567: sprintf (buf,
568: "unexec write failure: addr 0x%x, fileno %d, size 0x%x, wrote 0x%x, errno %d",
569: ptr, new, nwrite, ret, errno);
570: PERROR (buf);
571: }
572: i += nwrite;
573: ptr += nwrite;
574: }
575:
576: return 0;
577: #endif /* not COFF */
578: }
579:
580: /* ****************************************************************
581: * copy_sym
582: *
583: * Copy the relocation information and symbol table from the a.out to the new
584: */
585: static int
586: copy_sym (new, a_out, a_name, new_name)
587: int new, a_out;
588: char *a_name, *new_name;
589: {
590: char page[1024];
591: int n;
592:
593: if (a_out < 0)
594: return 0;
595:
596: #ifdef COFF
597: if (SYMS_START == 0L)
598: return 0;
599: #endif /* COFF */
600:
601: #ifdef sun3
602: /* BZS - I might be covering a sin with this */
603: lseek (new, N_SYMOFF (hdr), 0);
604: #else
605: #ifdef COFF
606: if (lnnoptr) /* if there is line number info */
607: lseek (a_out, lnnoptr, 0); /* start copying from there */
608: else
609: #endif /* COFF */
610: lseek (a_out, SYMS_START, 0); /* Position a.out to symtab. */
611: #endif
612: while ((n = read (a_out, page, sizeof page)) > 0)
613: {
614: if (write (new, page, n) != n)
615: {
616: PERROR (new_name);
617: }
618: }
619: if (n < 0)
620: {
621: PERROR (a_name);
622: }
623: return 0;
624: }
625:
626: /* ****************************************************************
627: * mark_x
628: *
629: * After succesfully building the new a.out, mark it executable
630: */
631: static
632: mark_x (name)
633: char *name;
634: {
635: struct stat sbuf;
636: int um;
637: int new = 0; /* for PERROR */
638:
639: um = umask (777);
640: umask (um);
641: if (stat (name, &sbuf) == -1)
642: {
643: PERROR (name);
644: }
645: sbuf.st_mode |= 0111 & ~um;
646: if (chmod (name, sbuf.st_mode) == -1)
647: PERROR (name);
648: }
649:
650: /*
651: * If the COFF file contains a symbol table and a line number section,
652: * then any auxiliary entries that have values for x_lnnoptr must
653: * be adjusted by the amount that the line number section has moved
654: * in the file (bias computed in make_hdr). The #@$%&* designers of
655: * the auxiliary entry structures used the absolute file offsets for
656: * the line number entry rather than an offset from the start of the
657: * line number section!
658: *
659: * When I figure out how to scan through the symbol table and pick out
660: * the auxiliary entries that need adjustment, this routine will
661: * be fixed. As it is now, all such entries are wrong and sdb
662: * will complain. Fred Fish, UniSoft Systems Inc.
663: */
664:
665: #ifdef COFF
666:
667: /* This function is probably very slow. Instead of reopening the new
668: file for input and output it should copy from the old to the new
669: using the two descriptors already open (WRITEDESC and READDESC).
670: Instead of reading one small structure at a time it should use
671: a reasonable size buffer. But I don't have time to work on such
672: things, so I am installing it as submitted to me. -- RMS. */
673:
674: adjust_lnnoptrs (writedesc, readdesc, new_name)
675: int writedesc;
676: int readdesc;
677: char *new_name;
678: {
679: register int nsyms;
680: register int new;
681: struct syment symentry;
682: struct auxent auxentry;
683:
684: if (!lnnoptr || !f_hdr.f_symptr)
685: return 0;
686:
687: if ((new = open (new_name, 2)) < 0)
688: {
689: PERROR (new_name);
690: return -1;
691: }
692:
693: lseek (new, f_hdr.f_symptr, 0);
694: for (nsyms = 0; nsyms < f_hdr.f_nsyms; nsyms++)
695: {
696: read (new, &symentry, SYMESZ);
697: if (symentry.n_numaux)
698: {
699: read (new, &auxentry, AUXESZ);
700: nsyms++;
701: if (ISFCN (symentry.n_type)) {
702: auxentry.x_sym.x_fcnary.x_fcn.x_lnnoptr += bias;
703: lseek (new, -AUXESZ, 1);
704: write (new, &auxentry, AUXESZ);
705: }
706: }
707: }
708: close (new);
709: }
710:
711: #endif /* COFF */
712:
713: #endif /* not CANNOT_DUMP */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.