// Public build function.
// Fails to build (and returns null) if it can't load the file.
static public SourceViewerForm Build(MainForm parent,string path)
{
ArrayList lines = LoadLinesFromFile(path);
if (lines == null) { return null; }
return new SourceViewerForm(parent, path, lines);
}
// parent - main containing window that this source window lives inside of.
// path - unique string identifier for source window (full pathname)
// lines - content
SourceViewerForm(MainForm parent,string path,ArrayList lines)
{
m_lines = lines;
BeginInit(parent);
InitLines("{0,4}:", lines, null);
EndInit(path);
}
public static void Gui(string args)
{
// just do the check that gui is not already loaded,
// strange things are happening else:
ArgParser ap = new ArgParser(args);
if( ap.Exists(0) )
{
if( ap.AsString(0) == "close" )
{
if( m_mainForm!=null )
{
m_mainForm.CloseGui();
Application.Exit(); // this line will cause the message pump on other thread to quit.
return;
}
else
throw new MDbgShellException("GUI not started.");
}
else
throw new MDbgShellException("invalid argument");
}
if(Shell.IO == m_mainForm)
{
WriteOutput("GUI already started. Cannot start second instance.");
return;
}
WriteOutput("starting gui");
m_mainForm = new MainForm(Shell);
Thread t = new Thread(new ThreadStart(RunMessageLoop));
// Only MTA Threads can access CorDebug interfaces because mscordbi doesn't provide marshalling to make them accessable from STA Threads
t.SetApartmentState(ApartmentState.MTA);
t.IsBackground = true;
t.Start();
m_mainForm.InitComplete.WaitOne(); // wait till form is fully displayed.
WriteOutput("GUI: Simple Extension for Managed debugger (Mdbg) started");
WriteOutput("\nfor information on how to use the extension select in menu bar help->Info\n");
}
public SequencePointIterator(RawWriter w,MainForm parent,
int[] seqIlOffsets,
string[] seqPaths,
int[] seqStartLines,
int[] seqStartColumns,
int[] seqEndLines,
int [] seqEndColumns)
{
m_writer = w;
m_parent = parent;
this.m_seqIlOffsets = seqIlOffsets;
this.m_seqPaths = seqPaths;
this.m_seqStartLines = seqStartLines;
this.m_seqStartColumns = seqStartColumns;
this.m_seqEndLines = seqEndLines;
this.m_seqEndColumns = seqEndColumns;
Debug.Assert(m_seqCount == 0);
if (m_seqIlOffsets != null)
{
m_seqCount = m_seqIlOffsets.Length;
// All arrays should be same length.
Debug.Assert(seqIlOffsets.Length == m_seqCount);
Debug.Assert(seqPaths.Length == m_seqCount);
Debug.Assert(seqStartLines.Length == m_seqCount);
Debug.Assert(seqStartColumns.Length == m_seqCount);
Debug.Assert(seqEndLines.Length == m_seqCount);
Debug.Assert(seqEndColumns.Length == m_seqCount);
}
}
// parent - main containing window that this source window lives inside of.
// function - function for which we're building virtual source around.
// Get the IL from the given frame.
// Called on UI thread.
internal VirtualSourceViewerForm(MainForm parent, MDbgFunction function)
{
m_function = function;
Debug.Assert(function != null);
// Now actually right in text. do this first so that we can get the current font.
BeginInit(parent);
// Get fonts
FontCache cache;
{
Font fontCurrent = this.richText.Font;
Font emphasis = new Font(
fontCurrent.FontFamily,
fontCurrent.Size,
FontStyle.Bold
);
cache = new FontCache(emphasis);
}
// Underlying writer to the window.
RawWriter rawWriter = new RawWriter(cache);
// Il2Native mapping can be used to find out what IL offsets we can actually stop on.
Il2NativeIterator il2nativeIterator = null;
// Actual IL disassembly in string form.
ILDasmIterator ilDasm = null;
// Iterator through sequence points and source files.
SequencePointIterator seqIterator = null;
string fullName = "?";
int token = 0;
ulong nativeStartAddress = 0;
CorDebugJITCompilerFlags codeFlags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DEFAULT;
// Make cross-thread call to worker thread to collect raw information.
// This needs to access MDbg and so can't be done on our UI thread.
parent.ExecuteOnWorkerThreadIfStoppedAndBlock(delegate(MDbgProcess proc)
{
Debug.Assert(proc != null);
Debug.Assert(!proc.IsRunning);
Debug.Assert(function.Module.Process == proc);
// Get some properties about this function to display.
token = function.CorFunction.Token;
nativeStartAddress = function.CorFunction.NativeCode.Address;
codeFlags = function.CorFunction.NativeCode.CompilerFlags;
CorCode ilCode = function.CorFunction.ILCode;
Debug.Assert(true == ilCode.IsIL);
byte[] code = ilCode.GetCode();
fullName = function.FullName;
// This does the real disassembly work.
string[] lines = null; // strings of IL.
ILDisassembler.Disassemble(code, function.Module.Importer, out lines, out m_il2RowMapping);
ilDasm = new ILDasmIterator(rawWriter, m_il2RowMapping, lines);
IL2NativeMap[] il2nativeMapping = function.CorFunction.NativeCode.GetILToNativeMapping();
il2nativeIterator = new Il2NativeIterator(rawWriter, il2nativeMapping, code);
// Get sequence points
ISymbolMethod symMethod = function.SymMethod;
// Sequence point information
int[] seqIlOffsets = null;
string[] seqPaths = null;
int[] seqStartLines = null, seqEndLines = null, seqStartColumns = null, seqEndColumns = null;
int seqCount = 0;
if (symMethod != null)
{
seqCount = symMethod.SequencePointCount;
seqIlOffsets = new int[seqCount];
ISymbolDocument[] seqDocuments = new ISymbolDocument[seqCount];
seqPaths = new string[seqCount];
seqStartLines = new int[seqCount];
seqEndLines = new int[seqCount];
seqStartColumns = new int[seqCount];
seqEndColumns = new int[seqCount];
symMethod.GetSequencePoints(seqIlOffsets, seqDocuments, seqStartLines, seqStartColumns, seqEndLines, seqEndColumns);
for (int i = 0; i < seqCount; i++)
{
seqPaths[i] = seqDocuments[i].URL;
}
}
seqIterator = new SequencePointIterator(rawWriter, parent, seqIlOffsets, seqPaths, seqStartLines, seqStartColumns, seqEndLines, seqEndColumns);
}
); // end worker call
// We assume sequence points are sorted by IL offset. We assert that in the iterators below.
// Now we need to go through and stitch the IL + Source together.
// This also works even if we have no source (since that's just the degenerate case of 0 sequence points)
// Print out header information
Debug.Assert(token != 0);
rawWriter.WriteLine(String.Format(CultureInfo.InvariantCulture,
"> Function name:{0} (token={1:x})", fullName, token));
rawWriter.WriteLine(String.Format(CultureInfo.InvariantCulture,
"> Native Code Address =0x{0:x}, flags={1}", nativeStartAddress, codeFlags));
// Walk through the IL in order and write out interleaved IL and Sequence Points.
while (!seqIterator.IsDone)
{
// Add IL snippets that occur before this sequence point.
WriteIlAndNative(ilDasm, il2nativeIterator, seqIterator.IlOffset);
seqIterator.WriteSource();
seqIterator.Next();
}
// Write the IL that's after the last sequence point
WriteIlAndNative(ilDasm, il2nativeIterator, ilDasm.IlLength);
// Set the text.
InitLines(null, rawWriter.Lines, rawWriter.FormatList);
EndInit(fullName);
}
public SyncWriter(MainForm form, string txt)
{
Debug.Assert(txt != null && form != null);
m_txt = txt;
m_form = form;
}
// We pass in a type of the form to create rather than encode it as a generic parameter
// so that we can have an array of the HelperWindowMenuItem.
public HelperWindowMenuItem(MainForm mainForm, string name, System.Type tForm)
{
Debug.Assert(tForm.IsSubclassOf(typeof(gui.DebuggerToolWindow)));
this.m_mainForm = mainForm;
this.m_typeHelperForm = tForm;
EventHandler handler = new EventHandler(this.OnClick);
MenuItem item = new MenuItem(name, handler);
this.m_mainForm.AddToViewMenu(item);
}
public SyncWriter(MainForm form, string outputType, string txt, int highlightStart, int highlightLen)
{
Debug.Assert(txt != null && form != null);
if (highlightLen == Int32.MaxValue)
{
highlightLen = txt.Length;
}
m_txt = txt;
m_form = form;
m_type = outputType;
m_highlightStart = highlightStart;
m_highlightLen = highlightLen;
}
// There's one SourceViewerForm instance for each source-file
// Get the instance for the new source file.
// Called on UI thread.
public static SourceViewerBaseForm GetSourceFile(MainForm parent, MDbgFunction function)
{
SourceViewerBaseForm source = (SourceViewerBaseForm)m_sourceList[function];
if (source == null)
{
source = new VirtualSourceViewerForm(parent, function);
AddSourceViewer(source);
}
m_ActiveSourceFile = source;
return source;
}
// There's one SourceViewerForm instance for each source-file
// Get the instance for the new source file.
// Called on UI thread.
public static SourceViewerForm GetSourceFile(MainForm parent,string path)
{
path = CommandBase.Shell.FileLocator.GetFileLocation(path);
SourceViewerForm source = (SourceViewerForm)m_sourceList[path];
if(source==null)
{
source = SourceViewerForm.Build(parent, path);
if (source != null)
{
AddSourceViewer(source);
}
}
m_ActiveSourceFile = source;
return source;
}
// Initialization function. called by derived ctor.
// parent - main containing window that this source window lives inside of.
// path - unique string identifier for source window (full pathname)
// lines - content
protected void BeginInit(MainForm parent)
{
if (m_glyphs == null)
{
m_glyphs = new Glyphs();
}
//
// Required for Windows Form Designer support
//
InitializeComponent();
// Set window properties
MdiParent = parent;
Debug.Assert(parent == MainForm);
// Still not visisible. We return from here, and then caller will initialize content
// and then call EndInit().
}