Merge from emacs-24; up to 2012-04-25T15:23:19Z!sdl.web@gmail.com
[emacs.git] / src / unexcw.c
blobeae534cf4ddd957a669c3a9fd8f7c95df2d859e7
1 /* unexec() support for Cygwin;
2 complete rewrite of xemacs Cygwin unexec() code
4 Copyright (C) 2004-2012 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 #include <config.h>
22 #include "unexec.h"
24 #include <setjmp.h>
25 #include <lisp.h>
26 #include <stdio.h>
27 #include <fcntl.h>
28 #include <a.out.h>
29 #include <unistd.h>
30 #include <assert.h>
32 #define DOTEXE ".exe"
34 extern int bss_sbrk_did_unexec;
36 extern int __malloc_initialized;
38 /* emacs symbols that indicate where bss and data end for emacs internals */
39 extern char my_endbss[];
40 extern char my_edata[];
43 ** header for Windows executable files
45 typedef struct
47 FILHDR file_header;
48 PEAOUTHDR file_optional_header;
49 SCNHDR section_header[32];
50 } exe_header_t;
52 int debug_unexcw = 0;
55 ** Read the header from the executable into memory so we can more easily access it.
57 static exe_header_t *
58 read_exe_header (int fd, exe_header_t * exe_header_buffer)
60 int i;
61 int ret;
63 assert (fd >= 0);
64 assert (exe_header_buffer != 0);
66 ret = lseek (fd, 0L, SEEK_SET);
67 assert (ret != -1);
69 ret =
70 read (fd, &exe_header_buffer->file_header,
71 sizeof (exe_header_buffer->file_header));
72 assert (ret == sizeof (exe_header_buffer->file_header));
74 assert (exe_header_buffer->file_header.e_magic == 0x5a4d);
75 assert (exe_header_buffer->file_header.nt_signature == 0x4550);
76 assert (exe_header_buffer->file_header.f_magic == 0x014c);
77 assert (exe_header_buffer->file_header.f_nscns > 0);
78 assert (exe_header_buffer->file_header.f_nscns <=
79 sizeof (exe_header_buffer->section_header) /
80 sizeof (exe_header_buffer->section_header[0]));
81 assert (exe_header_buffer->file_header.f_opthdr > 0);
83 ret =
84 read (fd, &exe_header_buffer->file_optional_header,
85 sizeof (exe_header_buffer->file_optional_header));
86 assert (ret == sizeof (exe_header_buffer->file_optional_header));
88 assert (exe_header_buffer->file_optional_header.magic == 0x010b);
90 for (i = 0; i < exe_header_buffer->file_header.f_nscns; ++i)
92 ret =
93 read (fd, &exe_header_buffer->section_header[i],
94 sizeof (exe_header_buffer->section_header[i]));
95 assert (ret == sizeof (exe_header_buffer->section_header[i]));
98 return (exe_header_buffer);
102 ** Fix the dumped emacs executable:
104 ** - copy .data section data of interest from running executable into
105 ** output .exe file
107 ** - convert .bss section into an initialized data section (like
108 ** .data) and copy .bss section data of interest from running
109 ** executable into output .exe file
111 static void
112 fixup_executable (int fd)
114 exe_header_t exe_header_buffer;
115 exe_header_t *exe_header;
116 int i;
117 int ret;
118 int found_data = 0;
119 int found_bss = 0;
121 exe_header = read_exe_header (fd, &exe_header_buffer);
122 assert (exe_header != 0);
124 assert (exe_header->file_header.f_nscns > 0);
125 for (i = 0; i < exe_header->file_header.f_nscns; ++i)
127 unsigned long start_address =
128 exe_header->section_header[i].s_vaddr +
129 exe_header->file_optional_header.ImageBase;
130 unsigned long end_address =
131 exe_header->section_header[i].s_vaddr +
132 exe_header->file_optional_header.ImageBase +
133 exe_header->section_header[i].s_paddr;
134 if (debug_unexcw)
135 printf ("%8s start 0x%08x end 0x%08x\n",
136 exe_header->section_header[i].s_name,
137 start_address, end_address);
138 if (my_edata >= (char *) start_address
139 && my_edata < (char *) end_address)
141 /* data section */
142 ret =
143 lseek (fd, (long) (exe_header->section_header[i].s_scnptr),
144 SEEK_SET);
145 assert (ret != -1);
146 ret =
147 write (fd, (char *) start_address,
148 my_edata - (char *) start_address);
149 assert (ret == my_edata - (char *) start_address);
150 ++found_data;
151 if (debug_unexcw)
152 printf (" .data, mem start 0x%08x mem length %d\n",
153 start_address, my_edata - (char *) start_address);
154 if (debug_unexcw)
155 printf (" .data, file start %d file length %d\n",
156 (int) exe_header->section_header[i].s_scnptr,
157 (int) exe_header->section_header[i].s_paddr);
159 else if (my_endbss >= (char *) start_address
160 && my_endbss < (char *) end_address)
162 /* bss section */
163 ++found_bss;
164 if (exe_header->section_header[i].s_flags & 0x00000080)
166 /* convert uninitialized data section to initialized data section */
167 struct stat statbuf;
168 ret = fstat (fd, &statbuf);
169 assert (ret != -1);
171 exe_header->section_header[i].s_flags &= ~0x00000080;
172 exe_header->section_header[i].s_flags |= 0x00000040;
174 exe_header->section_header[i].s_scnptr =
175 (statbuf.st_size +
176 exe_header->file_optional_header.FileAlignment) /
177 exe_header->file_optional_header.FileAlignment *
178 exe_header->file_optional_header.FileAlignment;
180 exe_header->section_header[i].s_size =
181 (exe_header->section_header[i].s_paddr +
182 exe_header->file_optional_header.FileAlignment) /
183 exe_header->file_optional_header.FileAlignment *
184 exe_header->file_optional_header.FileAlignment;
186 ret =
187 lseek (fd,
188 (long) (exe_header->section_header[i].s_scnptr +
189 exe_header->section_header[i].s_size - 1),
190 SEEK_SET);
191 assert (ret != -1);
192 ret = write (fd, "", 1);
193 assert (ret == 1);
195 ret =
196 lseek (fd,
197 (long) ((char *) &exe_header->section_header[i] -
198 (char *) exe_header), SEEK_SET);
199 assert (ret != -1);
200 ret =
201 write (fd, &exe_header->section_header[i],
202 sizeof (exe_header->section_header[i]));
203 assert (ret == sizeof (exe_header->section_header[i]));
204 if (debug_unexcw)
205 printf (" seek to %ld, write %d\n",
206 (long) ((char *) &exe_header->section_header[i] -
207 (char *) exe_header),
208 sizeof (exe_header->section_header[i]));
210 /* write initialized data section */
211 ret =
212 lseek (fd, (long) (exe_header->section_header[i].s_scnptr),
213 SEEK_SET);
214 assert (ret != -1);
215 /* force the dumped emacs to reinitialize malloc */
216 __malloc_initialized = 0;
217 ret =
218 write (fd, (char *) start_address,
219 my_endbss - (char *) start_address);
220 __malloc_initialized = 1;
221 assert (ret == (my_endbss - (char *) start_address));
222 if (debug_unexcw)
223 printf (" .bss, mem start 0x%08x mem length %d\n",
224 start_address, my_endbss - (char *) start_address);
225 if (debug_unexcw)
226 printf (" .bss, file start %d file length %d\n",
227 (int) exe_header->section_header[i].s_scnptr,
228 (int) exe_header->section_header[i].s_paddr);
231 assert (found_bss == 1);
232 assert (found_data == 1);
236 ** Windows likes .exe suffixes on executables.
238 static char *
239 add_exe_suffix_if_necessary (const char *name, char *modified)
241 int i = strlen (name);
242 if (i <= (sizeof (DOTEXE) - 1))
244 sprintf (modified, "%s%s", name, DOTEXE);
246 else if (!strcasecmp (name + i - (sizeof (DOTEXE) - 1), DOTEXE))
248 strcpy (modified, name);
250 else
252 sprintf (modified, "%s%s", name, DOTEXE);
254 return (modified);
257 void
258 unexec (const char *outfile, const char *infile)
260 char infile_buffer[FILENAME_MAX];
261 char outfile_buffer[FILENAME_MAX];
262 int fd_in;
263 int fd_out;
264 int ret;
265 int ret2;
267 if (bss_sbrk_did_unexec)
269 /* can only dump once */
270 printf ("You can only dump Emacs once on this platform.\n");
271 return;
274 report_sheap_usage (1);
276 infile = add_exe_suffix_if_necessary (infile, infile_buffer);
277 outfile = add_exe_suffix_if_necessary (outfile, outfile_buffer);
279 fd_in = open (infile, O_RDONLY | O_BINARY);
280 assert (fd_in >= 0);
281 fd_out = open (outfile, O_RDWR | O_TRUNC | O_CREAT | O_BINARY, 0755);
282 assert (fd_out >= 0);
283 for (;;)
285 char buffer[4096];
286 ret = read (fd_in, buffer, sizeof (buffer));
287 if (ret == 0)
289 /* eof */
290 break;
292 assert (ret > 0);
293 /* data */
294 ret2 = write (fd_out, buffer, ret);
295 assert (ret2 == ret);
297 ret = close (fd_in);
298 assert (ret == 0);
300 bss_sbrk_did_unexec = 1;
301 fixup_executable (fd_out);
302 bss_sbrk_did_unexec = 0;
304 ret = close (fd_out);
305 assert (ret == 0);