bool ObjIeeeAscii::ExternalSymbol(const char *buffer, eParseType ParseType)
{
if (!file)
ThrowSyntax(buffer, ParseType);
int index = 0;
ObjString name = GetSymbolName(buffer, &index);
ObjSymbol *sym = factory->MakeExternalSymbol(name, index);
PutSymbol(externals, index, sym);
return false;
}
bool ObjIeeeAscii::LocalSymbol(const char *buffer, eParseType ParseType)
{
if (!file)
ThrowSyntax(buffer, ParseType);
int index = 0;
ObjString name = GetSymbolName(buffer, &index);
ObjSymbol *sym = factory->MakeLocalSymbol(name, index);
PutSymbol(locals, index, sym);
sym->SetSourceFile(GetFile(0));
return false;
}
RVALUE FindWatSymbol( address *addr, syminfo *si, int getsrcinfo )
{
DWORD symoff;
DWORD line;
BOOL ret;
if( !GetSymbolName( addr, si->name, &symoff ) ) {
return( NOT_FOUND );
}
si->symoff = symoff;
if( getsrcinfo ) {
ret = GetLineNum( addr, si->filename, MAX_FILE_NAME, &line );
if( !ret ) return( NOT_FOUND );
si->linenum = line;
}
return( FOUND );
}
/******************************************************************************
* Function Name: AddBindingSymbol
*
* Inputs :
* Outputs :
* Returns :
* Globals Used : -
*
* Description : Add a binding symbol entry
*****************************************************************************/
static GLSLBindingSymbol *AddBindingSymbol(GLSLCompilerPrivateData *psCPD,
GLSLUniFlexContext *psUFContext,
HWSYMBOL *psHWSymbol,
GLSLIdentifierData *psIdentifierData,
GLSLBindingSymbolList *psBindingSymbolList)
{
GLSLBindingSymbol *psBindingSymbol = IMG_NULL;
IMG_CHAR *pszName;
IMG_BYTE *pbyConstantData = psIdentifierData->pvConstantData;
/* Get a symbol entry */
if(psBindingSymbolList->uNumBindings == psBindingSymbolList->uMaxBindingEntries)
{
IMG_UINT32 uNewEntries = psBindingSymbolList->uMaxBindingEntries + 32;
psBindingSymbolList->psBindingSymbolEntries = DebugMemRealloc(psBindingSymbolList->psBindingSymbolEntries,
uNewEntries * sizeof(GLSLBindingSymbol));
if(psBindingSymbolList->psBindingSymbolEntries == IMG_NULL)
{
LOG_INTERNAL_ERROR(("AddTopLevelBindingSymbols: Failed to extend the active symbol list \n"));
return IMG_NULL;
}
psBindingSymbolList->uMaxBindingEntries = uNewEntries;
}
psBindingSymbol = &psBindingSymbolList->psBindingSymbolEntries[psBindingSymbolList->uNumBindings];
psBindingSymbolList->uNumBindings++;
/* Work out the name and fill in */
pszName = (IMG_CHAR *)GetSymbolName(psUFContext->psSymbolTable, psHWSymbol->uSymbolId);
psBindingSymbol->pszName = DebugMemAlloc(strlen(pszName) + 1);
if(psBindingSymbol->pszName == IMG_NULL)
{
LOG_INTERNAL_ERROR(("AddTopLevelBindingSymbols: Failed to allocate memory for a symbol name \n"));
return IMG_NULL;
}
strcpy(psBindingSymbol->pszName, pszName);
/* Fill in other information of the binding symbol */
ProcessBindingSymbolEntry(psCPD, psUFContext, psHWSymbol, &pbyConstantData, psIdentifierData, psBindingSymbol, psBindingSymbolList);
return psBindingSymbol;
}
bool ObjIeeeAscii::AutoSymbol(const char *buffer, eParseType ParseType)
{
if (!file)
ThrowSyntax(buffer, ParseType);
int index = 0;
ObjString name = GetSymbolName(buffer, &index);
ObjSymbol *sym = GetSymbol(autos,index);
// autos can be forward declared in function type declarations
if (sym)
{
sym->SetName(name);
}
else
{
sym = factory->MakeAutoSymbol(name, index);
PutSymbol(autos, index, sym);
}
return false;
}
void COMF2ASM::MakeExternalSymbolsTable() {
// Make symbol table and string table entries for external symbols
uint32 iextsym; // External symbol index
uint32 isymo; // Symbol index in disassembler
uint32 NumExtSym = SymbolNameOffset.GetNumEntries(); // Number of external symbols
ExtdefTranslation.SetNum(NumExtSym+1); // Allocate space in symbol index translation table
// Loop through external symbol names
for (iextsym = 1; iextsym < NumExtSym; iextsym++) {
// Get name
const char * Name = GetSymbolName(iextsym);
// Define symbol
isymo = Disasm.AddSymbol(0, 0, 0, 0, 0x20, 0, Name);
// Update table for translating old EXTDEF number to disassembler symbol index
ExtdefTranslation[iextsym] = isymo;
}
}
void CCOFF::PublicNames(CMemoryBuffer * Strings, CSList<SStringEntry> * Index, int m) {
// Make list of public names in object file
// Strings will receive ASCIIZ strings
// Index will receive records of type SStringEntry with Member = m
// Interpret header:
ParseFile();
int isym = 0; // current symbol table entry
union { // Pointer to symbol table
SCOFF_SymTableEntry * p; // Normal pointer
int8 * b; // Used for address calculation
} Symtab;
// Loop through symbol table
Symtab.p = SymbolTable;
while (isym < NumberOfSymbols) {
// Check within buffer
if (Symtab.b >= Buf() + DataSize) {
err.submit(2040);
break;
}
// Search for public symbol
if (Symtab.p->s.SectionNumber > 0 && Symtab.p->s.StorageClass == COFF_CLASS_EXTERNAL) {
// Public symbol found
SStringEntry se;
se.Member = m;
// Store name
se.String = Strings->PushString(GetSymbolName(Symtab.p->s.Name));
// Store name index
Index->Push(se);
}
if ((int8)Symtab.p->s.NumAuxSymbols < 0) Symtab.p->s.NumAuxSymbols = 0;
// Increment point
isym += Symtab.p->s.NumAuxSymbols + 1;
Symtab.b += (1 + Symtab.p->s.NumAuxSymbols) * SIZE_SCOFF_SymTableEntry;
}
}
/** Perform shell-like macro path expansion. */
void ExpandPath(char **path) {
char *name;
char *value;
int x;
Assert(path);
for(x = 0; (*path)[x]; x++) {
if((*path)[x] == '$') {
name = GetSymbolName(*path + x + 1);
value = getenv(name);
ReplaceSymbol(path, name, value);
Release(name);
if(value) {
x += strlen(value) - 1;
}
}
}
}
std::string NOINLINE GetCallstack(const char *indent, const char *ignoreFilter)
{
static bool symInitialized = false;
HANDLE currentProcess = GetCurrentProcess();
HANDLE currentThread = GetCurrentThread();
if (!symInitialized)
{
SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS | SYMOPT_LOAD_LINES);
SymInitialize(currentProcess, NULL, TRUE);
symInitialized = true;
}
CONTEXT context = {};
STACKFRAME64 stack = {};
#ifdef _M_IX86
context.ContextFlags = CONTEXT_CONTROL;
_asm {
call x
x: pop eax
mov context.Eip, eax
mov context.Ebp, ebp
mov context.Esp, esp
}
#else
RtlCaptureContext(&context);
#endif
stack.AddrPC.Mode = AddrModeFlat;
stack.AddrStack.Mode = AddrModeFlat;
stack.AddrFrame.Mode = AddrModeFlat;
#ifdef _M_X64
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms680646(v=vs.85).aspx
stack.AddrPC.Offset = context.Rip;
stack.AddrStack.Offset = context.Rsp;
stack.AddrFrame.Offset = context.Rbp;
const DWORD machineType = IMAGE_FILE_MACHINE_AMD64;
#else
stack.AddrPC.Offset = context.Eip;
stack.AddrStack.Offset = context.Esp;
stack.AddrFrame.Offset = context.Ebp;
const DWORD machineType = IMAGE_FILE_MACHINE_I386;
#endif
const PVOID contextRecord = &context;
std::string callstack;
for(int i = 0; i < 128; ++i)
{
BOOL result = StackWalk64(machineType, currentProcess, currentThread, &stack, contextRecord, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL);
if (!result)
break;
std::string symbolName = GetSymbolName((void*)stack.AddrPC.Offset, currentProcess);
if (symbolName.find(" GetCallstack") == symbolName.length() - strlen(" GetCallstack"))
continue;
if (!ignoreFilter || symbolName.find(ignoreFilter) == symbolName.npos)
{
if (!symbolName.empty())
{
callstack += indent;
callstack += symbolName;
callstack += '\n';
}
ignoreFilter = 0;
}
if (symbolName.find(" main") == symbolName.length() - strlen(" main"))
break;
if (stack.AddrReturn.Offset == 0)
break;
}
return callstack;
}
void PE_Debug::DumpSymbolInfo(std::ostream& dumpBuffer, DWORD relativeAddress )
{
// Variables to keep track of function symbols
PIMAGE_SYMBOL currentSym = COFFSymbolTable ;
PIMAGE_SYMBOL fnSymbol = NULL ;
DWORD maxFnAddress = 0 ;
#ifdef DUMPRAM
InitSymbols();
#endif
// Variables to keep track of file symbols
PIMAGE_SYMBOL fileSymbol = NULL ;
PIMAGE_SYMBOL latestFileSymbol = NULL ;
for ( int i = 0; i < COFFSymbolCount; i++ ) {
// Look for .text section where relativeAddress belongs to.
// Keep track of the filename the .text section belongs to.
if ( currentSym->StorageClass == IMAGE_SYM_CLASS_FILE ) {
latestFileSymbol = currentSym;
}
// Borland uses "CODE" instead of the standard ".text" entry
// Microsoft uses sections that only _begin_ with .text
const char* symName = GetSymbolName( currentSym ) ;
if ( strnicmp( symName, ".text", 5 ) == 0 || strcmpi( symName, "CODE" ) == 0 ) {
if ( currentSym->Value <= relativeAddress ) {
PIMAGE_AUX_SYMBOL auxSym = (PIMAGE_AUX_SYMBOL)(currentSym + 1) ;
if ( currentSym->Value + auxSym->Section.Length >= relativeAddress ) {
fileSymbol = latestFileSymbol ;
}
}
}
// Look for the function with biggest address <= relativeAddress
BOOL isFunction = ISFCN( currentSym->Type ); // Type == 0x20, See WINNT.H
if ( isFunction && ( currentSym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL || currentSym->StorageClass == IMAGE_SYM_CLASS_STATIC ) ) {
if ( currentSym->Value <= relativeAddress && currentSym->Value > maxFnAddress ) {
maxFnAddress = currentSym->Value ;
fnSymbol = currentSym ;
}
}
#ifdef DUMPRAM
if ( !isFunction && (currentSym->SectionNumber >= 0) ) {
if ( (symName[0]=='_' && symName[1]!='$') || (symName[0]=='?') ) {
char pretty_module[1024];
if ( fileSymbol ) {
const char* auxSym = (const char*)(latestFileSymbol + 1) ;
char tmpFile[ VA_MAX_FILENAME_LEN ] ;
strcpy_s( tmpFile, auxSym ) ;
strcpy_s( pretty_module, tmpFile );
char *p = pretty_module+strlen(pretty_module)-1;
// Move p to point to first letter of EXE filename
while( (*p!='\\') && (*p!='/') && (*p!=':') )
p--;
p++;
if ( strlen(p) < 1 ) {
strcpy_s( pretty_module, "<unknown>" );
} else {
memmove( pretty_module, p, strlen(p)+1 );
}
} else {
strcpy_s( pretty_module, "" );
}
Add_Symbol( currentSym->SectionNumber, currentSym->Value, symName, pretty_module );
}
}
#endif
// Advance counters, skip aux symbols
i += currentSym->NumberOfAuxSymbols ;
currentSym += currentSym->NumberOfAuxSymbols ;
currentSym++ ;
}
#ifdef DUMPRAM
DumpSymbols();
#endif
// dump symbolic info if found
if ( fileSymbol ) {
const char* auxSym = (const char*)(fileSymbol + 1) ;
if( strcmpi( latestFile, auxSym ) ) {
strcpy_s( latestFile, auxSym ) ;
//JAS dumpBuffer.Printf( " file: %s\r\n", auxSym ) ;
}
} else {
latestFile[ 0 ] = 0 ;
//JAS dumpBuffer.Printf( " file: unknown\r\n" ) ;
}
if ( fnSymbol ) {
char tmp_name[1024];
unmangle(tmp_name, GetSymbolName( fnSymbol ) );
dumpBuffer << " " << tmp_name << "()";
} else {
dumpBuffer << " <unknown>";
}
}
/* static */ wxString
wxDbgHelpDLL::DumpUDT(wxPSYMBOL_INFO pSym, void *pVariable, unsigned level)
{
wxString s;
// we have to limit the depth of UDT dumping as otherwise we get in
// infinite loops trying to dump linked lists... 10 levels seems quite
// reasonable, full information is in minidump file anyhow
if ( level > 10 )
return s;
s.reserve(512);
s = GetSymbolName(pSym);
#if !wxUSE_STD_STRING
// special handling for ubiquitous wxString: although the code below works
// for it as well, it shows the wxStringBase class and takes 4 lines
// instead of only one as this branch
if ( s == wxT("wxString") )
{
wxString *ps = (wxString *)pVariable;
// we can't just dump wxString directly as it could be corrupted or
// invalid and it could also be locked for writing (i.e. if we're
// between GetWriteBuf() and UngetWriteBuf() calls) and assert when we
// try to access it contents using public methods, so instead use our
// knowledge of its internals
const wxChar *p = NULL;
if ( !::IsBadReadPtr(ps, sizeof(wxString)) )
{
p = ps->data();
wxStringData *data = (wxStringData *)p - 1;
if ( ::IsBadReadPtr(data, sizeof(wxStringData)) ||
::IsBadReadPtr(p, sizeof(wxChar *)*data->nAllocLength) )
{
p = NULL; // don't touch this pointer with 10 feet pole
}
}
s << wxT("(\"") << (p ? p : wxT("???")) << wxT(")\"");
}
else // any other UDT
#endif // !wxUSE_STD_STRING
{
// Determine how many children this type has.
DWORD dwChildrenCount = 0;
DoGetTypeInfo(pSym, TI_GET_CHILDRENCOUNT, &dwChildrenCount);
// Prepare to get an array of "TypeIds", representing each of the children.
TI_FINDCHILDREN_PARAMS *children = (TI_FINDCHILDREN_PARAMS *)
malloc(sizeof(TI_FINDCHILDREN_PARAMS) +
(dwChildrenCount - 1)*sizeof(ULONG));
if ( !children )
return s;
children->Count = dwChildrenCount;
children->Start = 0;
// Get the array of TypeIds, one for each child type
if ( !DoGetTypeInfo(pSym, TI_FINDCHILDREN, children) )
{
free(children);
return s;
}
s << wxT(" {\n");
// Iterate through all children
wxSYMBOL_INFO sym;
wxZeroMemory(sym);
sym.ModBase = pSym->ModBase;
for ( unsigned i = 0; i < dwChildrenCount; i++ )
{
sym.TypeIndex = children->ChildId[i];
// children here are in lexicographic sense, i.e. we get all our nested
// classes and not only our member fields, but we can't get the values
// for the members of the nested classes, of course!
DWORD nested;
if ( DoGetTypeInfo(&sym, TI_GET_NESTED, &nested) && nested )
continue;
// avoid infinite recursion: this does seem to happen sometimes with
// complex typedefs...
if ( sym.TypeIndex == pSym->TypeIndex )
continue;
s += DumpField(&sym, pVariable, level + 1);
}
free(children);
s << wxString(wxT('\t'), level + 1) << wxT('}');
}
return s;
}
char *CoffLoader::GetSymbolName(int index)
{
SymbolTable_t *sym = &(SymTable[index]);
return GetSymbolName(sym);
}
wxString
wxDbgHelpDLL::DumpField(PSYMBOL_INFO pSym, void *pVariable, unsigned level)
{
wxString s;
// avoid infinite recursion
if ( level > 100 )
{
return s;
}
SymbolTag tag = SYMBOL_TAG_NULL;
if ( !DoGetTypeInfo(pSym, TI_GET_SYMTAG, &tag) )
{
return s;
}
switch ( tag )
{
case SYMBOL_TAG_UDT:
case SYMBOL_TAG_BASE_CLASS:
s = DumpUDT(pSym, pVariable, level);
break;
case SYMBOL_TAG_DATA:
if ( !pVariable )
{
s = _T("NULL");
}
else // valid location
{
wxDbgHelpDLL::DataKind kind;
if ( !DoGetTypeInfo(pSym, TI_GET_DATAKIND, &kind) ||
kind != DATA_MEMBER )
{
// maybe it's a static member? we're not interested in them...
break;
}
// get the offset of the child member, relative to its parent
DWORD ofs = 0;
if ( !DoGetTypeInfo(pSym, TI_GET_OFFSET, &ofs) )
break;
pVariable = (void *)((DWORD_PTR)pVariable + ofs);
// now pass to the type representing the type of this member
SYMBOL_INFO sym = *pSym;
if ( !DoGetTypeInfo(pSym, TI_GET_TYPEID, &sym.TypeIndex) )
break;
ULONG64 size;
DoGetTypeInfo(&sym, TI_GET_LENGTH, &size);
switch ( DereferenceSymbol(&sym, &pVariable) )
{
case SYMBOL_TAG_BASE_TYPE:
{
BasicType bt = GetBasicType(&sym);
if ( bt )
{
s = DumpBaseType(bt, size, pVariable);
}
}
break;
case SYMBOL_TAG_UDT:
case SYMBOL_TAG_BASE_CLASS:
s = DumpUDT(&sym, pVariable, level);
break;
}
}
if ( !s.empty() )
{
s = GetSymbolName(pSym) + _T(" = ") + s;
}
break;
}
if ( !s.empty() )
{
s = wxString(_T('\t'), level + 1) + s + _T('\n');
}
return s;
}
void CCOF2OMF::MakeSymbolList() {
// Make temporary symbol conversion list
int isym = 0; // current symbol table entry
int jsym = 0; // auxiliary entry number
union { // Pointer to symbol table
SCOFF_SymTableEntry * p; // Normal pointer
int8 * b; // Used for address calculation
} Symtab;
Symtab.p = SymbolTable; // Set pointer to begin of SymbolTable
// Loop through symbol table
while (isym < NumberOfSymbols) {
// Check scope
if (Symtab.p->s.StorageClass == COFF_CLASS_EXTERNAL) {
// Scope is public or external
if (Symtab.p->s.SectionNumber > 0) {
// Symbol is public
SymbolBuffer[isym].Scope = S_PUBLIC; // Scope = public
SymbolBuffer[isym].NewIndex = ++NumPublicSymbols; // Public symbol number
// Get name
SymbolBuffer[isym].Name = NameBuffer.PushString(GetSymbolName(Symtab.p->s.Name));
// Find section in SectionBuffer
uint32 OldSection = Symtab.p->s.SectionNumber;
SymbolBuffer[isym].Segment = SectionBuffer[OldSection].NewNumber; // New segment number
// Calculate offset = offset into old section + offset of old section to first section with same name
SymbolBuffer[isym].Offset = Symtab.p->s.Value + SectionBuffer[OldSection].Offset;
}
else if (Symtab.p->s.SectionNumber == 0) {
// Symbol is external
SymbolBuffer[isym].Scope = S_EXTERNAL; // Scope = external
SymbolBuffer[isym].NewIndex = ++NumExternalSymbols; // External symbol number
SymbolBuffer[isym].Name = NameBuffer.PushString(GetSymbolName(Symtab.p->s.Name));
}
else if (Symtab.p->s.SectionNumber == COFF_SECTION_ABSOLUTE) {
// Symbol is public, absolute
SymbolBuffer[isym].Scope = S_PUBLIC; // Scope = public
SymbolBuffer[isym].NewIndex = ++NumPublicSymbols; // Public symbol number
// Get name
SymbolBuffer[isym].Name = NameBuffer.PushString(GetSymbolName(Symtab.p->s.Name));
SymbolBuffer[isym].Segment = 0; // 0 indicates absolute
SymbolBuffer[isym].Offset = Symtab.p->s.Value; // Store value in Offset
}
else {
// COFF_SECTION_DEBUG, COFF_SECTION_N_TV, COFF_SECTION_P_TV
// Ignore
}
}
// Skip auxiliary symbol table entries and increment pointer
isym += Symtab.p->s.NumAuxSymbols + 1;
Symtab.b += (Symtab.p->s.NumAuxSymbols + 1) * SIZE_SCOFF_SymTableEntry;
}
}
void COMF::DumpRelocations() {
// Dump all LEDATA, LIDATA, COMDAT and FIXUPP records
uint32 LastDataRecord = 0; // Index to the data record that relocations refer to
uint32 LastDataRecordSize = 0; // Size of the data record that relocations refer to
int8 * LastDataRecordPointer = 0; // Pointer to data in the data record that relocations refer to
uint32 i; // Loop counter
uint32 Segment, Offset, Size; // Contents of LEDATA or LIDATA record
uint32 LastOffset = 0; // Offset of last LEDATA or LIDATA record
uint32 Frame, Target, TargetDisplacement; // Contents of FIXUPP record
uint8 byte1, byte2; // First two bytes of subrecord
// Bitfields in subrecords
OMF_SLocat Locat; // Structure of first two bytes of FIXUP subrecord swapped = Locat field
OMF_SFixData FixData; // Structure of FixData field in FIXUP subrecord of FIXUPP record
OMF_STrdDat TrdDat; // Structure of Thread Data field in THREAD subrecord of FIXUPP record
printf("\n\nLEDATA, LIDATA, COMDAT and FIXUPP records:");
for (i = 0; i < NumRecords; i++) {
if (Records[i].Type2 == OMF_LEDATA) {
// LEDATA record
Segment = Records[i].GetIndex(); // Read segment and offset
Offset = Records[i].GetNumeric();
Size = Records[i].End - Records[i].Index; // Calculate size of data
LastDataRecord = i; // Save for later FIXUPP that refers to this record
LastDataRecordSize = Size;
LastDataRecordPointer = Records[i].buffer + Records[i].FileOffset + Records[i].Index;
if (Segment < 0x4000) {
printf("\n LEDATA: segment %s, Offset 0x%X, Size 0x%X", // Dump segment, offset, size
GetSegmentName(Segment), Offset, Size);
LastOffset = Offset;
}
else { // Undocumented Borland communal section
printf("\n LEDATA communal section %i, Offset 0x%X, Size 0x%X", // Dump segment, offset, size
(Segment & ~0x4000), Offset, Size);
LastOffset = Offset;
}
}
if (Records[i].Type2 == OMF_LIDATA) {
// LIDATA record
Segment = Records[i].GetIndex();
Offset = Records[i].GetNumeric();
LastDataRecord = i;
LastDataRecordSize = Records[i].End - Records[i].Index; // Size before expansion of repeat blocks
LastDataRecordPointer = Records[i].buffer + Records[i].FileOffset + Records[i].Index;
printf("\n LIDATA: segment %s, Offset 0x%X, Size ",
GetSegmentName(Segment), Offset);
// Call recursive function to interpret repeat data block
Size = Records[i].InterpretLIDATABlock();
printf(" = 0x%X", Size);
LastOffset = Offset;
}
if (Records[i].Type2 == OMF_COMDAT) {
// COMDAT record
uint32 Flags = Records[i].GetByte(); // 1 = continuation, 2 = iterated, 4 = local, 8 = data in code segment
uint32 Attributes = Records[i].GetByte();
uint32 Base = 0;
// 0 = explicit, 1 = far code, 2 = far data, 3 = code32, 4 = data32
// 0x00 = no match, 0x10 = pick any, 0x20 = same size, 0x30 = exact match
uint32 Align = Records[i].GetByte(); // Alignment
Offset = Records[i].GetNumeric(); // Offset
uint32 TypeIndex = Records[i].GetIndex(); // Type index
if ((Attributes & 0x0F) == 0) {
Base = Records[i].GetIndex(); // Public base
}
uint32 NameIndex = Records[i].GetIndex(); // LNAMES index
Size = Records[i].End - Records[i].Index; // Calculate size of data
printf("\n COMDAT: name %s, Offset 0x%X, Size 0x%X, Attrib 0x%02X, Align %i, Type %i, Base %i",
GetLocalName(NameIndex), Offset, Size, Attributes, Align, TypeIndex, Base);
LastOffset = Offset;
}
if (Records[i].Type2 == OMF_FIXUPP) {
// FIXUPP record
printf("\n FIXUPP:");
Records[i].Index = 3;
// Loop through entries in record
while (Records[i].Index < Records[i].End) {
// Read first byte
byte1 = Records[i].GetByte();
if (byte1 & 0x80) {
// This is a FIXUP subrecord
Frame = 0; Target = 0; TargetDisplacement = 0;
// read second byte
byte2 = Records[i].GetByte();
// swap bytes and put into byte12 bitfield
Locat.bytes[1] = byte1;
Locat.bytes[0] = byte2;
// Read FixData
FixData.b = Records[i].GetByte();
// print mode and location
printf("\n %s %s, Offset 0x%X",
Lookup(OMFRelocationModeNames, Locat.s.M),
Lookup(OMFFixupLocationNames, Locat.s.Location),
Locat.s.Offset + LastOffset);
// Read conditional fields
if (FixData.s.F == 0) {
if (FixData.s.Frame < 4) {
Frame = Records[i].GetIndex();
}
else Frame = 0;
switch (FixData.s.Frame) { // Frame method
case 0: // F0: segment
printf(", segment %s", GetSegmentName(Frame)); break;
case 1: // F1: group
printf(", group %s", GetGroupName(Frame)); break;
case 2: // F2: external symbol
printf(", external frame %s", GetSymbolName(Frame)); break;
case 4: // F4: frame = source,
// or Borland floating point emulation record (undocumented?)
printf(", frame = source; or Borland f.p. emulation record");
break;
case 5: // F5: frame = target
printf(", frame = target"); break;
default:
printf(", target frame %i method F%i", Frame, FixData.s.Frame);
}
}
else {
printf(", frame uses thread %i", FixData.s.Frame);
}
if (FixData.s.T == 0) {
// Target specified
Target = Records[i].GetIndex();
uint32 TargetMethod = FixData.s.Target + FixData.s.P * 4;
switch (FixData.s.Target) { // = Target method modulo 4
case 0: // T0 and T4: Target = segment
case 1: // T1 and T5: Target = segment group
printf(". Segment %s (T%i)",
GetSegmentName(Target), TargetMethod);
break;
case 2: // T2 and T6: Target = external symbol
printf(". Symbol %s (T%i)",
GetSymbolName(Target), TargetMethod);
break;
default: // Unknown method
printf(", target %i unknown method T%i", Target, TargetMethod);
}
}
else {
// Target specified in previous thread
printf(", target uses thread %i", FixData.s.Target);
}
if (FixData.s.P == 0) {
TargetDisplacement = Records[i].GetNumeric();
printf("\n target displacement %i", TargetDisplacement);
}
// Get inline addend
if (LastDataRecordPointer && Locat.s.Offset < LastDataRecordSize) {
int8 * inlinep = LastDataRecordPointer + Locat.s.Offset;
switch (Locat.s.Location) {
case 0: case 4: // 8 bit
printf(", inline 0x%X", *inlinep); break;
case 1: case 2: case 5: // 16 bit
printf(", inline 0x%X", *(int16*)inlinep); break;
case 3: // 16+16 bit
printf(", inline 0x%X:0x%X", *(int16*)(inlinep+2), *(int16*)inlinep); break;
case 9: case 13: // 32 bit
printf(", inline 0x%X", *(int32*)inlinep); break;
case 6: case 11: // 16+32 bit
printf(", inline 0x%X:0x%X", *(int16*)(inlinep+4), *(int32*)inlinep); break;
}
}
}
else {
// This is a THREAD subrecord
TrdDat.b = byte1; // Put byte into bitfield
uint32 Index = 0;
if (TrdDat.s.Method < 4) {
Index = Records[i].GetIndex(); // has index field if method < 4 ?
}
printf("\n %s Thread %i. Method %s%i, index %i",
(TrdDat.s.D ? "Frame" : "Target"), TrdDat.s.Thread,
(TrdDat.s.D ? "F" : "T"), TrdDat.s.Method, Index);
}
} // Finished loop through subrecords
if (Records[i].Index != Records[i].End) err.submit(1203); // Check for consistency
}
} // Finished loop through records
}
void PrintSymbolName(FILE *f, void *addr) {
char func[150];
GetSymbolName(addr, func, 150);
fprintf(stderr, "%s", func);
}
void CCOF2ELF<ELFSTRUCTURES>::MakeSymbolTable() {
// Convert subfunction: Make symbol table and string tables
int isym; // current symbol table entry
int numaux; // Number of auxiliary entries in source record
int OldSectionIndex; // Index into old section table. 1-based
int NewSectionIndex; // Index into new section table. 0-based
const int WordSize = sizeof(NewFileHeader.e_entry) * 8; // word size 32 or 64 bits
TELF_Symbol sym; // Temporary symbol table record
const char * name1; // Name of section or main record
// Pointer to old symbol table
union {
SCOFF_SymTableEntry * p; // Symtab entry pointer
int8 * b; // Used for increment
} OldSymtab;
// Make the first record empty
NewSections[symtab].Push(0, sizeof(TELF_Symbol));
// Make first string table entries empty
NewSections[strtab] .PushString("");
NewSections[stabstr].PushString("");
// Loop twice through source symbol table to get local symbols first, global symbols last
// Loop 1: Look for local symbols only
OldSymtab.p = SymbolTable; // Pointer to source symbol table
for (isym = 0; isym < this->NumberOfSymbols; isym += numaux+1, OldSymtab.b += SIZE_SCOFF_SymTableEntry*(numaux+1)) {
if (OldSymtab.b >= Buf() + DataSize) {
err.submit(2040);
break;
}
// Number of auxiliary records belonging to same symbol
numaux = OldSymtab.p->s.NumAuxSymbols;
if (numaux < 0) numaux = 0;
if (OldSymtab.p->s.StorageClass != COFF_CLASS_EXTERNAL && OldSymtab.p->s.StorageClass != COFF_CLASS_WEAK_EXTERNAL) {
// Symbol is local
// Reset destination entry
memset(&sym, 0, sizeof(sym));
// Binding
sym.st_bind = STB_LOCAL;
// Get first aux record if numaux > 0
//SCOFF_SymTableEntryAux * sa = (SCOFF_SymTableEntryAux *)(OldSymtab.b + SIZE_SCOFF_SymTableEntry);
// Symbol name
name1 = this->GetSymbolName(OldSymtab.p->s.Name);
// Symbol value
sym.st_value = OldSymtab.p->s.Value;
// Get section
OldSectionIndex = OldSymtab.p->s.SectionNumber; // 1-based index into old section table
NewSectionIndex = 0; // 0-based index into old section table
if (OldSectionIndex > 0 && OldSectionIndex <= this->NSections) {
// Subtract 1 from OldSectionIndex because NewSectIndex[] is zero-based while OldSectionIndex is 1-based
// Get new section index from translation table
NewSectionIndex = NewSectIndex[OldSectionIndex-1];
}
if (NewSectionIndex == COFF_SECTION_REMOVE_ME) {
continue; // Section has been removed. Remove symbol too
}
sym.st_shndx = (uint16)NewSectionIndex;
// Check symbol type
if (OldSymtab.p->s.StorageClass == COFF_CLASS_FILE) {
// This is a filename record
if (numaux > 0 && numaux < 20) {
// Get filename from subsequent Aux records.
// Remove path from filename because the path makes no sense on a different platform.
const char * filename = GetShortFileName(OldSymtab.p);
// Put file name into string table and debug string table
sym.st_name = NewSections[strtab].PushString(filename);
NewSections[stabstr].PushString(filename);
}
// Attributes for filename record
sym.st_shndx = (uint16)SHN_ABS;
sym.st_type = STT_FILE;
sym.st_bind = STB_LOCAL;
sym.st_value = 0;
}
else if (numaux && OldSymtab.p->s.StorageClass == COFF_CLASS_STATIC
&& OldSymtab.p->s.Value == 0 && OldSymtab.p->s.Type != 0x20) {
// This is a section definition record
sym.st_name = 0;
name1 = 0;
sym.st_type = STT_SECTION;
sym.st_bind = STB_LOCAL;
sym.st_value = 0;
// aux record contains length and number of relocations. Ignore aux record
}
else if (OldSymtab.p->s.SectionNumber < 0) {
// This is an absolute or debug symbol
sym.st_type = STT_NOTYPE;
sym.st_shndx = (uint16)SHN_ABS;
}
else if (OldSymtab.p->s.Type == 0 && OldSymtab.p->s.StorageClass == COFF_CLASS_FUNCTION) {
// This is a .bf, .lf, or .ef record following a function record
// Contains line number information etc. Ignore this record
continue;
}
else if (OldSymtab.p->s.SectionNumber <= 0) {
// Unknown
sym.st_type = STT_NOTYPE;
}
else {
// This is a local data definition record
sym.st_type = STT_OBJECT;
// The size is not specified in COFF record,
// so we may give it an arbitrary size:
// sym.size = 4;
}
// Put symbol name into string table if we have not already done so
if (sym.st_name == 0 && name1) {
sym.st_name = NewSections[strtab].PushString(name1);
}
// Put record into new symbol table
NewSections[symtab].Push(&sym, sizeof(sym));
// Insert into symbol translation table
NewSymbolIndex[isym] = NewSections[symtab].GetLastIndex();
} // End if not external
} // End loop 1
// Finished with local symbols
// Make index to first global symbol
NewSectionHeaders[symtab].sh_info = NewSections[symtab].GetLastIndex() + 1;
// Loop 2: Look for global symbols only
OldSymtab.p = SymbolTable; // Pointer to source symbol table
for (isym = 0; isym < NumberOfSymbols; isym += numaux+1, OldSymtab.b += SIZE_SCOFF_SymTableEntry*(numaux+1)) {
// Number of auxiliary records belonging to same symbol
numaux = OldSymtab.p->s.NumAuxSymbols;
if (numaux < 0) numaux = 0;
if (OldSymtab.p->s.StorageClass == COFF_CLASS_EXTERNAL || OldSymtab.p->s.StorageClass == COFF_CLASS_WEAK_EXTERNAL) {
// Symbol is global (public or external)
// Reset destination entry
memset(&sym, 0, sizeof(sym));
// Binding
sym.st_bind = STB_GLOBAL;
if (OldSymtab.p->s.StorageClass == COFF_CLASS_WEAK_EXTERNAL) sym.st_bind = STB_WEAK;
// Get first aux record if numaux > 0
SCOFF_SymTableEntry * sa = (SCOFF_SymTableEntry*)(OldSymtab.b + SIZE_SCOFF_SymTableEntry);
// Symbol name
name1 = GetSymbolName(OldSymtab.p->s.Name);
// Symbol value
sym.st_value = OldSymtab.p->s.Value;
// Get section
OldSectionIndex = OldSymtab.p->s.SectionNumber; // 1-based index into old section table
NewSectionIndex = 0; // 0-based index into old section table
if (OldSectionIndex > 0 && OldSectionIndex <= NSections) {
// Subtract 1 from OldSectionIndex because NewSectIndex[] is zero-based while OldSectionIndex is 1-based
// Get new section index from translation table
NewSectionIndex = NewSectIndex[OldSectionIndex-1];
}
if (NewSectionIndex == COFF_SECTION_REMOVE_ME) {
continue; // Section has been removed. Remove symbol too
}
if ((int16)OldSectionIndex == COFF_SECTION_ABSOLUTE) {
NewSectionIndex = SHN_ABS;
}
sym.st_shndx = (uint16)NewSectionIndex;
// Check symbol type
if (OldSymtab.p->s.SectionNumber < 0) {
// This is an absolute or debug symbol
sym.st_type = STT_NOTYPE;
}
else if (OldSymtab.p->s.Type == COFF_TYPE_FUNCTION && OldSymtab.p->s.SectionNumber > 0) {
// This is a function definition record
sym.st_type = STT_FUNC;
if (numaux) {
// Get size from aux record
sym.st_size = sa->func.TotalSize;
}
if (sym.st_size == 0) {
// The size is not specified in the COFF file.
// We may give it an arbitrary size:
// sym.size = 1;
}
}
else if (OldSymtab.p->s.SectionNumber <= 0) {
// This is an external symbol
sym.st_type = STT_NOTYPE;
}
else {
// This is a data definition record
sym.st_type = STT_OBJECT;
// Symbol must have a size. The size is not specified in COFF record,
// so we just give it an arbitrary size
sym.st_size = 4;
}
// Put symbol name into string table if we have not already done so
if (sym.st_name == 0 && name1) {
sym.st_name = NewSections[strtab].PushString(name1);
}
// Put record into new symbol table
NewSections[symtab].Push(&sym, sizeof(sym));
// Insert into symbol translation table
NewSymbolIndex[isym] = NewSections[symtab].GetLastIndex();
} // End if external
} // End loop 2
}
/******************************************************************************
* Function Name: ProcessHWSymbolEntry
*
* Inputs :
* Outputs :
* Returns :
* Globals Used : -
*
* Description : Process an entry of symbol reg use list
*****************************************************************************/
static IMG_VOID ProcessHWSymbolEntry(GLSLCompilerPrivateData *psCPD,
GLSLUniFlexContext *psUFContext,
HWSYMBOL *psHWSymbol,
GLSLBindingSymbolList *psBindingSymbolList)
{
GLSLBindingSymbol *psBindingSymbol;
GLSLIdentifierData *psIdentifierData;
/* Get psIndentifierData */
psIdentifierData = (GLSLIdentifierData *)GetSymbolTableData(psUFContext->psSymbolTable, psHWSymbol->uSymbolId);
if(psIdentifierData == IMG_NULL)
{
LOG_INTERNAL_ERROR(("ProcessHWSymbolEntry: Failed to get data for identifier %d\n", psHWSymbol->uSymbolId));
return;
}
psBindingSymbol = AddBindingSymbol(psCPD, psUFContext, psHWSymbol, psIdentifierData, psBindingSymbolList);
if(GLSL_IS_STRUCT(psBindingSymbol->eTypeSpecifier))
{
IMG_CHAR psName[512];
IMG_UINT32 uNameLength;
IMG_CHAR *pszStructName;
STRUCT_CONTEXT sContext;
GLSLStructureAlloc *psStructAlloc = GetStructAllocInfo(psCPD, psUFContext, &psHWSymbol->sFullType);
IMG_UINT32 uArraySize = (IMG_UINT32) (psBindingSymbol->iActiveArraySize);
pszStructName = (IMG_CHAR *)GetSymbolName(psUFContext->psSymbolTable, psHWSymbol->uSymbolId);
strcpy(psName, pszStructName);
/**
* OGL64 Review.
* Use size_t for strlen?
*/
uNameLength = (IMG_UINT32)strlen(pszStructName);
/*
Alloc memory for base type members
*/
psBindingSymbol->uNumBaseTypeMembers = psStructAlloc->uNumBaseTypeMembers * uArraySize;
psBindingSymbol->psBaseTypeMembers = DebugMemAlloc(psBindingSymbol->uNumBaseTypeMembers * sizeof(GLSLBindingSymbol));
if(psBindingSymbol->psBaseTypeMembers == IMG_NULL)
{
LOG_INTERNAL_ERROR(("ProcessHWSymbolEntry: Failed to alloc memory"));
return ;
}
/* Initialise and setup context for processing structure */
/* Unchanged fields */
sContext.psStructHWSymbol = psHWSymbol;
sContext.psStructStructAlloc = psStructAlloc;
sContext.psStructBindingSymbol = psBindingSymbol;
/* Changable fields */
sContext.uStructBaseOffset = psHWSymbol->u.uCompOffset;
sContext.uStructTextureUnitBase = psHWSymbol->uTextureUnit;
sContext.uMemberOffset = 0;
sContext.uNameLength = uNameLength;
sContext.psName = psName;
sContext.psIdentifierData = psIdentifierData;
sContext.pbyConstantData = psIdentifierData->pvConstantData;
/* Recursive processing structure members */
RecursivelyAddStructMembers(psCPD, psUFContext, &sContext, psBindingSymbolList);
/* Doublly check for correctness */
if(sContext.uMemberOffset != psBindingSymbol->uNumBaseTypeMembers)
{
LOG_INTERNAL_ERROR(("ProcessHWSymbolEntry: Number of structure members do not match\n"));
}
}
/* For literal constants etc. we don't need to add to the binding symbol list */
if( psBindingSymbol->eTypeQualifier == GLSLTQ_INVALID ||
psBindingSymbol->eTypeQualifier == GLSLTQ_TEMP ||
psBindingSymbol->eTypeQualifier == GLSLTQ_CONST )
{
if(psBindingSymbol->pszName) DebugMemFree(psBindingSymbol->pszName);
/* Free base type members */
if(psBindingSymbol->uNumBaseTypeMembers)
{
IMG_UINT32 j;
for(j = 0; j < psBindingSymbol->uNumBaseTypeMembers; j++)
{
if(psBindingSymbol->psBaseTypeMembers[j].pszName)
{
DebugMemFree(psBindingSymbol->psBaseTypeMembers[j].pszName);
}
}
DebugMemFree(psBindingSymbol->psBaseTypeMembers);
psBindingSymbol->psBaseTypeMembers = IMG_NULL;
}
/* Remove from binding symbol list */
psBindingSymbolList->uNumBindings--;
}
}
/* static */ wxString
wxDbgHelpDLL::DumpUDT(PSYMBOL_INFO pSym, void *pVariable, unsigned level)
{
wxString s;
// we have to limit the depth of UDT dumping as otherwise we get in
// infinite loops trying to dump linked lists... 10 levels seems quite
// reasonable, full information is in minidump file anyhow
if ( level > 10 )
return s;
s.reserve(512);
s = GetSymbolName(pSym);
#if !wxUSE_STL
// special handling for ubiquitous wxString: although the code below works
// for it as well, it shows the wxStringBase class and takes 4 lines
// instead of only one as this branch
if ( s == _T("wxString") )
{
wxString *ps = (wxString *)pVariable;
s << _T("(\"") << *ps << _T(")\"");
}
else // any other UDT
#endif // !wxUSE_STL
{
// Determine how many children this type has.
DWORD dwChildrenCount = 0;
DoGetTypeInfo(pSym, TI_GET_CHILDRENCOUNT, &dwChildrenCount);
// Prepare to get an array of "TypeIds", representing each of the children.
TI_FINDCHILDREN_PARAMS *children = (TI_FINDCHILDREN_PARAMS *)
malloc(sizeof(TI_FINDCHILDREN_PARAMS) +
(dwChildrenCount - 1)*sizeof(ULONG));
if ( !children )
return s;
children->Count = dwChildrenCount;
children->Start = 0;
// Get the array of TypeIds, one for each child type
if ( !DoGetTypeInfo(pSym, TI_FINDCHILDREN, children) )
{
free(children);
return s;
}
s << _T(" {\n");
// Iterate through all children
SYMBOL_INFO sym;
wxZeroMemory(sym);
sym.ModBase = pSym->ModBase;
for ( unsigned i = 0; i < dwChildrenCount; i++ )
{
sym.TypeIndex = children->ChildId[i];
// children here are in lexicographic sense, i.e. we get all our nested
// classes and not only our member fields, but we can't get the values
// for the members of the nested classes, of course!
DWORD nested;
if ( DoGetTypeInfo(&sym, TI_GET_NESTED, &nested) && nested )
continue;
// avoid infinite recursion: this does seem to happen sometimes with
// complex typedefs...
if ( sym.TypeIndex == pSym->TypeIndex )
continue;
s += DumpField(&sym, pVariable, level + 1);
}
free(children);
s << wxString(_T('\t'), level + 1) << _T('}');
}
return s;
}
void CCOFF::PrintSymbolTable(int symnum) {
// Print one or all public symbols for object file.
// Dump symbol table if symnum = -1, or
// Dump symbol number symnum (zero based) when symnum >= 0
int isym = 0; // current symbol table entry
int jsym = 0; // auxiliary entry number
union { // Pointer to symbol table
SCOFF_SymTableEntry * p; // Normal pointer
int8 * b; // Used for address calculation
} Symtab;
Symtab.p = SymbolTable; // Set pointer to begin of SymbolTable
if (symnum == -1) printf("\n\nSymbol table:");
if (symnum >= 0) {
// Print one symbol only
if (symnum >= NumberOfSymbols) {
printf("\nSymbol %i not found", symnum);
return;
}
isym = symnum;
Symtab.b += SIZE_SCOFF_SymTableEntry * isym;
}
while (isym < NumberOfSymbols) {
// Print symbol table entry
SCOFF_SymTableEntry *s0;
printf("\n");
if (symnum >= 0) printf(" ");
printf("Symbol %i - Name: %s\n Value=%i, ",
isym, GetSymbolName(Symtab.p->s.Name), Symtab.p->s.Value);
if (Symtab.p->s.SectionNumber > 0) {
printf("Section=%i", Symtab.p->s.SectionNumber);
}
else { // Special section numbers
switch (Symtab.p->s.SectionNumber) {
case COFF_SECTION_UNDEF:
printf("External"); break;
case COFF_SECTION_ABSOLUTE:
printf("Absolute"); break;
case COFF_SECTION_DEBUG:
printf("Debug"); break;
case COFF_SECTION_N_TV:
printf("Preload transfer"); break;
case COFF_SECTION_P_TV:
printf("Postload transfer"); break;
}
}
printf(", Type=0x%X, StorClass=%s, NumAux=%i",
Symtab.p->s.Type,
GetStorageClassName(Symtab.p->s.StorageClass), Symtab.p->s.NumAuxSymbols);
if (Symtab.p->s.StorageClass == COFF_CLASS_FILE && Symtab.p->s.NumAuxSymbols > 0) {
printf("\n File name: %s", GetFileName(Symtab.p));
}
// Increment point
s0 = Symtab.p;
Symtab.b += SIZE_SCOFF_SymTableEntry;
isym++; jsym = 0;
// Get auxiliary records
while (jsym < s0->s.NumAuxSymbols && isym + jsym < NumberOfSymbols) {
// Print auxiliary symbol table entry
SCOFF_SymTableEntry * sa = Symtab.p;
// Detect auxiliary entry type
if (s0->s.StorageClass == COFF_CLASS_EXTERNAL
&& s0->s.Type == COFF_TYPE_FUNCTION
&& s0->s.SectionNumber > 0) {
// This is a function definition aux record
printf("\n Aux function definition:");
printf("\n .bf_tag_index: 0x%X, code_size: %i, PLineNumRec: %i, PNext: %i",
sa->func.TagIndex, sa->func.TotalSize, sa->func.PointerToLineNumber,
sa->func.PointerToNextFunction);
}
else if (strcmp(s0->s.Name,".bf")==0 || strcmp(s0->s.Name,".ef")==0) {
// This is a .bf or .ef aux record
printf("\n Aux .bf/.ef definition:");
printf("\n Source line number: %i",
sa->bfef.SourceLineNumber);
if (strcmp(s0->s.Name,".bf")==0 ) {
printf(", PNext: %i", sa->bfef.PointerToNextFunction);
}
}
else if (s0->s.StorageClass == COFF_CLASS_EXTERNAL &&
s0->s.SectionNumber == COFF_SECTION_UNDEF &&
s0->s.Value == 0) {
// This is a Weak external aux record
printf("\n Aux Weak external definition:");
printf("\n Symbol2 index: %i, Characteristics: 0x%X",
sa->weak.TagIndex, sa->weak.Characteristics);
}
else if (s0->s.StorageClass == COFF_CLASS_FILE) {
// This is filename aux record. Contents has already been printed
}
else if (s0->s.StorageClass == COFF_CLASS_STATIC) {
// This is section definition aux record
printf("\n Aux section definition record:");
printf("\n Length: %i, Num. relocations: %i, Num linenums: %i, checksum 0x%X,"
"\n Number: %i, Selection: %i",
sa->section.Length, sa->section.NumberOfRelocations, sa->section.NumberOfLineNumbers,
sa->section.CheckSum, sa->section.Number, sa->section.Selection);
}
else {
// Unknown aux record type
printf("\n Unknown Auxiliary record type.");
}
Symtab.b += SIZE_SCOFF_SymTableEntry;
jsym++;
}
isym += jsym;
if (symnum >= 0) break;
}
}
void CoffLoader::PrintSymbolTable(void)
{
int SymIndex;
printf("COFF SYMBOL TABLE\n");
for (SymIndex = 0; SymIndex < NumberOfSymbols; SymIndex++)
{
printf("%03X ", SymIndex);
printf("%08lX ", SymTable[SymIndex].Value);
if (SymTable[SymIndex].SectionNumber == IMAGE_SYM_ABSOLUTE)
printf("ABS ");
else if (SymTable[SymIndex].SectionNumber == IMAGE_SYM_DEBUG)
printf("DEBUG ");
else if (SymTable[SymIndex].SectionNumber == IMAGE_SYM_UNDEFINED)
printf("UNDEF ");
else
{
printf("SECT%d ", SymTable[SymIndex].SectionNumber);
if (SymTable[SymIndex].SectionNumber < 10)
printf(" ");
if (SymTable[SymIndex].SectionNumber < 100)
printf(" ");
}
if (SymTable[SymIndex].Type == 0)
printf("notype ");
else
{
printf("%X ", SymTable[SymIndex].Type);
if (SymTable[SymIndex].Type < 0x10)
printf(" ");
if (SymTable[SymIndex].Type < 0x100)
printf(" ");
if (SymTable[SymIndex].Type < 0x1000)
printf(" ");
}
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_END_OF_FUNCTION)
printf("End of Function ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_NULL)
printf("Null ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_AUTOMATIC)
printf("Automatic ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
printf("External ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_STATIC)
printf("Static ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_REGISTER)
printf("Register ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_EXTERNAL_DEF)
printf("External Def ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_LABEL)
printf("Label ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_UNDEFINED_LABEL)
printf("Undefined Label ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_MEMBER_OF_STRUCT)
printf("Member Of Struct ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_ARGUMENT)
printf("Argument ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_STRUCT_TAG)
printf("Struct Tag ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_MEMBER_OF_UNION)
printf("Member Of Union ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_UNION_TAG)
printf("Union Tag ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_TYPE_DEFINITION)
printf("Type Definition ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_UNDEFINED_STATIC)
printf("Undefined Static ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_ENUM_TAG)
printf("Enum Tag ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_MEMBER_OF_ENUM)
printf("Member Of Enum ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_REGISTER_PARAM)
printf("Register Param ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_BIT_FIELD)
printf("Bit Field ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_BLOCK)
printf("Block ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_FUNCTION)
printf("Function ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_END_OF_STRUCT)
printf("End Of Struct ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_FILE)
printf("File ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_SECTION)
printf("Section ");
if (SymTable[SymIndex].StorageClass == IMAGE_SYM_CLASS_WEAK_EXTERNAL)
printf("Weak External ");
printf("| %s", GetSymbolName(SymIndex));
SymIndex += SymTable[SymIndex].NumberOfAuxSymbols;
printf("\n");
}
printf("\n");
}
void CCOF2ASM::MakeSymbolList() {
// Make Symbols list in Disasm
uint32 isym; // Symbol index
uint32 naux = 0; // Number of auxiliary entries in old symbol table
union { // Pointer to old symbol table entries
SCOFF_SymTableEntry * p; // Normal pointer
int8 * b; // Used for address calculation
} Sym, SymAux;
// Set pointer to old SymbolTable
Sym.p = SymbolTable;
// Loop through old symbol table
for (isym = 0; isym < (uint32)NumberOfSymbols; isym += 1+naux, Sym.b += (1+naux) * SIZE_SCOFF_SymTableEntry) {
// Number of auxiliary entries
naux = Sym.p->s.NumAuxSymbols;
if (Sym.p->s.SectionNumber != COFF_SECTION_ABSOLUTE
&& (Sym.p->s.SectionNumber < 0
|| (Sym.p->s.StorageClass != COFF_CLASS_EXTERNAL && Sym.p->s.StorageClass != COFF_CLASS_STATIC && Sym.p->s.StorageClass != COFF_CLASS_LABEL))) {
// Ignore irrelevant symbol table entries
continue;
}
// Symbol properties
uint32 Index = isym;
int32 Section = Sym.p->s.SectionNumber;
uint32 Offset = Sym.p->s.Value;
uint32 Size = 0;
uint32 Type = (Sym.p->s.Type == COFF_TYPE_FUNCTION) ? 0x83 : 0;
// Identify segment entries in symbol table
if (Sym.p->s.Value == 0 && Sym.p->s.StorageClass == COFF_CLASS_STATIC
&& naux && Sym.p->s.Type != 0x20) {
// Note: The official MS specification says that a symbol table entry
// is a section if the storage class is static and the value is 0,
// but I have encountered static functions that meet these criteria.
// Therefore, I am also checking Type and naux.
Type = 0x80000082;
}
const char * Name = GetSymbolName(Sym.p->s.Name);
// Get scope. Note that these values are different from the constants defined in maindef.h
uint32 Scope = 0;
if (Sym.p->s.StorageClass == COFF_CLASS_STATIC || Sym.p->s.StorageClass == COFF_CLASS_LABEL) {
Scope = 2; // Local
}
else if (Sym.p->s.SectionNumber > 0 || (Sym.p->s.SectionNumber == -1 && Sym.p->s.StorageClass == COFF_CLASS_EXTERNAL)) {
Scope = 4; // Public
}
else {
Scope = 0x20; // External
}
// Check auxiliary symbol table entries
if (naux && Sym.p->s.Type == COFF_TYPE_FUNCTION) {
// Function symbol has auxiliary entry. Get information about size
SymAux.b = Sym.b + SIZE_SCOFF_SymTableEntry;
Size = SymAux.p->func.TotalSize;
}
// Check for special section values
if (Section < 0) {
if (Section == COFF_SECTION_ABSOLUTE) {
// Symbol is an absolute constant
Section = ASM_SEGMENT_ABSOLUTE;
}
else {
// Debug symbols, etc
Section = ASM_SEGMENT_ERROR;
}
}
// Store new symbol record
Disasm.AddSymbol(Section, Offset, Size, Type, Scope, Index, Name);
}
}