* lisp/subr.el (with-eval-after-load): New macro.
[emacs.git] / nt / addsection.c
blob61a8cfce742fb6c7d0a47b303c512323b9f878d1
1 /* Add an uninitialized data section to an executable.
2 Copyright (C) 1999, 2001-2013 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
20 Andrew Innes <andrewi@harlequin.co.uk> 04-Jan-1999
21 based on code from unexw32.c
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <fcntl.h>
27 #include <time.h>
28 #if defined(__GNUC__) && !defined(_W64)
29 #define _ANONYMOUS_UNION
30 #define _ANONYMOUS_STRUCT
31 #endif
32 #include <windows.h>
34 /* Include relevant definitions from IMAGEHLP.H, which can be found
35 in \\win32sdk\mstools\samples\image\include\imagehlp.h. */
37 PIMAGE_NT_HEADERS
38 (__stdcall * pfnCheckSumMappedFile) (PVOID BaseAddress,
39 DWORD_PTR FileLength,
40 PDWORD_PTR HeaderSum,
41 PDWORD_PTR CheckSum);
43 #undef min
44 #undef max
45 #define min(x, y) (((x) < (y)) ? (x) : (y))
46 #define max(x, y) (((x) > (y)) ? (x) : (y))
49 /* File handling. */
51 typedef struct file_data {
52 const char *name;
53 unsigned long size;
54 HANDLE file;
55 HANDLE file_mapping;
56 unsigned char *file_base;
57 } file_data;
59 int
60 open_input_file (file_data *p_file, const char *filename)
62 HANDLE file;
63 HANDLE file_mapping;
64 void *file_base;
65 unsigned long size, upper_size;
67 file = CreateFile (filename, GENERIC_READ, FILE_SHARE_READ, NULL,
68 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
69 if (file == INVALID_HANDLE_VALUE)
70 return FALSE;
72 size = GetFileSize (file, &upper_size);
73 file_mapping = CreateFileMapping (file, NULL, PAGE_READONLY,
74 0, size, NULL);
75 if (!file_mapping)
76 return FALSE;
78 file_base = MapViewOfFile (file_mapping, FILE_MAP_READ, 0, 0, size);
79 if (file_base == 0)
80 return FALSE;
82 p_file->name = filename;
83 p_file->size = size;
84 p_file->file = file;
85 p_file->file_mapping = file_mapping;
86 p_file->file_base = file_base;
88 return TRUE;
91 int
92 open_output_file (file_data *p_file, const char *filename, unsigned long size)
94 HANDLE file;
95 HANDLE file_mapping;
96 void *file_base;
98 file = CreateFile (filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
99 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
100 if (file == INVALID_HANDLE_VALUE)
101 return FALSE;
103 file_mapping = CreateFileMapping (file, NULL, PAGE_READWRITE,
104 0, size, NULL);
105 if (!file_mapping)
106 return FALSE;
108 file_base = MapViewOfFile (file_mapping, FILE_MAP_WRITE, 0, 0, size);
109 if (file_base == 0)
110 return FALSE;
112 p_file->name = filename;
113 p_file->size = size;
114 p_file->file = file;
115 p_file->file_mapping = file_mapping;
116 p_file->file_base = file_base;
118 return TRUE;
121 /* Close the system structures associated with the given file. */
122 void
123 close_file_data (file_data *p_file)
125 UnmapViewOfFile (p_file->file_base);
126 CloseHandle (p_file->file_mapping);
127 /* For the case of output files, set final size. */
128 SetFilePointer (p_file->file, p_file->size, NULL, FILE_BEGIN);
129 SetEndOfFile (p_file->file);
130 CloseHandle (p_file->file);
134 /* Routines to manipulate NT executable file sections. */
136 unsigned long
137 get_unrounded_section_size (PIMAGE_SECTION_HEADER p_section)
139 /* The true section size, before rounding, for an initialized data or
140 code section. (Supposedly some linkers swap the meaning of these
141 two values.) */
142 return min (p_section->SizeOfRawData,
143 p_section->Misc.VirtualSize);
146 /* Return pointer to section header for named section. */
147 IMAGE_SECTION_HEADER *
148 find_section (const char *name, IMAGE_NT_HEADERS *nt_header)
150 PIMAGE_SECTION_HEADER section;
151 int i;
153 section = IMAGE_FIRST_SECTION (nt_header);
155 for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
157 if (strcmp (section->Name, name) == 0)
158 return section;
159 section++;
161 return NULL;
164 /* Return pointer to section header for section containing the given
165 relative virtual address. */
166 IMAGE_SECTION_HEADER *
167 rva_to_section (DWORD_PTR rva, IMAGE_NT_HEADERS * nt_header)
169 PIMAGE_SECTION_HEADER section;
170 int i;
172 section = IMAGE_FIRST_SECTION (nt_header);
174 for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
176 /* Some linkers (eg. the NT SDK linker I believe) swapped the
177 meaning of these two values - or rather, they ignored
178 VirtualSize entirely and always set it to zero. This affects
179 some very old exes (eg. gzip dated Dec 1993). Since
180 w32_executable_type relies on this function to work reliably,
181 we need to cope with this. */
182 DWORD_PTR real_size = max (section->SizeOfRawData,
183 section->Misc.VirtualSize);
184 if (rva >= section->VirtualAddress
185 && rva < section->VirtualAddress + real_size)
186 return section;
187 section++;
189 return NULL;
192 /* Return pointer to section header for section containing the given
193 offset in its raw data area. */
194 IMAGE_SECTION_HEADER *
195 offset_to_section (DWORD_PTR offset, IMAGE_NT_HEADERS * nt_header)
197 PIMAGE_SECTION_HEADER section;
198 int i;
200 section = IMAGE_FIRST_SECTION (nt_header);
202 for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
204 if (offset >= section->PointerToRawData
205 && offset < section->PointerToRawData + section->SizeOfRawData)
206 return section;
207 section++;
209 return NULL;
212 /* Return offset to an object in dst, given offset in src. We assume
213 there is at least one section in both src and dst images, and that
214 the some sections may have been added to dst (after sections in src). */
215 static DWORD_PTR
216 relocate_offset (DWORD_PTR offset,
217 IMAGE_NT_HEADERS * src_nt_header,
218 IMAGE_NT_HEADERS * dst_nt_header)
220 PIMAGE_SECTION_HEADER src_section = IMAGE_FIRST_SECTION (src_nt_header);
221 PIMAGE_SECTION_HEADER dst_section = IMAGE_FIRST_SECTION (dst_nt_header);
222 int i = 0;
224 while (offset >= src_section->PointerToRawData)
226 if (offset < src_section->PointerToRawData + src_section->SizeOfRawData)
227 break;
228 i++;
229 if (i == src_nt_header->FileHeader.NumberOfSections)
231 /* Handle offsets after the last section. */
232 dst_section = IMAGE_FIRST_SECTION (dst_nt_header);
233 dst_section += dst_nt_header->FileHeader.NumberOfSections - 1;
234 while (dst_section->PointerToRawData == 0)
235 dst_section--;
236 while (src_section->PointerToRawData == 0)
237 src_section--;
238 return offset
239 + (dst_section->PointerToRawData + dst_section->SizeOfRawData)
240 - (src_section->PointerToRawData + src_section->SizeOfRawData);
242 src_section++;
243 dst_section++;
245 return offset +
246 (dst_section->PointerToRawData - src_section->PointerToRawData);
249 #define OFFSET_TO_RVA(offset, section) \
250 (section->VirtualAddress + ((DWORD_PTR)(offset) - section->PointerToRawData))
252 #define RVA_TO_OFFSET(rva, section) \
253 (section->PointerToRawData + ((DWORD_PTR)(rva) - section->VirtualAddress))
255 #define RVA_TO_SECTION_OFFSET(rva, section) \
256 ((DWORD_PTR)(rva) - section->VirtualAddress)
258 /* Convert address in executing image to RVA. */
259 #define PTR_TO_RVA(ptr) ((DWORD_PTR)(ptr) - (DWORD_PTR) GetModuleHandle (NULL))
261 #define PTR_TO_OFFSET(ptr, pfile_data) \
262 ((unsigned const char *)(ptr) - (pfile_data)->file_base)
264 #define OFFSET_TO_PTR(offset, pfile_data) \
265 ((pfile_data)->file_base + (DWORD_PTR)(offset))
267 #define ROUND_UP(p, align) \
268 (((DWORD_PTR)(p) + (align)-1) & ~((DWORD_PTR)(align)-1))
269 #define ROUND_DOWN(p, align) ((DWORD_PTR)(p) & ~((DWORD_PTR)(align)-1))
272 static void
273 copy_executable_and_add_section (file_data *p_infile,
274 file_data *p_outfile,
275 const char *new_section_name,
276 DWORD_PTR new_section_size)
278 unsigned char *dst;
279 PIMAGE_DOS_HEADER dos_header;
280 PIMAGE_NT_HEADERS nt_header;
281 PIMAGE_NT_HEADERS dst_nt_header;
282 PIMAGE_SECTION_HEADER section;
283 PIMAGE_SECTION_HEADER dst_section;
284 DWORD_PTR offset;
285 int i;
286 int be_verbose = GetEnvironmentVariable ("DEBUG_DUMP", NULL, 0) > 0;
288 #define COPY_CHUNK(message, src, size, verbose) \
289 do { \
290 unsigned const char *s = (void *)(src); \
291 unsigned long count = (size); \
292 if (verbose) \
294 printf ("%s\n", (message)); \
295 printf ("\t0x%08x Offset in input file.\n", s - p_infile->file_base); \
296 printf ("\t0x%08x Offset in output file.\n", dst - p_outfile->file_base); \
297 printf ("\t0x%08x Size in bytes.\n", count); \
299 memcpy (dst, s, count); \
300 dst += count; \
301 } while (0)
303 #define DST_TO_OFFSET() PTR_TO_OFFSET (dst, p_outfile)
304 #define ROUND_UP_DST_AND_ZERO(align) \
305 do { \
306 unsigned char *newdst = p_outfile->file_base \
307 + ROUND_UP (DST_TO_OFFSET (), (align)); \
308 /* Zero the alignment slop; it may actually initialize real data. */ \
309 memset (dst, 0, newdst - dst); \
310 dst = newdst; \
311 } while (0)
313 /* Copy the source image sequentially, ie. section by section after
314 copying the headers and section table, to simplify the process of
315 adding an extra section table entry (which might force the raw
316 section data to be relocated).
318 Note that dst is updated implicitly by each COPY_CHUNK. */
320 dos_header = (PIMAGE_DOS_HEADER) p_infile->file_base;
321 nt_header = (PIMAGE_NT_HEADERS) (((unsigned char *) dos_header) +
322 dos_header->e_lfanew);
323 section = IMAGE_FIRST_SECTION (nt_header);
325 dst = (unsigned char *) p_outfile->file_base;
327 COPY_CHUNK ("Copying DOS header...", dos_header,
328 (DWORD_PTR) nt_header - (DWORD_PTR) dos_header, be_verbose);
329 dst_nt_header = (PIMAGE_NT_HEADERS) dst;
330 COPY_CHUNK ("Copying NT header...", nt_header,
331 (DWORD_PTR) section - (DWORD_PTR) nt_header, be_verbose);
332 dst_section = (PIMAGE_SECTION_HEADER) dst;
333 COPY_CHUNK ("Copying section table...", section,
334 nt_header->FileHeader.NumberOfSections * sizeof (*section),
335 be_verbose);
337 /* To improve the efficiency of demand loading, make the file
338 alignment match the section alignment (VC++ 6.0 does this by
339 default anyway). */
340 dst_nt_header->OptionalHeader.FileAlignment =
341 dst_nt_header->OptionalHeader.SectionAlignment;
343 /* Add an uninitialized data section at the end, of the specified name
344 and virtual size. */
345 if (find_section (new_section_name, nt_header) == NULL)
346 /* Leave room for extra section table entry; filled in below. */
347 dst += sizeof (*section);
348 else
349 new_section_name = NULL;
351 /* Align the first section's raw data area, and set the header size
352 field accordingly. */
353 ROUND_UP_DST_AND_ZERO (dst_nt_header->OptionalHeader.FileAlignment);
354 dst_nt_header->OptionalHeader.SizeOfHeaders = DST_TO_OFFSET ();
356 for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
358 char msg[100];
359 /* Windows section names are fixed 8-char strings, only
360 zero-terminated if the name is shorter than 8 characters. */
361 sprintf (msg, "Copying raw data for %.8s...", section->Name);
363 /* Update the file-relative offset for this section's raw data (if
364 it has any) in case things have been relocated; we will update
365 the other offsets below once we know where everything is. */
366 if (dst_section->PointerToRawData)
367 dst_section->PointerToRawData = DST_TO_OFFSET ();
369 /* Can always copy the original raw data. */
370 COPY_CHUNK
371 (msg, OFFSET_TO_PTR (section->PointerToRawData, p_infile),
372 section->SizeOfRawData, be_verbose);
374 /* Round up the raw data size to the new alignment. */
375 dst_section->SizeOfRawData =
376 ROUND_UP (dst_section->SizeOfRawData,
377 dst_nt_header->OptionalHeader.FileAlignment);
379 /* Align the next section's raw data area. */
380 ROUND_UP_DST_AND_ZERO (dst_nt_header->OptionalHeader.FileAlignment);
382 section++;
383 dst_section++;
386 /* Add the extra section entry (which adds no raw data). */
387 if (new_section_name != NULL)
389 dst_nt_header->FileHeader.NumberOfSections++;
390 dst_nt_header->OptionalHeader.SizeOfImage += new_section_size;
391 strncpy (dst_section->Name, new_section_name, sizeof (dst_section->Name));
392 dst_section->VirtualAddress =
393 section[-1].VirtualAddress
394 + ROUND_UP (section[-1].Misc.VirtualSize,
395 dst_nt_header->OptionalHeader.SectionAlignment);
396 dst_section->Misc.VirtualSize = new_section_size;
397 dst_section->PointerToRawData = 0;
398 dst_section->SizeOfRawData = 0;
399 dst_section->Characteristics =
400 IMAGE_SCN_CNT_UNINITIALIZED_DATA
401 | IMAGE_SCN_MEM_READ
402 | IMAGE_SCN_MEM_WRITE;
405 /* Copy remainder of source image. */
406 section--;
407 offset = ROUND_UP (section->PointerToRawData + section->SizeOfRawData,
408 nt_header->OptionalHeader.FileAlignment);
409 COPY_CHUNK
410 ("Copying remainder of executable...",
411 OFFSET_TO_PTR (offset, p_infile),
412 p_infile->size - offset, be_verbose);
414 /* Final size for new image. */
415 p_outfile->size = DST_TO_OFFSET ();
417 /* Now patch up remaining file-relative offsets. */
418 section = IMAGE_FIRST_SECTION (nt_header);
419 dst_section = IMAGE_FIRST_SECTION (dst_nt_header);
421 #define ADJUST_OFFSET(var) \
422 do { \
423 if ((var) != 0) \
424 (var) = relocate_offset ((var), nt_header, dst_nt_header); \
425 } while (0)
427 dst_nt_header->OptionalHeader.SizeOfInitializedData = 0;
428 dst_nt_header->OptionalHeader.SizeOfUninitializedData = 0;
429 for (i = 0; i < dst_nt_header->FileHeader.NumberOfSections; i++)
431 /* Recompute data sizes for completeness. */
432 if (dst_section[i].Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
433 dst_nt_header->OptionalHeader.SizeOfInitializedData +=
434 ROUND_UP (dst_section[i].Misc.VirtualSize, dst_nt_header->OptionalHeader.FileAlignment);
435 else if (dst_section[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
436 dst_nt_header->OptionalHeader.SizeOfUninitializedData +=
437 ROUND_UP (dst_section[i].Misc.VirtualSize, dst_nt_header->OptionalHeader.FileAlignment);
439 ADJUST_OFFSET (dst_section[i].PointerToLinenumbers);
442 ADJUST_OFFSET (dst_nt_header->FileHeader.PointerToSymbolTable);
444 /* Update offsets in debug directory entries. */
446 IMAGE_DATA_DIRECTORY debug_dir =
447 dst_nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
448 PIMAGE_DEBUG_DIRECTORY debug_entry;
450 section = rva_to_section (debug_dir.VirtualAddress, dst_nt_header);
451 if (section)
453 debug_entry = (PIMAGE_DEBUG_DIRECTORY)
454 (RVA_TO_OFFSET (debug_dir.VirtualAddress, section) + p_outfile->file_base);
455 debug_dir.Size /= sizeof (IMAGE_DEBUG_DIRECTORY);
457 for (i = 0; i < debug_dir.Size; i++, debug_entry++)
458 ADJUST_OFFSET (debug_entry->PointerToRawData);
465 main (int argc, char **argv)
467 file_data in_file, out_file;
468 char out_filename[MAX_PATH], in_filename[MAX_PATH];
469 unsigned long size;
470 PIMAGE_DOS_HEADER dos_header;
471 PIMAGE_NT_HEADERS nt_header;
473 #define OLD_NAME argv[1]
474 #define NEW_NAME argv[2]
475 #define SECTION_NAME argv[3]
476 #define SECTION_SIZE argv[4]
478 strcpy (in_filename, OLD_NAME);
479 strcpy (out_filename, NEW_NAME);
481 printf ("Dumping from %s\n", in_filename);
482 printf (" to %s\n", out_filename);
484 /* Open the undumped executable file. */
485 if (!open_input_file (&in_file, in_filename))
487 printf ("Failed to open %s (%d)...bailing.\n",
488 in_filename, GetLastError ());
489 exit (1);
491 dos_header = (PIMAGE_DOS_HEADER) in_file.file_base;
492 nt_header = (PIMAGE_NT_HEADERS) ((char *) dos_header + dos_header->e_lfanew);
493 /* Allow for expansion due to increasing file align to section align.
494 We can overestimate here, since close_file_data will update the
495 size exactly. */
496 size = in_file.size
497 + nt_header->OptionalHeader.SectionAlignment
498 * nt_header->FileHeader.NumberOfSections;
499 if (!open_output_file (&out_file, out_filename, size))
501 printf ("Failed to open %s (%d)...bailing.\n",
502 out_filename, GetLastError ());
503 exit (1);
506 copy_executable_and_add_section (&in_file, &out_file,
507 SECTION_NAME,
508 atoi (SECTION_SIZE) * 1024 * 1024);
510 /* Patch up header fields; profiler is picky about this. */
512 HANDLE hImagehelp = LoadLibrary ("imagehlp.dll");
513 DWORD_PTR headersum;
514 DWORD_PTR checksum;
516 dos_header = (PIMAGE_DOS_HEADER) out_file.file_base;
517 nt_header = (PIMAGE_NT_HEADERS) ((char *) dos_header + dos_header->e_lfanew);
519 nt_header->OptionalHeader.CheckSum = 0;
520 // nt_header->FileHeader.TimeDateStamp = time (NULL);
521 // dos_header->e_cp = size / 512;
522 // nt_header->OptionalHeader.SizeOfImage = size;
524 pfnCheckSumMappedFile = (void *) GetProcAddress (hImagehelp, "CheckSumMappedFile");
525 if (pfnCheckSumMappedFile)
527 // nt_header->FileHeader.TimeDateStamp = time (NULL);
528 pfnCheckSumMappedFile (out_file.file_base,
529 out_file.size,
530 &headersum,
531 &checksum);
532 nt_header->OptionalHeader.CheckSum = checksum;
534 FreeLibrary (hImagehelp);
537 close_file_data (&in_file);
538 close_file_data (&out_file);
540 return 0;
543 /* eof */