# Patent

## Title
Identifying execution paths that satisfy reachability queries

## Abstract

Various technologies pertaining to answering reachability queries are described herein. A reachability query includes a user-specified destination line of code in source code that is desirably analyzed. A theorem prover is employed to identify an execution path through the source code that reaches the destination line of code. Graphical data is presented to the user that illustrates to the user the execution path through the source code that reaches the destination line of code.

## Background
BACKGROUND
Source code generated by developers during the course of a software project can often be quite lengthy and complex. For instance, source code pertaining to an operating system can include hundreds of thousands to millions of lines of code. During the software development process, developers will generate source code, test the source code for bugs, fix such bugs with the use of a debugger, etc. It is well known that oftentimes complex software will include many different branches, such that depending upon values of variables in the source code different branches may be taken during execution of the software.
Accordingly, software developers frequently have questions about software projects upon which they are working. Among some of the most difficult and time consuming of these questions are related to actual execution behavior of the software. For instance, a developer may wonder if a particular line of code is ever executed and, if it is executed, what branches were taken to reach such line of code. Oftentimes, during execution of a particular piece of software values are assigned to variables that were unintended or unexpected by the developer.
Conventionally, to monitor software execution behavior, developers typically have conversations with their colleagues or co-developers, manually inspect log data pertaining to software execution, or attempt to use a breakpoint debugger to drive the execution of the software to a particular line of code. As mentioned above, however, many current software projects include a significant number of lines of code, and thus answering any of the questions described above can be an error prone, time consuming, and frustrating process for the developer.
SUMMARY
The following is a brief summary of subject matter that is described in greater detail herein. This summary is not intended to be limiting as to the scope of the claims.
Described herein are various technologies pertaining to answering a reachability question with respect to source code set forth by a user (who may be a software developer that is responsible for the source code). The source code can be written in any suitable language, including C, C#, and the like. The reachability query set forth by the user can include a user-selection of a destination line of code, wherein the user wishes to be provided with an execution path through the source code that reaches the destination line of code. The user can set forth the reachability query in several possible manners; in an exemplary embodiment, the user, through utilization of a pointing mechanism such as a mouse or touch sensitive display screen, can select a particular line of code in the source code and indicate that such line of code is the destination line of code. Responsive to receiving the reachability query, a theorem prover can identify an execution path through the source code that results in reaching such destination line of code. In such an embodiment, the reachability query can be specified, for instance, in an integrated development environment.
In another exemplary embodiment, the developer may be employing a command line interface and can issue a reachability query, for instance, through utilization of a natural language query or a Boolean query. Pursuant to an example, the command line interface can be configured to support reachability queries that include a specification as to the destination line of code. Again a theorem prover can be utilized to identify an execution path through the source code that reaches the destination line of code.
In another exemplary embodiment, the reachability query can include other user-selected lines of code in the source code, which can include an initial line of code where execution of a program is desired to begin and at least one intermediate line of code through which execution of the program is desired to pass prior to reaching the destination line of code. Thus, the user, in the reachability query, can ask whether an execution path exists through the source code that begins at the initial line of code, passes through the at least one intermediate line of code, and subsequently reaches the destination line of code. An answer to the reachability query is an execution path that satisfies the conditions set forth in the reachability query (e.g., an execution path that begins at the initial line of code, passes through the at least one intermediate line of code, and thereafter reaches the destination line of code). Accordingly, the user can set forth a sequence of lines of code to identify an execution path through the code when executed by a computer processor that follows the sequence set forth by the user. An answer to the reachability query can also include identification of values of variables that cause the execution path to be taken during program execution.
An answer to the reachability query can be provided to a display screen of a computing device in the form of graphical data. Such graphical data can include a representation of the execution path that reaches the user-specified destination line of code. For example, the graphical data can include a graphical representation of a method executed at a beginning of the execution path, methods called in the execution path, and graphical data indicating an order that methods were called until the destination line of code is reached in the execution path. Further, particular lines of code executed in such execution path can be highlighted to inform the user of precisely which lines of code have been executed in the execution path. Moreover, values of one or more variables set forth in the source code that cause the execution the destination line of code to be reached can be displayed to the user.
Other aspects will be appreciated upon reading and understanding the attached figures and description.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a functional block diagram of an exemplary system that facilitates answering a reachability query set forth by a user with respect to a computer-executable program.
FIG. 2 is a functional block diagram of an exemplary computer-executable component that facilitates identifying an execution path that satisfies a reachability query.
FIG. 3 is a flow diagram that illustrates an exemplary methodology that facilitates answering a reachability query set forth by user with respect to a computer-executable program.
FIG. 4 is a flow diagram that illustrates an exemplary methodology for identifying an execution path through source code that satisfies a reachability query.
FIG. 5 is an exemplary graphical user interface that facilitates specifying a reachability query.
FIG. 6 is an exemplary graphical user interface depicting graphical data presented to a user that illustrates an execution path taken through source code that satisfies a reachability query set forth by the user.
FIG. 7 is an exemplary graphical user interface that facilitates setting forth a reachability query.
FIG. 8 is another exemplary graphical user-interface that indicates an execution path taken through source code that satisfies a reachability query set forth by a user.
FIG. 9 is an exemplary computing system.



