Mercurial > hg > xemacs-beta
annotate src/unexec.c @ 4792:95b04754ea8c
Make #'equalp more compatible with CL; add a compiler macro, test & doc it.
lisp/ChangeLog addition:
2009-11-08 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (cl-string-vector-equalp)
(cl-bit-vector-vector-equalp, cl-vector-array-equalp)
(cl-hash-table-contents-equalp): New functions, to implement
equalp treating arrays with identical contents as equivalent, as
specified by Common Lisp.
(equalp): Revise this function to implement array equivalence,
and the hash-table equalp behaviour specified by CL.
* cl-macs.el (equalp): Add a compiler macro for this function,
used when one of the arguments is constant, and as such, its type
is known at compile time.
man/ChangeLog addition:
2009-11-08 Aidan Kehoe <kehoea@parhasard.net>
* lispref/objects.texi (Equality Predicates):
Document #'equalp here, as well as #'equal and #'eq.
tests/ChangeLog addition:
2009-12-31 Aidan Kehoe <kehoea@parhasard.net>
* automated/lisp-tests.el:
Test much of the functionality of equalp; add a pointer to Paul
Dietz' ANSI test suite for this function, converted to Emacs
Lisp. Not including the tests themselves in XEmacs because who
owns the copyright on the files is unclear and the GCL people
didn't respond to my queries.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Thu, 31 Dec 2009 15:09:41 +0000 |
| parents | aa5ed11f473b |
| children | 304aebb79cd3 |
| rev | line source |
|---|---|
| 428 | 1 /* Copyright (C) 1985, 1986, 1987, 1988, 1992, 1993, 1994 |
| 771 | 2 /* Copyright (C) 2001 Ben Wing. |
| 428 | 3 Free Software Foundation, Inc. |
| 4 | |
| 5 This file is part of XEmacs. | |
| 6 | |
| 7 XEmacs is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 9 Free Software Foundation; either version 2, or (at your option) any | |
| 10 later version. | |
| 11 | |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with XEmacs; see the file COPYING. If not, write to | |
| 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 20 Boston, MA 02111-1307, USA. */ | |
| 21 | |
| 22 /* Synched up with: FSF 19.31. */ | |
| 23 | |
| 24 /* | |
| 25 * unexec.c - Convert a running program into an a.out file. | |
| 26 * | |
| 27 * Author: Spencer W. Thomas | |
| 28 * Computer Science Dept. | |
| 29 * University of Utah | |
| 30 * Date: Tue Mar 2 1982 | |
| 31 * Modified heavily since then. | |
| 32 * | |
| 33 * Synopsis: | |
| 34 * unexec (new_name, a_name, data_start, bss_start, entry_address) | |
| 35 * char *new_name, *a_name; | |
| 36 * unsigned data_start, bss_start, entry_address; | |
| 37 * | |
| 38 * Takes a snapshot of the program and makes an a.out format file in the | |
| 39 * file named by the string argument new_name. | |
| 40 * If a_name is non-NULL, the symbol table will be taken from the given file. | |
| 41 * On some machines, an existing a_name file is required. | |
| 42 * | |
| 43 * The boundaries within the a.out file may be adjusted with the data_start | |
| 44 * and bss_start arguments. Either or both may be given as 0 for defaults. | |
| 45 * | |
| 46 * Data_start gives the boundary between the text segment and the data | |
| 47 * segment of the program. The text segment can contain shared, read-only | |
| 48 * program code and literal data, while the data segment is always unshared | |
| 49 * and unprotected. Data_start gives the lowest unprotected address. | |
| 50 * The value you specify may be rounded down to a suitable boundary | |
| 51 * as required by the machine you are using. | |
| 52 * | |
| 53 * Specifying zero for data_start means the boundary between text and data | |
| 54 * should not be the same as when the program was loaded. | |
| 55 * If NO_REMAP is defined, the argument data_start is ignored and the | |
| 56 * segment boundaries are never changed. | |
| 57 * | |
| 58 * Bss_start indicates how much of the data segment is to be saved in the | |
| 59 * a.out file and restored when the program is executed. It gives the lowest | |
| 60 * unsaved address, and is rounded up to a page boundary. The default when 0 | |
| 61 * is given assumes that the entire data segment is to be stored, including | |
| 62 * the previous data and bss as well as any additional storage allocated with | |
| 63 * break (2). | |
| 64 * | |
| 65 * The new file is set up to start at entry_address. | |
| 66 * | |
| 67 * If you make improvements I'd like to get them too. | |
| 68 * harpo!utah-cs!thomas, thomas@Utah-20 | |
| 69 * | |
| 70 */ | |
| 71 | |
| 72 /* Modified to support SysVr3 shared libraries by James Van Artsdalen | |
| 73 * of Dell Computer Corporation. james@bigtex.cactus.org. | |
| 74 */ | |
| 75 | |
| 76 /* There are several compilation parameters affecting unexec: | |
| 77 | |
| 78 * COFF | |
| 79 | |
| 80 Define this if your system uses COFF for executables. | |
| 81 | |
| 82 * NO_REMAP | |
| 83 | |
| 84 Define this if you do not want to try to save Emacs's pure data areas | |
| 85 as part of the text segment. | |
| 86 | |
| 87 Saving them as text is good because it allows users to share more. | |
| 88 | |
| 89 However, on machines that locate the text area far from the data area, | |
| 90 the boundary cannot feasibly be moved. Such machines require | |
| 91 NO_REMAP. | |
| 92 | |
| 93 Also, remapping can cause trouble with the built-in startup routine | |
| 94 /lib/crt0.o, which defines `environ' as an initialized variable. | |
| 95 Dumping `environ' as pure does not work! So, to use remapping, | |
| 96 you must write a startup routine for your machine in Emacs's crt0.c. | |
| 97 If NO_REMAP is defined, Emacs uses the system's crt0.o. | |
| 98 | |
| 99 * SEGMENT_MASK | |
| 100 | |
| 101 Some machines require that the beginnings and ends of segments | |
| 102 *in core* be on certain boundaries. For most machines, a page | |
| 103 boundary is sufficient. That is the default. When a larger | |
| 104 boundary is needed, define SEGMENT_MASK to a mask of | |
| 105 the bits that must be zero on such a boundary. | |
| 106 | |
| 107 * A_TEXT_OFFSET(HDR) | |
| 108 | |
| 109 Some machines count the a.out header as part of the size of the text | |
| 110 segment (a_text); they may actually load the header into core as the | |
| 111 first data in the text segment. Some have additional padding between | |
| 112 the header and the real text of the program that is counted in a_text. | |
| 113 | |
| 114 For these machines, define A_TEXT_OFFSET(HDR) to examine the header | |
| 115 structure HDR and return the number of bytes to add to `a_text' | |
| 116 before writing it (above and beyond the number of bytes of actual | |
| 117 program text). HDR's standard fields are already correct, except that | |
| 118 this adjustment to the `a_text' field has not yet been made; | |
| 119 thus, the amount of offset can depend on the data in the file. | |
| 438 | 120 |
| 428 | 121 * A_TEXT_SEEK(HDR) |
| 122 | |
| 123 If defined, this macro specifies the number of bytes to seek into the | |
| 124 a.out file before starting to write the text segment. | |
| 125 | |
| 126 * EXEC_MAGIC | |
| 127 | |
| 128 For machines using COFF, this macro, if defined, is a value stored | |
| 129 into the magic number field of the output file. | |
| 130 | |
| 131 * ADJUST_EXEC_HEADER | |
| 132 | |
| 133 This macro can be used to generate statements to adjust or | |
| 134 initialize nonstandard fields in the file header | |
| 135 | |
| 136 * ADDR_CORRECT(ADDR) | |
| 137 | |
| 138 Macro to correct an int which is the bit pattern of a pointer to a byte | |
| 139 into an int which is the number of a byte. | |
| 140 | |
| 141 This macro has a default definition which is usually right. | |
| 142 This default definition is a no-op on most machines (where a | |
| 143 pointer looks like an int) but not on all machines. | |
| 144 | |
| 145 */ | |
| 146 | |
| 147 #ifndef emacs | |
| 148 #define PERROR(arg) perror (arg); return -1 | |
| 149 #else | |
| 150 #define IN_UNEXEC | |
| 151 #include <config.h> | |
| 3025 | 152 #define PERROR(file) report_error (file, new_) |
| 428 | 153 #endif |
| 154 | |
| 155 #if __STDC__ || defined(STDC_HEADERS) | |
| 156 | |
| 157 /* I don't know how correct this attempt to get more prototypes is... */ | |
| 158 # if defined(sun) && defined(_POSIX_SOURCE) | |
| 159 # undef _POSIX_SOURCE | |
| 160 # endif | |
| 161 | |
| 162 # include <stddef.h> | |
| 163 # include <stdlib.h> | |
| 164 # include <unistd.h> | |
| 165 # include <string.h> | |
| 166 # include <stddef.h> | |
| 438 | 167 # include <errno.h> |
| 428 | 168 |
| 169 #endif | |
| 170 | |
| 171 /* I don't understand this, but it's necessary to get some slots in struct exec | |
| 172 from /usr/include/sys/exec.h when running LCC in strict ANSI mode. We don't | |
| 173 need this in K&R mode... | |
| 174 */ | |
| 175 #if defined(__lucid) && defined(__sparc) && !defined(sun) | |
| 176 # define sun 1 | |
| 177 #endif | |
| 178 | |
| 179 #include <a.out.h> | |
| 180 | |
| 181 /* Define getpagesize if the system does not. | |
| 182 Note that this may depend on symbols defined in a.out.h. */ | |
| 183 #include "getpagesize.h" | |
| 184 | |
| 185 #ifndef makedev /* Try to detect types.h already loaded */ | |
| 186 #include <sys/types.h> | |
| 187 #endif /* makedev */ | |
| 188 #include <stdio.h> | |
| 189 #include <sys/stat.h> | |
| 190 #include <errno.h> | |
| 191 | |
|
4759
aa5ed11f473b
Remove support for obsolete systems. See xemacs-patches message with ID
Jerry James <james@xemacs.org>
parents:
3025
diff
changeset
|
192 #include <sys/file.h> /* Must be after sys/types.h for USG */ |
| 428 | 193 |
| 194 #ifdef USG5 | |
| 195 #include <fcntl.h> | |
| 196 #endif | |
| 197 | |
| 2286 | 198 #include "compiler.h" |
| 199 | |
| 428 | 200 #ifndef O_RDONLY |
| 201 #define O_RDONLY 0 | |
| 202 #endif | |
| 203 #ifndef O_RDWR | |
| 204 #define O_RDWR 2 | |
| 205 #endif | |
| 206 | |
| 207 extern char *start_of_text (); /* Start of text */ | |
| 208 | |
| 209 extern void *start_of_data (); /* Start of initialized data */ | |
| 210 | |
| 211 #ifdef COFF | |
| 212 static long block_copy_start; /* Old executable start point */ | |
| 213 static struct filehdr f_hdr; /* File header */ | |
| 214 static struct aouthdr f_ohdr; /* Optional file header (a.out) */ | |
| 215 long bias; /* Bias to add for growth */ | |
| 216 long lnnoptr; /* Pointer to line-number info within file */ | |
| 217 #define SYMS_START block_copy_start | |
| 218 | |
| 219 static long text_scnptr; | |
| 220 static long data_scnptr; | |
| 221 | |
| 222 #else /* not COFF */ | |
| 223 | |
| 224 #ifdef __STDC__ | |
| 225 #ifndef __sys_stdtypes_h | |
| 226 #if !defined(_PTRDIFF_T) && !defined(_BSD_PTRDIFF_T_) | |
| 227 typedef long ptrdiff_t; | |
| 228 #endif | |
| 229 #endif | |
| 230 #ifndef HPUX | |
| 231 /* not sure where this for NetBSD should really go | |
| 232 and it probably applies to other systems */ | |
| 233 #if !defined(__NetBSD__) && !defined(__bsdi__) && !defined(__OpenBSD__) | |
| 234 extern void *sbrk (ptrdiff_t); | |
| 235 #else | |
| 236 extern char *sbrk (); | |
| 237 #endif /* __NetBSD__ or __OpenBSD__ */ | |
| 238 #endif /* HPUX */ | |
| 239 #else | |
| 240 extern void *sbrk (); | |
| 241 #endif | |
| 242 | |
| 243 #define SYMS_START ((long) N_SYMOFF (ohdr)) | |
| 244 | |
| 245 #ifdef HPUX | |
| 246 #include <model.h> | |
| 247 #define MY_ID MYSYS | |
| 248 static MAGIC OLDMAGIC = {MY_ID, SHARE_MAGIC}; | |
| 249 static MAGIC NEWMAGIC = {MY_ID, DEMAND_MAGIC}; | |
| 250 #define N_TXTOFF(x) TEXT_OFFSET(x) | |
| 251 #define N_SYMOFF(x) LESYM_OFFSET(x) | |
|
4759
aa5ed11f473b
Remove support for obsolete systems. See xemacs-patches message with ID
Jerry James <james@xemacs.org>
parents:
3025
diff
changeset
|
252 static struct exec hdr, ohdr; |
| 428 | 253 |
| 254 #else /* not HPUX */ | |
| 255 | |
|
4759
aa5ed11f473b
Remove support for obsolete systems. See xemacs-patches message with ID
Jerry James <james@xemacs.org>
parents:
3025
diff
changeset
|
256 #if defined (USG) && !defined (LINUX) |
| 428 | 257 static struct bhdr hdr, ohdr; |
| 258 #define a_magic fmagic | |
| 259 #define a_text tsize | |
| 260 #define a_data dsize | |
| 261 #define a_bss bsize | |
| 262 #define a_syms ssize | |
| 263 #define a_trsize rtsize | |
| 264 #define a_drsize rdsize | |
| 265 #define a_entry entry | |
| 266 #define N_BADMAG(x) \ | |
| 267 (((x).fmagic)!=OMAGIC && ((x).fmagic)!=NMAGIC &&\ | |
| 268 ((x).fmagic)!=FMAGIC && ((x).fmagic)!=IMAGIC) | |
| 269 #define NEWMAGIC FMAGIC | |
|
4759
aa5ed11f473b
Remove support for obsolete systems. See xemacs-patches message with ID
Jerry James <james@xemacs.org>
parents:
3025
diff
changeset
|
270 #else /* !USG or LINUX */ |
|
aa5ed11f473b
Remove support for obsolete systems. See xemacs-patches message with ID
Jerry James <james@xemacs.org>
parents:
3025
diff
changeset
|
271 static struct exec hdr, ohdr; |
| 428 | 272 #define NEWMAGIC ZMAGIC |
|
4759
aa5ed11f473b
Remove support for obsolete systems. See xemacs-patches message with ID
Jerry James <james@xemacs.org>
parents:
3025
diff
changeset
|
273 #endif /* !USG or LINUX */ |
| 428 | 274 #endif /* not HPUX */ |
| 275 | |
| 276 static int unexec_text_start; | |
| 277 static int unexec_data_start; | |
| 278 | |
| 279 #endif /* not COFF */ | |
| 280 | |
| 281 static int pagemask; | |
| 282 | |
| 283 /* Correct an int which is the bit pattern of a pointer to a byte | |
| 284 into an int which is the number of a byte. | |
| 285 This is a no-op on ordinary machines, but not on all. */ | |
| 286 | |
| 287 #ifndef ADDR_CORRECT /* Let m-*.h files override this definition */ | |
| 288 #define ADDR_CORRECT(x) ((char *)(x) - (char*)0) | |
| 289 #endif | |
| 290 | |
| 291 #ifdef emacs | |
| 292 | |
| 293 #include "lisp.h" | |
| 294 | |
| 295 static void | |
| 440 | 296 report_error (const char *file, int fd) |
| 428 | 297 { |
| 298 if (fd) | |
| 299 close (fd); | |
| 563 | 300 report_error_with_errno (Qio_error, "Cannot unexec", |
| 301 build_ext_string (file, Qfile_name)); | |
| 428 | 302 } |
| 303 #endif /* emacs */ | |
| 304 | |
| 3025 | 305 #define ERROR0(msg) report_error_1 (new_, msg, 0, 0); return -1 |
| 306 #define ERROR1(msg,x) report_error_1 (new_, msg, x, 0); return -1 | |
| 307 #define ERROR2(msg,x,y) report_error_1 (new_, msg, x, y); return -1 | |
| 428 | 308 |
| 309 static void | |
| 310 report_error_1 (fd, msg, a1, a2) | |
| 311 int fd; | |
| 442 | 312 const char *msg; |
| 428 | 313 int a1, a2; |
| 314 { | |
| 315 close (fd); | |
| 316 #ifdef emacs | |
| 563 | 317 signal_ferror (Qio_error, msg, a1, a2); |
| 428 | 318 #else |
| 319 fprintf (stderr, msg, a1, a2); | |
| 320 fprintf (stderr, "\n"); | |
| 321 #endif | |
| 322 } | |
| 323 | |
| 3025 | 324 static int make_hdr (int new_, int a_out, unsigned data_start, |
| 428 | 325 unsigned bss_start, unsigned entry_address, |
| 326 char *a_name, char *new_name); | |
| 3025 | 327 static int copy_text_and_data (int new_, int a_out); |
| 328 static int copy_sym (int new_, int a_out, char *a_name, char *new_name); | |
| 428 | 329 static void mark_x (char *name); |
| 330 | |
| 331 /* **************************************************************** | |
| 332 * unexec | |
| 333 * | |
| 334 * driving logic. | |
| 335 */ | |
| 336 int | |
| 337 unexec (new_name, a_name, data_start, bss_start, entry_address) | |
| 338 char *new_name, *a_name; | |
| 339 unsigned data_start, bss_start, entry_address; | |
| 340 { | |
| 3025 | 341 int new_, a_out = -1; |
| 428 | 342 |
| 343 if (a_name && (a_out = open (a_name, O_RDONLY)) < 0) | |
| 344 { | |
| 345 PERROR (a_name); | |
| 346 } | |
| 3025 | 347 if ((new_ = creat (new_name, 0666)) < 0) |
| 428 | 348 { |
| 349 PERROR (new_name); | |
| 350 } | |
| 351 | |
| 3025 | 352 if (make_hdr (new_, a_out, data_start, bss_start, entry_address, a_name, new_name) < 0 |
| 353 || copy_text_and_data (new_, a_out) < 0 | |
| 354 || copy_sym (new_, a_out, a_name, new_name) < 0 | |
| 428 | 355 #ifdef COFF |
| 3025 | 356 || adjust_lnnoptrs (new_, a_out, new_name) < 0 |
| 428 | 357 #endif |
| 358 ) | |
| 359 { | |
| 3025 | 360 close (new_); |
| 428 | 361 /* unlink (new_name); / * Failed, unlink new a.out */ |
| 438 | 362 return -1; |
| 428 | 363 } |
| 364 | |
| 3025 | 365 close (new_); |
| 428 | 366 if (a_out >= 0) |
| 367 close (a_out); | |
| 368 mark_x (new_name); | |
| 369 return 0; | |
| 370 } | |
| 371 | |
| 372 /* **************************************************************** | |
| 373 * make_hdr | |
| 374 * | |
| 375 * Make the header in the new a.out from the header in core. | |
| 376 * Modify the text and data sizes. | |
| 377 */ | |
| 378 static int | |
| 3025 | 379 make_hdr (int new_, int a_out, unsigned data_start, unsigned bss_start, |
| 428 | 380 unsigned entry_address, char *a_name, char *new_name) |
| 381 { | |
| 382 #ifdef COFF | |
| 383 auto struct scnhdr f_thdr; /* Text section header */ | |
| 384 auto struct scnhdr f_dhdr; /* Data section header */ | |
| 385 auto struct scnhdr f_bhdr; /* Bss section header */ | |
| 386 auto struct scnhdr scntemp; /* Temporary section header */ | |
| 387 int scns; | |
| 388 #endif /* COFF */ | |
| 389 #ifdef USG_SHARED_LIBRARIES | |
| 390 extern unsigned int bss_end; | |
| 391 #else | |
| 392 unsigned int bss_end; | |
| 393 #endif | |
| 394 | |
| 395 pagemask = getpagesize () - 1; | |
| 396 | |
| 397 /* Adjust text/data boundary. */ | |
| 398 #ifdef NO_REMAP | |
| 399 data_start = (int) start_of_data (); | |
| 400 #else /* not NO_REMAP */ | |
| 401 if (!data_start) | |
| 402 data_start = (int) start_of_data (); | |
| 403 #endif /* not NO_REMAP */ | |
| 404 data_start = ADDR_CORRECT (data_start); | |
| 405 | |
| 406 #ifdef SEGMENT_MASK | |
| 407 data_start = data_start & ~SEGMENT_MASK; /* (Down) to segment boundary. */ | |
| 408 #else | |
| 409 data_start = data_start & ~pagemask; /* (Down) to page boundary. */ | |
| 410 #endif | |
| 411 | |
| 412 bss_end = ADDR_CORRECT (sbrk (0)) + pagemask; | |
| 413 bss_end &= ~ pagemask; | |
| 414 | |
| 415 /* Adjust data/bss boundary. */ | |
| 416 if (bss_start != 0) | |
| 417 { | |
| 418 bss_start = (ADDR_CORRECT (bss_start) + pagemask); | |
| 419 /* (Up) to page bdry. */ | |
| 420 bss_start &= ~ pagemask; | |
| 421 if (bss_start > bss_end) | |
| 422 { | |
| 423 ERROR1 ("unexec: Specified bss_start (%u) is past end of program", | |
| 424 bss_start); | |
| 425 } | |
| 426 } | |
| 427 else | |
| 428 bss_start = bss_end; | |
| 429 | |
| 430 if (data_start > bss_start) /* Can't have negative data size. */ | |
| 431 { | |
| 432 ERROR2 ("unexec: data_start (%u) can't be greater than bss_start (%u)", | |
| 433 data_start, bss_start); | |
| 434 } | |
| 435 | |
| 436 #ifdef COFF | |
| 437 /* Salvage as much info from the existing file as possible */ | |
| 438 if (a_out >= 0) | |
| 439 { | |
| 440 if (read (a_out, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr)) | |
| 441 { | |
| 442 PERROR (a_name); | |
| 443 } | |
| 444 block_copy_start += sizeof (f_hdr); | |
| 445 if (f_hdr.f_opthdr > 0) | |
| 446 { | |
| 447 if (read (a_out, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr)) | |
| 448 { | |
| 449 PERROR (a_name); | |
| 450 } | |
| 451 block_copy_start += sizeof (f_ohdr); | |
| 452 } | |
| 453 /* Loop through section headers, copying them in */ | |
| 454 lseek (a_out, sizeof (f_hdr) + f_hdr.f_opthdr, 0); | |
| 455 for (scns = f_hdr.f_nscns; scns > 0; scns--) { | |
| 456 if (read (a_out, &scntemp, sizeof (scntemp)) != sizeof (scntemp)) | |
| 457 { | |
| 458 PERROR (a_name); | |
| 459 } | |
| 460 if (scntemp.s_scnptr > 0L) | |
| 461 { | |
| 462 if (block_copy_start < scntemp.s_scnptr + scntemp.s_size) | |
| 463 block_copy_start = scntemp.s_scnptr + scntemp.s_size; | |
| 464 } | |
| 465 if (strcmp (scntemp.s_name, ".text") == 0) | |
| 466 { | |
| 467 f_thdr = scntemp; | |
| 468 } | |
| 469 else if (strcmp (scntemp.s_name, ".data") == 0) | |
| 470 { | |
| 471 f_dhdr = scntemp; | |
| 472 } | |
| 473 else if (strcmp (scntemp.s_name, ".bss") == 0) | |
| 474 { | |
| 475 f_bhdr = scntemp; | |
| 476 } | |
| 477 } | |
| 478 } | |
| 479 else | |
| 480 { | |
| 481 ERROR0 ("can't build a COFF file from scratch yet"); | |
| 482 } | |
| 483 | |
| 484 /* Now we alter the contents of all the f_*hdr variables | |
| 485 to correspond to what we want to dump. */ | |
| 486 | |
| 487 #ifdef USG_SHARED_LIBRARIES | |
| 488 | |
| 489 /* The amount of data we're adding to the file is distance from the | |
| 490 * end of the original .data space to the current end of the .data | |
| 491 * space. | |
| 492 */ | |
| 493 | |
| 494 bias = bss_start - (f_ohdr.data_start + f_dhdr.s_size); | |
| 495 | |
| 496 #endif | |
| 497 | |
| 498 f_hdr.f_flags |= (F_RELFLG | F_EXEC); | |
| 499 #ifdef EXEC_MAGIC | |
| 500 f_ohdr.magic = EXEC_MAGIC; | |
| 501 #endif | |
| 502 #ifndef NO_REMAP | |
| 503 f_ohdr.text_start = (long) start_of_text (); | |
| 504 f_ohdr.tsize = data_start - f_ohdr.text_start; | |
| 505 f_ohdr.data_start = data_start; | |
| 506 #endif /* NO_REMAP */ | |
| 507 f_ohdr.dsize = bss_start - f_ohdr.data_start; | |
| 508 f_ohdr.bsize = bss_end - bss_start; | |
| 509 /* On some machines, the old values are right. | |
| 510 ??? Maybe on all machines with NO_REMAP. */ | |
| 511 f_thdr.s_size = f_ohdr.tsize; | |
| 512 f_thdr.s_scnptr = sizeof (f_hdr) + sizeof (f_ohdr); | |
| 513 f_thdr.s_scnptr += (f_hdr.f_nscns) * (sizeof (f_thdr)); | |
| 514 lnnoptr = f_thdr.s_lnnoptr; | |
| 515 text_scnptr = f_thdr.s_scnptr; | |
| 516 f_dhdr.s_paddr = f_ohdr.data_start; | |
| 517 f_dhdr.s_vaddr = f_ohdr.data_start; | |
| 518 f_dhdr.s_size = f_ohdr.dsize; | |
| 519 f_dhdr.s_scnptr = f_thdr.s_scnptr + f_thdr.s_size; | |
| 520 data_scnptr = f_dhdr.s_scnptr; | |
| 521 f_bhdr.s_paddr = f_ohdr.data_start + f_ohdr.dsize; | |
| 522 f_bhdr.s_vaddr = f_ohdr.data_start + f_ohdr.dsize; | |
| 523 f_bhdr.s_size = f_ohdr.bsize; | |
| 524 f_bhdr.s_scnptr = 0L; | |
| 525 #ifndef USG_SHARED_LIBRARIES | |
| 526 bias = f_dhdr.s_scnptr + f_dhdr.s_size - block_copy_start; | |
| 527 #endif | |
| 528 | |
| 529 if (f_hdr.f_symptr > 0L) | |
| 530 { | |
| 531 f_hdr.f_symptr += bias; | |
| 532 } | |
| 533 | |
| 534 if (f_thdr.s_lnnoptr > 0L) | |
| 535 { | |
| 536 f_thdr.s_lnnoptr += bias; | |
| 537 } | |
| 538 | |
| 539 #ifdef ADJUST_EXEC_HEADER | |
| 540 ADJUST_EXEC_HEADER; | |
| 541 #endif /* ADJUST_EXEC_HEADER */ | |
| 542 | |
| 3025 | 543 if (write (new_, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr)) |
| 428 | 544 { |
| 545 PERROR (new_name); | |
| 546 } | |
| 547 | |
| 3025 | 548 if (write (new_, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr)) |
| 428 | 549 { |
| 550 PERROR (new_name); | |
| 551 } | |
| 552 | |
| 553 #ifndef USG_SHARED_LIBRARIES | |
| 554 | |
| 3025 | 555 if (write (new_, &f_thdr, sizeof (f_thdr)) != sizeof (f_thdr)) |
| 428 | 556 { |
| 557 PERROR (new_name); | |
| 558 } | |
| 559 | |
| 3025 | 560 if (write (new_, &f_dhdr, sizeof (f_dhdr)) != sizeof (f_dhdr)) |
| 428 | 561 { |
| 562 PERROR (new_name); | |
| 563 } | |
| 564 | |
| 3025 | 565 if (write (new_, &f_bhdr, sizeof (f_bhdr)) != sizeof (f_bhdr)) |
| 428 | 566 { |
| 567 PERROR (new_name); | |
| 568 } | |
| 569 | |
| 570 #else /* USG_SHARED_LIBRARIES */ | |
| 571 | |
| 572 /* The purpose of this code is to write out the new file's section | |
| 573 * header table. | |
| 574 * | |
| 575 * Scan through the original file's sections. If the encountered | |
| 576 * section is one we know (.text, .data or .bss), write out the | |
| 577 * correct header. If it is a section we do not know (such as | |
| 578 * .lib), adjust the address of where the section data is in the | |
| 579 * file, and write out the header. | |
| 580 * | |
| 581 * If any section precedes .text or .data in the file, this code | |
| 582 * will not adjust the file pointer for that section correctly. | |
| 583 */ | |
| 584 | |
| 585 /* This used to use sizeof (f_ohdr) instead of .f_opthdr. | |
| 586 .f_opthdr is said to be right when there is no optional header. */ | |
| 587 lseek (a_out, sizeof (f_hdr) + f_hdr.f_opthdr, 0); | |
| 588 | |
| 589 for (scns = f_hdr.f_nscns; scns > 0; scns--) | |
| 590 { | |
| 591 if (read (a_out, &scntemp, sizeof (scntemp)) != sizeof (scntemp)) | |
| 592 PERROR (a_name); | |
| 593 | |
| 594 if (!strcmp (scntemp.s_name, f_thdr.s_name)) /* .text */ | |
| 595 { | |
| 3025 | 596 if (write (new_, &f_thdr, sizeof (f_thdr)) != sizeof (f_thdr)) |
| 428 | 597 PERROR (new_name); |
| 598 } | |
| 599 else if (!strcmp (scntemp.s_name, f_dhdr.s_name)) /* .data */ | |
| 600 { | |
| 3025 | 601 if (write (new_, &f_dhdr, sizeof (f_dhdr)) != sizeof (f_dhdr)) |
| 428 | 602 PERROR (new_name); |
| 603 } | |
| 604 else if (!strcmp (scntemp.s_name, f_bhdr.s_name)) /* .bss */ | |
| 605 { | |
| 3025 | 606 if (write (new_, &f_bhdr, sizeof (f_bhdr)) != sizeof (f_bhdr)) |
| 428 | 607 PERROR (new_name); |
| 608 } | |
| 609 else | |
| 610 { | |
| 611 if (scntemp.s_scnptr) | |
| 612 scntemp.s_scnptr += bias; | |
| 3025 | 613 if (write (new_, &scntemp, sizeof (scntemp)) != sizeof (scntemp)) |
| 428 | 614 PERROR (new_name); |
| 615 } | |
| 616 } | |
| 617 #endif /* USG_SHARED_LIBRARIES */ | |
| 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 { | |
| 647 | 626 if (read (a_out, (char *) &ohdr, sizeof (hdr)) != sizeof (hdr)) |
| 428 | 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 { | |
| 647 | 639 memset ((void *)&hdr, 0, sizeof (hdr)); |
| 428 | 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 | |
| 3025 | 668 if (write (new_, (char *) &hdr, sizeof (hdr)) != sizeof (hdr)) |
| 428 | 669 { |
| 670 PERROR (new_name); | |
| 671 } | |
| 672 | |
| 673 #if 0 /* This #ifndef caused a bug on Linux when using QMAGIC. */ | |
| 674 /* This adjustment was done above only #ifndef NO_REMAP, | |
| 675 so only undo it now #ifndef NO_REMAP. */ | |
| 676 /* #ifndef NO_REMAP */ | |
| 677 #endif | |
| 678 #ifdef A_TEXT_OFFSET | |
| 679 hdr.a_text -= A_TEXT_OFFSET (ohdr); | |
| 680 #endif | |
| 681 | |
| 682 return 0; | |
| 683 | |
| 684 #endif /* not COFF */ | |
| 685 } | |
| 686 | |
| 687 static void write_segment (int, char *, char *); | |
| 688 | |
| 689 /* **************************************************************** | |
| 690 * copy_text_and_data | |
| 691 * | |
| 692 * Copy the text and data segments from memory to the new a.out | |
| 693 */ | |
| 694 static int | |
| 3025 | 695 copy_text_and_data (int new_, |
| 2286 | 696 #if defined (COFF) && defined (USG_SHARED_LIBRARIES) |
| 697 int a_out | |
| 698 #else | |
| 699 int UNUSED (a_out) | |
| 700 #endif | |
| 701 ) | |
| 428 | 702 { |
| 703 char *end; | |
| 704 char *ptr; | |
| 705 | |
| 706 #ifdef COFF | |
| 707 | |
| 708 #ifdef USG_SHARED_LIBRARIES | |
| 709 | |
| 710 int scns; | |
| 711 struct scnhdr scntemp; /* Temporary section header */ | |
| 712 | |
| 713 /* The purpose of this code is to write out the new file's section | |
| 714 * contents. | |
| 715 * | |
| 716 * Step through the section table. If we know the section (.text, | |
| 717 * .data) do the appropriate thing. Otherwise, if the section has | |
| 718 * no allocated space in the file (.bss), do nothing. Otherwise, | |
| 719 * the section has space allocated in the file, and is not a section | |
| 720 * we know. So just copy it. | |
| 721 */ | |
| 722 | |
| 723 lseek (a_out, sizeof (struct filehdr) + sizeof (struct aouthdr), 0); | |
| 724 | |
| 725 for (scns = f_hdr.f_nscns; scns > 0; scns--) | |
| 726 { | |
| 727 if (read (a_out, &scntemp, sizeof (scntemp)) != sizeof (scntemp)) | |
| 728 PERROR ("temacs"); | |
| 729 | |
| 730 if (!strcmp (scntemp.s_name, ".text")) | |
| 731 { | |
| 3025 | 732 lseek (new_, (long) text_scnptr, 0); |
| 428 | 733 ptr = (char *) f_ohdr.text_start; |
| 734 end = ptr + f_ohdr.tsize; | |
| 3025 | 735 write_segment (new_, ptr, end); |
| 428 | 736 } |
| 737 else if (!strcmp (scntemp.s_name, ".data")) | |
| 738 { | |
| 3025 | 739 lseek (new_, (long) data_scnptr, 0); |
| 428 | 740 ptr = (char *) f_ohdr.data_start; |
| 741 end = ptr + f_ohdr.dsize; | |
| 3025 | 742 write_segment (new_, ptr, end); |
| 428 | 743 } |
| 744 else if (!scntemp.s_scnptr) | |
| 745 ; /* do nothing - no data for this section */ | |
| 746 else | |
| 747 { | |
| 748 char page[BUFSIZ]; | |
| 749 int size, n; | |
| 750 long old_a_out_ptr = lseek (a_out, 0, 1); | |
| 751 | |
| 752 lseek (a_out, scntemp.s_scnptr, 0); | |
| 753 for (size = scntemp.s_size; size > 0; size -= sizeof (page)) | |
| 754 { | |
| 755 n = size > sizeof (page) ? sizeof (page) : size; | |
| 3025 | 756 if (read (a_out, page, n) != n || write (new_, page, n) != n) |
| 428 | 757 PERROR ("emacs"); |
| 758 } | |
| 759 lseek (a_out, old_a_out_ptr, 0); | |
| 760 } | |
| 761 } | |
| 762 | |
| 763 #else /* COFF, but not USG_SHARED_LIBRARIES */ | |
| 764 | |
| 3025 | 765 lseek (new_, (long) text_scnptr, 0); |
| 428 | 766 ptr = (char *) f_ohdr.text_start; |
| 767 end = ptr + f_ohdr.tsize; | |
| 3025 | 768 write_segment (new_, ptr, end); |
| 428 | 769 |
| 3025 | 770 lseek (new_, (long) data_scnptr, 0); |
| 428 | 771 ptr = (char *) f_ohdr.data_start; |
| 772 end = ptr + f_ohdr.dsize; | |
| 3025 | 773 write_segment (new_, ptr, end); |
| 428 | 774 |
| 775 #endif /* USG_SHARED_LIBRARIES */ | |
| 776 | |
| 777 #else /* if not COFF */ | |
| 778 | |
| 779 /* Some machines count the header as part of the text segment. | |
| 780 That is to say, the header appears in core | |
| 781 just before the address that start_of_text returns. | |
| 782 For them, N_TXTOFF is the place where the header goes. | |
| 783 We must adjust the seek to the place after the header. | |
| 784 Note that at this point hdr.a_text does *not* count | |
| 785 the extra A_TEXT_OFFSET bytes, only the actual bytes of code. */ | |
| 786 | |
| 787 #ifdef A_TEXT_SEEK | |
| 3025 | 788 lseek (new_, (long) A_TEXT_SEEK (hdr), 0); |
| 428 | 789 #else |
| 3025 | 790 lseek (new_, (long) N_TXTOFF (hdr), 0); |
| 428 | 791 #endif /* no A_TEXT_SEEK */ |
| 792 | |
| 793 ptr = (char *) unexec_text_start; | |
| 794 end = ptr + hdr.a_text; | |
| 3025 | 795 write_segment (new_, ptr, end); |
| 428 | 796 |
| 797 ptr = (char *) unexec_data_start; | |
| 798 end = ptr + hdr.a_data; | |
| 799 /* This lseek is certainly incorrect when A_TEXT_OFFSET | |
| 800 and I believe it is a no-op otherwise. | |
| 801 Let's see if its absence ever fails. */ | |
| 3025 | 802 /* lseek (new_, (long) N_TXTOFF (hdr) + hdr.a_text, 0); */ |
| 803 write_segment (new_, ptr, end); | |
| 428 | 804 |
| 805 #endif /* not COFF */ | |
| 806 | |
| 807 return 0; | |
| 808 } | |
| 809 | |
| 810 static void | |
| 3025 | 811 write_segment (new_, ptr, end) |
| 812 int new_; | |
| 428 | 813 char *ptr, *end; |
| 814 { | |
| 815 int i, nwrite, ret; | |
| 816 #if 0 | |
| 817 char buf[80]; | |
| 818 #endif | |
| 819 /* This is the normal amount to write at once. | |
| 820 It is the size of block that NFS uses. */ | |
| 821 int writesize = 1 << 13; | |
| 822 int pagesize = getpagesize (); | |
| 823 char zeros[1 << 13]; | |
| 824 | |
| 825 memset (zeros, 0, sizeof (zeros)); | |
| 826 | |
| 827 for (i = 0; ptr < end;) | |
| 828 { | |
| 829 /* Distance to next multiple of writesize. */ | |
| 830 nwrite = (((int) ptr + writesize) & -writesize) - (int) ptr; | |
| 831 /* But not beyond specified end. */ | |
| 832 if (nwrite > end - ptr) nwrite = end - ptr; | |
| 3025 | 833 ret = write (new_, ptr, nwrite); |
| 428 | 834 /* If write gets a page fault, it means we reached |
| 835 a gap between the old text segment and the old data segment. | |
| 836 This gap has probably been remapped into part of the text segment. | |
| 837 So write zeros for it. */ | |
| 838 if (ret == -1 | |
| 839 #ifdef EFAULT | |
| 840 && errno == EFAULT | |
| 841 #endif | |
| 842 ) | |
| 843 { | |
| 844 /* Write only a page of zeros at once, | |
| 845 so that we don't overshoot the start | |
| 846 of the valid memory in the old data segment. */ | |
| 847 if (nwrite > pagesize) | |
| 848 nwrite = pagesize; | |
| 3025 | 849 write (new_, zeros, nwrite); |
| 428 | 850 } |
| 851 #if 0 /* Now that we have can ask `write' to write more than a page, | |
| 852 it is legit for write do less than the whole amount specified. */ | |
| 853 else if (nwrite != ret) | |
| 854 { | |
| 855 sprintf (buf, | |
| 856 "unexec write failure: addr 0x%lx, fileno %d, size 0x%x, wrote 0x%x, errno %d", | |
| 3025 | 857 (unsigned long) ptr, new_, nwrite, ret, errno); |
| 428 | 858 PERROR (buf); |
| 859 } | |
| 860 #endif | |
| 861 i += nwrite; | |
| 862 ptr += nwrite; | |
| 863 } | |
| 864 } | |
| 865 | |
| 866 /* **************************************************************** | |
| 867 * copy_sym | |
| 868 * | |
| 869 * Copy the relocation information and symbol table from the a.out to the new | |
| 870 */ | |
| 871 static int | |
| 3025 | 872 copy_sym (int new_, int a_out, char *a_name, char *new_name) |
| 428 | 873 { |
| 874 char page[1024]; | |
| 875 int n; | |
| 876 | |
| 877 if (a_out < 0) | |
| 878 return 0; | |
| 879 | |
| 880 #ifdef COFF | |
| 881 if (SYMS_START == 0L) | |
| 882 return 0; | |
| 883 #endif /* COFF */ | |
| 884 | |
| 885 #ifdef COFF | |
| 886 if (lnnoptr) /* if there is line number info */ | |
| 887 lseek (a_out, lnnoptr, 0); /* start copying from there */ | |
| 888 else | |
| 889 #endif /* COFF */ | |
| 890 lseek (a_out, SYMS_START, 0); /* Position a.out to symtab. */ | |
| 891 | |
| 647 | 892 while ((n = read (a_out, page, sizeof (page))) > 0) |
| 428 | 893 { |
| 3025 | 894 if (write (new_, page, n) != n) |
| 428 | 895 { |
| 896 PERROR (new_name); | |
| 897 } | |
| 898 } | |
| 899 if (n < 0) | |
| 900 { | |
| 901 PERROR (a_name); | |
| 902 } | |
| 903 return 0; | |
| 904 } | |
| 905 | |
| 906 /* **************************************************************** | |
| 907 * mark_x | |
| 908 * | |
| 909 * After successfully building the new a.out, mark it executable | |
| 910 */ | |
| 911 static void | |
| 912 mark_x (char *name) | |
| 913 { | |
| 914 struct stat sbuf; | |
| 915 int um; | |
| 3025 | 916 int new_ = 0; /* for PERROR */ |
| 428 | 917 |
| 918 um = umask (777); | |
| 919 umask (um); | |
| 920 if (stat (name, &sbuf) == -1) | |
| 921 { | |
| 922 PERROR (name); | |
| 923 } | |
| 924 sbuf.st_mode |= 0111 & ~um; | |
| 925 if (chmod (name, sbuf.st_mode) == -1) | |
| 926 PERROR (name); | |
| 927 } | |
| 928 | |
| 929 #ifdef COFF | |
| 930 /* | |
| 931 * If the COFF file contains a symbol table and a line number section, | |
| 932 * then any auxiliary entries that have values for x_lnnoptr must | |
| 933 * be adjusted by the amount that the line number section has moved | |
| 934 * in the file (bias computed in make_hdr). The #@$%&* designers of | |
| 935 * the auxiliary entry structures used the absolute file offsets for | |
| 936 * the line number entry rather than an offset from the start of the | |
| 937 * line number section! | |
| 938 * | |
| 939 * When I figure out how to scan through the symbol table and pick out | |
| 940 * the auxiliary entries that need adjustment, this routine will | |
| 941 * be fixed. As it is now, all such entries are wrong and sdb | |
| 942 * will complain. Fred Fish, UniSoft Systems Inc. | |
| 943 */ | |
| 944 | |
| 945 /* This function is probably very slow. Instead of reopening the new | |
| 946 file for input and output it should copy from the old to the new | |
| 947 using the two descriptors already open (WRITEDESC and READDESC). | |
| 948 Instead of reading one small structure at a time it should use | |
| 949 a reasonable size buffer. But I don't have time to work on such | |
| 950 things, so I am installing it as submitted to me. -- RMS. */ | |
| 951 | |
| 952 int | |
| 953 adjust_lnnoptrs (writedesc, readdesc, new_name) | |
| 2286 | 954 int UNUSED (writedesc); |
| 955 int UNUSED (readdesc); | |
| 428 | 956 char *new_name; |
| 957 { | |
| 958 int nsyms; | |
| 3025 | 959 int new_; |
|
4759
aa5ed11f473b
Remove support for obsolete systems. See xemacs-patches message with ID
Jerry James <james@xemacs.org>
parents:
3025
diff
changeset
|
960 #if defined defined (pfa) |
| 428 | 961 SYMENT symentry; |
| 962 AUXENT auxentry; | |
| 963 #else | |
| 964 struct syment symentry; | |
| 965 union auxent auxentry; | |
| 966 #endif | |
| 967 | |
| 968 if (!lnnoptr || !f_hdr.f_symptr) | |
| 969 return 0; | |
| 970 | |
| 3025 | 971 if ((new_ = open (new_name, O_RDWR)) < 0) |
| 428 | 972 { |
| 973 PERROR (new_name); | |
| 974 return -1; | |
| 975 } | |
| 976 | |
| 3025 | 977 lseek (new_, f_hdr.f_symptr, 0); |
| 428 | 978 for (nsyms = 0; nsyms < f_hdr.f_nsyms; nsyms++) |
| 979 { | |
| 3025 | 980 read (new_, &symentry, SYMESZ); |
| 428 | 981 if (symentry.n_numaux) |
| 982 { | |
| 3025 | 983 read (new_, &auxentry, AUXESZ); |
| 428 | 984 nsyms++; |
| 985 if (ISFCN (symentry.n_type) || symentry.n_type == 0x2400) | |
| 986 { | |
| 987 auxentry.x_sym.x_fcnary.x_fcn.x_lnnoptr += bias; | |
| 3025 | 988 lseek (new_, -AUXESZ, 1); |
| 989 write (new_, &auxentry, AUXESZ); | |
| 428 | 990 } |
| 991 } | |
| 992 } | |
| 3025 | 993 close (new_); |
| 428 | 994 return 0; |
| 995 } | |
| 996 | |
| 997 #endif /* COFF */ |