Mercurial > hg > xemacs-beta
annotate src/unexnt.c @ 5585:86d6adeb1cf4
Refactor check for Xaw3d.
| author | Stephen J. Turnbull <stephen@xemacs.org> |
|---|---|
| date | Fri, 14 Oct 2011 03:54:46 +0900 |
| parents | 308d34e9f07d |
| children |
| rev | line source |
|---|---|
| 613 | 1 /* unexec for XEmacs on Windows NT. |
| 428 | 2 Copyright (C) 1994 Free Software Foundation, Inc. |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4854
diff
changeset
|
3 Copyright (C) 2002, 2010 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5050
diff
changeset
|
7 XEmacs is free software: you can redistribute it and/or modify it |
| 428 | 8 under the terms of the GNU General Public License as published by the |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5050
diff
changeset
|
9 Free Software Foundation, either version 3 of the License, or (at your |
|
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5050
diff
changeset
|
10 option) any later version. |
| 428 | 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 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5050
diff
changeset
|
18 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. |
| 428 | 19 Geoff Voelker (voelker@cs.washington.edu) 8-12-94 */ |
| 20 | |
| 21 /* Adapted for XEmacs by David Hobley <david@spook-le0.cia.com.au> */ | |
| 22 | |
| 814 | 23 /* This file has been Mule-ized, Ben Wing, 4-13-02. */ |
| 24 | |
| 428 | 25 /* The linkers that come with MSVC >= 4.0 merge .bss into .data and reorder |
| 26 * uninitialised data so that the .data section looks like: | |
| 27 * | |
| 28 * crt0 initialised data | |
| 29 * emacs initialised data | |
| 30 * <my_edata> | |
| 31 * library initialised data | |
| 32 * <start of bss part of .data> | |
| 33 * emacs static uninitialised data | |
| 34 * library static uninitialised data | |
| 35 * emacs global uninitialised data | |
| 36 * <my_ebss> | |
| 37 * library global uninitialised data | |
| 38 * | |
| 39 * This means that we can't use the normal my_ebss in lastfile.c trick to | |
| 40 * differentiate between unitialised data that belongs to emacs and | |
| 41 * uninitialised data that belongs to system libraries. This is bad because | |
| 42 * we do want to initialise the emacs data, but we don't want to initialise | |
| 43 * the system library data. | |
| 44 * | |
| 45 * To solve this problem using MSVC >= 5.0 we use a pragma directive to tell | |
| 46 * the compiler to put emacs's data (both initialised and uninitialised) in | |
| 47 * a separate section in the executable, and we only dump that section. This | |
| 48 * means that all files that define initialized data must include config.h | |
| 49 * to pick up the pragma. We don't try to make any part of that section | |
| 50 * read-only. | |
| 51 * | |
| 52 * This pragma directive isn't supported by the MSVC 4.x compiler. Instead, | |
| 53 * we dump crt0 initialised data and library static uninitialised data in | |
| 54 * addition to the emacs data. This is wrong, but we appear to be able to | |
| 55 * get away with it. A proper fix might involve the introduction of a static | |
| 56 * version of my_ebss in lastfile.c and a new firstfile.c file. jhar */ | |
| 57 | |
| 58 #include <config.h> | |
| 442 | 59 #include "lisp.h" |
| 60 | |
| 558 | 61 #include "sysfile.h" |
| 442 | 62 #include "syswindows.h" |
| 63 | |
| 428 | 64 /* From IMAGEHLP.H which is not installed by default by MSVC < 5 */ |
| 65 /* The IMAGEHLP.DLL library is not distributed by default with Windows95 */ | |
| 442 | 66 typedef PIMAGE_NT_HEADERS |
| 67 (__stdcall * pfnCheckSumMappedFile_t) (LPVOID BaseAddress, DWORD FileLength, | |
| 68 LPDWORD HeaderSum, LPDWORD CheckSum); | |
| 69 | |
| 428 | 70 |
| 71 #if 0 | |
| 72 extern BOOL ctrl_c_handler (unsigned long type); | |
| 73 #endif | |
| 74 | |
| 442 | 75 /* Sync with FSF Emacs 19.34.6 |
| 76 note: struct file_data is now defined in nt.h */ | |
| 428 | 77 |
| 78 enum { | |
| 79 HEAP_UNINITIALIZED = 1, | |
| 80 HEAP_UNLOADED, | |
| 81 HEAP_LOADED | |
| 82 }; | |
| 83 | |
| 84 /* Basically, our "initialized" flag. */ | |
| 85 int heap_state = HEAP_UNINITIALIZED; | |
| 86 | |
| 87 /* So we can find our heap in the file to recreate it. */ | |
| 88 unsigned long heap_index_in_executable = UNINIT_LONG; | |
| 89 | |
| 90 void get_section_info (file_data *p_file); | |
| 91 void copy_executable_and_dump_data_section (file_data *, file_data *); | |
| 92 void dump_bss_and_heap (file_data *p_infile, file_data *p_outfile); | |
| 93 | |
| 94 /* Cached info about the .data section in the executable. */ | |
| 95 PUCHAR data_start_va = UNINIT_PTR; | |
| 96 DWORD data_start_file = UNINIT_LONG; | |
| 97 DWORD data_size = UNINIT_LONG; | |
| 98 | |
| 99 /* Cached info about the .bss section in the executable. */ | |
| 100 PUCHAR bss_start = UNINIT_PTR; | |
| 101 DWORD bss_size = UNINIT_LONG; | |
| 102 | |
| 103 /* Startup code for running on NT. When we are running as the dumped | |
| 104 version, we need to bootstrap our heap and .bss section into our | |
| 105 address space before we can actually hand off control to the startup | |
| 106 code supplied by NT (primarily because that code relies upon malloc ()). */ | |
| 440 | 107 |
| 108 /* ********************** | |
| 1204 | 109 Hackers please remember, this _start() thingy is *not* called either |
| 110 when dumping portably, or when running from temacs! Do not put | |
| 440 | 111 significant XEmacs initialization here! |
| 112 ********************** */ | |
| 113 | |
| 1204 | 114 EXTERN_C void mainCRTStartup (void); |
| 115 | |
| 116 EXTERN_C int _start (void); | |
| 117 | |
| 118 int | |
| 428 | 119 _start (void) |
| 120 { | |
| 121 /* Cache system info, e.g., the NT page size. */ | |
| 122 cache_system_info (); | |
| 814 | 123 /* Set OS type, so that tchar stuff below works */ |
| 124 init_win32_very_early (); | |
| 428 | 125 |
| 126 /* If we're a dumped version of emacs then we need to recreate | |
| 127 our heap and play tricks with our .bss section. Do this before | |
| 128 start up. (WARNING: Do not put any code before this section | |
| 129 that relies upon malloc () and runs in the dumped version. It | |
| 130 won't work.) */ | |
| 131 if (heap_state == HEAP_UNLOADED) | |
| 132 { | |
| 4854 | 133 Extbyte executable_path[PATH_MAX_TCHAR]; |
| 428 | 134 |
| 814 | 135 /* Don't use mswindows_get_module_file_name() because it uses |
| 136 xmalloc() */ | |
| 2421 | 137 if (qxeGetModuleFileName (NULL, executable_path, _MAX_PATH) == 0) |
| 428 | 138 { |
| 139 exit (1); | |
| 140 } | |
| 141 | |
| 440 | 142 /* #### This is super-bogus. When I rename xemacs.exe, |
| 143 the renamed file still loads its heap from xemacs.exe --kkm */ | |
| 144 #if 0 | |
| 145 { | |
| 814 | 146 Extbyte *p; |
| 147 | |
| 440 | 148 /* To allow profiling, make sure executable_path names the .exe |
| 149 file, not the file created by the profiler */ | |
| 2421 | 150 p = qxetcsrchr (executable_path, '\\'); |
| 151 qxetcscpy (p + 1, XETEXT (PATH_PROGNAME ".exe")); | |
| 440 | 152 } |
| 153 #endif | |
| 428 | 154 |
| 155 recreate_heap (executable_path); | |
| 156 heap_state = HEAP_LOADED; | |
| 157 } | |
| 158 | |
| 440 | 159 /* #### This is bogus, too. _fmode is set to different values |
| 160 when we run `xemacs' and `temacs run-emacs'. The sooner we | |
| 161 hit and fix all the weirdities this causes us, the better --kkm */ | |
| 162 #if 0 | |
| 428 | 163 /* The default behavior is to treat files as binary and patch up |
| 442 | 164 text files appropriately. */ |
| 428 | 165 _fmode = O_BINARY; |
| 440 | 166 #endif |
| 428 | 167 |
| 168 #if 0 | |
| 169 /* This prevents ctrl-c's in shells running while we're suspended from | |
| 170 having us exit. */ | |
| 171 SetConsoleCtrlHandler ((PHANDLER_ROUTINE) ctrl_c_handler, TRUE); | |
| 172 #endif | |
| 173 | |
| 174 mainCRTStartup (); | |
| 1204 | 175 return 0; /* not reached? */ |
| 428 | 176 } |
| 177 | |
| 178 /* Dump out .data and .bss sections into a new executable. */ | |
| 442 | 179 int |
| 2286 | 180 unexec (Ibyte *new_name, Ibyte *old_name, unsigned int UNUSED (start_data), |
| 181 unsigned int UNUSED (start_bss), unsigned int UNUSED (entry_address)) | |
| 428 | 182 { |
| 183 file_data in_file, out_file; | |
| 867 | 184 Ibyte *out_filename = alloca_ibytes (qxestrlen (new_name) + 10); |
| 185 Ibyte *in_filename = alloca_ibytes (qxestrlen (old_name) + 10); | |
| 428 | 186 unsigned long size; |
| 867 | 187 Ibyte *ptr; |
| 442 | 188 HINSTANCE hImagehelp; |
| 428 | 189 |
| 190 /* Make sure that the input and output filenames have the | |
| 191 ".exe" extension...patch them up if they don't. */ | |
| 814 | 192 qxestrcpy (in_filename, old_name); |
| 193 ptr = in_filename + qxestrlen (in_filename) - 4; | |
| 2367 | 194 if (qxestrcmp_ascii (ptr, ".exe")) |
| 195 qxestrcat_ascii (in_filename, ".exe"); | |
| 428 | 196 |
| 814 | 197 qxestrcpy (out_filename, new_name); |
| 198 ptr = out_filename + qxestrlen (out_filename) - 4; | |
| 2367 | 199 if (qxestrcmp_ascii (ptr, ".exe")) |
| 200 qxestrcat_ascii (out_filename, ".exe"); | |
| 428 | 201 |
| 814 | 202 stdout_out ("Dumping from %s\n", in_filename); |
| 203 stdout_out (" to %s\n", out_filename); | |
| 428 | 204 |
| 205 /* We need to round off our heap to NT's allocation unit (64KB). */ | |
| 206 round_heap (get_allocation_unit ()); | |
| 207 | |
| 208 /* Open the undumped executable file. */ | |
| 209 if (!open_input_file (&in_file, in_filename)) | |
| 210 { | |
| 814 | 211 stdout_out ("Failed to open %s (%d)...bailing.\n", |
| 212 in_filename, GetLastError ()); | |
| 428 | 213 exit (1); |
| 214 } | |
| 215 | |
| 216 /* Get the interesting section info, like start and size of .bss... */ | |
| 217 get_section_info (&in_file); | |
| 218 | |
| 219 /* The size of the dumped executable is the size of the original | |
| 220 executable plus the size of the heap and the size of the .bss section. */ | |
| 221 heap_index_in_executable = (unsigned long) | |
| 2367 | 222 round_to_next ((Rawbyte *) in_file.size, get_allocation_unit ()); |
| 428 | 223 size = heap_index_in_executable + get_committed_heap_size () + bss_size; |
| 224 if (!open_output_file (&out_file, out_filename, size)) | |
| 225 { | |
| 814 | 226 stdout_out ("Failed to open %s (%d)...bailing.\n", |
| 227 out_filename, GetLastError ()); | |
| 428 | 228 exit (1); |
| 229 } | |
| 230 | |
| 231 /* Set the flag (before dumping). */ | |
| 232 heap_state = HEAP_UNLOADED; | |
| 233 | |
| 234 copy_executable_and_dump_data_section (&in_file, &out_file); | |
| 235 dump_bss_and_heap (&in_file, &out_file); | |
| 236 | |
| 237 /* Patch up header fields; profiler is picky about this. */ | |
| 812 | 238 hImagehelp = LoadLibraryA ("imagehlp.dll"); |
| 428 | 239 if (hImagehelp) |
| 240 { | |
| 241 PIMAGE_DOS_HEADER dos_header; | |
| 242 PIMAGE_NT_HEADERS nt_header; | |
| 442 | 243 |
| 428 | 244 DWORD headersum; |
| 245 DWORD checksum; | |
| 442 | 246 pfnCheckSumMappedFile_t pfnCheckSumMappedFile; |
| 428 | 247 |
| 248 dos_header = (PIMAGE_DOS_HEADER) out_file.file_base; | |
| 2367 | 249 nt_header = (PIMAGE_NT_HEADERS) ((Rawbyte *) dos_header + |
| 814 | 250 dos_header->e_lfanew); |
| 428 | 251 |
| 252 nt_header->OptionalHeader.CheckSum = 0; | |
| 442 | 253 #if 0 |
| 254 nt_header->FileHeader.TimeDateStamp = time (NULL); | |
| 255 dos_header->e_cp = size / 512; | |
| 256 nt_header->OptionalHeader.SizeOfImage = size; | |
| 257 #endif | |
| 428 | 258 |
| 442 | 259 pfnCheckSumMappedFile = |
| 260 (pfnCheckSumMappedFile_t) GetProcAddress (hImagehelp, | |
| 261 "CheckSumMappedFile"); | |
| 428 | 262 if (pfnCheckSumMappedFile) |
| 263 { | |
| 442 | 264 #if 0 |
| 265 nt_header->FileHeader.TimeDateStamp = time (NULL); | |
| 266 #endif | |
| 428 | 267 pfnCheckSumMappedFile (out_file.file_base, |
| 268 out_file.size, | |
| 269 &headersum, | |
| 270 &checksum); | |
| 271 nt_header->OptionalHeader.CheckSum = checksum; | |
| 272 } | |
| 273 FreeLibrary (hImagehelp); | |
| 274 } | |
| 275 | |
| 276 close_file_data (&in_file); | |
| 277 close_file_data (&out_file); | |
| 278 | |
| 442 | 279 return 0; |
| 428 | 280 } |
| 281 | |
| 282 /* Routines to manipulate NT executable file sections. */ | |
| 283 | |
| 284 #ifndef DUMP_SEPARATE_SECTION | |
| 285 static void | |
| 286 get_bss_info_from_map_file (file_data *p_infile, PUCHAR *p_bss_start, | |
| 287 DWORD *p_bss_size) | |
| 288 { | |
| 289 int n, start, len; | |
| 867 | 290 Ibyte *map_filename = alloca_ibytes (qxestrlen (p_infile->name) + 10); |
| 814 | 291 Extbyte buffer[256]; |
| 428 | 292 FILE *map; |
| 293 | |
| 294 /* Overwrite the .exe extension on the executable file name with | |
| 295 the .map extension. */ | |
| 814 | 296 qxestrcpy (map_filename, p_infile->name); |
| 297 n = qxestrlen (map_filename) - 3; | |
| 298 qxestrcpy (&map_filename[n], "map"); | |
| 428 | 299 |
| 814 | 300 map = qxe_fopen (map_filename, "r"); |
| 428 | 301 if (!map) |
| 302 { | |
| 814 | 303 stdout_out ("Failed to open map file %s, error %d...bailing out.\n", |
| 304 map_filename, GetLastError ()); | |
| 428 | 305 exit (-1); |
| 306 } | |
| 307 | |
| 308 while (fgets (buffer, sizeof (buffer), map)) | |
| 309 { | |
| 310 if (!(strstr (buffer, ".bss") && strstr (buffer, "DATA"))) | |
| 311 continue; | |
| 312 n = sscanf (buffer, " %*d:%x %x", &start, &len); | |
| 313 if (n != 2) | |
| 314 { | |
| 814 | 315 /* printf with external data, stdout_out with internal */ |
| 428 | 316 printf ("Failed to scan the .bss section line:\n%s", buffer); |
| 317 exit (-1); | |
| 318 } | |
| 319 break; | |
| 320 } | |
| 321 *p_bss_start = (PUCHAR) start; | |
| 322 *p_bss_size = (DWORD) len; | |
| 323 } | |
| 324 #endif | |
| 325 | |
| 326 /* Flip through the executable and cache the info necessary for dumping. */ | |
| 327 static void | |
| 328 get_section_info (file_data *p_infile) | |
| 329 { | |
| 330 PIMAGE_DOS_HEADER dos_header; | |
| 331 PIMAGE_NT_HEADERS nt_header; | |
| 332 PIMAGE_SECTION_HEADER section, data_section; | |
| 2367 | 333 Rawbyte *ptr; |
| 428 | 334 int i; |
| 335 | |
| 336 dos_header = (PIMAGE_DOS_HEADER) p_infile->file_base; | |
| 337 if (dos_header->e_magic != IMAGE_DOS_SIGNATURE) | |
| 338 { | |
| 814 | 339 stdout_out ("Unknown EXE header in %s...bailing.\n", p_infile->name); |
| 428 | 340 exit (1); |
| 341 } | |
| 342 nt_header = (PIMAGE_NT_HEADERS) (((unsigned long) dos_header) + | |
| 343 dos_header->e_lfanew); | |
| 344 if (nt_header == NULL) | |
| 345 { | |
| 814 | 346 stdout_out ("Failed to find IMAGE_NT_HEADER in %s...bailing.\n", |
| 347 p_infile->name); | |
| 428 | 348 exit (1); |
| 349 } | |
| 350 | |
| 351 /* Check the NT header signature ... */ | |
| 352 if (nt_header->Signature != IMAGE_NT_SIGNATURE) | |
| 353 { | |
| 814 | 354 stdout_out ("Invalid IMAGE_NT_SIGNATURE 0x%x in %s...bailing.\n", |
| 355 nt_header->Signature, p_infile->name); | |
| 428 | 356 } |
| 357 | |
| 358 /* Flip through the sections for .data and .bss ... */ | |
| 359 section = (PIMAGE_SECTION_HEADER) IMAGE_FIRST_SECTION (nt_header); | |
| 360 for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++) | |
| 361 { | |
| 362 #ifndef DUMP_SEPARATE_SECTION | |
| 2367 | 363 if (!qxestrcmp_ascii (section->Name, ".bss")) |
| 428 | 364 { |
| 365 extern int my_ebss; /* From lastfile.c */ | |
| 366 | |
| 2367 | 367 ptr = (Rawbyte *) nt_header->OptionalHeader.ImageBase + |
| 428 | 368 section->VirtualAddress; |
| 369 bss_start = ptr; | |
| 2367 | 370 bss_size = (Rawbyte*) &my_ebss - (Rawbyte*) bss_start; |
| 428 | 371 } |
| 372 | |
| 2367 | 373 if (!qxestrcmp_ascii (section->Name, ".data")) |
| 428 | 374 #else |
| 2367 | 375 if (!qxestrcmp_ascii (section->Name, "xdata")) |
| 428 | 376 #endif |
| 377 { | |
| 2367 | 378 extern Rawbyte my_edata[]; /* From lastfile.c */ |
| 428 | 379 |
| 380 /* The .data section. */ | |
| 381 data_section = section; | |
| 2367 | 382 ptr = (Rawbyte *) nt_header->OptionalHeader.ImageBase + |
| 428 | 383 section->VirtualAddress; |
| 384 data_start_va = ptr; | |
| 385 data_start_file = section->PointerToRawData; | |
| 386 | |
| 387 #ifndef DUMP_SEPARATE_SECTION | |
| 388 /* Write only the part of the section that contains emacs data. */ | |
| 389 data_size = my_edata - data_start_va; | |
| 390 #else | |
| 391 /* Write back the full section. */ | |
| 392 data_size = section->SizeOfRawData; | |
| 393 | |
| 394 /* This code doesn't know how to grow the raw size of a section. */ | |
| 395 if (section->SizeOfRawData < section->Misc.VirtualSize) | |
| 396 { | |
| 814 | 397 stdout_out ("The emacs data section is smaller than expected" |
| 398 "...bailing.\n"); | |
| 428 | 399 exit (1); |
| 400 } | |
| 401 #endif | |
| 402 } | |
| 403 section++; | |
| 404 } | |
| 405 | |
| 406 #ifndef DUMP_SEPARATE_SECTION | |
| 407 if (bss_start == UNINIT_PTR) | |
| 408 { | |
| 409 /* Starting with MSVC 4.0, the .bss section has been eliminated | |
| 410 and appended virtually to the end of the .data section. Our | |
| 411 only hint about where the .bss section starts in the address | |
| 412 comes from the SizeOfRawData field in the .data section | |
| 413 header. Unfortunately, this field is only approximate, as it | |
| 414 is a rounded number and is typically rounded just beyond the | |
| 415 start of the .bss section. To find the start and size of the | |
| 416 .bss section exactly, we have to peek into the map file. */ | |
| 417 extern int my_ebss; | |
| 418 | |
| 419 get_bss_info_from_map_file (p_infile, &ptr, &bss_size); | |
| 420 bss_start = ptr + nt_header->OptionalHeader.ImageBase | |
| 421 + data_section->VirtualAddress; | |
| 2367 | 422 bss_size = (Rawbyte *) &my_ebss - (Rawbyte *) bss_start; |
| 428 | 423 } |
| 424 #else | |
| 425 bss_size = 0; | |
| 426 #endif | |
| 427 } | |
| 428 | |
| 429 | |
| 430 /* The dump routines. */ | |
| 431 | |
| 432 #ifdef DEBUG_XEMACS | |
| 814 | 433 /* printf with external data, stdout_out with internal */ |
| 428 | 434 #define DUMP_MSG(x) printf x |
| 435 #else | |
| 436 #define DUMP_MSG(x) | |
| 437 #endif | |
| 438 | |
| 439 static void | |
| 440 copy_executable_and_dump_data_section (file_data *p_infile, | |
| 441 file_data *p_outfile) | |
| 442 { | |
| 2367 | 443 Rawbyte *data_file, *data_va; |
| 428 | 444 unsigned long size, index; |
| 445 | |
| 446 /* Get a pointer to where the raw data should go in the executable file. */ | |
| 2367 | 447 data_file = (Rawbyte *) p_outfile->file_base + data_start_file; |
| 428 | 448 |
| 449 /* Get a pointer to the raw data in our address space. */ | |
| 450 data_va = data_start_va; | |
| 451 | |
| 452 size = (DWORD) data_file - (DWORD) p_outfile->file_base; | |
| 453 DUMP_MSG (("Copying executable up to data section...\n")); | |
| 454 DUMP_MSG (("\t0x%08x Offset in input file.\n", 0)); | |
| 455 DUMP_MSG (("\t0x%08x Offset in output file.\n", 0)); | |
| 456 DUMP_MSG (("\t0x%08x Size in bytes.\n", size)); | |
| 457 memcpy (p_outfile->file_base, p_infile->file_base, size); | |
| 458 | |
| 459 size = data_size; | |
| 460 DUMP_MSG (("Dumping data section...\n")); | |
| 461 DUMP_MSG (("\t0x%08x Address in process.\n", data_va)); | |
| 462 DUMP_MSG (("\t0x%08x Offset in output file.\n", | |
| 2367 | 463 (Rawbyte *) data_file - |
| 464 (Rawbyte *) p_outfile->file_base)); | |
| 428 | 465 DUMP_MSG (("\t0x%08x Size in bytes.\n", size)); |
| 466 memcpy (data_file, data_va, size); | |
| 467 | |
| 468 index = (DWORD) data_file + size - (DWORD) p_outfile->file_base; | |
| 469 size = p_infile->size - index; | |
| 470 DUMP_MSG (("Copying rest of executable...\n")); | |
| 471 DUMP_MSG (("\t0x%08x Offset in input file.\n", index)); | |
| 472 DUMP_MSG (("\t0x%08x Offset in output file.\n", index)); | |
| 473 DUMP_MSG (("\t0x%08x Size in bytes.\n", size)); | |
| 2367 | 474 memcpy ((Rawbyte *) p_outfile->file_base + index, |
| 475 (Rawbyte *) p_infile->file_base + index, size); | |
| 428 | 476 } |
| 477 | |
| 478 static void | |
| 2286 | 479 dump_bss_and_heap (file_data *UNUSED (p_infile), file_data *p_outfile) |
| 428 | 480 { |
| 2367 | 481 Rawbyte *heap_data; |
| 814 | 482 unsigned long size, index; |
| 428 | 483 |
| 814 | 484 DUMP_MSG (("Dumping heap onto end of executable...\n")); |
| 428 | 485 |
| 814 | 486 index = heap_index_in_executable; |
| 487 size = get_committed_heap_size (); | |
| 488 heap_data = get_heap_start (); | |
| 428 | 489 |
| 814 | 490 DUMP_MSG (("\t0x%08x Heap start in process.\n", heap_data)); |
| 491 DUMP_MSG (("\t0x%08x Heap offset in executable.\n", index)); | |
| 492 DUMP_MSG (("\t0x%08x Heap size in bytes.\n", size)); | |
| 428 | 493 |
| 814 | 494 memcpy ((PUCHAR) p_outfile->file_base + index, heap_data, size); |
| 428 | 495 |
| 496 #ifndef DUMP_SEPARATE_SECTION | |
| 814 | 497 DUMP_MSG (("Dumping bss onto end of executable...\n")); |
| 428 | 498 |
| 814 | 499 index += size; |
| 500 size = bss_size; | |
| 428 | 501 |
| 814 | 502 DUMP_MSG (("\t0x%08x BSS start in process.\n", bss_start)); |
| 503 DUMP_MSG (("\t0x%08x BSS offset in executable.\n", index)); | |
| 504 DUMP_MSG (("\t0x%08x BSS size in bytes.\n", size)); | |
| 2367 | 505 memcpy ((Rawbyte *) p_outfile->file_base + index, bss_start, size); |
| 428 | 506 #endif |
| 507 } | |
| 508 | |
| 509 #undef DUMP_MSG | |
| 510 | |
| 511 /* Reload and remap routines. */ | |
| 512 | |
| 513 | |
| 514 /* Load the dumped .bss section into the .bss area of our address space. */ | |
| 515 /* Already done if the .bss was part of a separate emacs data section */ | |
| 516 void | |
| 814 | 517 read_in_bss (Extbyte *filename) |
| 428 | 518 { |
| 519 #ifndef DUMP_SEPARATE_SECTION | |
| 520 HANDLE file; | |
| 521 unsigned long index, n_read; | |
| 522 | |
| 814 | 523 file = qxeCreateFile (filename, GENERIC_READ, FILE_SHARE_READ, NULL, |
| 524 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4854
diff
changeset
|
525 assert (file != INVALID_HANDLE_VALUE); |
| 428 | 526 |
| 527 /* Seek to where the .bss section is tucked away after the heap... */ | |
| 528 index = heap_index_in_executable + get_committed_heap_size (); | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4854
diff
changeset
|
529 if (SetFilePointer (file, index, NULL, FILE_BEGIN) == 0xFFFFFFFF) |
| 2500 | 530 ABORT (); |
| 428 | 531 |
| 532 /* Ok, read in the saved .bss section and initialize all | |
| 533 uninitialized variables. */ | |
| 534 if (!ReadFile (file, bss_start, bss_size, &n_read, NULL)) | |
| 2500 | 535 ABORT (); |
| 428 | 536 |
| 537 CloseHandle (file); | |
| 538 #endif | |
| 539 } | |
| 540 | |
| 541 /* Map the heap dumped into the executable file into our address space. */ | |
| 542 void | |
| 814 | 543 map_in_heap (Extbyte *filename) |
| 428 | 544 { |
| 545 HANDLE file; | |
| 546 HANDLE file_mapping; | |
| 547 void *file_base; | |
| 548 unsigned long size, upper_size, n_read; | |
| 549 | |
| 814 | 550 file = qxeCreateFile (filename, GENERIC_READ, FILE_SHARE_READ, NULL, |
| 551 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4854
diff
changeset
|
552 assert (file != INVALID_HANDLE_VALUE); |
| 428 | 553 |
| 554 size = GetFileSize (file, &upper_size); | |
| 814 | 555 file_mapping = qxeCreateFileMapping (file, NULL, PAGE_WRITECOPY, |
| 556 0, size, NULL); | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4854
diff
changeset
|
557 assert (file_mapping); |
| 428 | 558 |
| 559 size = get_committed_heap_size (); | |
| 560 file_base = MapViewOfFileEx (file_mapping, FILE_MAP_COPY, 0, | |
| 561 heap_index_in_executable, size, | |
| 562 get_heap_start ()); | |
| 563 if (file_base != 0) | |
| 564 { | |
| 565 return; | |
| 566 } | |
| 567 | |
| 568 /* If we don't succeed with the mapping, then copy from the | |
| 569 data into the heap. */ | |
| 570 | |
| 571 CloseHandle (file_mapping); | |
| 572 | |
| 573 if (VirtualAlloc (get_heap_start (), get_committed_heap_size (), | |
| 574 MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE) == NULL) | |
| 2500 | 575 ABORT (); |
| 428 | 576 |
| 577 /* Seek to the location of the heap data in the executable. */ | |
| 578 if (SetFilePointer (file, heap_index_in_executable, | |
| 579 NULL, FILE_BEGIN) == 0xFFFFFFFF) | |
| 2500 | 580 ABORT (); |
| 428 | 581 |
| 582 /* Read in the data. */ | |
| 583 if (!ReadFile (file, get_heap_start (), | |
| 584 get_committed_heap_size (), &n_read, NULL)) | |
| 2500 | 585 ABORT (); |
| 428 | 586 |
| 587 CloseHandle (file); | |
| 588 } |