Mercurial > emacs
annotate src/unexaix.c @ 4329:dfabe5b99500
(Man-filter-list): Insert \n newlines in awk script.
author | Richard M. Stallman <rms@gnu.org> |
---|---|
date | Thu, 29 Jul 1993 02:31:06 +0000 |
parents | 507f64624555 |
children | 1fc792473491 |
rev | line source |
---|---|
560 | 1 /* Modified by Andrew.Vignaux@comp.vuw.ac.nz 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 | |
117
08356dc1077c
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
110
diff
changeset
|
23 |
560 | 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 | |
117
08356dc1077c
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
110
diff
changeset
|
75 |
560 | 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 | |
117
08356dc1077c
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
110
diff
changeset
|
109 |
560 | 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) | |
117
08356dc1077c
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
110
diff
changeset
|
131 |
560 | 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 | |
117
08356dc1077c
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
110
diff
changeset
|
154 */ |
08356dc1077c
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
110
diff
changeset
|
155 |
560 | 156 #define XCOFF |
157 #define COFF | |
158 #define NO_REMAP | |
110 | 159 |
560 | 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 | |
110 | 166 |
560 | 167 #ifndef CANNOT_DUMP /* all rest of file! */ |
168 | |
169 #ifndef CANNOT_UNEXEC /* most of rest of file */ | |
110 | 170 |
560 | 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" | |
110 | 176 |
560 | 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> | |
110 | 183 |
560 | 184 extern char *start_of_text (); /* Start of text */ |
185 extern char *start_of_data (); /* Start of initialized data */ | |
110 | 186 |
560 | 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 | |
110 | 213 |
560 | 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; | |
110 | 222 |
560 | 223 #ifndef MAX_SECTIONS |
224 #define MAX_SECTIONS 10 | |
225 #endif | |
110 | 226 |
560 | 227 #endif /* COFF */ |
228 | |
229 static int pagemask; | |
110 | 230 |
560 | 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. */ | |
234 | |
235 #ifndef ADDR_CORRECT /* Let m-*.h files override this definition */ | |
236 #define ADDR_CORRECT(x) ((char *)(x) - (char*)0) | |
237 #endif | |
238 | |
239 #ifdef emacs | |
110 | 240 |
560 | 241 static |
242 report_error (file, fd) | |
243 char *file; | |
244 int fd; | |
245 { | |
246 if (fd) | |
247 close (fd); | |
248 error ("Failure operating on %s", file); | |
249 } | |
250 #endif /* emacs */ | |
110 | 251 |
560 | 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 | |
110 | 255 |
560 | 256 static |
257 report_error_1 (fd, msg, a1, a2) | |
258 int fd; | |
259 char *msg; | |
260 int a1, a2; | |
110 | 261 { |
560 | 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 | |
269 } | |
110 | 270 |
560 | 271 static int make_hdr (); |
272 static void mark_x (); | |
273 static int copy_text_and_data (); | |
274 static int copy_sym (); | |
275 | |
276 /* **************************************************************** | |
277 * unexec | |
278 * | |
279 * driving logic. | |
280 */ | |
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; | |
284 { | |
285 int new, a_out = -1; | |
286 | |
287 if (a_name && (a_out = open (a_name, 0)) < 0) | |
110 | 288 { |
560 | 289 PERROR (a_name); |
290 } | |
291 if ((new = creat (new_name, 0666)) < 0) | |
292 { | |
293 PERROR (new_name); | |
110 | 294 } |
560 | 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 | |
304 ) | |
110 | 305 { |
560 | 306 close (new); |
307 /* unlink (new_name); /* Failed, unlink new a.out */ | |
308 return -1; | |
110 | 309 } |
310 | |
560 | 311 close (new); |
312 if (a_out >= 0) | |
313 close (a_out); | |
314 mark_x (new_name); | |
315 return 0; | |
316 } | |
317 | |
318 /* **************************************************************** | |
319 * make_hdr | |
320 * | |
321 * Make the header in the new a.out from the header in core. | |
322 * Modify the text and data sizes. | |
323 */ | |
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; | |
330 { | |
331 register int scns; | |
332 unsigned int bss_end; | |
110 | 333 |
560 | 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 */ | |
342 | |
343 load_scnptr = orig_load_scnptr = lnnoptr = 0; | |
344 pagemask = getpagesize () - 1; | |
345 | |
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); | |
351 | |
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 | |
357 | |
358 | |
359 bss_end = ADDR_CORRECT (sbrk (0)) + pagemask; | |
360 bss_end &= ~ pagemask; | |
361 /* Adjust data/bss boundary. */ | |
362 if (bss_start != 0) | |
110 | 363 { |
560 | 364 bss_start = (ADDR_CORRECT (bss_start) + pagemask); |
365 /* (Up) to page bdry. */ | |
366 bss_start &= ~ pagemask; | |
367 if (bss_start > bss_end) | |
368 { | |
369 ERROR1 ("unexec: Specified bss_start (%u) is past end of program", | |
370 bss_start); | |
371 } | |
110 | 372 } |
560 | 373 else |
374 bss_start = bss_end; | |
110 | 375 |
560 | 376 if (data_start > bss_start) /* Can't have negative data size. */ |
110 | 377 { |
560 | 378 ERROR2 ("unexec: data_start (%u) can't be greater than bss_start (%u)", |
379 data_start, bss_start); | |
110 | 380 } |
381 | |
560 | 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) | |
110 | 388 { |
560 | 389 if (read (a_out, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr)) |
390 { | |
391 PERROR (a_name); | |
392 } | |
393 block_copy_start += sizeof (f_hdr); | |
394 if (f_hdr.f_opthdr > 0) | |
395 { | |
396 if (read (a_out, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr)) | |
397 { | |
398 PERROR (a_name); | |
399 } | |
400 block_copy_start += sizeof (f_ohdr); | |
401 } | |
402 if (f_hdr.f_nscns > MAX_SECTIONS) | |
403 { | |
404 ERROR0 ("unexec: too many section headers -- increase MAX_SECTIONS"); | |
405 } | |
406 /* Loop through section headers */ | |
407 for (scns = 0; scns < f_hdr.f_nscns; scns++) { | |
408 struct scnhdr *s = §ion[scns]; | |
409 if (read (a_out, s, sizeof (*s)) != sizeof (*s)) | |
410 { | |
411 PERROR (a_name); | |
412 } | |
413 if (s->s_scnptr > 0L) | |
414 { | |
415 if (block_copy_start < s->s_scnptr + s->s_size) | |
416 block_copy_start = s->s_scnptr + s->s_size; | |
417 } | |
110 | 418 |
560 | 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); \ | |
424 } \ | |
425 if (ptr) { \ | |
426 fprintf(stderr, "unexec: duplicate section header for section %s.\n", \ | |
427 name); \ | |
428 } \ | |
429 ptr = s; \ | |
430 } | |
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); | |
438 } | |
439 | |
440 if (f_thdr == 0) | |
441 { | |
442 ERROR1 ("unexec: couldn't find \"%s\" section", _TEXT); | |
443 } | |
444 if (f_dhdr == 0) | |
445 { | |
446 ERROR1 ("unexec: couldn't find \"%s\" section", _DATA); | |
447 } | |
448 if (f_bhdr == 0) | |
110 | 449 { |
560 | 450 ERROR1 ("unexec: couldn't find \"%s\" section", _BSS); |
451 } | |
452 } | |
453 else | |
454 { | |
455 ERROR0 ("can't build a COFF file from scratch yet"); | |
456 } | |
457 orig_data_scnptr = f_dhdr->s_scnptr; | |
458 orig_load_scnptr = f_lhdr ? f_lhdr->s_scnptr : 0; | |
110 | 459 |
560 | 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; | |
110 | 472 |
560 | 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; | |
477 | |
478 /* fix scnptr's */ | |
479 { | |
480 long ptr; | |
481 | |
482 for (scns = 0; scns < f_hdr.f_nscns; scns++) { | |
483 struct scnhdr *s = §ion[scns]; | |
484 if (scns == 0) | |
485 ptr = s->s_scnptr; | |
486 | |
487 if (s->s_scnptr != 0) | |
488 { | |
489 s->s_scnptr = ptr; | |
110 | 490 } |
491 | |
560 | 492 if ((s->s_flags & 0xffff) == STYP_PAD) |
110 | 493 { |
560 | 494 /* |
495 * the text_start should probably be o_algntext but that doesn't | |
496 * seem to change | |
497 */ | |
498 if (f_ohdr.text_start != 0) /* && scns != 0 */ | |
499 { | |
500 s->s_size = 512 - (s->s_scnptr % 512); | |
501 if (s->s_size == 512) | |
502 s->s_size = 0; | |
503 } | |
110 | 504 } |
505 | |
560 | 506 ptr = ptr + s->s_size; |
507 } | |
508 | |
509 bias = ptr - block_copy_start; | |
510 } | |
511 | |
512 /* fix other pointers */ | |
513 for (scns = 0; scns < f_hdr.f_nscns; scns++) { | |
514 struct scnhdr *s = §ion[scns]; | |
515 | |
516 if (s->s_relptr != 0) | |
517 { | |
518 s->s_relptr += bias; | |
519 } | |
520 if (s->s_lnnoptr != 0) | |
521 { | |
522 if (lnnoptr == 0) lnnoptr = s->s_lnnoptr; | |
523 s->s_lnnoptr += bias; | |
524 } | |
525 } | |
110 | 526 |
560 | 527 if (f_hdr.f_symptr > 0L) |
528 { | |
529 f_hdr.f_symptr += bias; | |
530 } | |
110 | 531 |
560 | 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; | |
110 | 537 |
560 | 538 #ifdef ADJUST_EXEC_HEADER |
539 ADJUST_EXEC_HEADER | |
540 #endif /* ADJUST_EXEC_HEADER */ | |
541 | |
542 if (write (new, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr)) | |
543 { | |
544 PERROR (new_name); | |
545 } | |
546 | |
547 if (f_hdr.f_opthdr > 0) | |
548 { | |
549 if (write (new, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr)) | |
110 | 550 { |
560 | 551 PERROR (new_name); |
110 | 552 } |
553 } | |
554 | |
560 | 555 for (scns = 0; scns < f_hdr.f_nscns; scns++) { |
556 struct scnhdr *s = §ion[scns]; | |
557 if (write (new, s, sizeof (*s)) != sizeof (*s)) | |
558 { | |
559 PERROR (new_name); | |
560 } | |
561 } | |
562 | |
563 return (0); | |
564 | |
565 #endif /* COFF */ | |
566 } | |
567 | |
568 /* **************************************************************** | |
569 | |
570 * | |
571 * Copy the text and data segments from memory to the new a.out | |
572 */ | |
573 static int | |
574 copy_text_and_data (new) | |
575 int new; | |
576 { | |
577 register char *end; | |
578 register char *ptr; | |
579 | |
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); | |
584 | |
585 lseek (new, (long) data_scnptr, 0); | |
586 ptr = (char *) &_data; | |
587 end = ptr + f_ohdr.dsize; | |
588 write_segment (new, ptr, end); | |
589 | |
590 return 0; | |
110 | 591 } |
592 | |
560 | 593 write_segment (new, ptr, end) |
594 int new; | |
595 register char *ptr, *end; | |
596 { | |
597 register int i, nwrite, ret; | |
598 char buf[80]; | |
599 extern int errno; | |
600 char zeros[128]; | |
601 | |
602 bzero (zeros, sizeof zeros); | |
110 | 603 |
560 | 604 for (i = 0; ptr < end;) |
605 { | |
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) | |
616 { | |
617 write (new, zeros, nwrite); | |
618 } | |
619 else if (nwrite != ret) | |
620 { | |
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); | |
625 } | |
626 i += nwrite; | |
627 ptr += nwrite; | |
628 } | |
629 } | |
630 | |
631 /* **************************************************************** | |
632 * copy_sym | |
633 * | |
634 * Copy the relocation information and symbol table from the a.out to the new | |
635 */ | |
636 static int | |
637 copy_sym (new, a_out, a_name, new_name) | |
638 int new, a_out; | |
639 char *a_name, *new_name; | |
110 | 640 { |
560 | 641 char page[1024]; |
642 int n; | |
643 | |
644 if (a_out < 0) | |
645 return 0; | |
646 | |
647 if (SYMS_START == 0L) | |
648 return 0; | |
649 | |
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. */ | |
654 | |
655 while ((n = read (a_out, page, sizeof page)) > 0) | |
656 { | |
657 if (write (new, page, n) != n) | |
658 { | |
659 PERROR (new_name); | |
660 } | |
661 } | |
662 if (n < 0) | |
663 { | |
664 PERROR (a_name); | |
665 } | |
666 return 0; | |
667 } | |
668 | |
669 /* **************************************************************** | |
670 * mark_x | |
671 * | |
3591
507f64624555
Apply typo patches from Paul Eggert.
Jim Blandy <jimb@redhat.com>
parents:
560
diff
changeset
|
672 * After successfully building the new a.out, mark it executable |
560 | 673 */ |
674 static void | |
675 mark_x (name) | |
676 char *name; | |
677 { | |
678 struct stat sbuf; | |
679 int um; | |
680 int new = 0; /* for PERROR */ | |
110 | 681 |
560 | 682 um = umask (777); |
683 umask (um); | |
684 if (stat (name, &sbuf) == -1) | |
685 { | |
686 PERROR (name); | |
687 } | |
688 sbuf.st_mode |= 0111 & ~um; | |
689 if (chmod (name, sbuf.st_mode) == -1) | |
690 PERROR (name); | |
691 } | |
692 | |
693 /* | |
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! | |
701 * | |
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. | |
706 */ | |
707 | |
708 #ifdef COFF | |
709 | |
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. */ | |
716 | |
717 adjust_lnnoptrs (writedesc, readdesc, new_name) | |
718 int writedesc; | |
719 int readdesc; | |
720 char *new_name; | |
721 { | |
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 | |
110 | 731 |
560 | 732 if (!lnnoptr || !f_hdr.f_symptr) |
733 return 0; | |
734 | |
735 if ((new = open (new_name, 2)) < 0) | |
736 { | |
737 PERROR (new_name); | |
738 return -1; | |
739 } | |
740 | |
741 lseek (new, f_hdr.f_symptr, 0); | |
742 for (nsyms = 0; nsyms < f_hdr.f_nsyms; nsyms++) | |
743 { | |
744 read (new, &symentry, SYMESZ); | |
745 if (symentry.n_numaux) | |
746 { | |
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); | |
753 } | |
754 } | |
755 } | |
756 close (new); | |
757 } | |
758 | |
759 #endif /* COFF */ | |
760 | |
761 #ifdef XCOFF | |
762 | |
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 */ | |
766 | |
767 unrelocate_symbols (new, a_out, a_name, new_name) | |
768 int new, a_out; | |
769 char *a_name, *new_name; | |
770 { | |
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; | |
780 | |
781 if (load_scnptr == 0) | |
782 return 0; | |
783 | |
784 lseek (a_out, orig_load_scnptr, 0); | |
785 if (read (a_out, &ldhdr, sizeof (ldhdr)) != sizeof (ldhdr)) | |
786 { | |
787 PERROR (new_name); | |
788 } | |
789 | |
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++) | |
795 { | |
796 if (l == 0) { | |
797 lseek (a_out, | |
798 orig_load_scnptr + LDHDRSZ + LDSYMSZ*ldhdr.l_nsyms + LDRELSZ*i, | |
799 0); | |
110 | 800 |
560 | 801 l = ldhdr.l_nreloc - i; |
802 if (l > sizeof (ldrel_buf) / LDRELSZ) | |
803 l = sizeof (ldrel_buf) / LDRELSZ; | |
804 | |
805 if (read (a_out, ldrel_buf, l * LDRELSZ) != l * LDRELSZ) | |
806 { | |
807 PERROR (a_name); | |
808 } | |
809 ldrel = ldrel_buf; | |
810 } | |
811 dirty = 0; | |
812 | |
813 /* this code may not be necessary */ | |
814 /* I originally had == in the "assignment" and it still unrelocated */ | |
815 | |
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++; | |
819 | |
820 if (ldrel->l_symndx == SYMNDX_BSS) | |
821 ldrel->l_symndx = SYMNDX_DATA, dirty++; | |
822 | |
823 if (dirty) | |
824 { | |
825 lseek (new, | |
826 load_scnptr + LDHDRSZ + LDSYMSZ*ldhdr.l_nsyms + LDRELSZ*i, | |
827 0); | |
828 | |
829 if (write (new, ldrel, LDRELSZ) != LDRELSZ) | |
830 { | |
831 PERROR (new_name); | |
832 } | |
833 } | |
834 | |
835 if (ldrel->l_rsecnm == f_ohdr.o_sndata) | |
836 { | |
837 int orig_int; | |
838 | |
839 lseek (a_out, orig_data_scnptr + ldrel->l_vaddr, 0); | |
840 | |
841 if (read (a_out, (void *) &orig_int, sizeof (orig_int)) != sizeof (orig_int)) | |
842 { | |
843 PERROR (a_name); | |
844 } | |
845 | |
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; | |
851 | |
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; | |
857 } | |
858 | |
859 lseek (new, data_scnptr + ldrel->l_vaddr, 0); | |
860 if (write (new, (void *) &orig_int, sizeof (orig_int)) != sizeof (orig_int)) | |
861 { | |
862 PERROR (new_name); | |
863 } | |
864 } | |
865 } | |
110 | 866 } |
560 | 867 #endif /* XCOFF */ |
868 | |
869 #endif /* not CANNOT_UNEXEC */ | |
870 | |
871 #endif /* not CANNOT_DUMP */ |