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