Abstract: A profiler may be detached from an actively running application by first sealing communications between the application and profiler, then evacuating the profiler by waiting for any profiler-modified or instrumented code to complete execution, profiler runtime code to complete execution, cleaning up any residual items from the profiler, and shutting down the profiler. The profiler may be operational in many different environments, including a managed environment such as a virtual machine and those environments having just in time compiling of executable code.

Abstract: A profiler manager may attach and detach profilers from a running application. A profiler may be detached through a two step process where the profiler is sealed from communicating with the running application, then an evacuation step where the application is able to complete any responses that are pending. While the profiler is in the evacuation phase, another profiler may be attached to the application. Messages to the evacuating profiler may be captured and directed to the proper profiler.

Abstract: Example embodiments provide for effectively executing a stack-walk and other operations by dynamically accessing information about the expected location of cookies on a stack. For example, a first function is executed that causes a stack-walk operation to occur. While performing the stack-walk operation, cookie location information for a cookie placed on the stack by a second function different from the first function is accessed. The cookie, if uncorrupted, includes a known value that is used to determine if the stack has been corrupted. Based on the cookie location information, corrupt data representative of the cookie is accessed. A global cookie, which also includes the known value, is also accessed. The known value of the global cookie is then compared with the corrupt data to determine that the stack is corrupted at least up to the location of the corrupt data representative of the cookie.

Abstract: A system and method for mitigating problems associated with automatic execution of initialization code is provided. The system includes an initialization method activator that can call a class initialization method at a pre-determined execution point. The system also includes a deadlock analyzer that can determine whether calling the initialization method will create a deadlock, and, if a deadlock is detected that can resolve such a deadlock. The system also includes a semantic analyzing component that can analyze a semantic type associated with the initialization method and a domain uniqueness analyzer that can analyze the uniqueness of the domain with which the class will interact, to facilitate determining where to place code that will check whether a class is initialized, and if the class is not initialized that will invoke the class initializing method.

Abstract: A compiler that completes compilation upon identifying unresolvable input during compilation instead of aborting compilation. This can be accomplished by inserting an exception-throwing instruction, and/or handlers in place of the unresolvable input in the compiled code output. If the section of the compiled code containing the inserted exception throwing instruction is later executed, an exception is thrown and/or handled. Compilation of code from a trusted source can be completed without inserting an exception throwing instruction when the code has only suspected but unverifiable problems.

Abstract: The subject disclosure pertains to systems and methods for supporting null capabilities for general purpose programming languages. Low level, runtime support for a nullable type is provided to ensure consistency and coherency. An execution component restricts support of the nullable type to programming language types that lack a null capability. The execution component may also provide support for conversion between the nullable type and a reference type.

Abstract: A host intercepts calls between two executables and determines whether the calls are permissible according to the host's security model which can be identify based, such as user identity based—for instance, mapping access rights within a specific data base user context to database object access. Such an identity security model differs from a common language runtime security model where managed code uses Code Access Security to prevent managed assemblies from performing certain operations. Managed assemblies registered with the host are host objects from the host's perspective for which access rights can be defined via security rules, such as are defined for individual user identities. A host can decide access between managed executables based on the host's identity based access rules by trapping any cross assembly calls and deciding whether such calls should proceed or be blocked from taking place based on the corresponding identity security settings.

Abstract: A system and method for facilitating cross-process access into a managed code process is useful in an embodiment of the invention for debugging managed code without perturbing the process being accessed or requiring the code under test to be running during debugging. A compiler according to an embodiment of the invention is used to produce mirror code wherein in-process pointers have been replaced with cross-process pointers in order to mirror the address space of the process under test to the address space of the mirror code process. In a further embodiment, the mirror code process is modified not only to allow but also to optimize the cross-process access.

Abstract: A system and method of providing edit and continue support in a software program debugging environment. “Edit and continue” support allows a user (e.g., programmer and/or developer) to update the code and/or data structure(s) of an executing program while it is running. After the user has finished editing their code and resumes execution, an integrated development environment (IDE) propagates the edit(s) into a common language runtime (CLR) environment before continuing. Therefore, from the CLR environment's perspective, an edit is a block of intermediate language code (IL) and/or metadata that is inserted into a running process. The IDE can facilitate: determining “legality” of an edit; building the edit; sending the edit to the CLR environment; and/or, facilitating the CLR environment switch execution to the edited code.

Abstract: A method and system are disclosed for editing a software program in a common language runtime environment, wherein the software program has a source code component, an intermediate language component, and a native code component. The method comprises executing a first portion of the native code component, suspending execution of the native code component at a first point, and allowing a user to edit the source code component to create an edited source code component. The edited source code component is compiled using a source compiler to create an edited intermediate language component, and the edited intermediate language component is compiled using an intermediate language compiler to create an edited native code component. The edited native code component is then executed beginning at the point where execution was previously suspended.