static void dumpSymbolNameInfo( // DUMP SYMBOL_NAME ENTRY
SYMBOL_NAME sn ) // - the entry
{
DumpSymbolName( sn );
DumpSymbol( sn->name_type );
RingWalk( sn->name_syms, &DumpSymbol );
}
//-----------------------------------------------------------------------------
// GetSymbolPointer - find record for name, restricted by type.
//-----------------------------------------------------------------------------
// from current context or wider.
//-----------------------------------------------------------------------------
Symbol *GetSymbolPointer(Context *co, char *SymbolName, int SymbolType, int IncludeGlobal)
{ Symbol *s;
CodeOutput(VERBOSE_L, "\n// GetSymbolPointer params co: %x, SymbolName: %s, Type: %d, IncludeGolbal: %d\n",
co, SymbolName, SymbolType, IncludeGlobal);
for (;co != NULL; co=co->Wider) {
CodeOutput(VERBOSE_XL, "\n// GetSymbolPointer co %x\n", co);
// return if Global scope is not included.
if ((co->IsGlobal) && (IncludeGlobal == 0)) return NULL;
CodeOutput(VERBOSE_XL, "// GetSymbolPointer mark 1\n");
for(s = co->Head; s != NULL; s = s->Next) {
CodeOutput(VERBOSE_XL, "\n// GetSymbolPointer s %x\n", s);
// check name
if (strcmp(SymbolName, s->Name) != 0) continue;
CodeOutput(VERBOSE_XL, "// GetSymbolPointer mark 2\n");
// check Type
if ((s->Type & SymbolType) == 0) continue;
CodeOutput(VERBOSE_XL, "// GetSymbolPointer mark 3\n");
// -----
// match
// -----
for (;;) {
// alias resolving
if (s->Type == S_ALIAS) {
CodeOutput(VERBOSE_XL, "// alias resolve step\n");
DumpSymbol(VERBOSE_XL, s);
s = s->details;
} else {
break;
}
}
CodeOutput(VERBOSE_L, "// matched symbol:\n");
DumpSymbol(VERBOSE_L, s);
return s;
}
}
return NULL; // no match
}
void DumpSymInfo( // DUMP COMPLETE INFO FOR SYMBOL
SYMBOL sym ) // - symbol
{
print_delimit_line();
DumpSymbol( sym );
if( sym->name != NULL ) {
DumpSymbolName( sym->name );
}
}
static void DumpSymbols(IDiaSession *session)
{
HRESULT hr;
IDiaEnumSymbolsByAddr * enumByAddr = NULL;
IDiaSymbol * symbol = NULL;
hr = session->getSymbolsByAddr(&enumByAddr);
if (!SUCCEEDED(hr))
goto Exit;
// get first symbol to get first RVA (argh)
hr = enumByAddr->symbolByAddr(1, 0, &symbol);
if (!SUCCEEDED(hr))
goto Exit;
DWORD rva;
hr = symbol->get_relativeVirtualAddress(&rva);
if (S_OK != hr)
goto Exit;
symbol->Release();
symbol = NULL;
// enumerate by rva
hr = enumByAddr->symbolByRVA(rva, &symbol);
if (!SUCCEEDED(hr))
goto Exit;
AddReportSepLine();
g_report.Append("Symbols:\n");
ULONG numFetched;
for (;;)
{
DumpSymbol(symbol);
symbol->Release();
symbol = NULL;
hr = enumByAddr->Next(1, &symbol, &numFetched);
if (FAILED(hr) || (numFetched != 1))
break;
}
Exit:
UnkReleaseSafe(symbol);
UnkReleaseSafe(enumByAddr);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void DumpContext(Context *co)
{ Symbol *s;
CodeOutput(VERBOSE_ALL, "\n//DumpContext -------------------------------\n");
for (;;) {
if (co == NULL) break;
CodeOutput(VERBOSE_ALL, "//\n//Context %x, IsGlobal: %d\n", co, co->IsGlobal);
for(s = co->Head; s != NULL; s = s->Next) {
if (s== NULL) break;
//CodeOutput(VERBOSE_ALL, "DumpSymbolTable %x\n", s);
DumpSymbol(VERBOSE_ALL, s);
}
co = co->Wider;
}
}
static void dumpPTreeNode( // DUMP A PARSE TREE NODE
PTREE node ) // - node in parse tree
{
static char buffer[128]; // - debugging buffer
char *node_name; // - name of node
VSTK_CTL ctl; // - VSTK control information (nodes)
VSTK_CTL dup; // - VSTK control information (duplicates)
int dup_out; // - last duplicate printed
VstkOpen( &ctl, sizeof( PTREE ), 32 );
VstkOpen( &dup, sizeof( PTREE ), 8 );
dup_out = -1;
for( ; ; ) {
switch( node->op ) {
case PT_ERROR :
printf( "PT_ERROR" F_BADDR
" ***** ERROR TREE *****" F_EOL
, node
);
break;
case PT_INT_CONSTANT :
node_name = "PT_INT_CONSTANT";
printf( F_NAME F_BADDR
" flags" F_HEX_4
" type" F_PTR
, node_name
, node
, node->flags
, node->type
);
if( NULL == Integral64Type( node->type ) ) {
printf( " integer" F_HEX_4
, node->u.int_constant
);
} else {
printf( " integer-64" F_S64
, VAL64( node->u.int64_constant )
);
}
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
case PT_FLOATING_CONSTANT : {
char buffer[256];
BFCnvFS( node->u.floating_constant, buffer, 256 );
printf( "PT_FLOATING_CONSTANT" F_BADDR
" flags" F_HEX_4
" float" F_CPP_FLOAT
, node
, node->flags
, buffer
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
}
break;
case PT_STRING_CONSTANT :
stvcpy( buffer, node->u.string->string, node->u.string->len );
printf( "PT_STRING_CONSTANT" F_BADDR
" flags" F_HEX_4
" string" F_STRING
, node
, node->flags
, buffer
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
case PT_ID :
printf( "PT_ID" F_BADDR
" flags" F_HEX_4
" cgop" F_STRING F_NL
" id" F_PTR
"=" F_STRING
" id_cgop" F_STRING
" u.id.scope" F_PTR
, node
, node->flags
, DbgOperator( node->cgop )
, node->u.id.name
, NameStr( node->u.id.name )
, DbgOperator( node->id_cgop )
, node->u.id.scope
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
case PT_TYPE :
printf( "PT_TYPE" F_BADDR
" cgop" F_STRING
" flags" F_HEX_4
" next" F_PTR
" scope" F_PTR
, node
, DbgOperator( node->cgop )
, node->flags
, node->u.type.next
, node->u.type.scope
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
case PT_SYMBOL :
if( node->cgop == CO_NAME_THIS ) {
printf( "PT_SYMBOL" F_BADDR
" flags" F_HEX_4
" this "
, node
, node->flags
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
} else if( node->cgop == CO_NAME_CDTOR_EXTRA ) {
printf( "PT_SYMBOL" F_BADDR
" flags" F_HEX_4
" cdtor_extra_parm "
, node
, node->flags
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
} else {
printf( "PT_SYMBOL" F_BADDR
" flags" F_HEX_4
" cgop" F_STRING F_NL
" symbol" F_PTR
" result" F_PTR
, node
, node->flags
, DbgOperator( node->cgop )
, node->u.symcg.symbol
, node->u.symcg.result
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
DumpSymbol( node->u.symcg.symbol );
}
break;
case PT_UNARY :
printf( "PT_UNARY" F_BADDR
F_POINTS F_ADDR
" flags" F_HEX_4
" cgop" F_STRING
, node
, node->u.subtree[0]
, node->flags
, DbgOperator( node->cgop )
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
PUSH_NODE( ctl, node->u.subtree[0] );
break;
case PT_BINARY :
printf( "PT_BINARY" F_BADDR
F_POINTS F_ADDR
"," F_ADDR
" flags" F_HEX_4
" cgop" F_STRING
, node
, node->u.subtree[0]
, node->u.subtree[1]
, node->flags
, DbgOperator( node->cgop )
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
PUSH_NODE( ctl, node->u.subtree[1] );
PUSH_NODE( ctl, node->u.subtree[0] );
break;
case PT_DUP_EXPR :
{ PTREE *duped; // - duplicated expression
printf( "PT_DUP_EXPR" F_BADDR
F_POINTS F_ADDR
" flags" F_HEX_4
" node" F_ADDR
, node
, node->u.dup.subtree[0]
, node->flags
, node->u.dup.node
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
if( node->u.subtree[0] != NULL ) {
for( duped = VstkTop( &dup )
;
; duped = VstkNext( &dup, duped ) ) {
if( duped == NULL ) {
PUSH_NODE( dup, node->u.subtree[0] );
} else if( *duped == node->u.subtree[0] ) {
break;
}
}
}
} break;
case PT_IC :
printf( "PT_IC" F_BADDR
" " F_NAME
" value" F_ADDR
, node
, DbgIcOpcode( node->u.ic.opcode )
, node->u.ic.value.pvalue
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
default :
printf( "***INVALID***" F_BADDR
" flags" F_HEX_4
" op" F_HEX_1
, node
, node->flags
, node->op
);
dumpNodeType( node );
dumpLocation( &node->locn );
dumpPtreeFlags( node );
break;
}
{
PTREE *next; // - addr[next node]
next = VstkPop( &ctl );
if( next != NULL ) {
node = *next;
} else {
++dup_out;
if( dup_out > VstkDimension( &dup ) ) break;
next = VstkIndex( &dup, dup_out );
printf( "--------------- duplicate ------------\n" );
node = *next;
}
}
}
VstkClose( &ctl );
VstkClose( &dup );
}