Mercurial > emacs
annotate src/unexw32.c @ 12918:88c1220e3dec
Use post-command-idle-hook.
(show-paren-command-hook): No need to test for idleness.
author | Richard M. Stallman <rms@gnu.org> |
---|---|
date | Mon, 21 Aug 1995 22:00:21 +0000 |
parents | 3f4da17a7cd8 |
children | eefa4f720371 |
rev | line source |
---|---|
12245 | 1 /* |
2 unexec for GNU Emacs on Windows NT. | |
3 | |
4 Copyright (C) 1994 Free Software Foundation, Inc. | |
5 | |
6 This file is part of GNU Emacs. | |
7 | |
8 GNU Emacs is free software; you can redistribute it and/or modify it | |
9 under the terms of the GNU General Public License as published by the | |
10 Free Software Foundation; either version 2, or (at your option) any later | |
11 version. | |
12 | |
13 GNU Emacs is distributed in the hope that it will be useful, but WITHOUT | |
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
16 more details. | |
17 | |
18 You should have received a copy of the GNU General Public License along | |
19 with GNU Emacs; see the file COPYING. If not, write to the Free Software | |
20 Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | |
21 | |
22 Geoff Voelker (voelker@cs.washington.edu) 8-12-94 | |
23 */ | |
24 | |
25 #include <stdlib.h> /* _fmode */ | |
26 #include <stdio.h> | |
27 #include <fcntl.h> | |
28 #include <windows.h> | |
29 | |
30 extern BOOL ctrl_c_handler (unsigned long type); | |
31 | |
32 #include "ntheap.h" | |
33 | |
34 /* A convenient type for keeping all the info about a mapped file together. */ | |
35 typedef struct file_data { | |
36 char *name; | |
37 unsigned long size; | |
38 HANDLE file; | |
39 HANDLE file_mapping; | |
40 unsigned char *file_base; | |
41 } file_data; | |
42 | |
43 /* Basically, our "initialized" flag. */ | |
44 BOOL need_to_recreate_heap = FALSE; | |
45 | |
46 /* So we can find our heap in the file to recreate it. */ | |
47 unsigned long heap_index_in_executable = 0; | |
48 | |
49 void open_input_file (file_data *p_file, char *name); | |
50 void open_output_file (file_data *p_file, char *name, unsigned long size); | |
51 void close_file_data (file_data *p_file); | |
52 | |
53 void get_section_info (file_data *p_file); | |
54 void copy_executable_and_dump_data_section (file_data *, file_data *); | |
55 void dump_bss_and_heap (file_data *p_infile, file_data *p_outfile); | |
56 | |
57 /* Cached info about the .data section in the executable. */ | |
58 PUCHAR data_start_va = 0; | |
59 DWORD data_start_file = 0; | |
60 DWORD data_size = 0; | |
61 | |
62 /* Cached info about the .bss section in the executable. */ | |
63 PUCHAR bss_start = 0; | |
64 DWORD bss_size = 0; | |
65 | |
66 /* Startup code for running on NT. When we are running as the dumped | |
67 version, we need to bootstrap our heap and .bss section into our | |
68 address space before we can actually hand off control to the startup | |
69 code supplied by NT (primarily because that code relies upon malloc ()). */ | |
70 void | |
71 _start (void) | |
72 { | |
73 extern void mainCRTStartup (void); | |
74 | |
75 /* Cache system info, e.g., the NT page size. */ | |
76 cache_system_info (); | |
77 | |
78 /* If we're a dumped version of emacs then we need to recreate | |
79 our heap and play tricks with our .bss section. Do this before | |
80 start up. (WARNING: Do not put any code before this section | |
81 that relies upon malloc () and runs in the dumped version. It | |
82 won't work.) */ | |
83 if (need_to_recreate_heap) | |
84 { | |
85 char executable_path[MAX_PATH]; | |
86 | |
87 if (GetModuleFileName (NULL, executable_path, MAX_PATH) == 0) | |
88 { | |
89 printf ("Failed to find path for executable.\n"); | |
90 exit (1); | |
91 } | |
92 recreate_heap (executable_path); | |
93 need_to_recreate_heap = FALSE; | |
94 } | |
95 | |
96 /* The default behavior is to treat files as binary and patch up | |
97 text files appropriately, in accordance with the MSDOS code. */ | |
98 _fmode = O_BINARY; | |
99 | |
100 /* This prevents ctrl-c's in shells running while we're suspended from | |
101 having us exit. */ | |
102 SetConsoleCtrlHandler ((PHANDLER_ROUTINE) ctrl_c_handler, TRUE); | |
103 | |
104 /* Invoke the NT CRT startup routine now that our housecleaning | |
105 is finished. */ | |
106 mainCRTStartup (); | |
107 } | |
108 | |
109 /* Dump out .data and .bss sections into a new exectubale. */ | |
110 void | |
111 unexec (char *new_name, char *old_name, void *start_data, void *start_bss, | |
112 void *entry_address) | |
113 { | |
114 file_data in_file, out_file; | |
115 char out_filename[MAX_PATH], in_filename[MAX_PATH]; | |
116 unsigned long size; | |
117 char *ptr; | |
118 | |
119 /* Make sure that the input and output filenames have the | |
120 ".exe" extension...patch them up if they don't. */ | |
121 strcpy (in_filename, old_name); | |
122 ptr = in_filename + strlen (in_filename) - 4; | |
123 if (strcmp (ptr, ".exe")) | |
124 strcat (in_filename, ".exe"); | |
125 | |
126 strcpy (out_filename, new_name); | |
127 ptr = out_filename + strlen (out_filename) - 4; | |
128 if (strcmp (ptr, ".exe")) | |
129 strcat (out_filename, ".exe"); | |
130 | |
131 printf ("Dumping from %s\n", in_filename); | |
132 printf (" to %s\n", out_filename); | |
133 | |
134 /* We need to round off our heap to NT's allocation unit (64KB). */ | |
135 round_heap (get_allocation_unit ()); | |
136 | |
137 /* Open the undumped executable file. */ | |
138 open_input_file (&in_file, in_filename); | |
139 | |
140 /* Get the interesting section info, like start and size of .bss... */ | |
141 get_section_info (&in_file); | |
142 | |
143 /* The size of the dumped executable is the size of the original | |
144 executable plus the size of the heap and the size of the .bss section. */ | |
12454
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
145 heap_index_in_executable = (unsigned long) |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
146 round_to_next ((unsigned char *) in_file.size, get_allocation_unit ()); |
12245 | 147 size = heap_index_in_executable + get_committed_heap_size () + bss_size; |
148 open_output_file (&out_file, out_filename, size); | |
149 | |
150 /* Set the flag (before dumping). */ | |
151 need_to_recreate_heap = TRUE; | |
152 | |
153 copy_executable_and_dump_data_section (&in_file, &out_file); | |
154 dump_bss_and_heap (&in_file, &out_file); | |
155 | |
156 close_file_data (&in_file); | |
157 close_file_data (&out_file); | |
158 } | |
159 | |
160 | |
161 /* File handling. */ | |
162 | |
163 | |
164 void | |
165 open_input_file (file_data *p_file, char *filename) | |
166 { | |
167 HANDLE file; | |
168 HANDLE file_mapping; | |
169 void *file_base; | |
170 unsigned long size, upper_size; | |
171 | |
172 file = CreateFile (filename, GENERIC_READ, FILE_SHARE_READ, NULL, | |
173 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); | |
174 if (file == INVALID_HANDLE_VALUE) | |
175 { | |
176 printf ("Failed to open %s (%d)...bailing.\n", | |
177 filename, GetLastError ()); | |
178 exit (1); | |
179 } | |
180 | |
181 size = GetFileSize (file, &upper_size); | |
182 file_mapping = CreateFileMapping (file, NULL, PAGE_READONLY, | |
183 0, size, NULL); | |
184 if (!file_mapping) | |
185 { | |
186 printf ("Failed to create file mapping of %s (%d)...bailing.\n", | |
187 filename, GetLastError ()); | |
188 exit (1); | |
189 } | |
190 | |
191 file_base = MapViewOfFile (file_mapping, FILE_MAP_READ, 0, 0, size); | |
192 if (file_base == 0) | |
193 { | |
194 printf ("Failed to map view of file of %s (%d)...bailing.\n", | |
195 filename, GetLastError ()); | |
196 exit (1); | |
197 } | |
198 | |
199 p_file->name = filename; | |
200 p_file->size = size; | |
201 p_file->file = file; | |
202 p_file->file_mapping = file_mapping; | |
203 p_file->file_base = file_base; | |
204 } | |
205 | |
206 void | |
207 open_output_file (file_data *p_file, char *filename, unsigned long size) | |
208 { | |
209 HANDLE file; | |
210 HANDLE file_mapping; | |
211 void *file_base; | |
212 | |
213 file = CreateFile (filename, GENERIC_READ | GENERIC_WRITE, 0, NULL, | |
214 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0); | |
215 if (file == INVALID_HANDLE_VALUE) | |
216 { | |
217 printf ("open_output_file: Failed to open %s (%d).\n", | |
218 filename, GetLastError ()); | |
219 exit (1); | |
220 } | |
221 | |
222 file_mapping = CreateFileMapping (file, NULL, PAGE_READWRITE, | |
223 0, size, NULL); | |
224 if (!file_mapping) | |
225 { | |
226 printf ("open_output_file: Failed to create file mapping of %s (%d).\n", | |
227 filename, GetLastError ()); | |
228 exit (1); | |
229 } | |
230 | |
231 file_base = MapViewOfFile (file_mapping, FILE_MAP_WRITE, 0, 0, size); | |
232 if (file_base == 0) | |
233 { | |
234 printf ("open_output_file: Failed to map view of file of %s (%d).\n", | |
235 filename, GetLastError ()); | |
236 exit (1); | |
237 } | |
238 | |
239 p_file->name = filename; | |
240 p_file->size = size; | |
241 p_file->file = file; | |
242 p_file->file_mapping = file_mapping; | |
243 p_file->file_base = file_base; | |
244 } | |
245 | |
246 /* Close the system structures associated with the given file. */ | |
247 static void | |
248 close_file_data (file_data *p_file) | |
249 { | |
250 UnmapViewOfFile (p_file->file_base); | |
251 CloseHandle (p_file->file_mapping); | |
252 CloseHandle (p_file->file); | |
253 } | |
254 | |
255 | |
256 /* Routines to manipulate NT executable file sections. */ | |
257 | |
258 | |
259 static unsigned long | |
260 get_section_size (PIMAGE_SECTION_HEADER p_section) | |
261 { | |
262 /* The section size is in different locations in the different versions. */ | |
263 switch (get_nt_minor_version ()) | |
264 { | |
265 case 10: | |
266 return p_section->SizeOfRawData; | |
267 default: | |
268 return p_section->Misc.VirtualSize; | |
269 } | |
270 } | |
271 | |
272 /* Flip through the executable and cache the info necessary for dumping. */ | |
273 static void | |
274 get_section_info (file_data *p_infile) | |
275 { | |
276 PIMAGE_DOS_HEADER dos_header; | |
277 PIMAGE_NT_HEADERS nt_header; | |
278 PIMAGE_SECTION_HEADER section; | |
279 unsigned char *ptr; | |
280 int i; | |
281 | |
282 dos_header = (PIMAGE_DOS_HEADER) p_infile->file_base; | |
283 if (dos_header->e_magic != IMAGE_DOS_SIGNATURE) | |
284 { | |
285 printf ("Unknown EXE header in %s...bailing.\n", p_infile->name); | |
286 exit (1); | |
287 } | |
288 nt_header = (PIMAGE_NT_HEADERS) (((unsigned long) dos_header) + | |
289 dos_header->e_lfanew); | |
290 if (nt_header == NULL) | |
291 { | |
292 printf ("Failed to find IMAGE_NT_HEADER in %s...bailing.\n", | |
293 p_infile->name); | |
294 exit (1); | |
295 } | |
296 | |
297 /* Check the NT header signature ... */ | |
298 if (nt_header->Signature != IMAGE_NT_SIGNATURE) | |
299 { | |
300 printf ("Invalid IMAGE_NT_SIGNATURE 0x%x in %s...bailing.\n", | |
301 nt_header->Signature, p_infile->name); | |
302 } | |
303 | |
304 /* Flip through the sections for .data and .bss ... */ | |
305 section = (PIMAGE_SECTION_HEADER) IMAGE_FIRST_SECTION (nt_header); | |
306 for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++) | |
307 { | |
308 if (!strcmp (section->Name, ".bss")) | |
309 { | |
310 /* The .bss section. */ | |
311 ptr = (char *) nt_header->OptionalHeader.ImageBase + | |
312 section->VirtualAddress; | |
313 bss_start = ptr; | |
314 bss_size = get_section_size (section); | |
315 } | |
316 if (!strcmp (section->Name, ".data")) | |
317 { | |
12454
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
318 /* From lastfile.c */ |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
319 extern char my_edata[]; |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
320 |
12245 | 321 /* The .data section. */ |
322 ptr = (char *) nt_header->OptionalHeader.ImageBase + | |
323 section->VirtualAddress; | |
324 data_start_va = ptr; | |
325 data_start_file = section->PointerToRawData; | |
12454
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
326 |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
327 /* We want to only write Emacs data back to the executable, |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
328 not any of the library data (if library data is included, |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
329 then a dumped Emacs won't run on system versions other |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
330 than the one Emacs was dumped on). */ |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
331 data_size = my_edata - data_start_va; |
12245 | 332 } |
333 section++; | |
334 } | |
335 } | |
336 | |
337 | |
338 /* The dump routines. */ | |
339 | |
340 static void | |
341 copy_executable_and_dump_data_section (file_data *p_infile, | |
342 file_data *p_outfile) | |
343 { | |
344 unsigned char *data_file, *data_va; | |
345 unsigned long size, index; | |
346 | |
347 /* Get a pointer to where the raw data should go in the executable file. */ | |
348 data_file = (char *) p_outfile->file_base + data_start_file; | |
349 | |
350 /* Get a pointer to the raw data in our address space. */ | |
351 data_va = data_start_va; | |
352 | |
353 size = (DWORD) data_file - (DWORD) p_outfile->file_base; | |
354 printf ("Copying executable up to data section...\n"); | |
355 printf ("\t0x%08x Offset in input file.\n", 0); | |
356 printf ("\t0x%08x Offset in output file.\n", 0); | |
357 printf ("\t0x%08x Size in bytes.\n", size); | |
358 memcpy (p_outfile->file_base, p_infile->file_base, size); | |
359 | |
360 size = data_size; | |
361 printf ("Dumping .data section...\n"); | |
362 printf ("\t0x%08x Address in process.\n", data_va); | |
363 printf ("\t0x%08x Offset in output file.\n", | |
364 data_file - p_outfile->file_base); | |
365 printf ("\t0x%08x Size in bytes.\n", size); | |
366 memcpy (data_file, data_va, size); | |
367 | |
368 index = (DWORD) data_file + size - (DWORD) p_outfile->file_base; | |
369 size = p_infile->size - index; | |
370 printf ("Copying rest of executable...\n"); | |
371 printf ("\t0x%08x Offset in input file.\n", index); | |
372 printf ("\t0x%08x Offset in output file.\n", index); | |
373 printf ("\t0x%08x Size in bytes.\n", size); | |
374 memcpy ((char *) p_outfile->file_base + index, | |
375 (char *) p_infile->file_base + index, size); | |
376 } | |
377 | |
378 static void | |
379 dump_bss_and_heap (file_data *p_infile, file_data *p_outfile) | |
380 { | |
381 unsigned char *heap_data, *bss_data; | |
382 unsigned long size, index; | |
383 | |
384 printf ("Dumping heap into executable...\n"); | |
385 | |
386 index = heap_index_in_executable; | |
387 size = get_committed_heap_size (); | |
388 heap_data = get_heap_start (); | |
389 | |
390 printf ("\t0x%08x Heap start in process.\n", heap_data); | |
391 printf ("\t0x%08x Heap offset in executable.\n", index); | |
392 printf ("\t0x%08x Heap size in bytes.\n", size); | |
393 | |
394 memcpy ((PUCHAR) p_outfile->file_base + index, heap_data, size); | |
395 | |
396 printf ("Dumping .bss into executable...\n"); | |
397 | |
398 index += size; | |
399 size = bss_size; | |
400 bss_data = bss_start; | |
401 | |
402 printf ("\t0x%08x BSS start in process.\n", bss_data); | |
403 printf ("\t0x%08x BSS offset in executable.\n", index); | |
404 printf ("\t0x%08x BSS size in bytes.\n", size); | |
405 memcpy ((char *) p_outfile->file_base + index, bss_data, size); | |
406 } | |
407 | |
408 | |
409 /* Reload and remap routines. */ | |
410 | |
411 | |
412 /* Load the dumped .bss section into the .bss area of our address space. */ | |
413 void | |
414 read_in_bss (char *filename) | |
415 { | |
416 HANDLE file; | |
417 unsigned long size, index, n_read, total_read; | |
418 char buffer[512], *bss; | |
419 int i; | |
420 | |
421 file = CreateFile (filename, GENERIC_READ, FILE_SHARE_READ, NULL, | |
422 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); | |
423 if (file == INVALID_HANDLE_VALUE) | |
424 { | |
425 i = GetLastError (); | |
426 exit (1); | |
427 } | |
428 | |
429 /* Seek to where the .bss section is tucked away after the heap... */ | |
430 index = heap_index_in_executable + get_committed_heap_size (); | |
431 if (SetFilePointer (file, index, NULL, FILE_BEGIN) == 0xFFFFFFFF) | |
432 { | |
433 i = GetLastError (); | |
434 exit (1); | |
435 } | |
436 | |
437 | |
438 /* Ok, read in the saved .bss section and initialize all | |
439 uninitialized variables. */ | |
12454
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
440 if (!ReadFile (file, bss_start, bss_size, &n_read, NULL)) |
12245 | 441 { |
12454
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
442 i = GetLastError (); |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
443 exit (1); |
12245 | 444 } |
12454
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
445 |
12245 | 446 CloseHandle (file); |
447 } | |
448 | |
449 /* Map the heap dumped into the executable file into our address space. */ | |
450 void | |
451 map_in_heap (char *filename) | |
452 { | |
453 HANDLE file; | |
454 HANDLE file_mapping; | |
455 void *file_base; | |
12454
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
456 unsigned long size, upper_size, n_read; |
12245 | 457 int i; |
458 | |
459 file = CreateFile (filename, GENERIC_READ, FILE_SHARE_READ, NULL, | |
460 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); | |
461 if (file == INVALID_HANDLE_VALUE) | |
462 { | |
463 i = GetLastError (); | |
464 exit (1); | |
465 } | |
466 | |
467 size = GetFileSize (file, &upper_size); | |
468 file_mapping = CreateFileMapping (file, NULL, PAGE_WRITECOPY, | |
469 0, size, NULL); | |
470 if (!file_mapping) | |
471 { | |
12454
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
472 i = GetLastError (); |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
473 exit (1); |
12245 | 474 } |
475 | |
476 size = get_committed_heap_size (); | |
477 file_base = MapViewOfFileEx (file_mapping, FILE_MAP_COPY, 0, | |
478 heap_index_in_executable, size, | |
479 get_heap_start ()); | |
12454
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
480 if (file_base != 0) |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
481 { |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
482 return; |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
483 } |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
484 |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
485 /* If we don't succeed with the mapping, then copy from the |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
486 data into the heap. */ |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
487 |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
488 CloseHandle (file_mapping); |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
489 |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
490 if (VirtualAlloc (get_heap_start (), get_committed_heap_size (), |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
491 MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE) == NULL) |
12245 | 492 { |
493 i = GetLastError (); | |
494 exit (1); | |
495 } | |
12454
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
496 |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
497 /* Seek to the location of the heap data in the executable. */ |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
498 i = heap_index_in_executable; |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
499 if (SetFilePointer (file, i, NULL, FILE_BEGIN) == 0xFFFFFFFF) |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
500 { |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
501 i = GetLastError (); |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
502 exit (1); |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
503 } |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
504 |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
505 /* Read in the data. */ |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
506 if (!ReadFile (file, get_heap_start (), |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
507 get_committed_heap_size (), &n_read, NULL)) |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
508 { |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
509 i = GetLastError (); |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
510 exit (1); |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
511 } |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
512 |
3f4da17a7cd8
(get_section_info): Set the end of the data region
Geoff Voelker <voelker@cs.washington.edu>
parents:
12245
diff
changeset
|
513 CloseHandle (file); |
12245 | 514 } |