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