/**
* Are there managed callbacks queued up for the requested thread?
*/
public bool HasQueuedCallbacks(CorThread managedThread)
{
int queued = 0;
m_controller.HasQueuedCallbacks((managedThread == null) ? null : managedThread.GetInterface(),
out queued
);
return !(queued == 0);
}
/**
* Are there managed callbacks queued up for the requested thread?
*/
public bool HasQueuedCallbacks(CorThread managedThread)
{
int queued = 0;
m_controller.HasQueuedCallbacks((managedThread == null) ? null : managedThread.GetInterface(),
out queued
);
return(!(queued == 0));
}
//
// IEnumerator interface
//
#region IEnumerator Members
public bool MoveNext()
{
var a = new ICorDebugThread[1];
uint c = 0;
int r = m_enum.Next((uint) a.Length, a, out c);
if (r == 0 && c == 1) // S_OK && we got 1 new element
m_th = new CorThread(a[0]);
else
m_th = null;
return m_th != null;
}
//
// IEnumerator interface
//
#region IEnumerator Members
public bool MoveNext()
{
var a = new ICorDebugThread[1];
uint c = 0;
int r = m_enum.Next((uint)a.Length, a, out c);
if (r == 0 && c == 1) // S_OK && we got 1 new element
{
m_th = new CorThread(a[0]);
}
else
{
m_th = null;
}
return(m_th != null);
}
private void InternalSignalRuntimeIsStopped(CorThread activeThread, Object stopReason)
{
lock (this)
{
// we need to be very carefull here. Debugger API is not reentrant.
// Normally this method is called only from callback to signal to main thread
// that debuggee has stopped but there is one important exception -- async break.
// When we do async-break we are calling AsyncStop() method from another thread, which
// is calling InternalSignalRuntimeIsStopped. Therefore we can be running this function
// from async-break thread and from managed callback thread. Because this method is
// calling DebuggerAPI and functions there are not reentrant, bad thinkgs are happening.
// .
OriginalMDbgMessages.WriteLine("InternalSignalRuntimeIsStopped (" + stopReason + ")");
m_stopCount++;
OriginalMDbgMessages.WriteLine("Increasing StopCount to " + m_stopCount + " (" + stopReason + ")");
m_stopReason = stopReason;
if (activeThread != null)
{
if (!m_threadMgr.HaveActive || !m_processAttaching)
{
m_threadMgr.SetActiveThread(activeThread);
}
MDbgThread t = m_threadMgr.GetThreadFromThreadId(activeThread.Id);
// now check if we are in a special seqence point -- if so than just do another step.
try
{
MDbgSourcePosition sp = t.CurrentSourcePosition;
if (sp != null && sp.IsSpecial && (stopReason is StepCompleteStopReason))
{
// we want to perform antother step when we end-up in special seqence point
// only if we are stopped because of StepComplete. If we are stopped for any other
// reason (e.g. ExceptionThrown, we should not make any other steps since then we
// would receive stop reason for StepComplete and not for ExceptionThrown).
OriginalMDbgMessages.WriteLine("Making another step because of special line number (0xfeefee)");
StepImpl(false, false);
return; // we will be called again
}
}
catch (MDbgNoCurrentFrameException)
{
// if we don't have current frame, let's ignore it.
}
}
else
{
m_threadMgr.SetActiveThread(null);
}
if (IsAlive)
m_engine.Processes.Active = this;
OriginalMDbgMessages.WriteLine("Signaling Real Stop (" + stopReason + ")");
m_processAttaching = false;
Thread.Sleep(100);
// we are not interested in completing step
if (m_activeStepper != null)
try
{
m_activeStepper.Deactivate();
}
catch (COMException)
{
// let's ignore if we cannot deactivate the stepper
// This can happen in cases where the app finishes
// (we receive ExitProcess callback) but we have outstanding
// stepper.
}
m_stopCounter = g_stopCounter++;
m_stopEvent.Set();
}
}
public CorEvalEventArgs(CorAppDomain appDomain, CorThread thread,
CorEval eval)
: base(appDomain, thread)
{
m_eval = eval;
}
public CorExceptionEventArgs(CorAppDomain appDomain,
CorThread thread,
bool unhandled)
: base(appDomain, thread)
{
m_unhandled = unhandled;
}
public CorStepCompleteEventArgs(CorAppDomain appDomain, CorThread thread,
CorStepper stepper, CorDebugStepReason stepReason)
: base(appDomain, thread)
{
m_stepper = stepper;
m_stepReason = stepReason;
}
public CorFunctionRemapOpportunityEventArgs(CorAppDomain appDomain,
CorThread thread,
CorFunction oldFunction,
CorFunction newFunction,
int oldILoffset
)
: base(appDomain, thread)
{
m_oldFunction = oldFunction;
m_newFunction = newFunction;
m_oldILoffset = oldILoffset;
}
public CorBreakpointSetErrorEventArgs(CorAppDomain appDomain,
CorThread thread,
CorBreakpoint breakpoint,
int errorCode,
ManagedCallbackType callbackType)
: base(appDomain, thread, callbackType)
{
m_breakpoint = breakpoint;
m_errorCode = errorCode;
}
public CorBreakpointSetErrorEventArgs(CorAppDomain appDomain,
CorThread thread,
CorBreakpoint breakpoint,
int errorCode)
: base(appDomain, thread)
{
m_breakpoint = breakpoint;
m_errorCode = errorCode;
}
public CorEditAndContinueRemapEventArgs(CorAppDomain appDomain,
CorThread thread,
CorFunction managedFunction,
int accurate,
ManagedCallbackType callbackType)
: base(appDomain, thread, callbackType)
{
m_managedFunction = managedFunction;
m_accurate = accurate;
}
public CorMDAEventArgs(CorMDA mda, CorThread thread, CorProcess proc,
ManagedCallbackType callbackType)
: base(proc, callbackType)
{
m_mda = mda;
Thread = thread;
//m_proc = proc;
}
public CorMDAEventArgs(CorMDA mda, CorThread thread, CorProcess proc)
: base(proc)
{
m_mda = mda;
Thread = thread;
//m_proc = proc;
}
public CorFunctionRemapOpportunityEventArgs(CorAppDomain appDomain,
CorThread thread,
CorFunction oldFunction,
CorFunction newFunction,
int oldILoffset,
ManagedCallbackType callbackType
)
: base(appDomain, thread, callbackType)
{
m_oldFunction = oldFunction;
m_newFunction = newFunction;
m_oldILoffset = oldILoffset;
}
public CorLogSwitchEventArgs(CorAppDomain appDomain, CorThread thread,
int level, int reason, string logSwitchName, string parentName,
ManagedCallbackType callbackType)
: base(appDomain, thread, callbackType)
{
m_level = level;
m_reason = reason;
m_logSwitchName = logSwitchName;
m_parentName = parentName;
}
public CorFunctionRemapCompleteEventArgs(CorAppDomain appDomain,
CorThread thread,
CorFunction managedFunction
)
: base(appDomain, thread)
{
m_managedFunction = managedFunction;
}
public CorStepCompleteEventArgs(CorAppDomain appDomain, CorThread thread,
CorStepper stepper, CorDebugStepReason stepReason,
ManagedCallbackType callbackType)
: base(appDomain, thread, callbackType)
{
m_stepper = stepper;
m_stepReason = stepReason;
}
public CorFunctionRemapCompleteEventArgs(CorAppDomain appDomain,
CorThread thread,
CorFunction managedFunction,
ManagedCallbackType callbackType
)
: base(appDomain, thread, callbackType)
{
m_managedFunction = managedFunction;
}
public CorExceptionEventArgs(CorAppDomain appDomain,
CorThread thread,
bool unhandled,
ManagedCallbackType callbackType)
: base(appDomain, thread, callbackType)
{
m_unhandled = unhandled;
}
public CorExceptionUnwind2EventArgs(CorAppDomain appDomain, CorThread thread,
CorDebugExceptionUnwindCallbackType eventType,
int flags,
ManagedCallbackType callbackType)
: base(appDomain, thread, callbackType)
{
m_eventType = eventType;
m_flags = flags;
}
public CorEvalEventArgs(CorAppDomain appDomain, CorThread thread,
CorEval eval, ManagedCallbackType callbackType)
: base(appDomain, thread, callbackType)
{
m_eval = eval;
}
public CorException2EventArgs(CorAppDomain appDomain,
CorThread thread,
CorFrame frame,
int offset,
CorDebugExceptionCallbackType eventType,
int flags,
ManagedCallbackType callbackType)
: base(appDomain, thread, callbackType)
{
m_frame = frame;
m_offset = offset;
m_eventType = eventType;
m_flags = flags;
}
void IMDbgProcessController.Stop(CorThread activeThread, object stopReason)
{
if (process == null)
throw new InvalidOperationException("Process controller is not active anymore");
if (needAsyncStopCall)
{
process.CorProcess.Stop(int.MaxValue);
process.m_stopCount++;
}
eventArgs.Continue = false; // signal to CorLayer that we want to stop
process.InternalSignalRuntimeIsStopped(activeThread, stopReason);
customStopRequested = true;
}
public CorThreadEventArgs(CorAppDomain appDomain, CorThread thread)
: base(appDomain != null ? appDomain : thread.AppDomain)
{
Thread = thread;
}
public void SetAllThreadsDebugState(CorDebugThreadState state, CorThread exceptThis)
{
m_controller.SetAllThreadsDebugState(state, exceptThis != null ? exceptThis.GetInterface() : null);
}
public CorThreadEventArgs(CorAppDomain appDomain, CorThread thread,
ManagedCallbackType callbackType)
: base(appDomain != null ? appDomain : thread.AppDomain, callbackType)
{
Thread = thread;
}
public void SetAllThreadsDebugState(CorDebugThreadState state, CorThread exceptThis)
{
m_controller.SetAllThreadsDebugState(state, exceptThis != null ? exceptThis.GetInterface() : null);
}
public CorBreakpointEventArgs(CorAppDomain appDomain,
CorThread thread,
CorBreakpoint managedBreakpoint)
: base(appDomain, thread)
{
m_break = managedBreakpoint;
}
public void Reset()
{
m_enum.Reset();
m_th = null;
}
public CorBreakpointEventArgs(CorAppDomain appDomain,
CorThread thread,
CorBreakpoint managedBreakpoint,
ManagedCallbackType callbackType)
: base(appDomain, thread, callbackType)
{
m_break = managedBreakpoint;
}
public void Reset()
{
m_enum.Reset();
m_th = null;
}
public CorLogMessageEventArgs(CorAppDomain appDomain, CorThread thread,
int level, string logSwitchName, string message,
ManagedCallbackType callbackType)
: base(appDomain, thread, callbackType)
{
m_level = level;
m_logSwitchName = logSwitchName;
m_message = message;
}