/* 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); } } }