// Called by MDbgBreakpoint after it has set the Number property.
internal void FireAddBreakpointEvent(MDbgBreakpoint breakpoint)
{
if (AddBreakpoint != null)
{
AddBreakpoint(this, new BreakpointCollectionChangedEventArgs(breakpoint));
}
}
/// <summary>
/// Fire the ChangedBreakpoint event for the given breakpoint.
/// </summary>
/// <param name="breakpoint">Breakpoint that has changed</param>
internal void NotifyChanged(MDbgBreakpoint breakpoint)
{
if (ChangedBreakpoint != null)
{
ChangedBreakpoint(this, new BreakpointCollectionChangedEventArgs(breakpoint));
}
}
internal void UnRegister(MDbgBreakpoint breakpoint)
{
Debug.Assert(breakpoint != null);
m_items.Remove(breakpoint);
if (RemoveBreakpoint != null)
{
RemoveBreakpoint(this, new BreakpointCollectionChangedEventArgs(breakpoint));
}
}
internal int Register(MDbgBreakpoint breakpoint)
{
Debug.Assert(breakpoint != null);
m_items.Add(breakpoint);
// At this point, derived properties have not yet been set.
// Let MDbgBreakpoint do a little more initialization and then it will fire the Add
// event via calling FireAddBreakpointEvent
return(m_freeBreakpointNumber++);
}
public BreakpointPair(MDbgBreakpoint bp, int iLine)
{
m_bp = bp;
m_iLine = iLine;
}
internal BreakpointCollectionChangedEventArgs(MDbgBreakpoint breakpoint)
{
m_breakpoint = breakpoint;
}
internal void UnRegister(MDbgBreakpoint breakpoint)
{
Debug.Assert(breakpoint != null);
m_items.Remove(breakpoint);
if (RemoveBreakpoint != null)
{
RemoveBreakpoint(this, new BreakpointCollectionChangedEventArgs(breakpoint));
}
}
// Called by MDbgBreakpoint after it has set the Number property.
internal void FireAddBreakpointEvent(MDbgBreakpoint breakpoint)
{
if (AddBreakpoint != null)
{
AddBreakpoint(this, new BreakpointCollectionChangedEventArgs(breakpoint));
}
}
internal int Register(MDbgBreakpoint breakpoint)
{
Debug.Assert(breakpoint != null);
m_items.Add(breakpoint);
// At this point, derived properties have not yet been set.
// Let MDbgBreakpoint do a little more initialization and then it will fire the Add
// event via calling FireAddBreakpointEvent
return m_freeBreakpointNumber++;
}
/// <summary>
/// Fire the ChangedBreakpoint event for the given breakpoint.
/// </summary>
/// <param name="breakpoint">Breakpoint that has changed</param>
internal void NotifyChanged(MDbgBreakpoint breakpoint)
{
if (ChangedBreakpoint != null)
{
ChangedBreakpoint(this, new BreakpointCollectionChangedEventArgs(breakpoint));
}
}
// Update process's state that to let them know we've hit this we've hit.
internal void OnUserEntryBreakpointHit()
{
m_userEntryBreakpoint.Delete();
m_userEntryBreakpointEnabled = false;
m_userEntryBreakpoint = null;
}
private void LoadModuleEventHandler(Object sender, CorModuleEventArgs e)
{
MDbgModule m = m_moduleMgr.Register(e.Module);
OriginalMDbgMessages.WriteLine("ManagedCallback::LoadModule(" + m.CorModule.Name + ")");
if (!m_processAttaching
&& (m_debugMode != DebugModeFlag.Default))
{
// translate DebugModeFlags to JITCompilerFlags
CorDebugJITCompilerFlags jcf = MapDebugModeToJITCompilerFlags(m_debugMode);
OriginalMDbgMessages.WriteLine("Setting module jit compiler flags:" + jcf);
try
{
e.Module.JITCompilerFlags = jcf;
// Flags may succeed but not set all bits, so requery.
CorDebugJITCompilerFlags jcfActual = e.Module.JITCompilerFlags;
if (jcf != jcfActual)
{
OriginalMDbgMessages.WriteLine("Couldn't set all flags. Actual flags:" + jcfActual);
}
}
catch (COMException ex)
{
// we'll ignore the error if we cannot set the jit flags
OriginalMDbgMessages.WriteLine(string.Format("Failed to set flags with hr=0x{0:x}", ex.ErrorCode));
}
}
m_breakpointMgr.BindBreakpoints(m);
// let's try to bind all unboud breakpoints (maybe the types got loaded this time)
if (InternalHandleRawMode(ManagedCallbackType.OnModuleLoad, e))
return;
// Symbols track a user entry method.
// We set a breakpoint at the user entry method and then just run to that to skip any
// compiler-injected non-user code before main.
if (!m_processAttaching
&& m_userEntryBreakpointEnabled
&& m_userEntryBreakpoint == null)
{
//now try to set user entry Breakpoint
if (m.SymReader != null)
{
int st = 0;
st = m.SymReader.UserEntryPoint.GetToken();
if (st != 0)
{
MDbgFunction mfunc = m.GetFunction(st);
m_userEntryBreakpoint = new UserEntryBreakpoint(this, mfunc);
bool ok = m_userEntryBreakpoint.BindToModule(m);
Debug.Assert(ok);
// now we cannot call BindBreakpoints again otherwise userEntrBreakpoint will be bound
// twice
}
// We explicitly don't set JMC. An extension can hook up to this module and set JMC policy if it wants.
}
}
if (HandleCustomPostCallback(ManagedCallbackType.OnModuleLoad, e))
return;
if (m_engine.Options.StopOnModuleLoad)
{
e.Continue = false;
InternalSignalRuntimeIsStopped(null, new ModuleLoadedStopReason(Modules.Lookup(e.Module)));
}
}
// Cleans up the process's resources. This may be called on any thread (including clalback threads).
private void CleanAfterProcessExit()
{
lock (this)
{
// synchronize with ReallyContinue
m_userEntryBreakpoint = null;
m_threadMgr.Clear();
m_breakpointMgr.Clear();
m_moduleMgr.Dispose();
if (m_corProcess != null)
{
m_corProcess.Dispose();
m_corProcess = null;
}
m_engine.Processes.DeleteProcess(this);
}
// The SymbolReader interfaces hold a file lock to the pdb file. This lock is held
// until the final SymbolReader (including any objects obtained from that SymReader
// such as SymDocument, SymMethods) is released.
//
// We're holding Sym* objects via Com-interop wrappres. So we need to cut all references
// and then force a GC to get the Com-wrapper finalizers to run and do the real release.
ForceGCCollection();
}
/// <summary>
/// Create a new instance of the BreakpointHitStopReason class.
/// </summary>
/// <param name="breakpoint">The breakpoint that has been hit.</param>
public BreakpointHitStopReason(MDbgBreakpoint breakpoint)
{
Debug.Assert(breakpoint != null);
m_breakpoint = breakpoint;
}
/// <summary>
/// Create a new instance of the BreakpointHitStopReason class.
/// </summary>
/// <param name="breakpoint">The breakpoint that has been hit.</param>
public BreakpointHitStopReason(MDbgBreakpoint breakpoint)
{
Debug.Assert(breakpoint != null);
m_breakpoint = breakpoint;
}
internal BreakpointCollectionChangedEventArgs(MDbgBreakpoint breakpoint)
{
m_breakpoint = breakpoint;
}