public static void PyCode_New(DkmThread thread, ulong frameBase, ulong vframe, ulong returnAddress)
{
var process = thread.Process;
var cppEval = new CppExpressionEvaluator(thread, frameBase, vframe);
var filenamePtr = cppEval.EvaluateUInt64("filename");
var filenameObj = PyObject.FromAddress(process, filenamePtr) as IPyBaseStringObject;
if (filenameObj == null)
{
return;
}
string filename = filenameObj.ToString();
if (process.GetPythonRuntimeInstance().GetModuleInstances().Any(mi => mi.FullName == filename))
{
return;
}
new RemoteComponent.CreateModuleRequest {
ModuleId = Guid.NewGuid(),
FileName = filename
}.SendLower(process);
}
static FactoryBuilder()
{
FactoryFunc nonPolymorphicFactory;
var ctor = typeof(TProxy).GetConstructor(new[] { typeof(DkmProcess), typeof(ulong) });
if (ctor != null)
{
var processParam = Expression.Parameter(typeof(DkmProcess));
var addressParam = Expression.Parameter(typeof(ulong));
var polymorphicParam = Expression.Parameter(typeof(bool));
nonPolymorphicFactory = Expression.Lambda <FactoryFunc>(
Expression.New(ctor, processParam, addressParam),
new[] { processParam, addressParam, polymorphicParam })
.Compile();
}
else
{
nonPolymorphicFactory = (process, address, polymorphic) =>
{
Debug.Fail("IDebuggeeReference-derived type " + typeof(TProxy).Name + " does not have a (DkmProcess, ulong) constructor.");
throw new NotSupportedException();
};
}
if (typeof(IPyObject).IsAssignableFrom(typeof(TProxy)))
{
Factory = (process, address, polymorphic) =>
{
if (polymorphic)
{
return((TProxy)(object)PyObject.FromAddress(process, address));
}
else
{
return(nonPolymorphicFactory(process, address, polymorphic));
}
};
}
else
{
Factory = nonPolymorphicFactory;
}
}
public void call_function(DkmThread thread, ulong frameBase, ulong vframe, bool useRegisters)
{
var process = thread.Process;
var cppEval = new CppExpressionEvaluator(thread, frameBase, vframe);
int oparg = cppEval.EvaluateInt32(useRegisters ? "@rdx" : "oparg");
int na = oparg & 0xff;
int nk = (oparg >> 8) & 0xff;
int n = na + 2 * nk;
ulong func = cppEval.EvaluateUInt64(
"*((*(PyObject***){0}) - {1} - 1)",
useRegisters ? "@rcx" : "pp_stack",
n);
var obj = PyObject.FromAddress(process, func);
ulong ml_meth = cppEval.EvaluateUInt64(
"((PyObject*){0})->ob_type == &PyCFunction_Type ? ((PyCFunctionObject*){0})->m_ml->ml_meth : 0",
func);
_owner.OnPotentialRuntimeExit(thread, ml_meth);
}
private DkmEvaluationResult GetPythonView(DkmVisualizedExpression visualizedExpression)
{
var stackFrame = visualizedExpression.StackFrame;
var process = stackFrame.Process;
var pythonRuntime = process.GetPythonRuntimeInstance();
if (pythonRuntime == null)
{
return(null);
}
var home = visualizedExpression.ValueHome as DkmPointerValueHome;
if (home == null)
{
Debug.Fail("PythonViewNativeVisualizer given a visualized expression that has a non-DkmPointerValueHome home.");
return(null);
}
else if (home.Address == 0)
{
return(null);
}
var exprEval = process.GetDataItem <ExpressionEvaluator>();
if (exprEval == null)
{
Debug.Fail("PythonViewNativeVisualizer failed to obtain an instance of ExpressionEvaluator.");
return(null);
}
string cppTypeName = null;
var childExpr = visualizedExpression as DkmChildVisualizedExpression;
if (childExpr != null)
{
var evalResult = childExpr.EvaluationResult as DkmSuccessEvaluationResult;
cppTypeName = evalResult.Type;
}
else
{
object punkTypeSymbol;
visualizedExpression.GetSymbolInterface(typeof(IDiaSymbol).GUID, out punkTypeSymbol);
using (ComPtr.Create(punkTypeSymbol)) {
var typeSymbol = punkTypeSymbol as IDiaSymbol;
if (typeSymbol != null)
{
cppTypeName = typeSymbol.name;
}
}
}
PyObject objRef;
try {
objRef = PyObject.FromAddress(process, home.Address);
} catch {
return(null);
}
// TODO: Localization - [Python view] also appears in .natvis file, leave as-is for now
var pyEvalResult = new PythonEvaluationResult(objRef, "[Python view]")
{
Category = DkmEvaluationResultCategory.Property,
AccessType = DkmEvaluationResultAccessType.Private
};
var inspectionContext = visualizedExpression.InspectionContext;
CppExpressionEvaluator cppEval;
try {
cppEval = new CppExpressionEvaluator(inspectionContext, stackFrame);
} catch {
return(null);
}
var pythonContext = DkmInspectionContext.Create(visualizedExpression.InspectionSession, pythonRuntime, stackFrame.Thread,
inspectionContext.Timeout, inspectionContext.EvaluationFlags, inspectionContext.FuncEvalFlags, inspectionContext.Radix,
DkmLanguage.Create("Python", new DkmCompilerId(Guids.MicrosoftVendorGuid, Guids.PythonLanguageGuid)), null);
try {
return(exprEval.CreatePyObjectEvaluationResult(pythonContext, stackFrame, null, pyEvalResult, cppEval, cppTypeName, hasCppView: true));
} catch {
return(null);
}
}