public SymbolValue(string name, string typeName, string strValue, uint size, DEBUG_SYMBOL_ENTRY debugSymbolEntry, DEBUG_SYMBOL_PARAMETERS debugSymbolParameters)
{
Name = name;
TypeName = typeName;
StrValue = strValue;
Size = size;
DebugSymbolEntry = debugSymbolEntry;
DebugSymbolParameters = debugSymbolParameters;
}
} // end WireUpChildren()
/// <summary>
/// Creates a new DbgLocalSymbol object.
/// </summary>
internal DbgLocalSymbol(DbgSymbolGroup symGroup,
uint idx,
string name,
DEBUG_SYMBOL_PARAMETERS symParams,
DEBUG_SYMBOL_ENTRY?dse,
DbgTarget target)
: base(_GetDebugger(symGroup), name, target)
{
if (null == symGroup)
{
throw new ArgumentNullException("symGroup");
}
m_symGroup = symGroup;
m_idx = idx;
m_nativeParams = symParams;
m_dse = dse;
m_metaDataUnavailable = (null == dse);
if (!m_metaDataUnavailable && DbgTypeInfo.IsDbgGeneratedType(m_dse.Value.TypeId))
{
// HACK HACKALERT WORKAROUND
//
// This is a workaround for the fact that we can't get at the type
// information that the debugger generates. It tends to do this to create
// pointer types, pointing to UDTs (not sure why the pointer types don't
// exist in the PDB).
//
// It of course knows what the pointee type is, but it isn't exposed in
// any way. I'd like to add a new IDebugAdvancedN::Request request to grab
// it out, but until I get to that, I'll cheat and parse it out of some
// string output.
//
// I don't know how robust this is, because I've rarely seen it (only once
// with this code).
//
_GenerateSyntheticTypeToMatchDbgEngGeneratedType(name, Debugger, m_dse.Value);
} // end if( it's a debugger-generated type )
m_pointerAdjustment = 0;
if (0 == Util.Strcmp_OI(name, "this"))
{
try
{
ulong displacementDontCare;
var sym = Debugger.GetSymbolByAddress(symGroup.Frame.InstructionPointer, out displacementDontCare);
var ftti = sym.Type as DbgFunctionTypeTypeInfo;
Util.Assert(null != ftti); // if we made it this far, we should have the right type
m_pointerAdjustment = ftti.ThisAdjust;
}
catch (DbgEngException dee)
{
LogManager.Trace("Could not get thisadjust: {0}", Util.GetExceptionMessages(dee));
}
}
} // end constructor
internal void Refresh(uint idx,
DEBUG_SYMBOL_PARAMETERS nativeParams,
DEBUG_SYMBOL_ENTRY?dse)
{
if (null != m_orphanChildren)
{
m_orphanChildren.Clear(); // in preparation for WireUpChildren being called again.
}
m_idx = idx;
m_nativeParams = nativeParams;
m_dse = dse;
} // end Refresh()
private DEBUG_SYMBOL_PARAMETERS[] GetSymbolParameters(uint start, uint count)
{
DEBUG_SYMBOL_PARAMETERS[] parameters = new DEBUG_SYMBOL_PARAMETERS[count];
if (count > 0)
{
int res = _group.GetSymbolParameters(start, count, parameters);
if (res != 0)
{
ThrowDebuggerException(res, "IDebugSymbolGroups2.GetSymbolParameters");
}
}
return(parameters);
}
} // end constructor
public SymbolIdentity(string name,
DEBUG_SYMBOL_PARAMETERS nativeParams,
DEBUG_SYMBOL_ENTRY?dse,
DbgEngContext processContext)
{
Name = name;
ModuleBase = nativeParams.Module;
if (null == dse)
{
Offset = DebuggerObject.InvalidAddress;
}
else
{
Offset = ((DEBUG_SYMBOL_ENTRY)dse).Offset;
}
_SetContext(processContext);
} // end constructor
private IEnumerable<Variable> DoGetVariablesFromSymbols(IDebugSymbolGroup2 symbols, uint startIndex, uint parentSymbolListIndex, int parentId)
{
List<Variable> result = new List<Variable>();
uint variableCount;
var hr = symbols.GetNumberSymbols(out variableCount);
if (hr != HResult.Ok)
return result;
DEBUG_SYMBOL_PARAMETERS[] parameters = new DEBUG_SYMBOL_PARAMETERS[variableCount];
hr = symbols.GetSymbolParameters(0, variableCount, parameters);
if (hr != HResult.Ok)
return result;
for (uint variableIndex = startIndex; variableIndex < variableCount; variableIndex++)
{
if (parentSymbolListIndex != Defaults.NoParent && !IsChild(parentSymbolListIndex, parameters, variableIndex))
continue;
DEBUG_SYMBOL_ENTRY entry;
symbols.GetSymbolEntryInformation(variableIndex, out entry);
StringBuilder buffer = new StringBuilder(Defaults.BufferSize);
uint nameSize;
hr = symbols.GetSymbolNameWide(variableIndex, buffer, Defaults.BufferSize, out nameSize);
if (hr != HResult.Ok)
continue;
var variableName = buffer.ToString();
hr = symbols.GetSymbolTypeNameWide(variableIndex, buffer, Defaults.BufferSize, out nameSize);
if (hr != HResult.Ok)
continue;
var typeName = buffer.ToString();
hr = symbols.GetSymbolValueTextWide(variableIndex, buffer, Defaults.BufferSize, out nameSize);
if (hr != HResult.Ok)
continue;
var value = buffer.ToString();
var typedData = _requestHelper.CreateTypedData(entry.ModuleBase, entry.Offset, entry.TypeId);
VisualizationResult handledVariable;
Variable variable;
if (_visualizers.TryHandle(new VariableMetaData(variableName, typeName, typedData), out handledVariable))
{
variable = State.AddVariable(
parentId,
(id) => new Variable(id, variableName, typeName, handledVariable.Value, handledVariable.HasChildren),
typedData);
}
else
{
bool hasChildren = false;
if (parameters.Length > variableIndex)
hasChildren = parameters[variableIndex].SubElements > 0;
variable = State.AddVariable(parentId, (id) => new Variable(id, variableName, typeName, value, hasChildren), typedData);
}
result.Add(variable);
}
return result;
}
public void AddSymbol(string name, string typeName, string strValue, uint size, DEBUG_SYMBOL_ENTRY debugSymbolEntry, DEBUG_SYMBOL_PARAMETERS debugSymbolParameters)
{
_symbols.Add(new SymbolValue(name, typeName, strValue, size, debugSymbolEntry, debugSymbolParameters));
}
