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