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…

2

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…

5

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 emits using reflection-emit (here’s a sample…

2

"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 the program’s natural control flow and thus may be considered incorrect…

0

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. Practically, this means that…

8

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 very costly. So if you have a C# and native…

6

3rd-parties and Edit And Continue (Part 2: Debuggers)

I recently blogged about what’s involved for 3rd-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 3rd-party would need to do to their editor and compiler to support EnC. In this entry, I’ll…

4

3rd-parties and Edit-and-Continue (Part 1: Editors + Compilers)

I’ve said before that any 3rd 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) add EnC support for…

13

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, we wanted to focus…

4

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 as well. The Edit-and-Continue…

13