DETAILED DESCRIPTION
Various technologies pertaining to answering reachability queries will now be described with reference to the drawings, where like reference numerals represent like elements throughout. In addition, several functional block diagrams of exemplary systems are illustrated and described herein for purposes of explanation; however, it is to be understood that functionality that is described as being carried out by certain system components may be performed by multiple components. Similarly, for instance, a component may be configured to perform functionality that is described as being carried out by multiple components. Additionally, as used herein, the term “exemplary” is intended to mean serving as an illustration or example of something, and is not intended to indicate a preference.
As used herein, the terms “component” and “system” are intended to encompass computer-readable data storage that is configured with computer-executable instructions that cause certain functionality to be performed when executed by a processor. The computer-executable instructions may include a routine, a function, or the like. It is also to be understood that a component or system may be localized on a single device or distributed across several devices.
With reference now to FIG. 1, an exemplary system 100 that facilitates answering a reachability query set forth by a user with respect to a computer-executable program (or a portion thereof) is illustrated. A reachability query represents a question set forth by a user as to how a particular line of a program is reached during execution of such program, while considering user-imposed constraints, such as intermediate execution points, constraints on variable values, and the like. The system 100 includes a data store 102, which can be or include a memory, a hard drive, a flash drive, or other suitable computer-readable data storage device. The data store 102 comprises source code 104 written by a developer or group of developers. The source code 104 can be written in any suitable programming language, including but not limited to C, C#, or the like. Further, the source code 104 can include a plurality of lines of code, such as between ten lines of code and several million lines of code. For example, the source code 104 can be a portion of a relatively large computer-executable program, such as an operating system, a word processing program, a spreadsheet program, an e-mail program, or the like. In an exemplary embodiment, the plurality of lines of code comprise between ten thousand lines of code and one hundred thousand lines of code. The source code 104 comprises numerous branches, such that several (possibly infinite) potential execution paths exist through the source code 104. The source code 104 further comprises several variables, wherein an execution path taken during execution of the computer-executable program is based upon values for the variables.
The system 100 further comprises a query receiver component 106 that receives a reachability query set forth by a user that is interested in at least a portion of the source code 104. For example, the user can be a developer of the source code 104. Oftentimes, due to relatively large size of source code and complexity thereof (particularly in settings where multiple developers are working on the source code 104), a developer may lack understanding as to how the computer executable program reaches a certain line of code or a certain program state. Accordingly, the reachability query set forth by the user, as indicated above, comprises a user-selected destination line of code, wherein the user constructs the reachability query to ascertain whether the destination line of code is reachable during execution of a computer-executable program that is based upon such source code 104, and to further ascertain what causes the destination line of code to be reached. Additionally, the user can set forth additional constraints in the reachability query.
Pursuant to an example, the user can set forth an initial line of code in the source code 104 and variable values corresponding thereto; thus, the reachability query is constructed by the user to determine whether and under what circumstances (e.g., what values are assigned to variables) the computer-executable program, during a possible execution thereof by a computer processor, starts at the initial line of code (with variable values defined in the reachability query) and reaches the destination line of code. In another exemplary embodiment, the user can specify an intermediate line of code of the source code 104 in the reachability query. In such an embodiment, the user constructs the reachability query to ascertain whether an execution path exists that passes through the intermediate line of code (e.g., from the initial line of code) and thereafter reaches the user-specified destination line of code. It is to be understood that the user can specify multiple intermediate lines of code, such that an execution sequence is specified in the reachability query. Moreover, the user can specify other constraints in the reachability query, such as discrete values of variables or ranges of variable values in the source code 104. For instance, the user can specify the destination line of code in the source code 104 and then set forth a constraint for a particular variable, thereby constructing the reachability query to determine whether the computer executable program can reach the destination line of code when the variable is constrained to the value specified by the user.
The system 100 further comprises a path determiner component 108 that is in communication with the query receiver component 106. Responsive to the query receiver component 106 receiving the reachability query, the path determiner component 108 identifies an execution path in the source code 104 from amongst the plurality of potential execution paths that satisfies the constraints set forth by the user in the reachability query. For instance, the path determiner component 108 can identify an execution path that reaches the destination line of code specified by the user in the reachability query. Additionally, the path determiner component 108 can identify values of variables that cause such execution path to be taken in the source code 104. As will be described in greater detail below, the path determiner component 108 can undertake a global analysis of the source code 104 when identifying the execution path that satisfies the constraints in the reachability query. With more specificity, the path determiner component 108 can employ a theorem prover in connection with identifying the execution path through the source code 104 that satisfies the reachability query set forth by the user. The theorem prover can be configured to output a counter-example to an assertion, wherein the counter-example is indicative of an execution trace that satisfies the reachability query.
The system 100 additionally comprises a visualizer component 110 that is in communication with the path determiner component 108. The visualizer component 110 generates graphical data 112 for display on a display screen of a computing device, wherein the graphical data is based at least in part upon the trace generated by the path determiner component 108. The graphical data 112 graphically depicts the execution path that satisfies the reachability query and the value of at least one variable that causes the execution path to be taken through the source code 104. As will be shown in greater detail below, the graphical data 112 generated by the visualizer component 110 can graphically depict methods called in the execution path, sequence of methods called in the execution path that causes the destination line of code (and other constraints in the reachability query) to be met, amongst other information. For instance, the graphical data 112 can be a graphical user interface that depicts respective methods called in the execution path, graphically indicates which lines of code were executed in the methods called, graphically depicts variable values in such path, and graphically depicts a sequence of methods called in the execution path. In such an exemplary embodiment, the system 100 can be comprised by an integrated development environment (IDE).
In another exemplary embodiment, the graphical data 112 can be a textual description of the execution path that satisfies the reachability query. Such textual description, for instance, can be a sequence of lines of code executed in the execution path and values of variables at such lines of code when executed in the execution path. Accordingly, the graphical data 112 can be presented in a command line interface. In another exemplary embodiment, the graphical data 112 can be depicted in a form similar as to how a step-through debugger displays graphical data. In such an exemplary embodiment, the user can cause execution of the computer executable program to execute step-by-step along the execution path identified by the path determiner component 108, such that the user can sequentially review which lines of code were executed along the execution path identified by the path determiner component 108 and values of relevant variables at such lines of code.
With reference now to FIG. 2, an exemplary implementation of the path determiner component 108 is illustrated. The path determiner component 108 includes a common intermediate language (CI L) translator component 202 that receives the source code 104 and translates the source code 104 into code in CIL. While shown as being a translator, it is to be understood that the CIL translator component 202 can be a portion of a compiler that compiles the source code 104 into code in CIL. For instance, the source code 104 can be written in a .NET language (object oriented managed language) that compiles to CIL.
The path determiner component 108 further comprises a byte code translator component 204 that receives the code in CIL and translates such code to code in a verification language, which can also be referred to as an intermediate language. In an exemplary embodiment, the verification language can be BoogieTM, which is not object-oriented, and instead of classes containing instance methods, a BoogieTM program comprises a set of global procedures, where the implicit instance reference (this) becomes an explicit parameter. The type system of BoogieTM is relatively simple, encompassing Boolean integer values and maps (arrays with an arbitrarily-typed domain). Each procedure comprises conventional program constructs: assignment statements, conditionals, and loops; everything else in the Boogie language is encoded as user-defined data types, functions, and axioms. The byte code translator component 204 encodes source language constructs, such as dynamic dispatch events and delegates as well as a model of the heap and the object type hierarchy. Thus, Boogie relies on constructs such as assert, assume, and nondeterminism for explicitly modeling source language constructs, such as dynamic dispatch, events, and control flow constructs. It can therefore be ascertained that the code in the verification language generated by the byte code translator component 204 is a global representation of the source code 104.
The path determiner component 108 additionally includes an assertion injector component 206 that injects an assertion into the code in the verification language generated by the byte code translator component 204 based at least in part upon the reachability query. The assertions injected into the code in the verification language by the assertion injector component 206 essentially asserts that execution of the computer-executable program based upon the source code 104 is impossible given the constraints set forth in the reachability query. For instance, if the reachability query includes a single condition-less end point, the assertion injector component 206 can place the statement assert false at the line of code that the user wishes to reach. The assertion injector component 206 turns all previous assertions in the code in the verification language to assumptions; an assumption places a logical constraint on a program execution.
A theorem prover component 208 receives the code in the verification language with the assertions and assumptions injected therein by the assertion injector component 206, and identifies a counter-example that proves that the assertion is false. Pursuant to an example, the theorem prover component 208 can employ a satisfiability modulo theory (SMT) solver, which is configured to reason about programs with unbounded data types, such as integers, maps, and operations, such as arithmetic, map select, update, etc. While the BoogieTM programming language supports high-level source constructs such as conditionals and loops, in an exemplary embodiment, a de-sugared form of the code in the verification language can be employed that uses just assignment, procedure call, and goto statements. The control flow induced by the conditional statements can be encoded using assume statements; Boogie's goto statements are non-deterministic. Such statements take a list of labels and may branch to any of the target blocks. Fields are represented as maps whose domain are object references, with a range that is the type of the field. Accordingly, the value of the map C.x is an integer for any object, even if its type is not C. While this is not practical when executing a program, it does not cause problems for the theorem prover component 208 when reasoning about the program.
The modified program in verification language is provided to the theorem prover component 208, which in an exemplary embodiment, can comprise CorralTM, which is a whole-program analyzer for BoogieTM programs, which uses an SMT solver (Z3TM) for reasoning about programs with unbounded data types such as integers and maps, and operations such as arithmetic, map select and update, etc. Generally, CorralTM converts a subset S of the program's behaviors to a Z3TM formula φS such that φS is satisfiable if and only if S includes an assertion violation. If S is insufficient, then CorralTM can issue a different query to Z3TM to either expand S or conclude that the program does not have any assertion violations. For relatively small programs (single procedure, no loops), CorralTM can pick the subset S to be the set of all program behaviors.
State changes in the computer-executable program can be encoded by having multiple incarnations of the same variable with equations linking the values between states. Incarnations are denoted with subscripts; thus x1 is the value of x after being incremented from its value of x0 When such formula is fed to Z3TM, Z3TM attempts to locate values of a and b that satisfy the formula. Thus, the search undertaken by Z3TM for a satisfying assignment essentially corresponds to searching over all possible executions of the program.
The theorem prover component 208 can additionally operate on larger programs, for which generating a single formula is either not feasible or too expensive in terms of processing cycles or memory. In an exemplary embodiment, CorralTM can employ a heuristic where, for most programs, only a few number of variables and a few number of procedures will be relevant to the assertions in the program. Consequently, at any point in time, the subset S is defined as a pair (V, I), where V is a subset of the set of all BoogieTM variables, and I is a partially in-lined program. Initially, V is empty and I is the entry procedure of the program. Semantically, S encodes the set of all program executions that are contained in I and only reasons about variables in V, while abstracting away the rest. As the set V is increased, CorralTM gains more precision (trading off time because the formulas needed to analyze the programs becomes more complicated). When I rises (e.g. more procedures are inlined), then the syntactic scope of CorralTM increases and it can find longer counterexamples.
In an exemplary embodiment, the code in the verification language can be a Turing-complete language, such that the problem of finding assertion violations in the verification language is undecidable. Therefore, it is possible that the expansion of S inside CorralTM can extend indefinitely. To counter non-termination, a bound can be imposed on I (the set V is always bounded by the set of all global variables in BoogieTM, which is a finite number). This bound limits the number of loop iterations and recursive calls.
Since the assertion injector component 206 injected a false assertion at the destination line of code, when CorralTM produces a counter-example, such counter-example must be a trace that finishes at the specified destination line of code from the reachability query. The counter-example reported by CorralTM can include a trace in the BoogieTM program along with valuables at various points in the trace. Such trace can be translated into one that corresponds to the language in which the source code 104 is written.
















