Microsoft Technology Licensing, LLC

Steven J Steiner

Steven E Lucco

Jesse D McGatha

Jomo Fisher

Jedrzej Z Miadowicz

Michael Wayne Jackson

Yunus Kilic

Brian Robert Crawford

Li Zhang

Patrick Henri Dussud

Michael M Magruder

Vance Palmer Morrison

Sean Edwin Trowbridge

James S Miller

John Lawrence Hamby

Peter A Hallam

Jason L Zander

James H Hogg

Sam Spencer

William G Evans

John Joseph Rivard

Douglas Jay Rosen

Ian H Carmichael

Abhijit Rao

Paul Matthew Pietrek

Mario Chenier

Jennifer A Hamilton

Habib Heydarian

James P Griesmer

Lawrence B Sullivan

Steven Edward Lucco

Jesse D Mcgatha

Aspects of the subject matter described herein relate to generating and caching software code. In aspects, a target device may receive software to install. The software may include source code that has not been compiled. The target device may install the software and indicate the source code of the package is to be compiled into intermediate or executable code that is persistently stored. If the target device receives a request to execute the software prior to it being compiled, the target device may compile and execute the software without delay. If the target device receives a request to execute the software after it is compiled, the target device may obtain and execute the compiled code. The behavior above may also be applied to scripting code obtained from a server remote to the target device.

Generating and caching software code

A system and method for debugging a computer program by using a call graph. A call graph that represents trace events during execution of a debuggee program may be used as input to a system that enables a user to debug the debuggee program. Mechanisms facilitate conditionally forming clusters of event nodes, a cluster indicative of multiple event nodes corresponding to an execution of a source language statement. During a debugging session, in response to a command to perform a step operation, the nodes of a cluster are processed together so that a step corresponds to multiple events if the multiple events correspond to a single source language statement. A mechanism for inspecting variables is provided. Variable values may be selectively propagated and provided based on the call graph and a static control flow analysis of the debuggee program.

Debugging from a call graph

The claimed subject matter provides systems and mechanisms that create frame accurate call trees for threads. The system can include devices that determine the thread on which a break point or event halted execution, identifies a location of the event that halted execution, sets break points at multiple locations during a stopping event where stopping events do not typically involve setting or unsetting set break points, and constructs the frame accurate call tree subset for the thread based at least in part on the break point or event that halted execution and information gleaned from an inspection of a call stack associated with the event that halted execution or the break point.

Building call tree branches and utilizing break points

Various technologies and techniques are disclosed that provide an integrated debugger simulator. A debugger is provided that allows a user to debug an application in a live mode. A simulator is provided to read recorded data from an earlier point in time in an execution of the application. An integrated debugger simulator is provided by multiplexing the debugger between the application in the live mode and the simulator that reads the recorded data. A simulation mode is provided to allow the user to interact with the recorded data using the debugger. In this simulation mode, the user is able to interact with the recorded data using commands and data views available in the debugger. The user can multiplex between the live mode and the simulation mode from within the debugger.

Integrated debugger simulator

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. Moreover, 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.

Method and system for program editing and debugging in a common language runtime environment

Growing community of inventors

Seattle, WA, United States of America

Steven J Steiner