Mike Stall's .NET Debugging Blog

Notes on Managed Debugging, ICorDebug, and random .NET stuff

Browse by Tags

Tagged Content List
  • Blog Post: ICorDebugFunction is 1:1 with the IL

    In CLR 1.0, there was a simple invariant between IL code blob, and native code blob. It was either 1:0 if the code wasn't jitted, or 1:1 if it was. Method tokens (module scope, mdMethodDef) were also 1:1 with the IL blobs. 1:1 is a nice relationship. Each side can just point to the other without needing...
  • Blog Post: Developing Live Writer PlugIns with Edit-and-Continue

    I was playing around with Live Writer's (WLW) PlugIn API and am really impressed. It's clean, hassle-free, and very easy to write an PlugIn, and WLW appears to export a good set of services for plugins to consume. (Check out the WLW PlugIn gallery for plugins). The basic gist is you just need to write...
  • Blog Post: Enc APIs aren't exposed through reflection

    David Srbecky asked : Can a EnC capable compiler work on top of System.Refletion.Emit? (ie. If an existing compiler is to be extended to support EnC, does it have to be rewritten to use the unmanaged emitting interface?) Unfortuantely, No. Details: 1. You can indeed write a compiler in C# which...
  • Blog Post: "Correct" may depend on your point of view

    Correctness from the debugger's perspective is very different than correctness from the end-user's perspective. For example, the debugger exposes many invasive operations like SetIp. The debugger considers the operation successful if it sets the IP to the target line. However, doing that may violate...
  • Blog Post: When can't you do Edit-And-Continue?

    In .Net 2.0, we wanted to focus managed Edit-And-Continue (EnC) resources on the core-scenarios so that we could make those as good as possible. One significant resource was testing: if you think about what it means to really test EnC, you can probably appreciate our desire to reduce the test matrix...
  • Blog Post: You can't do Edit-and-Continue with Interop-debugging on.

    Somebody asked on the forums about Edit-and-Continue (EnC) in mixed mode . You can't use managed EnC with mixed-mode ( interop ) debugging enabled. This is a limitation of the CLR Debugging Services. Both Interop-debugging and EnC are complicated features; combining them would be a huge test-matrix and...
  • Blog Post: 3rd-parties and Edit And Continue (Part 2: Debuggers)

    I recently blogged about what’s involved for 3 rd -parties doing Edit-and-Continue (EnC ), where I explained EnC is an IDE (at least debugger+editor+compiler) wide feature, not just a debugger feature. In that entry, I alluded to some basic work a 3 rd -party would need to do to their editor and compiler...
  • Blog Post: 3rd-parties and Edit-and-Continue (Part 1: Editors + Compilers)

    I’ve said before that any 3 rd party debuggers can add Edit-And-Continue (EnC) support, and now I want to be very clear exactly what that means. I’ve found people mean two different questions here: 1) Managed debugging is language neutral, so how can I have an existing managed debugger (like Visual Studio...
  • Blog Post: Why you can’t do Edit-and-Continue on Dynamically generated code

    I gave a brief example of how you can debug dynamically generated code (e.g., code generated via Reflection.Emit). Jamie Cansdale observed that you can’t use EnC with dynamically generated code. This was a conscious choice. Here are some reasons for it: It was not a core EnC scenario . For v2.0...
  • Blog Post: ICorDebug, Edit-and-Continue, and C#

    In case anybody missed it, VS 2005 C# is going support Edit-and-Continue! (See announcement , and some follow up posts by the C# team from Andy and Steve ). The CLR is a language-neutral platform. So naturally, our debugging API (ICorDebug) operates at the IL level so that it can be language-neutral...
Page 1 of 1 (10 items)