Trace
:=
Statement*











Statment
:=
call MethodName




 |
location File, LineNumber




 |
state {Name    Value}




 |
return











Name
:=
Identifier | Address



Value
:=
int Integer










 |
bool Boolean



 |
fieldmap {Identifier    Value}



 |
arraymap {Integer    Value}



 |
ref Address









The call and return statements form a call tree, location indicates that the program executed the source code at the given location, and state describes a symbolic heap at the most recent location. The state map assigns values to local variables, global variables, and symbolic addresses that represent sharing and cycles in the heap graph. For example, if two local variables x and y both refer to an object with integer field f with value 3, then the state map contains {x→ref a0, y→ref a0, a0→fieldmap{f→3}}.
While the description set forth above indicates that a combination of BoogieTM, CorralTM, and Z3TM can be employed as the theorem prover component 208, it is to be understood that the theorem prover component 208 can include any suitable theorem prover technology.
With reference now to FIGS. 3-4, exemplary methodologies are illustrated and described. While the methodologies are described as being a series of acts that are performed in a sequence, it is to be understood that the methodologies are not limited by the order of the sequence. For instance, some acts may occur in a different order than what is described herein. In addition, an act may occur concurrently with another act. Furthermore, in some instances, not all acts may be required to implement a methodology described herein.
Moreover, the acts described herein may be computer-executable instructions that can be implemented by one or more processors and/or stored on a computer-readable medium or media. The computer-executable instructions may include a routine, a sub-routine, programs, a thread of execution, and/or the like. Still further, results of acts of the methodologies may be stored in a computer-readable medium, displayed on a display device, and/or the like. The computer-readable medium may be any suitable computer-readable storage device, such as memory, hard drive, CD, DVD, flash drive, or the like. As used herein, the term “computer-readable medium” is not intended to encompass a propagated signal.
Now referring solely to FIG. 3, an exemplary methodology 300 that facilitates answering a reachability query set forth by a user is illustrated. The methodology 300 starts at 302, and at 304 source code for a computer-executable program is received. As mentioned above, the source code comprises a plurality of lines of code, wherein the plurality of lines of code comprises statements that define values of variables and a plurality of branches. Execution paths are taken during execution of the computer-executable program by a computer processor based at least in part upon respective values of the variables. In an exemplary embodiment, the source code can be a relatively large portion of source code; between 1,000 and 100,000 lines.
At 306, a reachability query is received, wherein the reachability query comprises a user specification of a destination line of code from amongst the plurality of lines of code of the source code. In an exemplary embodiment, the reachability query can be specified through graphical interaction with the source code (e.g., in an IDE). In another exemplary embodiment, the reachability query can be a natural language query, a Boolean query, or the like.
At 308, an assertion is set forth for a computer-executable theorem prover. The assertion indicates that the destination line of code specified in the reachability query is unreachable during execution of the program.
At 310, a counter-example is received from the theorem prover, wherein the counter-example is a trace that identifies an execution path that reaches the destination line of code specified in the reachability query received at 306. The counter-example can further include a value of at least one variable in the variables that causes the program to reach the destination line of code specified in the reachability query by way of the execution path.
At 312, graphical data is displayed on a display screen of a computing device based at least in part upon the counter-example, wherein the graphical data comprises an indication of the execution path in the value of the at least one variable. The methodology 300 completes at 314.
Now referring to FIG. 4, an exemplary methodology 400 that facilitates setting forth a counter-example to an assertion injected in verification code is illustrated. The methodology 400 starts at 402, and at 404 source code is received. At 406, byte code is generated based at least in part upon the source code. At 408, verification code is generated based at least in part upon the byte code.
At 410, an assertion is injected into the verification code based upon a received reachability query. Additionally, an assumption can be injected into the verification code. At 412, a theorem prover is provided with the verification code that includes the injected assertion. The theorem prover may then provide a counter-example, which is a trace that includes reaching of the destination line of code in accordance with constraints set forth in the reachability query. The methodology 400 completes at 414.
Turning now to FIG. 5, an exemplary graphical user interface 500 that facilitates specification of a reachability query is illustrated. The graphical user interface 500 comprises a source code viewing region 502, which includes lines of source code that can be viewed/edited by a developer. While not shown, the viewing region 502 can include slide bars that allow a viewer of the viewing region 502 to relatively quickly view different portions of source code.
The user can select a line of the source code of interest through, for instance, a cursor 504 and a mouse. For instance, the user can position the cursor 504 over the line of code of interest and right click the mouse, which can cause a menu 506 to be displayed. In another exemplary embodiment, the user can select the line of code through a touch sensitive display mechanism, through voice commands, or the like. Responsive to the user selecting the line of code of interest, the menu 506 is presented, wherein the menu 506 includes a plurality of selectable options. One of such options can be to identify the selected line of code as the destination line of code mentioned above. For instance, if the user positions the cursor 504 over the option to reach the selected line of code, this can cause a reachability query to be generated such that an execution path is identified that reaches the selected line of code.
Now referring to FIG. 6, an exemplary graphical user interface 600 that depicts an execution path that satisfies a reachability query is illustrated. The graphical user interface 600 comprises a plurality of code bubbles 602-608, wherein each of the code bubbles 602-608 represents a respective method called/executed along an execution path that satisfies the reachability query. Thus, the first code bubble 602 represents a first method called/executed in the execution path, the second code bubble 604 represents a second method called/executed in the execution path, the third code bubble 606 represents a third method called/executed in the execution path, and the fourth code bubble 608 represents a fourth method called/executed in the execution path.
In each code bubble, respective lines of code that are executed can be highlighted. As shown in the graphical user interface 600, lines of code executed are displayed in bold type to visually differentiate such lines from lines of code that are not executed in the execution path. Other mechanisms for visually differentiating executed lines of code versus non-executed lines of code in the execution path are contemplated, including highlighting, altering font, and the like. In another embodiment, non-executed lines of code can be omitted from display.
Each code bubble can further comprise respective graphical data that indicates values of variables in the execution path. Such values are collectively shown by reference numeral 610. Additionally, the graphical user interface 600 can comprise arrows 612-616 that represent direct method calls and indirect method calls; for instance, solid arrows can be employed to represent direct method calls, while dashed arrows can be employed to represent indirect method calls (for example due to events).
The graphical user interface 600 can additionally be modified to depict further information. For instance, in a method body, a trace identified by the theorem prover component 208 can specify the order in which statements are executed and interleaved with outgoing calls. Thus, the graphical user interface 600 can be configured to illustrate an order of statement execution. Additionally, the graphical user-interface 600 can be modified to accommodate loops such that a timeline slider can be added to allow the user to witness an order of execution.
Now referring to FIG. 7, another exemplary graphical user-interface 700 that facilitates specification of a reachability query is illustrated. The graphical user interface 700 comprises the viewing region 502. Again, the user can select a particular line of code through utilization of the cursor 504 or other suitable selection mechanism, which can cause a menu 702 to be presented to the user. Such menu 702 can include a plurality of selectable options which pertain to specifying a reachability query. For instance, the menu 702 can include a first selectable option that allows the selected line of code to be identified as the initial line of code, such that execution of the program is to start at the selected line of code (optionally with some defined variable values). A second option can cause the selected line of code to be an intermediate line of code such that the execution path is restricted to pass through the selected line of code prior to reaching the destination line of code. Further, the user can specify an order in which lines of code are to be reached in the execution path. While not shown, this can be graphically depicted through numbers assigned to the line of code, letters assigned to the line of code, etc. Supporting the specification of intermediate lines of code can be useful given that the static analysis of the code relies on a theorem prover, which may be an SMT solver. In such an embodiment, the theorem prover is free to choose any counter-example, which means that the theorem prover can select any execution trace that reaches an endpoint. Such endpoint may be the choice of the theorem prover but not desirable for analysis purposes from the perspective of the user. Accordingly, allowing the user to specify a query that finds intermediate pointing conditions allows the user to search iteratively for a trace that is preferable to the user. For instance, if the user is provided with a trace that takes a normal path through a method, and the user prefers to see an exceptional path, the user can place an intermediate point inside, for instance, a catch statement. Similarly, if the theorem prover sets forth a counter-example in which an environment variable has a value of x and the user prefers the value of y, the user can set a conditional waypoint at the line of code where that environment variable is read.
The menu 702 may also include an option that allows the user to specify the selected line of code as the destination line of code as described above. Furthermore, the menu 702 can include a selectable option that allows the user to specify a condition such as a variable value, etc.
With reference now to FIG. 8, an exemplary user interface 800 that is illustrative of an exemplary implementation of the graphical data 112 in a command line interface is shown. In such an example, the execution path taken is shown as specified lines of code executed in an order, with pertinent variable values corresponding thereto shown adjacent to the lines of code. The user can walk through the lines of code executed in the execution path and see conditions that cause the code to execution along the execution path. As mentioned above, this can also be shown in a debugging mode, wherein execution lines can be sequentially presented upon receiving input from the user (depression of an enter key).
Now referring to FIG. 9, a high-level illustration of an exemplary computing device 900 that can be used in accordance with the systems and methodologies disclosed herein is illustrated. For instance, the computing device 900 may be used in a system that supports answering a reachability query set forth by a user. In another example, at least a portion of the computing device 900 may be used in a system that supports generating a graphical user interface that graphically depicts an execution path that answers a reachability query set forth by a user. The computing device 900 includes at least one processor 902 that executes instructions that are stored in a memory 904. The memory 904 may be or include RAM, ROM, EEPROM, Flash memory, or other suitable memory. The instructions may be, for instance, instructions for implementing functionality described as being carried out by one or more components discussed above or instructions for implementing one or more of the methods described above. The processor 902 may access the memory 904 by way of a system bus 906. In addition to storing executable instructions, the memory 904 may also store graphical data, etc.
The computing device 900 additionally includes a data store 908 that is accessible by the processor 902 by way of the system bus 906. The data store may be or include any suitable computer-readable storage, including a hard disk, memory, etc. The data store 908 may include executable instructions, graphical data, etc. The computing device 900 also includes an input interface 910 that allows external devices to communicate with the computing device 900. For instance, the input interface 910 may be used to receive instructions from an external computer device, from a user, etc. The computing device 900 also includes an output interface 912 that interfaces the computing device 900 with one or more external devices. For example, the computing device 900 may display text, images, etc. by way of the output interface 912.
Additionally, while illustrated as a single system, it is to be understood that the computing device 900 may be a distributed system. Thus, for instance, several devices may be in communication by way of a network connection and may collectively perform tasks described as being performed by the computing device 900.
It is noted that several examples have been provided for purposes of explanation. These examples are not to be construed as limiting the hereto-appended claims. Additionally, it may be recognized that the examples provided herein may be permutated while still falling under the scope of the claims.

