On Slicing Programs with Jump Statements

Program slices have potential uses in many software engineering applications. Traditional slicing algorithms, however, do not work correctly on programs that contain explicit jump statements. Two similar algorithms were proposed recently to alleviate this problem. Both require the flowgraph and the program dependence graph of the program to be modified. In this paper, we propose an alternative algorithm that leaves these graphs intact and uses a separate graph to store the additional required information. We also show that this algorithm permits an extremely efficient, conservative adaptation for use with programs that contain only "structured" jump statements

Towards automatic debugging of computer programs

Programmers spend considerable time debugging code. Symbolic debuggers provide some help but the task still remains complex and difficult. Other than breakpoints and tracing, these tools provide little high level help. Programmers must perform many tasks manually that the tools could perform automatically, such as finding which statements in the program affect the value of an output variable under a given testcase, what was the value of a given variable when the control last reached a given program location, and what does the program do differently under one testcase that it does not do under another. If the debugging tools provided explicit support for such tasks, the whole debugging process would be automated to a large extent. In this dissertation, we propose a new debugging paradigm that easily lends itself to automation. Two tasks in this paradigm translate into techniques called dynamic program slicing and execution backtracking. We discuss what these techniques are and how they can be automated. We present ways to obtain accurate dynamic slices of programs that may involve unconstrained pointers and composite variables. Dynamic slicing algorithms spanning a range of time-space-accuracy trade-offs are presented. We also propose ways in which multiple dynamic slices may be combined to provide further fault localization information. A new space-efficient approach to execution backtracking called structured backtracking is also proposed. Our experiment with the above techniques has also resulted in development of a prototype tool, S scPYDER, that explicitely supports them

Towards automatic debugging of computer programs

Programmers spend considerable time debugging code. Symbolic debuggers provide some help but the task still remains complex and difficult. Other than breakpoints and tracing, these tools provide little high level help. Programmers must perform many tasks manually that the tools could perform automatically, such as finding which statements in the program affect the value of an output variable under a given testcase, what was the value of a given variable when the control last reached a given program location, and what does the program do differently under one testcase that it does not do under another. If the debugging tools provided explicit support for such tasks, the whole debugging process would be automated to a large extent. In this dissertation, we propose a new debugging paradigm that easily lends itself to automation. Two tasks in this paradigm translate into techniques called dynamic program slicing and execution backtracking. We discuss what these techniques are and how they can be automated. We present ways to obtain accurate dynamic slices of programs that may involve unconstrained pointers and composite variables. Dynamic slicing algorithms spanning a range of time-space-accuracy trade-offs are presented. We also propose ways in which multiple dynamic slices may be combined to provide further fault localization information. A new space-efficient approach to execution backtracking called structured backtracking is also proposed. Our experiment with the above techniques has also resulted in development of a prototype tool, S scPYDER, that explicitely supports them

Dynamic Slicing in the Presence of Unconstrained Pointers

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 such as 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

Efficient Debugging with Slicing and Backtracking SERC-TR-80-P

Programmers spend considerable time debugging code. Several tools are available to help them in this task, varying from hexadecimal dumps of program state to window- and mouse-based interactive debuggers, but the task still remains complex and difficult. Most of these conventional debuggers provide breakpoints and traces as their main debugging aids. These features have changed little in the past 15–20 years desp}te the increased complexity of software systems on which debuggers are used. In this paper we present a prototype tool that enables users to follow their “natural ” thought process while debugging. It combines dynamic program slicing and execution backtracking techniques in a novel way. With the help of this powerful combination, program bugs may be localized and removed very quickly. Examples are given to show how our debugger may be used, and how it relates to other research in the area

Efficient Debugging with Slicing and Backtracking

Programmers spend considerable time debugging code. Several tools are available to help them in this task, varying from hexadecimal dumps of program state to window- and mouse-based interactive debuggers, but the task still remains complex and difficult. Most of these conventional debuggers provide breakpoints and traces as their main debugging aids. These features have changed little in the past 15--20 years despite the increased complexity of software systems on which debuggers are used. In this paper we present a prototype tool that enables users to follow their "natural" thought process while debugging. It combines dynamic program slicing and execution backtracking techniques in a novel way. With the help of this powerful combination, program bugs may be localized and removed very quickly. Examples are given to show how our debugger may be used, and how it relates to other research in the area. Keywords: program debugging, execution backtracking, reverse program execution, program..