*** empty log message ***
[emacs.git] / src / unexaix.c
blob3deca01b6654aef6b16613ded32be8a944091a07
1 /* Modified by Andrew.Vignaux@comp.vuw.ac.nz to get it to work :-) */
3 /* Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
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.
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.
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.
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! */
25 * unexec.c - Convert a running program into an a.out file.
27 * Author: Spencer W. Thomas
28 * Computer Science Dept.
29 * University of Utah
30 * Date: Tue Mar 2 1982
31 * Modified heavily since then.
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;
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.
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.
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.
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.
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).
65 * The new file is set up to start at entry_address.
67 * If you make improvements I'd like to get them too.
68 * harpo!utah-cs!thomas, thomas@Utah-20
72 /* There are several compilation parameters affecting unexec:
74 * COFF
76 Define this if your system uses COFF for executables.
77 Otherwise we assume you use Berkeley format.
79 * NO_REMAP
81 Define this if you do not want to try to save Emacs's pure data areas
82 as part of the text segment.
84 Saving them as text is good because it allows users to share more.
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.
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.
96 * SECTION_ALIGNMENT
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.
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.
108 * SEGMENT_MASK
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.
116 * A_TEXT_OFFSET(HDR)
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.
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.
130 * A_TEXT_SEEK(HDR)
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
135 * EXEC_MAGIC
137 For machines using COFF, this macro, if defined, is a value stored
138 into the magic number field of the output file.
140 * ADJUST_EXEC_HEADER
142 This macro can be used to generate statements to adjust or
143 initialize nonstandard fields in the file header
145 * ADDR_CORRECT(ADDR)
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.
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.
156 #define XCOFF
157 #define COFF
158 #define NO_REMAP
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
167 #ifndef CANNOT_DUMP /* all rest of file! */
169 #ifndef CANNOT_UNEXEC /* most of rest of file */
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
175 #include "getpagesize.h"
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>
184 extern char *start_of_text (); /* Start of text */
185 extern char *start_of_data (); /* Start of initialized data */
187 extern int _data;
188 extern int _edata;
189 extern int _text;
190 extern int _etext;
191 extern int _end;
192 #ifdef COFF
193 #ifndef USG
194 #ifndef STRIDE
195 #ifndef UMAX
196 #ifndef sun386
197 /* I have a suspicion that these are turned off on all systems
198 and can be deleted. Try it in version 19. */
199 #include <filehdr.h>
200 #include <aouthdr.h>
201 #include <scnhdr.h>
202 #include <syms.h>
203 #endif /* not sun386 */
204 #endif /* not UMAX */
205 #endif /* Not STRIDE */
206 #endif /* not USG */
207 static long block_copy_start; /* Old executable start point */
208 static struct filehdr f_hdr; /* File header */
209 static struct aouthdr f_ohdr; /* Optional file header (a.out) */
210 long bias; /* Bias to add for growth */
211 long lnnoptr; /* Pointer to line-number info within file */
212 #define SYMS_START block_copy_start
214 static long text_scnptr;
215 static long data_scnptr;
216 #ifdef XCOFF
217 static long load_scnptr;
218 static long orig_load_scnptr;
219 static long orig_data_scnptr;
220 #endif
221 static long data_st;
223 #ifndef MAX_SECTIONS
224 #define MAX_SECTIONS 10
225 #endif
227 #endif /* COFF */
229 static int pagemask;
231 /* Correct an int which is the bit pattern of a pointer to a byte
232 into an int which is the number of a byte.
233 This is a no-op on ordinary machines, but not on all. */
235 #ifndef ADDR_CORRECT /* Let m-*.h files override this definition */
236 #define ADDR_CORRECT(x) ((char *)(x) - (char*)0)
237 #endif
239 #ifdef emacs
241 static
242 report_error (file, fd)
243 char *file;
244 int fd;
246 if (fd)
247 close (fd);
248 error ("Failure operating on %s", file);
250 #endif /* emacs */
252 #define ERROR0(msg) report_error_1 (new, msg, 0, 0); return -1
253 #define ERROR1(msg,x) report_error_1 (new, msg, x, 0); return -1
254 #define ERROR2(msg,x,y) report_error_1 (new, msg, x, y); return -1
256 static
257 report_error_1 (fd, msg, a1, a2)
258 int fd;
259 char *msg;
260 int a1, a2;
262 close (fd);
263 #ifdef emacs
264 error (msg, a1, a2);
265 #else
266 fprintf (stderr, msg, a1, a2);
267 fprintf (stderr, "\n");
268 #endif
271 static int make_hdr ();
272 static void mark_x ();
273 static int copy_text_and_data ();
274 static int copy_sym ();
276 /* ****************************************************************
277 * unexec
279 * driving logic.
281 unexec (new_name, a_name, data_start, bss_start, entry_address)
282 char *new_name, *a_name;
283 unsigned data_start, bss_start, entry_address;
285 int new, a_out = -1;
287 if (a_name && (a_out = open (a_name, 0)) < 0)
289 PERROR (a_name);
291 if ((new = creat (new_name, 0666)) < 0)
293 PERROR (new_name);
295 if (make_hdr (new,a_out,data_start,bss_start,entry_address,a_name,new_name) < 0
296 || copy_text_and_data (new) < 0
297 || copy_sym (new, a_out, a_name, new_name) < 0
298 #ifdef COFF
299 || adjust_lnnoptrs (new, a_out, new_name) < 0
300 #endif
301 #ifdef XCOFF
302 || unrelocate_symbols (new, a_out, a_name, new_name) < 0
303 #endif
306 close (new);
307 /* unlink (new_name); /* Failed, unlink new a.out */
308 return -1;
311 close (new);
312 if (a_out >= 0)
313 close (a_out);
314 mark_x (new_name);
315 return 0;
318 /* ****************************************************************
319 * make_hdr
321 * Make the header in the new a.out from the header in core.
322 * Modify the text and data sizes.
324 static int
325 make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name)
326 int new, a_out;
327 unsigned data_start, bss_start, entry_address;
328 char *a_name;
329 char *new_name;
331 register int scns;
332 unsigned int bss_end;
334 struct scnhdr section[MAX_SECTIONS];
335 struct scnhdr * f_thdr; /* Text section header */
336 struct scnhdr * f_dhdr; /* Data section header */
337 struct scnhdr * f_bhdr; /* Bss section header */
338 struct scnhdr * f_lhdr; /* Loader section header */
339 struct scnhdr * f_tchdr; /* Typechk section header */
340 struct scnhdr * f_dbhdr; /* Debug section header */
341 struct scnhdr * f_xhdr; /* Except section header */
343 load_scnptr = orig_load_scnptr = lnnoptr = 0;
344 pagemask = getpagesize () - 1;
346 /* Adjust text/data boundary. */
347 #ifdef NO_REMAP
348 data_start = (long) start_of_data ();
349 #endif /* NO_REMAP */
350 data_start = ADDR_CORRECT (data_start);
352 #ifdef SEGMENT_MASK
353 data_start = data_start & ~SEGMENT_MASK; /* (Down) to segment boundary. */
354 #else
355 data_start = data_start & ~pagemask; /* (Down) to page boundary. */
356 #endif
359 bss_end = ADDR_CORRECT (sbrk (0)) + pagemask;
360 bss_end &= ~ pagemask;
361 /* Adjust data/bss boundary. */
362 if (bss_start != 0)
364 bss_start = (ADDR_CORRECT (bss_start) + pagemask);
365 /* (Up) to page bdry. */
366 bss_start &= ~ pagemask;
367 if (bss_start > bss_end)
369 ERROR1 ("unexec: Specified bss_start (%u) is past end of program",
370 bss_start);
373 else
374 bss_start = bss_end;
376 if (data_start > bss_start) /* Can't have negative data size. */
378 ERROR2 ("unexec: data_start (%u) can't be greater than bss_start (%u)",
379 data_start, bss_start);
382 #ifdef COFF
383 /* Salvage as much info from the existing file as possible */
384 block_copy_start = 0;
385 f_thdr = NULL; f_dhdr = NULL; f_bhdr = NULL;
386 f_lhdr = NULL; f_tchdr = NULL; f_dbhdr = NULL; f_xhdr = NULL;
387 if (a_out >= 0)
389 if (read (a_out, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
391 PERROR (a_name);
393 block_copy_start += sizeof (f_hdr);
394 if (f_hdr.f_opthdr > 0)
396 if (read (a_out, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
398 PERROR (a_name);
400 block_copy_start += sizeof (f_ohdr);
402 if (f_hdr.f_nscns > MAX_SECTIONS)
404 ERROR0 ("unexec: too many section headers -- increase MAX_SECTIONS");
406 /* Loop through section headers */
407 for (scns = 0; scns < f_hdr.f_nscns; scns++) {
408 struct scnhdr *s = &section[scns];
409 if (read (a_out, s, sizeof (*s)) != sizeof (*s))
411 PERROR (a_name);
413 if (s->s_scnptr > 0L)
415 if (block_copy_start < s->s_scnptr + s->s_size)
416 block_copy_start = s->s_scnptr + s->s_size;
419 #define CHECK_SCNHDR(ptr, name, flags) \
420 if (strcmp(s->s_name, name) == 0) { \
421 if (s->s_flags != flags) { \
422 fprintf(stderr, "unexec: %x flags where %x expected in %s section.\n", \
423 s->s_flags, flags, name); \
425 if (ptr) { \
426 fprintf(stderr, "unexec: duplicate section header for section %s.\n", \
427 name); \
429 ptr = s; \
431 CHECK_SCNHDR(f_thdr, _TEXT, STYP_TEXT);
432 CHECK_SCNHDR(f_dhdr, _DATA, STYP_DATA);
433 CHECK_SCNHDR(f_bhdr, _BSS, STYP_BSS);
434 CHECK_SCNHDR(f_lhdr, _LOADER, STYP_LOADER);
435 CHECK_SCNHDR(f_dbhdr, _DEBUG, STYP_DEBUG);
436 CHECK_SCNHDR(f_tchdr, _TYPCHK, STYP_TYPCHK);
437 CHECK_SCNHDR(f_xhdr, _EXCEPT, STYP_EXCEPT);
440 if (f_thdr == 0)
442 ERROR1 ("unexec: couldn't find \"%s\" section", _TEXT);
444 if (f_dhdr == 0)
446 ERROR1 ("unexec: couldn't find \"%s\" section", _DATA);
448 if (f_bhdr == 0)
450 ERROR1 ("unexec: couldn't find \"%s\" section", _BSS);
453 else
455 ERROR0 ("can't build a COFF file from scratch yet");
457 orig_data_scnptr = f_dhdr->s_scnptr;
458 orig_load_scnptr = f_lhdr ? f_lhdr->s_scnptr : 0;
460 /* Now we alter the contents of all the f_*hdr variables
461 to correspond to what we want to dump. */
462 f_hdr.f_flags |= (F_RELFLG | F_EXEC); /* Why? */
463 #ifdef EXEC_MAGIC
464 f_ohdr.magic = EXEC_MAGIC;
465 #endif
466 #ifndef NO_REMAP
467 f_ohdr.tsize = data_start - f_ohdr.text_start;
468 f_ohdr.text_start = (long) start_of_text ();
469 #endif
470 f_ohdr.dsize = bss_start - ((unsigned) &_data);
471 f_ohdr.bsize = bss_end - bss_start;
473 f_dhdr->s_size = f_ohdr.dsize;
474 f_bhdr->s_size = f_ohdr.bsize;
475 f_bhdr->s_paddr = f_ohdr.dsize;
476 f_bhdr->s_vaddr = f_ohdr.dsize;
478 /* fix scnptr's */
480 long ptr;
482 for (scns = 0; scns < f_hdr.f_nscns; scns++) {
483 struct scnhdr *s = &section[scns];
484 if (scns == 0)
485 ptr = s->s_scnptr;
487 if (s->s_scnptr != 0)
489 s->s_scnptr = ptr;
492 if ((s->s_flags & 0xffff) == STYP_PAD)
495 * the text_start should probably be o_algntext but that doesn't
496 * seem to change
498 if (f_ohdr.text_start != 0) /* && scns != 0 */
500 s->s_size = 512 - (s->s_scnptr % 512);
501 if (s->s_size == 512)
502 s->s_size = 0;
506 ptr = ptr + s->s_size;
509 bias = ptr - block_copy_start;
512 /* fix other pointers */
513 for (scns = 0; scns < f_hdr.f_nscns; scns++) {
514 struct scnhdr *s = &section[scns];
516 if (s->s_relptr != 0)
518 s->s_relptr += bias;
520 if (s->s_lnnoptr != 0)
522 if (lnnoptr == 0) lnnoptr = s->s_lnnoptr;
523 s->s_lnnoptr += bias;
527 if (f_hdr.f_symptr > 0L)
529 f_hdr.f_symptr += bias;
532 data_st = data_start;
533 text_scnptr = f_thdr->s_scnptr;
534 data_scnptr = f_dhdr->s_scnptr;
535 load_scnptr = f_lhdr ? f_lhdr->s_scnptr : 0;
536 block_copy_start = orig_load_scnptr;
538 #ifdef ADJUST_EXEC_HEADER
539 ADJUST_EXEC_HEADER
540 #endif /* ADJUST_EXEC_HEADER */
542 if (write (new, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
544 PERROR (new_name);
547 if (f_hdr.f_opthdr > 0)
549 if (write (new, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
551 PERROR (new_name);
555 for (scns = 0; scns < f_hdr.f_nscns; scns++) {
556 struct scnhdr *s = &section[scns];
557 if (write (new, s, sizeof (*s)) != sizeof (*s))
559 PERROR (new_name);
563 return (0);
565 #endif /* COFF */
568 /* ****************************************************************
571 * Copy the text and data segments from memory to the new a.out
573 static int
574 copy_text_and_data (new)
575 int new;
577 register char *end;
578 register char *ptr;
580 lseek (new, (long) text_scnptr, 0);
581 ptr = start_of_text () + text_scnptr;
582 end = ptr + f_ohdr.tsize;
583 write_segment (new, ptr, end);
585 lseek (new, (long) data_scnptr, 0);
586 ptr = (char *) &_data;
587 end = ptr + f_ohdr.dsize;
588 write_segment (new, ptr, end);
590 return 0;
593 write_segment (new, ptr, end)
594 int new;
595 register char *ptr, *end;
597 register int i, nwrite, ret;
598 char buf[80];
599 extern int errno;
600 char zeros[128];
602 bzero (zeros, sizeof zeros);
604 for (i = 0; ptr < end;)
606 /* distance to next multiple of 128. */
607 nwrite = (((int) ptr + 128) & -128) - (int) ptr;
608 /* But not beyond specified end. */
609 if (nwrite > end - ptr) nwrite = end - ptr;
610 ret = write (new, ptr, nwrite);
611 /* If write gets a page fault, it means we reached
612 a gap between the old text segment and the old data segment.
613 This gap has probably been remapped into part of the text segment.
614 So write zeros for it. */
615 if (ret == -1 && errno == EFAULT)
617 write (new, zeros, nwrite);
619 else if (nwrite != ret)
621 sprintf (buf,
622 "unexec write failure: addr 0x%x, fileno %d, size 0x%x, wrote 0x%x, errno %d",
623 ptr, new, nwrite, ret, errno);
624 PERROR (buf);
626 i += nwrite;
627 ptr += nwrite;
631 /* ****************************************************************
632 * copy_sym
634 * Copy the relocation information and symbol table from the a.out to the new
636 static int
637 copy_sym (new, a_out, a_name, new_name)
638 int new, a_out;
639 char *a_name, *new_name;
641 char page[1024];
642 int n;
644 if (a_out < 0)
645 return 0;
647 if (SYMS_START == 0L)
648 return 0;
650 if (lnnoptr && lnnoptr < SYMS_START) /* if there is line number info */
651 lseek (a_out, lnnoptr, 0); /* start copying from there */
652 else
653 lseek (a_out, SYMS_START, 0); /* Position a.out to symtab. */
655 while ((n = read (a_out, page, sizeof page)) > 0)
657 if (write (new, page, n) != n)
659 PERROR (new_name);
662 if (n < 0)
664 PERROR (a_name);
666 return 0;
669 /* ****************************************************************
670 * mark_x
672 * After succesfully building the new a.out, mark it executable
674 static void
675 mark_x (name)
676 char *name;
678 struct stat sbuf;
679 int um;
680 int new = 0; /* for PERROR */
682 um = umask (777);
683 umask (um);
684 if (stat (name, &sbuf) == -1)
686 PERROR (name);
688 sbuf.st_mode |= 0111 & ~um;
689 if (chmod (name, sbuf.st_mode) == -1)
690 PERROR (name);
694 * If the COFF file contains a symbol table and a line number section,
695 * then any auxiliary entries that have values for x_lnnoptr must
696 * be adjusted by the amount that the line number section has moved
697 * in the file (bias computed in make_hdr). The #@$%&* designers of
698 * the auxiliary entry structures used the absolute file offsets for
699 * the line number entry rather than an offset from the start of the
700 * line number section!
702 * When I figure out how to scan through the symbol table and pick out
703 * the auxiliary entries that need adjustment, this routine will
704 * be fixed. As it is now, all such entries are wrong and sdb
705 * will complain. Fred Fish, UniSoft Systems Inc.
708 #ifdef COFF
710 /* This function is probably very slow. Instead of reopening the new
711 file for input and output it should copy from the old to the new
712 using the two descriptors already open (WRITEDESC and READDESC).
713 Instead of reading one small structure at a time it should use
714 a reasonable size buffer. But I don't have time to work on such
715 things, so I am installing it as submitted to me. -- RMS. */
717 adjust_lnnoptrs (writedesc, readdesc, new_name)
718 int writedesc;
719 int readdesc;
720 char *new_name;
722 register int nsyms;
723 register int new;
724 #ifdef amdahl_uts
725 SYMENT symentry;
726 AUXENT auxentry;
727 #else
728 struct syment symentry;
729 union auxent auxentry;
730 #endif
732 if (!lnnoptr || !f_hdr.f_symptr)
733 return 0;
735 if ((new = open (new_name, 2)) < 0)
737 PERROR (new_name);
738 return -1;
741 lseek (new, f_hdr.f_symptr, 0);
742 for (nsyms = 0; nsyms < f_hdr.f_nsyms; nsyms++)
744 read (new, &symentry, SYMESZ);
745 if (symentry.n_numaux)
747 read (new, &auxentry, AUXESZ);
748 nsyms++;
749 if (ISFCN (symentry.n_type)) {
750 auxentry.x_sym.x_fcnary.x_fcn.x_lnnoptr += bias;
751 lseek (new, -AUXESZ, 1);
752 write (new, &auxentry, AUXESZ);
756 close (new);
759 #endif /* COFF */
761 #ifdef XCOFF
763 /* It is probably a false economy to optimise this routine (it used to
764 read one LDREL and do do two lseeks per iteration) but the wrath of
765 RMS (see above :-) would be too much to bear */
767 unrelocate_symbols (new, a_out, a_name, new_name)
768 int new, a_out;
769 char *a_name, *new_name;
771 register int i;
772 register int l;
773 register LDREL *ldrel;
774 LDHDR ldhdr;
775 LDREL ldrel_buf [20];
776 ulong t_start = (ulong) &_text;
777 ulong d_start = (ulong) &_data;
778 int * p;
779 int dirty;
781 if (load_scnptr == 0)
782 return 0;
784 lseek (a_out, orig_load_scnptr, 0);
785 if (read (a_out, &ldhdr, sizeof (ldhdr)) != sizeof (ldhdr))
787 PERROR (new_name);
790 #define SYMNDX_TEXT 0
791 #define SYMNDX_DATA 1
792 #define SYMNDX_BSS 2
793 l = 0;
794 for (i = 0; i < ldhdr.l_nreloc; i++, l--, ldrel++)
796 if (l == 0) {
797 lseek (a_out,
798 orig_load_scnptr + LDHDRSZ + LDSYMSZ*ldhdr.l_nsyms + LDRELSZ*i,
801 l = ldhdr.l_nreloc - i;
802 if (l > sizeof (ldrel_buf) / LDRELSZ)
803 l = sizeof (ldrel_buf) / LDRELSZ;
805 if (read (a_out, ldrel_buf, l * LDRELSZ) != l * LDRELSZ)
807 PERROR (a_name);
809 ldrel = ldrel_buf;
811 dirty = 0;
813 /* this code may not be necessary */
814 /* I originally had == in the "assignment" and it still unrelocated */
816 /* move the BSS loader symbols to the DATA segment */
817 if (ldrel->l_rsecnm == f_ohdr.o_snbss)
818 ldrel->l_rsecnm = f_ohdr.o_sndata, dirty++;
820 if (ldrel->l_symndx == SYMNDX_BSS)
821 ldrel->l_symndx = SYMNDX_DATA, dirty++;
823 if (dirty)
825 lseek (new,
826 load_scnptr + LDHDRSZ + LDSYMSZ*ldhdr.l_nsyms + LDRELSZ*i,
829 if (write (new, ldrel, LDRELSZ) != LDRELSZ)
831 PERROR (new_name);
835 if (ldrel->l_rsecnm == f_ohdr.o_sndata)
837 int orig_int;
839 lseek (a_out, orig_data_scnptr + ldrel->l_vaddr, 0);
841 if (read (a_out, (void *) &orig_int, sizeof (orig_int)) != sizeof (orig_int))
843 PERROR (a_name);
846 switch (ldrel->l_symndx) {
847 case SYMNDX_TEXT:
848 p = (int *) (d_start + ldrel->l_vaddr);
849 orig_int = * p - (t_start - f_ohdr.text_start);
850 break;
852 case SYMNDX_DATA:
853 case SYMNDX_BSS:
854 p = (int *) (d_start + ldrel->l_vaddr);
855 orig_int = * p - (d_start - f_ohdr.data_start);
856 break;
859 lseek (new, data_scnptr + ldrel->l_vaddr, 0);
860 if (write (new, (void *) &orig_int, sizeof (orig_int)) != sizeof (orig_int))
862 PERROR (new_name);
867 #endif /* XCOFF */
869 #endif /* not CANNOT_UNEXEC */
871 #endif /* not CANNOT_DUMP */