## Claims

1. A computer-implemented method comprising:
receiving source code for a computer-executable program, the source code comprising a plurality of lines of code, the plurality of lines of code comprising statements that define values of variables and a plurality of execution paths, wherein respective execution paths are taken during execution of the computer-executable program by a computer processor based at least in part respective values of the variables;
receiving a reachability query from a user, the reachability query comprising:
a user-selected initial line of code from amongst the plurality of lines of code;
a user-selected intermediate line of code from amongst the plurality of lines of code; and
a user-selected destination line of code from amongst the plurality of lines of code;
responsive to receiving the reachability query, identifying:
an execution path in the plurality of execution paths that begins at the initial line of code, then reaches the intermediate line of code, and subsequently reaches the destination line of code; and
a value of at least one variable in the variables that causes the program to execute over the execution path; and
displaying graphical data on a display screen of a computing device, the graphical data indicative of the execution path and the value of the at least one variable.

2. The method of claim 1, wherein the graphical data is displayed in an integrated development environment graphical user interface.

3. The method of claim 2, the execution path comprises a first method, followed by a second method, followed by a third method, the first method calls the second method, the second method calls the third method, the graphical data comprises a graphical representation of the first method, a graphical representation of the second method, and a graphical representation of the third method, the graphical data further comprises an indication that the execution path comprises execution of the first method, the second method, and the third method in sequence.

