static void DumpTypes(IDiaSession *session)
{
IDiaSymbol * globalScope = NULL;
IDiaEnumSymbols * enumSymbols = NULL;
IDiaSymbol * symbol = NULL;
HRESULT hr = session->get_globalScope(&globalScope);
if (FAILED(hr))
return;
AddReportSepLine();
g_report.Append("Types:\n");
DWORD flags = nsfCaseInsensitive|nsfUndecoratedName; // nsNone ?
hr = globalScope->findChildren(SymTagUDT, 0, flags, &enumSymbols);
if (FAILED(hr))
goto Exit;
ULONG celt = 0;
for (;;)
{
hr = enumSymbols->Next(1, &symbol, &celt);
if (FAILED(hr) || (celt != 1))
break;
DumpType(symbol, 0);
symbol->Release();
}
Exit:
UnkReleaseSafe(enumSymbols);
UnkReleaseSafe(globalScope);
}
//----------------------------------------------------------------------
static HRESULT for_all_children(
IDiaSymbol *sym,
enum SymTagEnum type,
children_visitor_t &cv)
{
IDiaEnumSymbols *pEnumSymbols;
HRESULT hr = sym->findChildren(type, NULL, nsNone, &pEnumSymbols);
if ( SUCCEEDED(hr) )
{
while ( true )
{
ULONG celt = 0;
IDiaSymbol *pChild;
hr = pEnumSymbols->Next(1, &pChild, &celt);
if ( FAILED(hr) || celt != 1 )
{
hr = S_OK; // end of enumeration
break;
}
hr = cv.visit_child(pChild);
pChild->Release();
if ( FAILED(hr) )
break;
}
pEnumSymbols->Release();
}
return hr;
}
static void DumpType(IDiaSymbol *symbol, int deep)
{
IDiaEnumSymbols * enumChilds = NULL;
HRESULT hr;
const char * nameStr = NULL;
const char * type;
LONG offset;
ULONGLONG length;
ULONG celt = 0;
ULONG symtag;
DWORD locType;
bool typeSeen;
#if 0
if (deep > 2)
return;
#endif
if (symbol->get_symTag(&symtag) != S_OK)
return;
nameStr = GetTypeName(symbol);
g_typesSeen.Intern(nameStr, &typeSeen);
if (typeSeen)
return;
symbol->get_length(&length);
symbol->get_offset(&offset);
if (SymTagData == symtag) {
if (symbol->get_locationType(&locType) != S_OK)
return; // must be a symbol in optimized code
// TODO: use get_offsetInUdt (http://msdn.microsoft.com/en-us/library/dd997149.aspx) ?
// TODO: use get_type (http://msdn.microsoft.com/en-US/library/cwx3656b(v=vs.80).aspx) ?
// TODO: see what else we can get http://msdn.microsoft.com/en-US/library/w8ae4k32(v=vs.80).aspx
if (LocIsThisRel == locType) {
g_report.AppendFmt("%s%s|%d\n", spaces(deep), nameStr, (int)offset);
}
} else if (SymTagUDT == symtag) {
// TODO: why is it always "struct" even for classes?
type = GetUdtType(symbol);
g_report.AppendFmt("%s%s|%s|%d\n", spaces(deep), type, nameStr, (int)length);
hr = symbol->findChildren(SymTagNull, NULL, nsNone, &enumChilds);
if (!SUCCEEDED(hr))
return;
IDiaSymbol* child;
while (SUCCEEDED(enumChilds->Next(1, &child, &celt)) && (celt == 1))
{
DumpType(child, deep+1);
child->Release();
}
enumChilds->Release();
} else {
if (symbol->get_locationType(&locType) != S_OK)
return; // must be a symbol in optimized code
// TODO: assert?
}
}
DDR_RC
PdbScanner::addEnumMembers(IDiaSymbol *symbol, EnumUDT *enumUDT)
{
DDR_RC rc = DDR_RC_OK;
/* All children symbols of a symbol for an Enum type should be
* enum members.
*/
IDiaEnumSymbols *enumSymbols = NULL;
HRESULT hr = symbol->findChildren(SymTagNull, NULL, nsNone, &enumSymbols);
if (FAILED(hr)) {
ERRMSG("findChildren() failed with HRESULT = %08lX", hr);
rc = DDR_RC_ERROR;
}
if (DDR_RC_OK == rc) {
vector<EnumMember *> *members = NULL;
NamespaceUDT *outerUDT = enumUDT->_outerNamespace;
/* literals of a nested anonymous enum are collected in the enclosing namespace */
if ((NULL != outerUDT) && enumUDT->isAnonymousType()) {
members = &outerUDT->_enumMembers;
} else {
members = &enumUDT->_enumMembers;
}
set<string> memberNames;
for (vector<EnumMember *>::iterator m = members->begin(); m != members->end(); ++m) {
memberNames.insert((*m)->_name);
}
IDiaSymbol *childSymbol = NULL;
ULONG celt = 0;
LONG count = 0;
enumSymbols->get_Count(&count);
members->reserve(count);
while (SUCCEEDED(enumSymbols->Next(1, &childSymbol, &celt))
&& (1 == celt)
&& (DDR_RC_OK == rc)
) {
string name = "";
int value = 0;
rc = getName(childSymbol, &name);
if (DDR_RC_OK == rc) {
VARIANT variantValue;
variantValue.vt = VT_EMPTY;
hr = childSymbol->get_value(&variantValue);
if (FAILED(hr)) {
ERRMSG("get_value() failed with HRESULT = %08lX", hr);
rc = DDR_RC_ERROR;
} else {
switch (variantValue.vt) {
case VT_I1:
value = variantValue.cVal;
break;
case VT_I2:
value = variantValue.iVal;
break;
case VT_I4:
value = (int)variantValue.lVal;
break;
case VT_UI1:
value = variantValue.bVal;
break;
case VT_UI2:
value = variantValue.uiVal;
break;
case VT_UI4:
value = (int)variantValue.ulVal;
break;
case VT_INT:
value = variantValue.intVal;
break;
case VT_UINT:
value = (int)variantValue.uintVal;
break;
default:
ERRMSG("get_value() unexpected variant: 0x%02X", variantValue.vt);
rc = DDR_RC_ERROR;
break;
}
}
}
if (DDR_RC_OK == rc) {
if (memberNames.end() == memberNames.find(name)) {
EnumMember *enumMember = new EnumMember;
enumMember->_name = name;
enumMember->_value = value;
members->push_back(enumMember);
memberNames.insert(name);
}
}
childSymbol->Release();
}
enumSymbols->Release();
}
return rc;
}
DDR_RC
PdbScanner::addChildrenSymbols(IDiaSymbol *symbol, enum SymTagEnum symTag, NamespaceUDT *outerNamespace)
{
DDR_RC rc = DDR_RC_OK;
IDiaEnumSymbols *classSymbols = NULL;
/* Find children symbols. SymTagUDT covers struct, union, and class symbols. */
HRESULT hr = symbol->findChildren(symTag, NULL, nsNone, &classSymbols);
if (FAILED(hr)) {
ERRMSG("findChildren() failed with HRESULT = %08lX", hr);
rc = DDR_RC_ERROR;
}
/* Allocate space for the children symbols. */
LONG count = 0;
if (DDR_RC_OK == rc) {
hr = classSymbols->get_Count(&count);
if (FAILED(hr)) {
ERRMSG("Failed to get count of children symbols with HRESULT = %08lX", hr);
rc = DDR_RC_ERROR;
}
}
IDiaSymbol **childSymbols = NULL;
ULONG celt = 0;
if ((DDR_RC_OK == rc) && (0 != count)) {
childSymbols = new IDiaSymbol*[count];
hr = classSymbols->Next(count, childSymbols, &celt);
if (FAILED(hr)) {
ERRMSG("Failed to get children symbols with HRESULT = %08lX", hr);
rc = DDR_RC_ERROR;
}
}
/* Iterate the children symbols, adding them to the IR.
* Inner symbols are first found with a decorated name and no
* parent reference. Ignore these for now and add the outer
* types first.
*/
vector<ULONG> innerTypeSymbols;
if (DDR_RC_OK == rc) {
bool alreadyHadFields = false;
bool alreadyCheckedFields = false;
bool alreadyHadSubtypes = false;
if (NULL != outerNamespace) {
alreadyHadSubtypes = !outerNamespace->_subUDTs.empty();
}
for (ULONG index = 0; index < celt; ++index) {
string udtName = "";
DWORD childTag = 0;
hr = childSymbols[index]->get_symTag(&childTag);
if (FAILED(hr)) {
ERRMSG("Failed to get child symbol SymTag with HRESULT = %08lX", hr);
rc = DDR_RC_ERROR;
}
if ((DDR_RC_OK == rc) && ((SymTagEnum == childTag) || (SymTagUDT == childTag))) {
rc = getName(childSymbols[index], &udtName);
}
if (DDR_RC_OK == rc) {
if ((NULL == outerNamespace) || (string::npos == udtName.find("::"))) {
/* When adding fields/subtypes to a type, only add fields to a type with no fields
* and only add subtypes to a type with no subtypes. This avoids adding duplicates
* fields/subtypes when scanning multiple files. Children symbols must be processed
* for already existing symbols because fields and subtypes can appear separately.
*/
if (!alreadyCheckedFields && (SymTagData == childTag)) {
alreadyCheckedFields = true;
alreadyHadFields = !((ClassType *)outerNamespace)->_fieldMembers.empty();
}
if (!((SymTagData == childTag) ? alreadyHadFields : alreadyHadSubtypes)) {
rc = addSymbol(childSymbols[index], outerNamespace);
}
childSymbols[index]->Release();
} else {
innerTypeSymbols.push_back(index);
}
}
if (DDR_RC_OK != rc) {
break;
}
}
}
/* Iterate the inner types. Only namespaces will be added to the IR
* here, since they have no associated symbol.
*/
if (DDR_RC_OK == rc) {
for (vector<ULONG>::iterator it = innerTypeSymbols.begin(); it != innerTypeSymbols.end() && DDR_RC_OK == rc; ++it) {
rc = addSymbol(childSymbols[*it], outerNamespace);
childSymbols[*it]->Release();
}
}
if (NULL != childSymbols) {
delete childSymbols;
}
if (NULL != classSymbols) {
classSymbols->Release();
}
return rc;
}
//-----------------------------------------------------------------------------
// Name: ParseModules
// Object: parse all compilands
// Parameters :
// in :
// out :
// return : TRUE on success
//-----------------------------------------------------------------------------
BOOL CDebugInfos::ParseModules()
{
HRESULT hr;
IDiaEnumSymbols* pEnumSymbols;
IDiaEnumSymbols* pEnumChildren;
IDiaSymbol* pCompiland;
IDiaSymbol* pSymbol;
ULONG celt = 0;
CModuleInfos* pModuleInfo;
BSTR Name;
// Retrieve the compilands first
if(FAILED(this->pDiaGlobalSymbol->findChildren(SymTagCompiland, NULL, nsNone, &pEnumSymbols)))
return FALSE;
// for each compiland
while(pEnumSymbols->Next(1, &pCompiland, &celt) == S_OK && celt == 1)
{
// Retrieve the name of the module
Name=NULL;
pCompiland->get_name(&Name);
#if (REMOVE_LINKER_COMPILAND==1)
// avoid to display "* Linker *" infos
if (Name)
{
if (wcsicmp(Name,LINKER_COMPILAND_NAME)==0)
{
SysFreeString(Name);
pCompiland->Release();
continue;
}
}
#endif
// create module info
pModuleInfo=new CModuleInfos();
// add it to modules list
this->pLinkListModules->AddItem(pModuleInfo);
// assume module name is set
if (Name)
{
#if (defined(UNICODE)||defined(_UNICODE))
pModuleInfo->Name=_tcsdup(Name);
#else
CAnsiUnicodeConvert::UnicodeToAnsi(Name,&pModuleInfo->Name);
#endif
SysFreeString(Name);
}
else
pModuleInfo->Name=_tcsdup(_T(""));
// Find all the symbols defined in this compiland and get their info
if(SUCCEEDED(pCompiland->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren)))
{
ULONG celt_ = 0;
while (pEnumChildren->Next(1, &pSymbol, &celt_) == S_OK && celt_ == 1)
{
hr=pModuleInfo->Parse(pSymbol);
if (FAILED(hr))
this->ReportError(_T("Error parsing module information"),hr);
pSymbol->Release();
}
pEnumChildren->Release();
}
pCompiland->Release();
}
pEnumSymbols->Release();
return TRUE;
}
HRESULT SymBase::GetInfoTable( SymbolInfoTable &InfoTable )
{
HRESULT hr;
ULONG SymULONG;
LPCWSTR SymStr;
BSTR SymBStr;
BOOL SymBOOL;
IDiaSymbol *SymSymbol;
IDiaEnumSymbols *SymEnum;
BOOL TableRet;
CString Tmp;
//
// Children
//
hr = Self()->findChildren(SymTagNull, NULL, nsNone, &SymEnum);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CHILDREN, BOOL_STR(SymEnum != NULL));
VERIFY_EXP(TableRet);
SymEnum->Release();
}
//
// access
//
hr = Self()->get_access(&SymULONG);
if (HR_OK(hr)) {
SymStr = GetAccessStr(SymULONG);
TableRet = InfoTable.Add(SYMBOL_ACCESS, SymStr);
VERIFY_EXP(TableRet);
}
//
// addressOffset
//
hr = Self()->get_addressOffset(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_ADDRESSOFFSET, Tmp);
VERIFY_EXP(TableRet);
}
//
// addressSection
//
hr = Self()->get_addressSection(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_ADDRESSSECTION, Tmp);
VERIFY_EXP(TableRet);
}
//
// addressTaken
//
hr = Self()->get_addressTaken(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ADDRESSTAKEN, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// age
//
hr = Self()->get_age(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_AGE, Tmp);
VERIFY_EXP(TableRet);
}
//
// arrayIndexType
//
hr = Self()->get_arrayIndexType(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ARRAYINDEXTYPE, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// arrayIndexTypeId
//
hr = Self()->get_arrayIndexTypeId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_ARRAYINDEXTYPEID, Tmp);
VERIFY_EXP(TableRet);
}
//
// backEndMajor (Not implement)
//
//
// backEndMinor (Not implement)
//
//
// backEndBuild (Not implement)
//
//
// baseType
//
hr = Self()->get_baseType(&SymULONG);
if (HR_OK(hr)) {
SymStr = GetBaseTypeStr(SymULONG, 0);
TableRet = InfoTable.Add(SYMBOL_BASETYPE, SymStr);
VERIFY_EXP(TableRet);
}
//
// bitPosition
//
hr = Self()->get_bitPosition(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_BITPOSITION, Tmp);
VERIFY_EXP(TableRet);
}
//
// callingConvention
//
hr = Self()->get_callingConvention(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CALLINGCONVENTION, GetCallingConventionStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// classParent
//
hr = Self()->get_classParent(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CLASSPARENT, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// classParentId
//
hr = Self()->get_classParentId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_CLASSPARENTID, Tmp);
VERIFY_EXP(TableRet);
}
//
// code
//
hr = Self()->get_code(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CODE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// compilerGenerated
//
hr = Self()->get_compilerGenerated(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_COMPILERGENERATED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// compilerName
//
hr = Self()->get_compilerName(&SymBStr);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_COMPILERNAME, SymBStr);
VERIFY_EXP(TableRet);
}
//
// constructor
//
hr = Self()->get_constructor(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CONSTRUCTOR, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// container
//
hr = Self()->get_container(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CONTAINER, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// constType
//
hr = Self()->get_constType(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CONSTTYPE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// count
//
hr = Self()->get_count(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_COUNT, Tmp);
VERIFY_EXP(TableRet);
}
//
// customCallingConvention
//
hr = Self()->get_customCallingConvention(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CUSTOMCALLINGCONVENTION, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// dataBytes (Not implement)
//
//
// dataKind
//
hr = Self()->get_dataKind(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_DATAKIND, GetDataKindStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// editAndContinueEnabled
//
hr = Self()->get_editAndContinueEnabled(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_EDITANDCONTINUEENABLED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// farReturn
//
hr = Self()->get_farReturn(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_FARRETURN, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// frontEndMajor (Not implement)
//
//
// frontEndMinor (Not implement)
//
//
// frontEndBuild (Not implement)
//
//
// function
//
hr = Self()->get_function(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_FARRETURN, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// guid
//
GUID SymGuid;
hr = Self()->get_guid(&SymGuid);
if (HR_OK(hr)) {
Tmp.Format(L"{%08X-%04X-%04x-%02X%02X-%02X%02X%02X%02X%02X%02X} ",
SymGuid.Data1, SymGuid.Data2, SymGuid.Data3, SymGuid.Data4[0],
SymGuid.Data4[1], SymGuid.Data4[2], SymGuid.Data4[3],
SymGuid.Data4[4], SymGuid.Data4[5],
SymGuid.Data4[6], SymGuid.Data4[7]);
TableRet = InfoTable.Add(SYMBOL_GUID, Tmp);
VERIFY_EXP(TableRet);
}
//
// hasAlloca
//
hr = Self()->get_hasAlloca(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASALLOCA, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasAssignmentOperator
//
hr = Self()->get_hasAssignmentOperator(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASASSIGNMENTOPERATOR, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasCastOperator
//
hr = Self()->get_hasCastOperator(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASCASTOPERATOR, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasDebugInfo
//
hr = Self()->get_hasDebugInfo(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASDEBUGINFO, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasEH
//
hr = Self()->get_hasEH(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASEH, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasEHa
//
hr = Self()->get_hasEHa(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASEHA, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasInlAsm
//
hr = Self()->get_hasInlAsm(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASINLASM, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasLongJump
//
hr = Self()->get_hasLongJump(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASLONGJUMP, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasManagedCode
//
hr = Self()->get_hasManagedCode(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASMANAGEDCODE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasNestedTypes
//
hr = Self()->get_hasNestedTypes(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASNESTEDTYPES, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasSecurityChecks
//
hr = Self()->get_hasSecurityChecks(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASSECURITYCHECKS, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasSEH
//
hr = Self()->get_hasSEH(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASSEH, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasSetJump
//
hr = Self()->get_hasSetJump(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASSETJUMP, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// indirectVirtualBaseClass
//
hr = Self()->get_indirectVirtualBaseClass(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_INDIRECTVIRTUALBASECLASS, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// inlSpec
//
hr = Self()->get_inlSpec(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_INLSPEC, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// interruptReturn
//
hr = Self()->get_interruptReturn(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_INTERRUPTRETURN, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// intro
//
hr = Self()->get_intro(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_INTRO, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isAggregated
//
hr = Self()->get_isAggregated(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISAGGREGATED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isCTypes
//
hr = Self()->get_isCTypes(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISCTYPES, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isCVTCIL
//
hr = Self()->get_isCVTCIL(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISCVTCIL, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isDataAligned
//
hr = Self()->get_isDataAligned(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISDATAALIGNED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isHotpatchable
//
hr = Self()->get_isHotpatchable(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISHOTPATCHABLE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isLTCG
//
hr = Self()->get_isLTCG(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISLTCG, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isMSILNetmodule
//
hr = Self()->get_isMSILNetmodule(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISMSILNETMODULE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isNaked
//
hr = Self()->get_isNaked(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISNAKED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isSplitted
//
hr = Self()->get_isSplitted(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISSPLITTED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isStatic
//
hr = Self()->get_isStatic(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISSTATIC, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isStripped
//
hr = Self()->get_isStripped(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISSTRIPPED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// language
//
hr = Self()->get_language(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_LANGUAGE, GetLanguageStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// length
//
ULONGLONG SymULONGLONG;
hr = Self()->get_length(&SymULONGLONG);
if (HR_OK(hr)) {
Tmp.Format(L"%0.16I64X", SymULONGLONG);
TableRet = InfoTable.Add(SYMBOL_LENGTH, Tmp);
VERIFY_EXP(TableRet);
}
//
// lexicalParent
//
hr = Self()->get_lexicalParent(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_LEXICALPARENT, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// lexicalParentId
//
hr = Self()->get_lexicalParentId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_LEXICALPARENTID, Tmp);
VERIFY_EXP(TableRet);
}
//
// libraryName
//
hr = Self()->get_libraryName(&SymBStr);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_LIBRARYNAME, SymBStr);
VERIFY_EXP(TableRet);
}
//
// liveLVarInstances (Not implement)
//
//
// locationType
//
hr = Self()->get_locationType(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_LOCATIONTYPE, GetLocationTypeStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// lowerBound (Not implement)
//
//
// lowerBoundId (Not implement)
//
//
// machineType
//
hr = Self()->get_machineType(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_MACHINETYPE, GetMachineTypeStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// managed
//
hr = Self()->get_managed(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_MANAGED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// msil
//
hr = Self()->get_msil(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_MSIL, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// name
//
hr = Self()->get_name(&SymBStr);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_NAME, SymBStr);
VERIFY_EXP(TableRet);
}
//
// nested
//
hr = Self()->get_nested(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_NESTED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// noInline
//
hr = Self()->get_noInline(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_NOINLINE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// noReturn
//
hr = Self()->get_noReturn(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_NORETURN, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// noStackOrdering
//
hr = Self()->get_noStackOrdering(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_NOSTACKORDERING, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// notReached
//
hr = Self()->get_notReached(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_NOTREACHED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// objectPointerType
//
hr = Self()->get_objectPointerType(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_OBJECTPOINTERTYPE, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// oemId
//
hr = Self()->get_oemId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_OEMID, Tmp);
VERIFY_EXP(TableRet);
}
//
// oemSymbolId
//
hr = Self()->get_oemSymbolId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_OEMSYMBOLID, Tmp);
VERIFY_EXP(TableRet);
}
//
// offset
//
LONG SymLONG;
hr = Self()->get_offset(&SymLONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymLONG);
TableRet = InfoTable.Add(SYMBOL_OFFSET, Tmp);
VERIFY_EXP(TableRet);
}
//
// optimizedCodeDebugInfo
//
hr = Self()->get_optimizedCodeDebugInfo(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_OPTIMIZEDCODEDEBUGINFO, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// overloadedOperator
//
hr = Self()->get_overloadedOperator(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_OVERLOADEDOPERATOR, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// packed
//
hr = Self()->get_packed(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_PACKED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// platform
//
hr = Self()->get_platform(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_OEMSYMBOLID, GetMachineTypeStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// pure
//
hr = Self()->get_pure(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_PURE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// rank (Not implement)
//
//
// reference
//
hr = Self()->get_reference(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_REFERENCE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// registerId
//
hr = Self()->get_platform(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_REGISTERID, GetMachineTypeStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// relativeVirtualAddress
//
hr = Self()->get_platform(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_RELATIVEVIRTUALADDRESS, GetMachineTypeStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// scoped
//
hr = Self()->get_scoped(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_SCOPED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// signature
//
hr = Self()->get_signature(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_SIGNATURE, Tmp);
VERIFY_EXP(TableRet);
}
//
// slot
//
hr = Self()->get_slot(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_SLOT, Tmp);
VERIFY_EXP(TableRet);
}
//
// sourceFileName
//
hr = Self()->get_sourceFileName(&SymBStr);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_SOURCEFILENAME, SymBStr);
VERIFY_EXP(TableRet);
}
//
// symbolsFileName
//
hr = Self()->get_symbolsFileName(&SymBStr);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_SYMBOLSFILENAME, SymBStr);
VERIFY_EXP(TableRet);
}
//
// symIndexId
//
hr = Self()->get_symIndexId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_SYMINDEXID, Tmp);
VERIFY_EXP(TableRet);
}
//
// symTag
//
hr = Self()->get_symTag(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_SYMTAG, GetSymTagStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// targetOffset
//
hr = Self()->get_targetOffset(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_SYMINDEXID, Tmp);
VERIFY_EXP(TableRet);
}
//
// targetRelativeVirtualAddress
//
hr = Self()->get_targetRelativeVirtualAddress(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_TARGETRELATIVEVIRTUALADDRESS, Tmp);
VERIFY_EXP(TableRet);
}
//
// targetSection
//
hr = Self()->get_targetSection(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_TARGETSECTION, Tmp);
VERIFY_EXP(TableRet);
}
//
// targetVirtualAddress
//
hr = Self()->get_targetVirtualAddress(&SymULONGLONG);
if (HR_OK(hr)) {
Tmp.Format(L"%0.16I64X", SymULONGLONG);
TableRet = InfoTable.Add(SYMBOL_TARGETVIRTUALADDRESS, Tmp);
VERIFY_EXP(TableRet);
}
//
// thisAdjust
//
hr = Self()->get_thisAdjust(&SymLONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymLONG);
TableRet = InfoTable.Add(SYMBOL_THISADJUST, Tmp);
VERIFY_EXP(TableRet);
}
//
// thunkOrdinal
//
hr = Self()->get_thunkOrdinal(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_THISADJUST, Tmp);
VERIFY_EXP(TableRet);
}
//
// timeStamp
//
hr = Self()->get_timeStamp(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_TIMESTAMP, Tmp);
VERIFY_EXP(TableRet);
}
//
// token
//
hr = Self()->get_token(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_TOKEN, Tmp);
VERIFY_EXP(TableRet);
}
//
// type
//
hr = Self()->get_type(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_TYPE, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// typeId
//
hr = Self()->get_typeId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_TYPEID, Tmp);
VERIFY_EXP(TableRet);
}
//
// types (Not implement)
//
//
// typeIds (Not implement)
//
//
// udtKind
//
hr = Self()->get_udtKind(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_UDTKIND, GetUdtKindStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// unalignedType
//
hr = Self()->get_unalignedType(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_UNALIGNEDTYPE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// undecoratedName
//
hr = Self()->get_undecoratedName(&SymBStr);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_UNDECORATEDNAME, SymBStr);
VERIFY_EXP(TableRet);
}
//
// undecoratedNameEx (Not implement)
//
//
// upperBound (Not implement)
//
//
// upperBoundId (Not implement)
//
//
// value
//
VARIANT SymVar;
SymVar.vt = VT_EMPTY;
hr = Self()->get_value(&SymVar);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_VALUE, L"TRUE");
VERIFY_EXP(TableRet);
}
//
// virtual
//
hr = Self()->get_virtual(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_VIRTUAL, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// virtualAddress
//
hr = Self()->get_virtualAddress(&SymULONGLONG);
if (HR_OK(hr)) {
Tmp.Format(L"%0.16I64X", SymULONGLONG);
TableRet = InfoTable.Add(SYMBOL_VIRTUALADDRESS, Tmp);
VERIFY_EXP(TableRet);
}
//
// virtualBaseClass
//
hr = Self()->get_virtualBaseClass(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_VIRTUALBASECLASS, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// virtualBaseDispIndex
//
hr = Self()->get_virtualBaseDispIndex(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_VIRTUALBASEDISPINDEX, Tmp);
VERIFY_EXP(TableRet);
}
//
// virtualBaseOffset
//
hr = Self()->get_virtualBaseOffset(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_VIRTUALBASEOFFSET, Tmp);
VERIFY_EXP(TableRet);
}
//
// virtualBasePointerOffset
//
hr = Self()->get_virtualBasePointerOffset(&SymLONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymLONG);
TableRet = InfoTable.Add(SYMBOL_VIRTUALBASEPOINTEROFFSET, Tmp);
VERIFY_EXP(TableRet);
}
//
// virtualBaseTableType
//
hr = Self()->get_virtualBaseTableType(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_VIRTUALBASETABLETYPE, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// virtualTableShape
//
hr = Self()->get_virtualTableShape(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_VIRTUALTABLESHAPE, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// virtualTableShapeId
//
hr = Self()->get_virtualTableShapeId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_VIRTUALTABLESHAPEID, Tmp);
VERIFY_EXP(TableRet);
}
//
// volatileType
//
hr = Self()->get_volatileType(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_VOLATILETYPE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
#ifdef DEBUG_PRINT
DisplayInfo(InfoTable);
#endif
return S_OK;
}