/* Flip through the executable and cache the info necessary for dumping. */
void
get_section_info (file_data *p_infile)
{
PIMAGE_DOS_HEADER dos_header;
PIMAGE_NT_HEADERS nt_header;
int overlap;
dos_header = (PIMAGE_DOS_HEADER) p_infile->file_base;
if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
{
printf ("Unknown EXE header in %s...bailing.\n", p_infile->name);
exit (1);
}
nt_header = (PIMAGE_NT_HEADERS) (((DWORD_PTR) dos_header) +
dos_header->e_lfanew);
if (nt_header == NULL)
{
printf ("Failed to find IMAGE_NT_HEADER in %s...bailing.\n",
p_infile->name);
exit (1);
}
/* Check the NT header signature ... */
if (nt_header->Signature != IMAGE_NT_SIGNATURE)
{
printf ("Invalid IMAGE_NT_SIGNATURE 0x%x in %s...bailing.\n",
nt_header->Signature, p_infile->name);
exit (1);
}
/* Locate the ".data" and ".bss" sections for Emacs. (Note that the
actual section names are probably different from these, and might
actually be the same section.)
We do this as follows: first we determine the virtual address
ranges in this process for the data and bss variables that we wish
to preserve. Then we map these VAs to the section entries in the
source image. Finally, we determine the new size of the raw data
area for the bss section, so we can make the new image the correct
size. */
/* We arrange for the Emacs initialized data to be in a separate
section if possible, because we cannot rely on my_begdata and
my_edata marking out the full extent of the initialized data, at
least on the Alpha where the linker freely reorders variables
across libraries. If we can arrange for this, all we need to do is
find the start and size of the EMDATA section. */
data_section = find_section ("EMDATA", nt_header);
if (data_section)
{
data_start = (char *) nt_header->OptionalHeader.ImageBase +
data_section->VirtualAddress;
data_size = data_section->Misc.VirtualSize;
}
else
{
/* Fallback on the old method if compiler doesn't support the
data_set #pragma (or its equivalent). */
data_start = my_begdata;
data_size = my_edata - my_begdata;
data_section = rva_to_section (PTR_TO_RVA (my_begdata), nt_header);
if (data_section != rva_to_section (PTR_TO_RVA (my_edata), nt_header))
{
printf ("Initialized data is not in a single section...bailing\n");
exit (1);
}
}
/* As noted in lastfile.c, the Alpha (but not the Intel) MSVC linker
globally segregates all static and public bss data (ie. across all
linked modules, not just per module), so we must take both static
and public bss areas into account to determine the true extent of
the bss area used by Emacs.
To be strictly correct, we dump the static and public bss areas
used by Emacs separately if non-overlapping (since otherwise we are
dumping bss data belonging to system libraries, eg. the static bss
system data on the Alpha). */
bss_start = my_begbss;
bss_size = my_endbss - my_begbss;
bss_section = rva_to_section (PTR_TO_RVA (my_begbss), nt_header);
if (bss_section != rva_to_section (PTR_TO_RVA (my_endbss), nt_header))
{
printf ("Uninitialized data is not in a single section...bailing\n");
exit (1);
}
/* Compute how much the .bss section's raw data will grow. */
extra_bss_size =
ROUND_UP (RVA_TO_SECTION_OFFSET (PTR_TO_RVA (my_endbss), bss_section),
nt_header->OptionalHeader.FileAlignment)
- bss_section->SizeOfRawData;
bss_start_static = my_begbss_static;
bss_size_static = my_endbss_static - my_begbss_static;
bss_section_static = rva_to_section (PTR_TO_RVA (my_begbss_static), nt_header);
if (bss_section_static != rva_to_section (PTR_TO_RVA (my_endbss_static), nt_header))
{
printf ("Uninitialized static data is not in a single section...bailing\n");
exit (1);
}
/* Compute how much the static .bss section's raw data will grow. */
extra_bss_size_static =
ROUND_UP (RVA_TO_SECTION_OFFSET (PTR_TO_RVA (my_endbss_static), bss_section_static),
nt_header->OptionalHeader.FileAlignment)
- bss_section_static->SizeOfRawData;
/* Combine the bss sections into one if they overlap. */
#ifdef _ALPHA_
overlap = 1; /* force all bss data to be dumped */
#else
overlap = 0;
#endif
if (bss_start < bss_start_static)
{
if (bss_start_static < bss_start + bss_size)
overlap = 1;
}
else
{
if (bss_start < bss_start_static + bss_size_static)
overlap = 1;
}
if (overlap)
{
if (bss_section != bss_section_static)
{
printf ("BSS data not in a single section...bailing\n");
exit (1);
}
bss_start = min (bss_start, bss_start_static);
bss_size = max (my_endbss, my_endbss_static) - bss_start;
bss_section_static = 0;
extra_bss_size_static = 0;
}
}
void
copy_executable_and_dump_data (file_data *p_infile,
file_data *p_outfile)
{
unsigned char *dst, *dst_save;
PIMAGE_DOS_HEADER dos_header;
PIMAGE_NT_HEADERS nt_header;
PIMAGE_NT_HEADERS dst_nt_header;
PIMAGE_SECTION_HEADER section;
PIMAGE_SECTION_HEADER dst_section;
DWORD_PTR offset;
int i;
int be_verbose = GetEnvironmentVariable ("DEBUG_DUMP", NULL, 0) > 0;
#define COPY_CHUNK(message, src, size, verbose) \
do { \
unsigned char *s = (void *)(src); \
unsigned long count = (size); \
if (verbose) \
{ \
printf ("%s\n", (message)); \
printf ("\t0x%08x Offset in input file.\n", s - p_infile->file_base); \
printf ("\t0x%08x Offset in output file.\n", dst - p_outfile->file_base); \
printf ("\t0x%08x Size in bytes.\n", count); \
} \
memcpy (dst, s, count); \
dst += count; \
} while (0)
#define COPY_PROC_CHUNK(message, src, size, verbose) \
do { \
unsigned char *s = (void *)(src); \
unsigned long count = (size); \
if (verbose) \
{ \
printf ("%s\n", (message)); \
printf ("\t0x%p Address in process.\n", s); \
printf ("\t0x%p Base output file.\n", p_outfile->file_base); \
printf ("\t0x%p Offset in output file.\n", dst - p_outfile->file_base); \
printf ("\t0x%p Address in output file.\n", dst); \
printf ("\t0x%p Size in bytes.\n", count); \
} \
memcpy (dst, s, count); \
dst += count; \
} while (0)
#define DST_TO_OFFSET() PTR_TO_OFFSET (dst, p_outfile)
#define ROUND_UP_DST(align) \
(dst = p_outfile->file_base + ROUND_UP (DST_TO_OFFSET (), (align)))
#define ROUND_UP_DST_AND_ZERO(align) \
do { \
unsigned char *newdst = p_outfile->file_base \
+ ROUND_UP (DST_TO_OFFSET (), (align)); \
/* Zero the alignment slop; it may actually initialize real data. */ \
memset (dst, 0, newdst - dst); \
dst = newdst; \
} while (0)
/* Copy the source image sequentially, ie. section by section after
copying the headers and section table, to simplify the process of
dumping the raw data for the bss and heap sections.
Note that dst is updated implicitly by each COPY_CHUNK. */
dos_header = (PIMAGE_DOS_HEADER) p_infile->file_base;
nt_header = (PIMAGE_NT_HEADERS) (((DWORD_PTR) dos_header) +
dos_header->e_lfanew);
section = IMAGE_FIRST_SECTION (nt_header);
dst = (unsigned char *) p_outfile->file_base;
COPY_CHUNK ("Copying DOS header...", dos_header,
(DWORD_PTR) nt_header - (DWORD_PTR) dos_header, be_verbose);
dst_nt_header = (PIMAGE_NT_HEADERS) dst;
COPY_CHUNK ("Copying NT header...", nt_header,
(DWORD_PTR) section - (DWORD_PTR) nt_header, be_verbose);
dst_section = (PIMAGE_SECTION_HEADER) dst;
COPY_CHUNK ("Copying section table...", section,
nt_header->FileHeader.NumberOfSections * sizeof (*section),
be_verbose);
/* Align the first section's raw data area, and set the header size
field accordingly. */
ROUND_UP_DST_AND_ZERO (dst_nt_header->OptionalHeader.FileAlignment);
dst_nt_header->OptionalHeader.SizeOfHeaders = DST_TO_OFFSET ();
for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
{
char msg[100];
/* Windows section names are fixed 8-char strings, only
zero-terminated if the name is shorter than 8 characters. */
sprintf (msg, "Copying raw data for %.8s...", section->Name);
dst_save = dst;
/* Update the file-relative offset for this section's raw data (if
it has any) in case things have been relocated; we will update
the other offsets below once we know where everything is. */
if (dst_section->PointerToRawData)
dst_section->PointerToRawData = DST_TO_OFFSET ();
/* Can always copy the original raw data. */
COPY_CHUNK
(msg, OFFSET_TO_PTR (section->PointerToRawData, p_infile),
section->SizeOfRawData, be_verbose);
/* Ensure alignment slop is zeroed. */
ROUND_UP_DST_AND_ZERO (dst_nt_header->OptionalHeader.FileAlignment);
/* Note that various sections below may be aliases. */
if (section == data_section)
{
dst = dst_save
+ RVA_TO_SECTION_OFFSET (PTR_TO_RVA (data_start), dst_section);
COPY_PROC_CHUNK ("Dumping initialized data...",
data_start, data_size, be_verbose);
dst = dst_save + dst_section->SizeOfRawData;
}
if (section == bss_section)
{
/* Dump contents of bss variables, adjusting the section's raw
data size as necessary. */
dst = dst_save
+ RVA_TO_SECTION_OFFSET (PTR_TO_RVA (bss_start), dst_section);
COPY_PROC_CHUNK ("Dumping bss data...", bss_start,
bss_size, be_verbose);
ROUND_UP_DST (dst_nt_header->OptionalHeader.FileAlignment);
dst_section->PointerToRawData = PTR_TO_OFFSET (dst_save, p_outfile);
/* Determine new size of raw data area. */
dst = max (dst, dst_save + dst_section->SizeOfRawData);
dst_section->SizeOfRawData = dst - dst_save;
dst_section->Characteristics &= ~IMAGE_SCN_CNT_UNINITIALIZED_DATA;
dst_section->Characteristics |= IMAGE_SCN_CNT_INITIALIZED_DATA;
}
if (section == bss_section_static)
{
/* Dump contents of static bss variables, adjusting the
section's raw data size as necessary. */
dst = dst_save
+ RVA_TO_SECTION_OFFSET (PTR_TO_RVA (bss_start_static), dst_section);
COPY_PROC_CHUNK ("Dumping static bss data...", bss_start_static,
bss_size_static, be_verbose);
ROUND_UP_DST (dst_nt_header->OptionalHeader.FileAlignment);
dst_section->PointerToRawData = PTR_TO_OFFSET (dst_save, p_outfile);
/* Determine new size of raw data area. */
dst = max (dst, dst_save + dst_section->SizeOfRawData);
dst_section->SizeOfRawData = dst - dst_save;
dst_section->Characteristics &= ~IMAGE_SCN_CNT_UNINITIALIZED_DATA;
dst_section->Characteristics |= IMAGE_SCN_CNT_INITIALIZED_DATA;
}
/* Align the section's raw data area. */
ROUND_UP_DST (dst_nt_header->OptionalHeader.FileAlignment);
section++;
dst_section++;
}
/* Copy remainder of source image. */
do
section--;
while (section->PointerToRawData == 0);
offset = ROUND_UP (section->PointerToRawData + section->SizeOfRawData,
nt_header->OptionalHeader.FileAlignment);
COPY_CHUNK
("Copying remainder of executable...",
OFFSET_TO_PTR (offset, p_infile),
p_infile->size - offset, be_verbose);
/* Final size for new image. */
p_outfile->size = DST_TO_OFFSET ();
/* Now patch up remaining file-relative offsets. */
section = IMAGE_FIRST_SECTION (nt_header);
dst_section = IMAGE_FIRST_SECTION (dst_nt_header);
#define ADJUST_OFFSET(var) \
do { \
if ((var) != 0) \
(var) = relocate_offset ((var), nt_header, dst_nt_header); \
} while (0)
dst_nt_header->OptionalHeader.SizeOfInitializedData = 0;
dst_nt_header->OptionalHeader.SizeOfUninitializedData = 0;
for (i = 0; i < dst_nt_header->FileHeader.NumberOfSections; i++)
{
/* Recompute data sizes for completeness. */
if (dst_section[i].Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
dst_nt_header->OptionalHeader.SizeOfInitializedData +=
ROUND_UP (dst_section[i].Misc.VirtualSize, dst_nt_header->OptionalHeader.FileAlignment);
else if (dst_section[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
dst_nt_header->OptionalHeader.SizeOfUninitializedData +=
ROUND_UP (dst_section[i].Misc.VirtualSize, dst_nt_header->OptionalHeader.FileAlignment);
ADJUST_OFFSET (dst_section[i].PointerToLinenumbers);
}
ADJUST_OFFSET (dst_nt_header->FileHeader.PointerToSymbolTable);
/* Update offsets in debug directory entries. */
{
IMAGE_DATA_DIRECTORY debug_dir =
dst_nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
PIMAGE_DEBUG_DIRECTORY debug_entry;
section = rva_to_section (debug_dir.VirtualAddress, dst_nt_header);
if (section)
{
debug_entry = (PIMAGE_DEBUG_DIRECTORY)
(RVA_TO_OFFSET (debug_dir.VirtualAddress, section) + p_outfile->file_base);
debug_dir.Size /= sizeof (IMAGE_DEBUG_DIRECTORY);
for (i = 0; i < debug_dir.Size; i++, debug_entry++)
ADJUST_OFFSET (debug_entry->PointerToRawData);
}
}
}
static void
copy_executable_and_add_section (file_data *p_infile,
file_data *p_outfile,
const char *new_section_name,
DWORD_PTR new_section_size)
{
unsigned char *dst;
PIMAGE_DOS_HEADER dos_header;
PIMAGE_NT_HEADERS nt_header;
PIMAGE_NT_HEADERS dst_nt_header;
PIMAGE_SECTION_HEADER section;
PIMAGE_SECTION_HEADER dst_section;
DWORD_PTR offset;
int i;
int be_verbose = GetEnvironmentVariable ("DEBUG_DUMP", NULL, 0) > 0;
#define COPY_CHUNK(message, src, size, verbose) \
do { \
unsigned const char *s = (void *)(src); \
unsigned long count = (size); \
if (verbose) \
{ \
printf ("%s\n", (message)); \
printf ("\t0x%08x Offset in input file.\n", s - p_infile->file_base); \
printf ("\t0x%08x Offset in output file.\n", dst - p_outfile->file_base); \
printf ("\t0x%08x Size in bytes.\n", count); \
} \
memcpy (dst, s, count); \
dst += count; \
} while (0)
#define DST_TO_OFFSET() PTR_TO_OFFSET (dst, p_outfile)
#define ROUND_UP_DST_AND_ZERO(align) \
do { \
unsigned char *newdst = p_outfile->file_base \
+ ROUND_UP (DST_TO_OFFSET (), (align)); \
/* Zero the alignment slop; it may actually initialize real data. */ \
memset (dst, 0, newdst - dst); \
dst = newdst; \
} while (0)
/* Copy the source image sequentially, ie. section by section after
copying the headers and section table, to simplify the process of
adding an extra section table entry (which might force the raw
section data to be relocated).
Note that dst is updated implicitly by each COPY_CHUNK. */
dos_header = (PIMAGE_DOS_HEADER) p_infile->file_base;
nt_header = (PIMAGE_NT_HEADERS) (((unsigned char *) dos_header) +
dos_header->e_lfanew);
section = IMAGE_FIRST_SECTION (nt_header);
dst = (unsigned char *) p_outfile->file_base;
COPY_CHUNK ("Copying DOS header...", dos_header,
(DWORD_PTR) nt_header - (DWORD_PTR) dos_header, be_verbose);
dst_nt_header = (PIMAGE_NT_HEADERS) dst;
COPY_CHUNK ("Copying NT header...", nt_header,
(DWORD_PTR) section - (DWORD_PTR) nt_header, be_verbose);
dst_section = (PIMAGE_SECTION_HEADER) dst;
COPY_CHUNK ("Copying section table...", section,
nt_header->FileHeader.NumberOfSections * sizeof (*section),
be_verbose);
/* To improve the efficiency of demand loading, make the file
alignment match the section alignment (VC++ 6.0 does this by
default anyway). */
dst_nt_header->OptionalHeader.FileAlignment =
dst_nt_header->OptionalHeader.SectionAlignment;
/* Add an uninitialized data section at the end, of the specified name
and virtual size. */
if (find_section (new_section_name, nt_header) == NULL)
/* Leave room for extra section table entry; filled in below. */
dst += sizeof (*section);
else
new_section_name = NULL;
/* Align the first section's raw data area, and set the header size
field accordingly. */
ROUND_UP_DST_AND_ZERO (dst_nt_header->OptionalHeader.FileAlignment);
dst_nt_header->OptionalHeader.SizeOfHeaders = DST_TO_OFFSET ();
for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
{
char msg[100];
/* Windows section names are fixed 8-char strings, only
zero-terminated if the name is shorter than 8 characters. */
sprintf (msg, "Copying raw data for %.8s...", section->Name);
/* Update the file-relative offset for this section's raw data (if
it has any) in case things have been relocated; we will update
the other offsets below once we know where everything is. */
if (dst_section->PointerToRawData)
dst_section->PointerToRawData = DST_TO_OFFSET ();
/* Can always copy the original raw data. */
COPY_CHUNK
(msg, OFFSET_TO_PTR (section->PointerToRawData, p_infile),
section->SizeOfRawData, be_verbose);
/* Round up the raw data size to the new alignment. */
dst_section->SizeOfRawData =
ROUND_UP (dst_section->SizeOfRawData,
dst_nt_header->OptionalHeader.FileAlignment);
/* Align the next section's raw data area. */
ROUND_UP_DST_AND_ZERO (dst_nt_header->OptionalHeader.FileAlignment);
section++;
dst_section++;
}
/* Add the extra section entry (which adds no raw data). */
if (new_section_name != NULL)
{
dst_nt_header->FileHeader.NumberOfSections++;
dst_nt_header->OptionalHeader.SizeOfImage += new_section_size;
strncpy (dst_section->Name, new_section_name, sizeof (dst_section->Name));
dst_section->VirtualAddress =
section[-1].VirtualAddress
+ ROUND_UP (section[-1].Misc.VirtualSize,
dst_nt_header->OptionalHeader.SectionAlignment);
dst_section->Misc.VirtualSize = new_section_size;
dst_section->PointerToRawData = 0;
dst_section->SizeOfRawData = 0;
dst_section->Characteristics =
IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_WRITE;
}
/* Copy remainder of source image. */
section--;
offset = ROUND_UP (section->PointerToRawData + section->SizeOfRawData,
nt_header->OptionalHeader.FileAlignment);
COPY_CHUNK
("Copying remainder of executable...",
OFFSET_TO_PTR (offset, p_infile),
p_infile->size - offset, be_verbose);
/* Final size for new image. */
p_outfile->size = DST_TO_OFFSET ();
/* Now patch up remaining file-relative offsets. */
section = IMAGE_FIRST_SECTION (nt_header);
dst_section = IMAGE_FIRST_SECTION (dst_nt_header);
#define ADJUST_OFFSET(var) \
do { \
if ((var) != 0) \
(var) = relocate_offset ((var), nt_header, dst_nt_header); \
} while (0)
dst_nt_header->OptionalHeader.SizeOfInitializedData = 0;
dst_nt_header->OptionalHeader.SizeOfUninitializedData = 0;
for (i = 0; i < dst_nt_header->FileHeader.NumberOfSections; i++)
{
/* Recompute data sizes for completeness. */
if (dst_section[i].Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
dst_nt_header->OptionalHeader.SizeOfInitializedData +=
ROUND_UP (dst_section[i].Misc.VirtualSize, dst_nt_header->OptionalHeader.FileAlignment);
else if (dst_section[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
dst_nt_header->OptionalHeader.SizeOfUninitializedData +=
ROUND_UP (dst_section[i].Misc.VirtualSize, dst_nt_header->OptionalHeader.FileAlignment);
ADJUST_OFFSET (dst_section[i].PointerToLinenumbers);
}
ADJUST_OFFSET (dst_nt_header->FileHeader.PointerToSymbolTable);
/* Update offsets in debug directory entries. */
{
IMAGE_DATA_DIRECTORY debug_dir =
dst_nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
PIMAGE_DEBUG_DIRECTORY debug_entry;
section = rva_to_section (debug_dir.VirtualAddress, dst_nt_header);
if (section)
{
debug_entry = (PIMAGE_DEBUG_DIRECTORY)
(RVA_TO_OFFSET (debug_dir.VirtualAddress, section) + p_outfile->file_base);
debug_dir.Size /= sizeof (IMAGE_DEBUG_DIRECTORY);
for (i = 0; i < debug_dir.Size; i++, debug_entry++)
ADJUST_OFFSET (debug_entry->PointerToRawData);
}
}
}