4. The method of claim 1, the method of claim 1, wherein the graphical data is displayed in a command line interface.

5. The method of claim 1 configured for execution in a debugger, wherein portions of the graphical data are sequentially displayed responsive to respective commands from the user.

6. The method of claim 1, wherein the source code is written in one of C# or C programming language.

7. The method of claim 1, wherein the reachability query comprises a constraint on the value of the at least one variable.

8. The method of claim 1, wherein the source code comprises between one thousand and one hundred thousand lines of code.

9. The method of claim 1, wherein the reachability query is expressed as a natural language query.

10. The method of claim 1, wherein the reachability query is expressed as a Boolean query.

11. The method of claim 1, wherein identifying the execution path comprises:
setting forth an assertion to a computer-executable theorem prover that the destination line of code specified in the reachability query is unreachable; and
receiving from the theorem prover a counter-example, the counter-example comprising the execution path.

12. The method of claim 11, further comprising generating a global representation of the computer program in formulaic code based at least in part upon the source code, wherein the theorem prover is provided with the formulaic code and generates the counter-example based upon the formulaic code and the assertion.

13. The method of claim 1, wherein identifying the value of the at least one variable comprises:
setting forth an assertion to a computer-executable theorem prover that the destination line of code specified in the reachability query is unreachable; and
receiving from the theorem prover a counter-example, the counter-example comprising the value of the at least one variable.

