A program slice consists of the parts of a program that (potentially) affect the values computed at some point of interest, referred to as a slicing criterion. The task of computing program slices is called program slicing. The original definition of a program slice was presented by Weiser in 1979. Since then, various slightly different notions of program slices have been proposed, as well as a number of methods to compute them. An important distinction is that between a static and a dynamic slice. The former notion is computed without making assumptions regarding a program's input, whereas the latter relies on some specific test case. Procedures, arbitrary control flow, composite datatypes and pointers, and interprocess communication each require a specific solution. We classify static and dynamic slicing methods for each of these features, and compare their accuracy and efficiency. Moreover, the possibilities for combining solutions for different features are investigated....

Program slicing is a decomposition technique that elides program components not relevant to a chosen computation, referred to as a slicing criterion. The remaining components form an executable program called a slice that computes a projection of the original program’s semantics. Using examples coupled with fundamental principles, a tutorial introduction to program slicing is presented. Then applications of program slicing are surveyed, ranging from its first use as a debugging technique to current applications in property verification using finite state models. Finally, a summary of research challenges for the slicing community is discussed.

this paper we present a debugging model, based on dynamic program slicing and execution backtracking techniques, that easily lends itself to automation. This model is based on experience with using these techniques to debug software. We also present a prototype debugging tool, SPYDER, that explicitly supports the proposed model, and with which we are performing further debugging research

Program slices are useful in debugging. Most work on program slicing to date has concentrated on finding slices of programs involving only scalar variables. Pointers and composite variables do not lend themselves well to static analysis, especially when the language involved is not strongly-typed. When debugging a program, however, we are interested in analyzing the program behavior for testcases that reveal a fault. In this paper, we present a uniform approach to handling pointers and composite variables suchas arrays, records, and unions for the purpose of obtaining dynamic program slices. The dynamic approach proposed works well even when the language involved allows unconstrained pointers and performs no runtime checks, as in C.

Finding a fault in a program is a complex process which involves understanding the program's purpose, structure, semantics, and the relevant characteristics of failureproducing tests. We describeatool which supports execution slicing and dicing based on test cases. We report the results of an experiment that uses heuristic techniques in fault localization.

Developing effective debugging strategies to guarantee the reliability of software is important. By analyzing the debugging process used by experienced programmers, four distinct tasks are found to be consistently performed: (1) determining statements involved in program failures, (2) selecting suspicious statements that might contain faults, (3) making hypotheses about suspicious faults (variables and locations), and (4) restoring program state to a specific statement for verification. If all four tasks could be performed with direct assistance from a debugging tool, the debugging effort would become much easier. We have built a prototype debugging tool, Spyder, to assist users in conducting the first and last tasks. Spyder executes the first task by using dynamic program slicing and the fourth task by backward execution. This research focuses on the second task, reducing the search domain containing faults, referred to as fault localization. Several heuristics are presented here based on dynamic program slices and information obtained from testing. A family tree of the heuristics is constructed to study effective application of the heuristics. The relationships among the heuristics and the potential order of using them are also explored. A preliminary

Data flow analysis is a process for collecting run-time information about data in programs without actually executing them. In this paper, we focus at the use of data flow analysis to support program understanding and reverse engineering. Data flow analysis is beneficial for these applications since the information obtained can be used to compute relationships between data objects in programs. These relations play a key role, for example, in the determination of the logical components of a system and their interaction. The general support of program understanding and reverse engineering requires the ability to analyse a variety of source languages and the ability to combine the results of analysing multiple languages. We present a flexible and generic software architecture for describing and performing language-independent data flow analysis which allows such transparent multi-language analysis. All components of this architecture were formally specified. 1 Introduction Data flow anal...

Declarative debugging is a method of debugging characterized by locating coding errors in a program using knowledge of the program's intended interpretation alone. A declarative debugger (GraDE) for Godel is presented which handles all of Godel's syntax together with support for abstract data types and coroutining. GraDE builds a computation tree for the program and goal, then works with this tree in a flexible way. The soundness and completeness of the debugger is proved. The performance of two well known approaches, top-down and divide-and-query, are compared on practical programs. GraDE also allows users to control the search method directly thus eliminating an automated search method. The implementation of G r aDE in Godel is discussed and proposals are put forward for further work.

To facilitate the process of tracking program bug symptoms to their causes while debugging, we have developed a robust architecture for program tracing and replay. rdb is a framework for program instrumentation which modifies user programs to perform complete and highly efficient tracing of an execution including interactions with the operating system and asynchronous interrupts. We have developed a library which can be plugged into existing debugging tools to add trace-and-replay functionality, and we have developed a new prototype debugger using our library which provides replay control and flowback capabilities. We discuss the design and implementation of all aspects of the system and suggest future debugging tools and techniques based on this technology. This paper is the discussion of the author's project for the degree of Master of Science, and is the culmination of two years of work in this area with Professor Robert H.B. Netzer. 1 1 Introduction Debugging is the process of bo...

Abstract not found