/*
* Usage: rsym input-file output-file
*
* There are two sources of information: the .stab/.stabstr
* sections of the executable and the COFF symbol table. Most
* of the information is in the .stab/.stabstr sections.
* However, most of our asm files don't contain .stab directives,
* so routines implemented in assembler won't show up in the
* .stab section. They are present in the COFF symbol table.
* So, we mostly use the .stab/.stabstr sections, but we augment
* the info there with info from the COFF symbol table when
* possible.
*
* This is a tool and is compiled using the host compiler,
* i.e. on Linux gcc and not mingw-gcc (cross-compiler).
* Therefore we can't include SDK headers and we have to
* duplicate some definitions here.
* Also note that the internal functions are "old C-style",
* returning an int, where a return of 0 means success and
* non-zero is failure.
*/
#include "../../dll/win32/dbghelp/compat.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <wchar.h>
#include "rsym.h"
#define MAX_PATH 260
#define MAX_SYM_NAME 2000
struct StringEntry
{
struct StringEntry *Next;
ULONG Offset;
char *String;
};
struct StringHashTable
{
ULONG TableSize;
struct StringEntry **Table;
};
/* This is the famous DJB hash */
static unsigned int
ComputeDJBHash(const char *name)
{
unsigned int val = 5381;
int i = 0;
for (i = 0; name[i]; i++)
{
val = (33 * val) + name[i];
}
return val;
}
static void
AddStringToHash(struct StringHashTable *StringTable,
unsigned int hash,
ULONG Offset,
char *StringPtr)
{
struct StringEntry *entry = calloc(1, sizeof(struct StringEntry));
entry->Offset = Offset;
entry->String = StringPtr;
entry->Next = StringTable->Table[hash];
StringTable->Table[hash] = entry;
}
static void
StringHashTableInit(struct StringHashTable *StringTable,
ULONG StringsLength,
char *StringsBase)
{
char *Start = StringsBase;
char *End = StringsBase + StringsLength;
StringTable->TableSize = 1024;
StringTable->Table = calloc(1024, sizeof(struct StringEntry *));
while (Start < End)
{
AddStringToHash(StringTable,
ComputeDJBHash(Start) % StringTable->TableSize,
Start - StringsBase,
Start);
Start += strlen(Start) + 1;
}
}
static void
StringHashTableFree(struct StringHashTable *StringTable)
{
int i;
struct StringEntry *entry;
for (i = 0; i < StringTable->TableSize; i++)
{
while ((entry = StringTable->Table[i]))
{
entry = entry->Next;
free(StringTable->Table[i]);
StringTable->Table[i] = entry;
}
}
free(StringTable->Table);
}
static int
CompareSymEntry(const PROSSYM_ENTRY SymEntry1, const PROSSYM_ENTRY SymEntry2)
{
if (SymEntry1->Address < SymEntry2->Address)
{
return -1;
}
if (SymEntry2->Address < SymEntry1->Address)
{
return +1;
}
if (SymEntry2->SourceLine == 0)
{
return -1;
}
if (SymEntry1->SourceLine == 0)
{
return +1;
}
return 0;
}
static int
GetStabInfo(void *FileData, PIMAGE_FILE_HEADER PEFileHeader,
PIMAGE_SECTION_HEADER PESectionHeaders,
ULONG *StabSymbolsLength, void **StabSymbolsBase,
ULONG *StabStringsLength, void **StabStringsBase)
{
ULONG Idx;
/* Load .stab and .stabstr sections if available */
*StabSymbolsBase = NULL;
*StabSymbolsLength = 0;
*StabStringsBase = NULL;
*StabStringsLength = 0;
for (Idx = 0; Idx < PEFileHeader->NumberOfSections; Idx++)
{
/* printf("section: '%.08s'\n", PESectionHeaders[Idx].Name); */
if ((strncmp((char *) PESectionHeaders[Idx].Name, ".stab", 5) == 0)
&& (PESectionHeaders[Idx].Name[5] == 0))
{
/* printf(".stab section found. Size %d\n", PESectionHeaders[Idx].SizeOfRawData); */
*StabSymbolsLength = PESectionHeaders[Idx].SizeOfRawData;
*StabSymbolsBase = (void *)((char *) FileData + PESectionHeaders[Idx].PointerToRawData);
}
if (strncmp((char *) PESectionHeaders[Idx].Name, ".stabstr", 8) == 0)
{
/* printf(".stabstr section found. Size %d\n", PESectionHeaders[Idx].SizeOfRawData); */
*StabStringsLength = PESectionHeaders[Idx].SizeOfRawData;
*StabStringsBase = (void *)((char *) FileData + PESectionHeaders[Idx].PointerToRawData);
}
}
return 0;
}
static int
GetCoffInfo(void *FileData, PIMAGE_FILE_HEADER PEFileHeader,
PIMAGE_SECTION_HEADER PESectionHeaders,
ULONG *CoffSymbolsLength, void **CoffSymbolsBase,
ULONG *CoffStringsLength, void **CoffStringsBase)
{
if (PEFileHeader->PointerToSymbolTable == 0 || PEFileHeader->NumberOfSymbols == 0)
{
/* No COFF symbol table */
*CoffSymbolsLength = 0;
*CoffStringsLength = 0;
}
else
{
*CoffSymbolsLength = PEFileHeader->NumberOfSymbols * sizeof(COFF_SYMENT);
*CoffSymbolsBase = (void *)((char *) FileData + PEFileHeader->PointerToSymbolTable);
*CoffStringsLength = *((ULONG *) ((char *) *CoffSymbolsBase + *CoffSymbolsLength));
*CoffStringsBase = (void *)((char *) *CoffSymbolsBase + *CoffSymbolsLength);
}
return 0;
}
static ULONG
FindOrAddString(struct StringHashTable *StringTable,
char *StringToFind,
ULONG *StringsLength,
void *StringsBase)
{
unsigned int hash = ComputeDJBHash(StringToFind) % StringTable->TableSize;
struct StringEntry *entry = StringTable->Table[hash];
while (entry && strcmp(entry->String, StringToFind))
entry = entry->Next;
if (entry)
{
return entry->Offset;
}
else
{
char *End = (char *)StringsBase + *StringsLength;
strcpy(End, StringToFind);
*StringsLength += strlen(StringToFind) + 1;
AddStringToHash(StringTable, hash, End - (char *)StringsBase, End);
return End - (char *)StringsBase;
}
}
static int
ConvertStabs(ULONG *SymbolsCount, PROSSYM_ENTRY *SymbolsBase,
ULONG *StringsLength, void *StringsBase,
ULONG StabSymbolsLength, void *StabSymbolsBase,
ULONG StabStringsLength, void *StabStringsBase,
ULONG_PTR ImageBase, PIMAGE_FILE_HEADER PEFileHeader,
PIMAGE_SECTION_HEADER PESectionHeaders)
{
PSTAB_ENTRY StabEntry;
ULONG Count, i;
ULONG_PTR Address, LastFunctionAddress;
int First = 1;
char *Name;
ULONG NameLen;
char FuncName[256];
PROSSYM_ENTRY Current;
struct StringHashTable StringHash;
StabEntry = StabSymbolsBase;
Count = StabSymbolsLength / sizeof(STAB_ENTRY);
*SymbolsCount = 0;
if (Count == 0)
{
/* No symbol info */
*SymbolsBase = NULL;
return 0;
}
*SymbolsBase = malloc(Count * sizeof(ROSSYM_ENTRY));
if (*SymbolsBase == NULL)
{
fprintf(stderr, "Failed to allocate memory for converted .stab symbols\n");
return 1;
}
Current = *SymbolsBase;
memset(Current, 0, sizeof(*Current));
StringHashTableInit(&StringHash, *StringsLength, (char *)StringsBase);
LastFunctionAddress = 0;
for (i = 0; i < Count; i++)
{
if (LastFunctionAddress == 0)
{
Address = StabEntry[i].n_value - ImageBase;
}
else
{
Address = LastFunctionAddress + StabEntry[i].n_value;
}
switch (StabEntry[i].n_type)
{
case N_SO:
case N_SOL:
case N_BINCL:
Name = (char *) StabStringsBase + StabEntry[i].n_strx;
if (StabStringsLength < StabEntry[i].n_strx
|| *Name == '\0' || Name[strlen(Name) - 1] == '/'
|| Name[strlen(Name) - 1] == '\\'
|| StabEntry[i].n_value < ImageBase)
{
continue;
}
if (First || Address != Current->Address)
{
if (!First)
{
memset(++Current, 0, sizeof(*Current));
Current->FunctionOffset = Current[-1].FunctionOffset;
}
else
First = 0;
Current->Address = Address;
}
Current->FileOffset = FindOrAddString(&StringHash,
(char *)StabStringsBase + StabEntry[i].n_strx,
StringsLength,
StringsBase);
break;
case N_FUN:
if (StabEntry[i].n_desc == 0 || StabEntry[i].n_value < ImageBase)
{
LastFunctionAddress = 0; /* line # 0 = end of function */
continue;
}
if (First || Address != Current->Address)
{
if (!First)
memset(++Current, 0, sizeof(*Current));
else
First = 0;
Current->Address = Address;
Current->FileOffset = Current[-1].FileOffset;
}
Name = (char *)StabStringsBase + StabEntry[i].n_strx;
NameLen = strcspn(Name, ":");
if (sizeof(FuncName) <= NameLen)
{
free(*SymbolsBase);
fprintf(stderr, "Function name too long\n");
return 1;
}
memcpy(FuncName, Name, NameLen);
FuncName[NameLen] = '\0';
Current->FunctionOffset = FindOrAddString(&StringHash,
FuncName,
StringsLength,
StringsBase);
Current->SourceLine = 0;
LastFunctionAddress = Address;
break;
case N_SLINE:
if (First || Address != Current->Address)
{
if (!First)
{
memset(++Current, 0, sizeof(*Current));
Current->FileOffset = Current[-1].FileOffset;
Current->FunctionOffset = Current[-1].FunctionOffset;
}
else
First = 0;
Current->Address = Address;
}
Current->SourceLine = StabEntry[i].n_desc;
break;
default:
continue;
}
}
*SymbolsCount = (Current - *SymbolsBase + 1);
qsort(*SymbolsBase, *SymbolsCount, sizeof(ROSSYM_ENTRY), (int (*)(const void *, const void *)) CompareSymEntry);
StringHashTableFree(&StringHash);
return 0;
}
static int
ConvertCoffs(ULONG *SymbolsCount, PROSSYM_ENTRY *SymbolsBase,
ULONG *StringsLength, void *StringsBase,
ULONG CoffSymbolsLength, void *CoffSymbolsBase,
ULONG CoffStringsLength, void *CoffStringsBase,
ULONG_PTR ImageBase, PIMAGE_FILE_HEADER PEFileHeader,
PIMAGE_SECTION_HEADER PESectionHeaders)
{
ULONG Count, i;
PCOFF_SYMENT CoffEntry;
char FuncName[256], FileName[1024];
char *p;
PROSSYM_ENTRY Current;
struct StringHashTable StringHash;
CoffEntry = (PCOFF_SYMENT) CoffSymbolsBase;
Count = CoffSymbolsLength / sizeof(COFF_SYMENT);
*SymbolsBase = malloc(Count * sizeof(ROSSYM_ENTRY));
if (*SymbolsBase == NULL)
{
fprintf(stderr, "Unable to allocate memory for converted COFF symbols\n");
return 1;
}
*SymbolsCount = 0;
Current = *SymbolsBase;
StringHashTableInit(&StringHash, *StringsLength, (char*)StringsBase);
for (i = 0; i < Count; i++)
{
if (ISFCN(CoffEntry[i].e_type) || C_EXT == CoffEntry[i].e_sclass)
{
Current->Address = CoffEntry[i].e_value;
if (CoffEntry[i].e_scnum > 0)
{
if (PEFileHeader->NumberOfSections < CoffEntry[i].e_scnum)
{
free(*SymbolsBase);
fprintf(stderr,
"Invalid section number %d in COFF symbols (only %d sections present)\n",
CoffEntry[i].e_scnum,
PEFileHeader->NumberOfSections);
return 1;
}
Current->Address += PESectionHeaders[CoffEntry[i].e_scnum - 1].VirtualAddress;
}
Current->FileOffset = 0;
if (CoffEntry[i].e.e.e_zeroes == 0)
{
if (sizeof(FuncName) <= strlen((char *) CoffStringsBase + CoffEntry[i].e.e.e_offset))
{
free(*SymbolsBase);
fprintf(stderr, "Function name too long\n");
StringHashTableFree(&StringHash);
return 1;
}
strcpy(FuncName, (char *) CoffStringsBase + CoffEntry[i].e.e.e_offset);
}
else
{
memcpy(FuncName, CoffEntry[i].e.e_name, E_SYMNMLEN);
FuncName[E_SYMNMLEN] = '\0';
}
/* Name demangling: stdcall */
p = strrchr(FuncName, '@');
if (p != NULL)
{
*p = '\0';
}
p = ('_' == FuncName[0] || '@' == FuncName[0] ? FuncName + 1 : FuncName);
Current->FunctionOffset = FindOrAddString(&StringHash,
p,
StringsLength,
StringsBase);
Current->SourceLine = 0;
memset(++Current, 0, sizeof(*Current));
}
i += CoffEntry[i].e_numaux;
}
*SymbolsCount = (Current - *SymbolsBase + 1);
qsort(*SymbolsBase, *SymbolsCount, sizeof(ROSSYM_ENTRY), (int (*)(const void *, const void *)) CompareSymEntry);
StringHashTableFree(&StringHash);
return 0;
}
struct DbgHelpLineEntry {
ULONG vma;
ULONG fileId;
ULONG functionId;
ULONG line;
};
struct DbgHelpStringTab {
ULONG Length;
ULONG Bytes;
char ***Table;
ULONG LineEntries, CurLineEntries;
struct DbgHelpLineEntry *LineEntryData;
void *process;
DWORD module_base;
char *PathChop;
char *SourcePath;
struct DbgHelpLineEntry *lastLineEntry;
};
static struct DbgHelpLineEntry*
DbgHelpAddLineEntry(struct DbgHelpStringTab *tab)
{
if (tab->CurLineEntries == tab->LineEntries)
{
struct DbgHelpLineEntry *newEntries = realloc(tab->LineEntryData,
tab->LineEntries * 2 * sizeof(struct DbgHelpLineEntry));
if (!newEntries)
return 0;
tab->LineEntryData = newEntries;
memset(tab->LineEntryData + tab->LineEntries, 0, sizeof(struct DbgHelpLineEntry) * tab->LineEntries);
tab->LineEntries *= 2;
}
return &tab->LineEntryData[tab->CurLineEntries++];
}
static int
DbgHelpAddStringToTable(struct DbgHelpStringTab *tab, char *name)
{
unsigned int bucket = ComputeDJBHash(name) % tab->Length;
char **tabEnt = tab->Table[bucket];
int i;
char **newBucket;
if (tabEnt)
{
for (i = 0; tabEnt[i] && strcmp(tabEnt[i], name); i++);
if (tabEnt[i])
{
free(name);
return (i << 10) | bucket;
}
}
else
i = 0;
/* At this point, we need to insert */
tab->Bytes += strlen(name) + 1;
newBucket = realloc(tab->Table[bucket], (i+2) * sizeof(char *));
if (!newBucket)
{
fprintf(stderr, "realloc failed!\n");
return -1;
}
tab->Table[bucket] = newBucket;
tab->Table[bucket][i+1] = 0;
tab->Table[bucket][i] = name;
return (i << 10) | bucket;
}
const char*
DbgHelpGetString(struct DbgHelpStringTab *tab, int id)
{
int i = id >> 10;
int bucket = id & 0x3ff;
return tab->Table[bucket][i];
}
/* Remove a prefix of PathChop if it exists and return a copy of the tail. */
static char *
StrDupShortenPath(char *PathChop, char *FilePath)
{
int pclen = strlen(PathChop);
if (!strncmp(FilePath, PathChop, pclen))
{
return strdup(FilePath+pclen);
}
else
{
return strdup(FilePath);
}
}
static BOOL
DbgHelpAddLineNumber(PSRCCODEINFO LineInfo, void *UserContext)
{
struct DbgHelpStringTab *tab = (struct DbgHelpStringTab *)UserContext;
DWORD64 disp;
int fileId, functionId;
PSYMBOL_INFO pSymbol = malloc(FIELD_OFFSET(SYMBOL_INFO, Name[MAX_SYM_NAME]));
if (!pSymbol) return FALSE;
memset(pSymbol, 0, FIELD_OFFSET(SYMBOL_INFO, Name[MAX_SYM_NAME]));
/* If any file can be opened by relative path up to a certain level, then
record that path. */
if (!tab->PathChop)
{
int i, endLen;
char *end = strrchr(LineInfo->FileName, '/');
if (!end)
end = strrchr(LineInfo->FileName, '\\');
if (end)
{
for (i = (end - LineInfo->FileName) - 1; i >= 0; i--)
{
if (LineInfo->FileName[i] == '/' || LineInfo->FileName[i] == '\\')
{
char *synthname = malloc(strlen(tab->SourcePath) +
strlen(LineInfo->FileName + i + 1)
+ 2);
strcpy(synthname, tab->SourcePath);
strcat(synthname, "/");
strcat(synthname, LineInfo->FileName + i + 1);
FILE *f = fopen(synthname, "r");
free(synthname);
if (f)
{
fclose(f);
break;
}
}
}
i++; /* Be in the string or past the next slash */
tab->PathChop = malloc(i + 1);
memcpy(tab->PathChop, LineInfo->FileName, i);
tab->PathChop[i] = 0;
}
}
fileId = DbgHelpAddStringToTable(tab,
StrDupShortenPath(tab->PathChop,
LineInfo->FileName));
pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
pSymbol->MaxNameLen = MAX_SYM_NAME;
if (!SymFromAddr(tab->process, LineInfo->Address, &disp, pSymbol))
{
//fprintf(stderr, "SymFromAddr failed.\n");
free(pSymbol);
return FALSE;
}
functionId = DbgHelpAddStringToTable(tab, strdup(pSymbol->Name));
if (LineInfo->Address == 0)
fprintf(stderr, "Address is 0.\n");
tab->lastLineEntry = DbgHelpAddLineEntry(tab);
tab->lastLineEntry->vma = LineInfo->Address - LineInfo->ModBase;
tab->lastLineEntry->functionId = functionId;
tab->lastLineEntry->fileId = fileId;
tab->lastLineEntry->line = LineInfo->LineNumber;
free(pSymbol);
return TRUE;
}
static int
ConvertDbgHelp(void *process, DWORD module_base, char *SourcePath,
ULONG *SymbolsCount, PROSSYM_ENTRY *SymbolsBase,
ULONG *StringsLength, void **StringsBase)
{
char *strings, *strings_copy;
int i, j, bucket, entry;
PROSSYM_ENTRY rossym;
struct DbgHelpStringTab strtab = { 0 };
strtab.process = process;
strtab.module_base = module_base;
strtab.Bytes = 1;
strtab.Length = 1024;
strtab.Table = calloc(1024, sizeof(const char **));
strtab.Table[0] = calloc(2, sizeof(const char *));
strtab.Table[0][0] = strdup(""); // The zero string
strtab.CurLineEntries = 0;
strtab.LineEntries = 16384;
strtab.LineEntryData = calloc(strtab.LineEntries, sizeof(struct DbgHelpLineEntry));
strtab.PathChop = NULL;
strtab.SourcePath = SourcePath ? SourcePath : "";
SymEnumLines(process, module_base, NULL, NULL, DbgHelpAddLineNumber, &strtab);
/* Transcribe necessary strings */
*StringsLength = strtab.Bytes;
strings = strings_copy = ((char *)(*StringsBase = malloc(strtab.Bytes)));
/* Copy in strings */
for (i = 0; i < strtab.Length; i++)
{
for (j = 0; strtab.Table[i] && strtab.Table[i][j]; j++)
{
/* Each entry is replaced by its corresponding entry in our string
section. We can substract the strings origin to get an offset. */
char *toFree = strtab.Table[i][j];
strtab.Table[i][j] = strcpy(strings_copy, strtab.Table[i][j]);
free(toFree);
strings_copy += strlen(strings_copy) + 1;
}
}
assert(strings_copy == strings + strtab.Bytes);
*SymbolsBase = calloc(strtab.CurLineEntries, sizeof(ROSSYM_ENTRY));
*SymbolsCount = strtab.CurLineEntries;
/* Copy symbols into rossym entries */
for (i = 0; i < strtab.CurLineEntries; i++)
{
rossym = &(*SymbolsBase)[i];
rossym->Address = strtab.LineEntryData[i].vma;
bucket = strtab.LineEntryData[i].fileId & 0x3ff;
entry = strtab.LineEntryData[i].fileId >> 10;
rossym->FileOffset = strtab.Table[bucket][entry] - strings;
bucket = strtab.LineEntryData[i].functionId & 0x3ff;
entry = strtab.LineEntryData[i].functionId >> 10;
rossym->FunctionOffset = strtab.Table[bucket][entry] - strings;
rossym->SourceLine = strtab.LineEntryData[i].line;
}
/* Free stringtab */
for (i = 0; i < strtab.Length; i++)
{
free(strtab.Table[i]);
}
free(strtab.LineEntryData);
free(strtab.PathChop);
qsort(*SymbolsBase, *SymbolsCount, sizeof(ROSSYM_ENTRY), (int (*)(const void *, const void *))CompareSymEntry);
return 0;
}
static int
MergeStabsAndCoffs(ULONG *MergedSymbolCount, PROSSYM_ENTRY *MergedSymbols,
ULONG StabSymbolsCount, PROSSYM_ENTRY StabSymbols,
ULONG CoffSymbolsCount, PROSSYM_ENTRY CoffSymbols)
{
ULONG StabIndex, j;
ULONG CoffIndex;
ULONG_PTR StabFunctionStartAddress;
ULONG StabFunctionStringOffset, NewStabFunctionStringOffset, CoffFunctionStringOffset;
PROSSYM_ENTRY CoffFunctionSymbol;
*MergedSymbolCount = 0;
if (StabSymbolsCount == 0)
{
*MergedSymbols = NULL;
return 0;
}
*MergedSymbols = malloc((StabSymbolsCount + CoffSymbolsCount) * sizeof(ROSSYM_ENTRY));
if (*MergedSymbols == NULL)
{
fprintf(stderr, "Unable to allocate memory for merged symbols\n");
return 1;
}
StabFunctionStartAddress = 0;
StabFunctionStringOffset = 0;
CoffFunctionStringOffset = 0;
CoffFunctionSymbol = NULL;
CoffIndex = 0;
for (StabIndex = 0; StabIndex < StabSymbolsCount; StabIndex++)
{
(*MergedSymbols)[*MergedSymbolCount] = StabSymbols[StabIndex];
for (j = StabIndex + 1;
j < StabSymbolsCount && StabSymbols[j].Address == StabSymbols[StabIndex].Address;
j++)
{
if (StabSymbols[j].FileOffset != 0 && (*MergedSymbols)[*MergedSymbolCount].FileOffset == 0)
{
(*MergedSymbols)[*MergedSymbolCount].FileOffset = StabSymbols[j].FileOffset;
}
if (StabSymbols[j].FunctionOffset != 0 && (*MergedSymbols)[*MergedSymbolCount].FunctionOffset == 0)
{
(*MergedSymbols)[*MergedSymbolCount].FunctionOffset = StabSymbols[j].FunctionOffset;
}
if (StabSymbols[j].SourceLine != 0 && (*MergedSymbols)[*MergedSymbolCount].SourceLine == 0)
{
(*MergedSymbols)[*MergedSymbolCount].SourceLine = StabSymbols[j].SourceLine;
}
}
StabIndex = j - 1;
while (CoffIndex < CoffSymbolsCount &&
CoffSymbols[CoffIndex].Address <= (*MergedSymbols)[*MergedSymbolCount].Address)
{
if (CoffSymbols[CoffIndex].FunctionOffset != 0)
{
CoffFunctionSymbol = &CoffSymbols[CoffIndex];
CoffFunctionStringOffset = CoffFunctionSymbol->FunctionOffset;
}
CoffIndex++;
}
NewStabFunctionStringOffset = (*MergedSymbols)[*MergedSymbolCount].FunctionOffset;
if (CoffFunctionSymbol &&
CoffFunctionSymbol->Address <= (*MergedSymbols)[*MergedSymbolCount].Address &&
StabFunctionStartAddress < CoffFunctionSymbol->Address)
{
(*MergedSymbols)[*MergedSymbolCount].FunctionOffset = CoffFunctionStringOffset;
CoffFunctionSymbol->FunctionOffset = 0;
}
if (StabFunctionStringOffset != NewStabFunctionStringOffset)
{
StabFunctionStartAddress = (*MergedSymbols)[*MergedSymbolCount].Address;
}
StabFunctionStringOffset = NewStabFunctionStringOffset;
(*MergedSymbolCount)++;
}
/* Handle functions that have no analog in the upstream data */
for (CoffIndex = 0; CoffIndex < CoffSymbolsCount; CoffIndex++)
{
if (CoffSymbols[CoffIndex].Address &&
CoffSymbols[CoffIndex].FunctionOffset)
{
(*MergedSymbols)[*MergedSymbolCount] = CoffSymbols[CoffIndex];
(*MergedSymbolCount)++;
}
}
qsort(*MergedSymbols, *MergedSymbolCount, sizeof(ROSSYM_ENTRY), (int (*)(const void *, const void *)) CompareSymEntry);
return 0;
}
static PIMAGE_SECTION_HEADER
FindSectionForRVA(DWORD RVA, unsigned NumberOfSections, PIMAGE_SECTION_HEADER SectionHeaders)
{
unsigned Section;
for (Section = 0; Section < NumberOfSections; Section++)
{
if (SectionHeaders[Section].VirtualAddress <= RVA &&
RVA < SectionHeaders[Section].VirtualAddress + SectionHeaders[Section].Misc.VirtualSize)
{
return SectionHeaders + Section;
}
}
return NULL;
}
static int
ProcessRelocations(ULONG *ProcessedRelocsLength, void **ProcessedRelocs,
void *RawData, PIMAGE_OPTIONAL_HEADER OptHeader,
unsigned NumberOfSections, PIMAGE_SECTION_HEADER SectionHeaders)
{
PIMAGE_SECTION_HEADER RelocSectionHeader, TargetSectionHeader;
PIMAGE_BASE_RELOCATION BaseReloc, End, AcceptedRelocs;
int Found;
if (OptHeader->NumberOfRvaAndSizes < IMAGE_DIRECTORY_ENTRY_BASERELOC ||
OptHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress == 0)
{
/* No relocation entries */
*ProcessedRelocsLength = 0;
*ProcessedRelocs = NULL;
return 0;
}
RelocSectionHeader = FindSectionForRVA(OptHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress,
NumberOfSections, SectionHeaders);
if (RelocSectionHeader == NULL)
{
fprintf(stderr, "Can't find section header for relocation data\n");
return 1;
}
*ProcessedRelocs = malloc(RelocSectionHeader->SizeOfRawData);
if (*ProcessedRelocs == NULL)
{
fprintf(stderr,
"Failed to allocate %u bytes for relocations\n",
(unsigned int)RelocSectionHeader->SizeOfRawData);
return 1;
}
*ProcessedRelocsLength = 0;
BaseReloc = (PIMAGE_BASE_RELOCATION) ((char *) RawData +
RelocSectionHeader->PointerToRawData +
(OptHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress -
RelocSectionHeader->VirtualAddress));
End = (PIMAGE_BASE_RELOCATION) ((char *) BaseReloc +
OptHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size);
while (BaseReloc < End && BaseReloc->SizeOfBlock > 0)
{
TargetSectionHeader = FindSectionForRVA(BaseReloc->VirtualAddress,
NumberOfSections,
SectionHeaders);
if (TargetSectionHeader != NULL)
{
AcceptedRelocs = *ProcessedRelocs;
Found = 0;
while (AcceptedRelocs < (PIMAGE_BASE_RELOCATION) ((char *) *ProcessedRelocs +
*ProcessedRelocsLength)
&& !Found)
{
Found = BaseReloc->SizeOfBlock == AcceptedRelocs->SizeOfBlock &&
memcmp(BaseReloc, AcceptedRelocs, AcceptedRelocs->SizeOfBlock) == 0;
AcceptedRelocs = (PIMAGE_BASE_RELOCATION) ((char *) AcceptedRelocs +
AcceptedRelocs->SizeOfBlock);
}
if (!Found)
{
memcpy((char *) *ProcessedRelocs + *ProcessedRelocsLength,
BaseReloc,
BaseReloc->SizeOfBlock);
*ProcessedRelocsLength += BaseReloc->SizeOfBlock;
}
}
BaseReloc = (PIMAGE_BASE_RELOCATION)((char *) BaseReloc + BaseReloc->SizeOfBlock);
}
return 0;
}
static const BYTE*
GetSectionName(void *StringsBase, const BYTE *SectionTitle)
{
if (SectionTitle[0] == '/')
{
int offset = atoi((char*)SectionTitle+1);
return ((BYTE *)StringsBase) + offset;
}
else
return SectionTitle;
}
static int
CreateOutputFile(FILE *OutFile, void *InData,
PIMAGE_DOS_HEADER InDosHeader, PIMAGE_FILE_HEADER InFileHeader,
PIMAGE_OPTIONAL_HEADER InOptHeader, PIMAGE_SECTION_HEADER InSectionHeaders,
ULONG RosSymLength, void *RosSymSection)
{
ULONG StartOfRawData;
unsigned Section;
void *OutHeader, *ProcessedRelocs, *PaddedRosSym, *Data;
unsigned char *PaddedStringTable;
PIMAGE_DOS_HEADER OutDosHeader;
PIMAGE_FILE_HEADER OutFileHeader;
PIMAGE_OPTIONAL_HEADER OutOptHeader;
PIMAGE_SECTION_HEADER OutSectionHeaders, CurrentSectionHeader;
DWORD CheckSum;
ULONG Length, i;
ULONG ProcessedRelocsLength;
ULONG RosSymOffset, RosSymFileLength;
ULONG PaddedStringTableLength;
int InRelocSectionIndex;
PIMAGE_SECTION_HEADER OutRelocSection;
/* Each coff symbol is 18 bytes and the string table follows */
char *StringTable = (char *)InData +
InFileHeader->PointerToSymbolTable + 18 * InFileHeader->NumberOfSymbols;
ULONG StringTableLength = 0;
ULONG StringTableLocation;
StartOfRawData = 0;
for (Section = 0; Section < InFileHeader->NumberOfSections; Section++)
{
const BYTE *SectionName = GetSectionName(StringTable,
InSectionHeaders[Section].Name);
if (InSectionHeaders[Section].Name[0] == '/')
{
StringTableLength = atoi((const char *)InSectionHeaders[Section].Name + 1) +
strlen((const char *)SectionName) + 1;
}
if ((StartOfRawData == 0 || InSectionHeaders[Section].PointerToRawData < StartOfRawData)
&& InSectionHeaders[Section].PointerToRawData != 0
&& (strncmp((char *) SectionName, ".stab", 5)) != 0
&& (strncmp((char *) SectionName, ".debug_", 7)) != 0)
{
StartOfRawData = InSectionHeaders[Section].PointerToRawData;
}
}
OutHeader = malloc(StartOfRawData);
if (OutHeader == NULL)
{
fprintf(stderr,
"Failed to allocate %u bytes for output file header\n",
(unsigned int)StartOfRawData);
return 1;
}
memset(OutHeader, '\0', StartOfRawData);
OutDosHeader = (PIMAGE_DOS_HEADER) OutHeader;
memcpy(OutDosHeader, InDosHeader, InDosHeader->e_lfanew + sizeof(ULONG));
OutFileHeader = (PIMAGE_FILE_HEADER)((char *) OutHeader + OutDosHeader->e_lfanew + sizeof(ULONG));
memcpy(OutFileHeader, InFileHeader, sizeof(IMAGE_FILE_HEADER));
OutFileHeader->PointerToSymbolTable = 0;
OutFileHeader->NumberOfSymbols = 0;
OutFileHeader->Characteristics &= ~(IMAGE_FILE_LINE_NUMS_STRIPPED | IMAGE_FILE_LOCAL_SYMS_STRIPPED |
IMAGE_FILE_DEBUG_STRIPPED);
OutOptHeader = (PIMAGE_OPTIONAL_HEADER)(OutFileHeader + 1);
memcpy(OutOptHeader, InOptHeader, sizeof(IMAGE_OPTIONAL_HEADER));
OutOptHeader->CheckSum = 0;
OutSectionHeaders = (PIMAGE_SECTION_HEADER)((char *) OutOptHeader + OutFileHeader->SizeOfOptionalHeader);
if (ProcessRelocations(&ProcessedRelocsLength,
&ProcessedRelocs,
InData,
InOptHeader,
InFileHeader->NumberOfSections,
InSectionHeaders))
{
return 1;
}
if (InOptHeader->NumberOfRvaAndSizes < IMAGE_DIRECTORY_ENTRY_BASERELOC ||
InOptHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress == 0)
{
InRelocSectionIndex = -1;
}
else
{
InRelocSectionIndex = FindSectionForRVA(InOptHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress,
InFileHeader->NumberOfSections, InSectionHeaders) - InSectionHeaders;
}
OutFileHeader->NumberOfSections = 0;
CurrentSectionHeader = OutSectionHeaders;
OutOptHeader->SizeOfImage = 0;
RosSymOffset = 0;
OutRelocSection = NULL;
StringTableLocation = StartOfRawData;
for (Section = 0; Section < InFileHeader->NumberOfSections; Section++)
{
const BYTE *SectionName = GetSectionName(StringTable,
InSectionHeaders[Section].Name);
if ((strncmp((char *) SectionName, ".stab", 5) != 0) &&
(strncmp((char *) SectionName, ".debug_", 7)) != 0)
{
*CurrentSectionHeader = InSectionHeaders[Section];
CurrentSectionHeader->PointerToLinenumbers = 0;
CurrentSectionHeader->NumberOfLinenumbers = 0;
if (OutOptHeader->SizeOfImage < CurrentSectionHeader->VirtualAddress +
CurrentSectionHeader->Misc.VirtualSize)
{
OutOptHeader->SizeOfImage = ROUND_UP(CurrentSectionHeader->VirtualAddress +
CurrentSectionHeader->Misc.VirtualSize,
OutOptHeader->SectionAlignment);
}
if (RosSymOffset < CurrentSectionHeader->PointerToRawData + CurrentSectionHeader->SizeOfRawData)
{
RosSymOffset = CurrentSectionHeader->PointerToRawData + CurrentSectionHeader->SizeOfRawData;
}
if (Section == (ULONG)InRelocSectionIndex)
{
OutRelocSection = CurrentSectionHeader;
}
StringTableLocation = CurrentSectionHeader->PointerToRawData + CurrentSectionHeader->SizeOfRawData;
OutFileHeader->NumberOfSections++;
CurrentSectionHeader++;
}
}
if (OutRelocSection == CurrentSectionHeader - 1)
{
OutOptHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size = ProcessedRelocsLength;
if (OutOptHeader->SizeOfImage == OutRelocSection->VirtualAddress +
ROUND_UP(OutRelocSection->Misc.VirtualSize,
OutOptHeader->SectionAlignment))
{
OutOptHeader->SizeOfImage = OutRelocSection->VirtualAddress +
ROUND_UP(ProcessedRelocsLength,
OutOptHeader->SectionAlignment);
}
OutRelocSection->Misc.VirtualSize = ProcessedRelocsLength;
if (RosSymOffset == OutRelocSection->PointerToRawData +
OutRelocSection->SizeOfRawData)
{
RosSymOffset = OutRelocSection->PointerToRawData +
ROUND_UP(ProcessedRelocsLength,
OutOptHeader->FileAlignment);
}
OutRelocSection->SizeOfRawData = ROUND_UP(ProcessedRelocsLength,
OutOptHeader->FileAlignment);
}
if (RosSymLength > 0)
{
RosSymFileLength = ROUND_UP(RosSymLength, OutOptHeader->FileAlignment);
memcpy(CurrentSectionHeader->Name, ".rossym", 8); /* We're lucky: string is exactly 8 bytes long */
CurrentSectionHeader->Misc.VirtualSize = RosSymLength;
CurrentSectionHeader->VirtualAddress = OutOptHeader->SizeOfImage;
CurrentSectionHeader->SizeOfRawData = RosSymFileLength;
CurrentSectionHeader->PointerToRawData = RosSymOffset;
CurrentSectionHeader->PointerToRelocations = 0;
CurrentSectionHeader->PointerToLinenumbers = 0;
CurrentSectionHeader->NumberOfRelocations = 0;
CurrentSectionHeader->NumberOfLinenumbers = 0;
CurrentSectionHeader->Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_LNK_REMOVE | IMAGE_SCN_TYPE_NOLOAD;
OutOptHeader->SizeOfImage = ROUND_UP(CurrentSectionHeader->VirtualAddress + CurrentSectionHeader->Misc.VirtualSize,
OutOptHeader->SectionAlignment);
OutFileHeader->NumberOfSections++;
PaddedRosSym = malloc(RosSymFileLength);
if (PaddedRosSym == NULL)
{
fprintf(stderr,
"Failed to allocate %u bytes for padded .rossym\n",
(unsigned int)RosSymFileLength);
return 1;
}
memcpy(PaddedRosSym, RosSymSection, RosSymLength);
memset((char *) PaddedRosSym + RosSymLength,
'\0',
RosSymFileLength - RosSymLength);
/* Position the string table after our new section */
StringTableLocation = RosSymOffset + RosSymFileLength;
}
else
{
PaddedRosSym = NULL;
}
/* Set the string table area in the header if we need it */
if (StringTableLength)
{
OutFileHeader->PointerToSymbolTable = StringTableLocation;
OutFileHeader->NumberOfSymbols = 0;
}
CheckSum = 0;
for (i = 0; i < StartOfRawData / 2; i++)
{
CheckSum += ((unsigned short*) OutHeader)[i];
CheckSum = 0xffff & (CheckSum + (CheckSum >> 16));
}
Length = StartOfRawData;
for (Section = 0; Section < OutFileHeader->NumberOfSections; Section++)
{
DWORD SizeOfRawData;
if (OutRelocSection == OutSectionHeaders + Section)
{
Data = (void *) ProcessedRelocs;
SizeOfRawData = ProcessedRelocsLength;
}
else if (RosSymLength > 0 && Section + 1 == OutFileHeader->NumberOfSections)
{
Data = (void *) PaddedRosSym;
SizeOfRawData = OutSectionHeaders[Section].SizeOfRawData;
}
else
{
Data = (void *) ((char *) InData + OutSectionHeaders[Section].PointerToRawData);
SizeOfRawData = OutSectionHeaders[Section].SizeOfRawData;
}
for (i = 0; i < SizeOfRawData / 2; i++)
{
CheckSum += ((unsigned short*) Data)[i];
CheckSum = 0xffff & (CheckSum + (CheckSum >> 16));
}
Length += OutSectionHeaders[Section].SizeOfRawData;
}
if (OutFileHeader->PointerToSymbolTable)
{
int PaddingFrom = (OutFileHeader->PointerToSymbolTable + StringTableLength) %
OutOptHeader->FileAlignment;
int PaddingSize = PaddingFrom ? OutOptHeader->FileAlignment - PaddingFrom : 0;
PaddedStringTableLength = StringTableLength + PaddingSize;
PaddedStringTable = malloc(PaddedStringTableLength);
/* COFF string section is preceeded by a length */
assert(sizeof(StringTableLength) == 4);
memcpy(PaddedStringTable, &StringTableLength, sizeof(StringTableLength));
/* We just copy enough of the string table to contain the strings we want
The string table length technically counts as part of the string table
space itself. */
memcpy(PaddedStringTable + 4, StringTable + 4, StringTableLength - 4);
memset(PaddedStringTable + StringTableLength, 0, PaddingSize);
assert(OutFileHeader->PointerToSymbolTable % 2 == 0);
for (i = 0; i < PaddedStringTableLength / 2; i++)
{
CheckSum += ((unsigned short*)PaddedStringTable)[i];
CheckSum = 0xffff & (CheckSum + (CheckSum >> 16));
}
Length += PaddedStringTableLength;
}
else
{
PaddedStringTable = NULL;
}
CheckSum += Length;
OutOptHeader->CheckSum = CheckSum;
if (fwrite(OutHeader, 1, StartOfRawData, OutFile) != StartOfRawData)
{
perror("Error writing output header\n");
free(OutHeader);
return 1;
}
for (Section = 0; Section < OutFileHeader->NumberOfSections; Section++)
{
if (OutSectionHeaders[Section].SizeOfRawData != 0)
{
DWORD SizeOfRawData;
fseek(OutFile, OutSectionHeaders[Section].PointerToRawData, SEEK_SET);
if (OutRelocSection == OutSectionHeaders + Section)
{
Data = (void *) ProcessedRelocs;
SizeOfRawData = ProcessedRelocsLength;
}
else if (RosSymLength > 0 && Section + 1 == OutFileHeader->NumberOfSections)
{
Data = (void *) PaddedRosSym;
SizeOfRawData = OutSectionHeaders[Section].SizeOfRawData;
}
else
{
Data = (void *) ((char *) InData + OutSectionHeaders[Section].PointerToRawData);
SizeOfRawData = OutSectionHeaders[Section].SizeOfRawData;
}
if (fwrite(Data, 1, SizeOfRawData, OutFile) != SizeOfRawData)
{
perror("Error writing section data\n");
free(PaddedRosSym);
free(OutHeader);
return 1;
}
}
}
if (PaddedStringTable)
{
fseek(OutFile, OutFileHeader->PointerToSymbolTable, SEEK_SET);
fwrite(PaddedStringTable, 1, PaddedStringTableLength, OutFile);
free(PaddedStringTable);
}
if (PaddedRosSym)
{
free(PaddedRosSym);
}
free(OutHeader);
return 0;
}
int main(int argc, char* argv[])
{
PSYMBOLFILE_HEADER SymbolFileHeader;
PIMAGE_DOS_HEADER PEDosHeader;
PIMAGE_FILE_HEADER PEFileHeader;
PIMAGE_OPTIONAL_HEADER PEOptHeader;
PIMAGE_SECTION_HEADER PESectionHeaders;
ULONG ImageBase;
void *StabBase;
ULONG StabsLength;
void *StabStringBase;
ULONG StabStringsLength;
void *CoffBase = NULL;
ULONG CoffsLength;
void *CoffStringBase = NULL;
ULONG CoffStringsLength;
char* path1;
char* path2;
FILE* out;
void *StringBase = NULL;
ULONG StringsLength = 0;
ULONG StabSymbolsCount = 0;
PROSSYM_ENTRY StabSymbols = NULL;
ULONG CoffSymbolsCount = 0;
PROSSYM_ENTRY CoffSymbols = NULL;
ULONG MergedSymbolsCount = 0;
PROSSYM_ENTRY MergedSymbols = NULL;
size_t FileSize;
void *FileData;
ULONG RosSymLength;
void *RosSymSection;
DWORD module_base;
void *file;
char elfhdr[4] = { '\177', 'E', 'L', 'F' };
BOOLEAN UseDbgHelp = FALSE;
int arg, argstate = 0;
char *SourcePath = NULL;
for (arg = 1; arg < argc; arg++)
{
switch (argstate)
{
default:
argstate = -1;
break;
case 0:
if (!strcmp(argv[arg], "-s"))
{
argstate = 1;
}
else
{
argstate = 2;
path1 = convert_path(argv[arg]);
}
break;
case 1:
free(SourcePath);
SourcePath = strdup(argv[arg]);
argstate = 0;
break;
case 2:
path2 = convert_path(argv[arg]);
argstate = 3;
break;
}
}
if (argstate != 3)
{
fprintf(stderr, "Usage: rsym [-s <sources>] <input> <output>\n");
exit(1);
}
FileData = load_file(path1, &FileSize);
if (!FileData)
{
fprintf(stderr, "An error occured loading '%s'\n", path1);
exit(1);
}
file = fopen(path1, "rb");
/* Check if MZ header exists */
PEDosHeader = (PIMAGE_DOS_HEADER) FileData;
if (PEDosHeader->e_magic != IMAGE_DOS_MAGIC ||
PEDosHeader->e_lfanew == 0L)
{
/* Ignore elf */
if (!memcmp(PEDosHeader, elfhdr, sizeof(elfhdr)))
exit(0);
perror("Input file is not a PE image.\n");
free(FileData);
exit(1);
}
/* Locate PE file header */
/* sizeof(ULONG) = sizeof(MAGIC) */
PEFileHeader = (PIMAGE_FILE_HEADER)((char *) FileData + PEDosHeader->e_lfanew + sizeof(ULONG));
/* Locate optional header */
assert(sizeof(ULONG) == 4);
PEOptHeader = (PIMAGE_OPTIONAL_HEADER)(PEFileHeader + 1);
ImageBase = PEOptHeader->ImageBase;
/* Locate PE section headers */
PESectionHeaders = (PIMAGE_SECTION_HEADER)((char *) PEOptHeader + PEFileHeader->SizeOfOptionalHeader);
if (GetStabInfo(FileData,
PEFileHeader,
PESectionHeaders,
&StabsLength,
&StabBase,
&StabStringsLength,
&StabStringBase))
{
free(FileData);
exit(1);
}
if (StabsLength == 0)
{
// SYMOPT_AUTO_PUBLICS
// SYMOPT_FAVOR_COMPRESSED
// SYMOPT_LOAD_ANYTHING
// SYMOPT_LOAD_LINES
SymSetOptions(0x10000 | 0x800000 | 0x40 | 0x10);
SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, TRUE);
SymInitialize(FileData, ".", 0);
module_base = SymLoadModule(FileData, file, path1, path1, 0, FileSize) & 0xffffffff;
if (ConvertDbgHelp(FileData,
module_base,
SourcePath,
&StabSymbolsCount,
&StabSymbols,
&StringsLength,
&StringBase))
{
free(FileData);
exit(1);
}
UseDbgHelp = TRUE;
SymUnloadModule(FileData, module_base);
SymCleanup(FileData);
}
if (GetCoffInfo(FileData,
PEFileHeader,
PESectionHeaders,
&CoffsLength,
&CoffBase,
&CoffStringsLength,
&CoffStringBase))
{
free(FileData);
exit(1);
}
if (!UseDbgHelp)
{
StringBase = malloc(1 + StringsLength + CoffStringsLength +
(CoffsLength / sizeof(ROSSYM_ENTRY)) * (E_SYMNMLEN + 1));
if (StringBase == NULL)
{
free(FileData);
fprintf(stderr, "Failed to allocate memory for strings table\n");
exit(1);
}
/* Make offset 0 into an empty string */
*((char *) StringBase) = '\0';
StringsLength = 1;
if (ConvertStabs(&StabSymbolsCount,
&StabSymbols,
&StringsLength,
StringBase,
StabsLength,
StabBase,
StabStringsLength,
StabStringBase,
ImageBase,
PEFileHeader,
PESectionHeaders))
{
free(StringBase);
free(FileData);
fprintf(stderr, "Failed to allocate memory for strings table\n");
exit(1);
}
}
else
{
StringBase = realloc(StringBase, StringsLength + CoffStringsLength);
if (!StringBase)
{
free(FileData);
fprintf(stderr, "Failed to allocate memory for strings table\n");
exit(1);
}
}
if (ConvertCoffs(&CoffSymbolsCount,
&CoffSymbols,
&StringsLength,
StringBase,
CoffsLength,
CoffBase,
CoffStringsLength,
CoffStringBase,
ImageBase,
PEFileHeader,
PESectionHeaders))
{
if (StabSymbols)
{
free(StabSymbols);
}
free(StringBase);
free(FileData);
exit(1);
}
if (MergeStabsAndCoffs(&MergedSymbolsCount,
&MergedSymbols,
StabSymbolsCount,
StabSymbols,
CoffSymbolsCount,
CoffSymbols))
{
if (CoffSymbols)
{
free(CoffSymbols);
}
if (StabSymbols)
{
free(StabSymbols);
}
free(StringBase);
free(FileData);
exit(1);
}
if (CoffSymbols)
{
free(CoffSymbols);
}
if (StabSymbols)
{
free(StabSymbols);
}
if (MergedSymbolsCount == 0)
{
RosSymLength = 0;
RosSymSection = NULL;
}
else
{
RosSymLength = sizeof(SYMBOLFILE_HEADER) +
MergedSymbolsCount * sizeof(ROSSYM_ENTRY) +
StringsLength;
RosSymSection = malloc(RosSymLength);
if (RosSymSection == NULL)
{
free(MergedSymbols);
free(StringBase);
free(FileData);
fprintf(stderr, "Unable to allocate memory for .rossym section\n");
exit(1);
}
memset(RosSymSection, '\0', RosSymLength);
SymbolFileHeader = (PSYMBOLFILE_HEADER)RosSymSection;
SymbolFileHeader->SymbolsOffset = sizeof(SYMBOLFILE_HEADER);
SymbolFileHeader->SymbolsLength = MergedSymbolsCount * sizeof(ROSSYM_ENTRY);
SymbolFileHeader->StringsOffset = SymbolFileHeader->SymbolsOffset +
SymbolFileHeader->SymbolsLength;
SymbolFileHeader->StringsLength = StringsLength;
memcpy((char *) RosSymSection + SymbolFileHeader->SymbolsOffset,
MergedSymbols,
SymbolFileHeader->SymbolsLength);
memcpy((char *) RosSymSection + SymbolFileHeader->StringsOffset,
StringBase,
SymbolFileHeader->StringsLength);
free(MergedSymbols);
}
free(StringBase);
out = fopen(path2, "wb");
if (out == NULL)
{
perror("Cannot open output file");
free(RosSymSection);
free(FileData);
exit(1);
}
if (CreateOutputFile(out,
FileData,
PEDosHeader,
PEFileHeader,
PEOptHeader,
PESectionHeaders,
RosSymLength,
RosSymSection))
{
fclose(out);
if (RosSymSection)
{
free(RosSymSection);
}
free(FileData);
exit(1);
}
fclose(out);
if (RosSymSection)
{
free(RosSymSection);
}
free(FileData);
return 0;
}
/* EOF */