14. A system comprising:
a computer processor; and
a memory that comprises a plurality of components that are executed by the processor, the plurality of components comprising:
a query receiver component that receives a reachability query, the reachability query comprising:
a user-selected initial line of code in source code of a computer-executable program;
a user-selected intermediate line of code in the source code of the computer-executable program; and
a user-selected destination line of code in the source code of the computer-executable program, the source code comprising a plurality of lines of code and a plurality of potential execution paths therethrough;

a path determiner component that identifies an execution path from amongst the plurality of potential execution paths that begins at the initial line of code, passes through the intermediate line of code, and subsequently reaches the destination line of code, the path determiner component further identifying a value of at least one variable in the computer-executable program that at least partially causes the execution path to be taken during execution of the computer-executable program; and
a visualizer component that generates graphical data for display on a display screen of a computing device, the graphical data depicting the execution path.

15. The system of claim 14, wherein the plurality of components are comprised by an integrated development environment.

16. The system of claim 14, wherein the plurality of components are comprised by a debugger.

17. The system of claim 14, wherein the plurality of components are comprised by a command line interface.

18. The system of claim 14, wherein the path determiner component comprises a theorem prover that outputs a trace that identifies the execution path.

19. A computer-readable medium comprising instructions that, when executed by a processor, cause the processor to perform acts comprising:
receiving source code of a computer-executable program, the source code comprising a plurality of lines of code, the source code comprising a plurality of potential execution paths therethrough;
receiving a reachability query, the reachability query comprising a user-selected initial line of code, a user-selected intermediate line of code, and a user-selected destination line of code;
responsive to receiving the reachability query, identifying an execution path in the plurality of execution paths that begins at the user-selected initial line of code, then reaches the intermediate line of code, and subsequently reaches the destination line of code; and
displaying graphical data on a display screen of a computing device, the graphical data depicting the execution path and at least one value for at least one variable corresponding to the execution path.

20. The computer-readable medium of claim 19, wherein identifying the execution path in the plurality of execution paths comprises:
setting forth an assertion to a computer-executable theorem prover that the destination line of code specified in the reachability query is unreachable; and
receiving from the theorem prover a counter-example, the counter-example comprising the execution path.