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.

Traditional, syntax-preserving program slicing simpli es a program by deleting components (e.g., statements and predicates) that do not aect a computation of interest. Amorphous slicing removes the limitation to component deletion as the only means of simpli cation, while retaining the semantic property that a slice preserves the selected behaviour of interest from the original program. This leads to slices which are often considerably smaller than their syntax-preserving counterparts.

Program slicing is a viable method to restrict the focus of a task to specific sub-components of a program. Examples of applications include debugging, testing, program comprehension, restructuring, downsizing, and parallelization. This paper discusses different statement deletion based slicing methods, together with algorithms and applications to software engineering.

. A new algorithm is presented that automatically uncovers memory errors such as NULL pointers dereference and memory leaks in C programs. The algorithm is conservative, i.e., it can never miss an error but may report "false alarms". When applied to several intricate C programs manipulating singly linked lists, the new algorithm yields more accurate results, does not report any false alarm and usually runs even faster and consumes less space than a less precise algorithm. 1 Introduction Many nasty bugs result from misusing memory by NULL pointer dereference, access to freed storage, or memory leaks. We refer to these errors as memory cleanness errors since they should never occur in bug-free programs. No wonder that many academic and commercial projects are aimed at producing tools that detect classes of memory cleanness problems (see Section 4.1). This paper does not intend to introduce another shape analysis or pointer analysis algorithms. Instead, we focus on detecting clea...

The incorrect use of pointers is one of the most common source of bugs. As a consequence, any kind of static code checking capable of detecting potential bugs at compile time is welcome. This paper presents a static analysis for the detection of incorrect accesses to memory (dereferences of invalid pointers). A pointer may be invalid because it has not been initialised or because it refers to a memory location which has been deallocated. The analyser is derived from an axiomatisation of alias and connectivity properties which is shown to be sound with respect to the natural semantics of the language. It deals with dynamically allocated data structures and it is accurate enough to handle circular structures. 1 Introduction The motivation for the work described in this paper comes from two observations: ffl Most widely used programming languages allow explicit pointer manipulations. The expressiveness provided by such features is appreciated by many programmers because it makes it pos...

Abstract not found

. In an earlier paper, one of the present authors presented a preliminary account of an equational logic called PIM. PIM is intended to function as a "transformational toolkit" to be used by compilers and analysis tools for imperative languages, and has been applied to such problems as program slicing, symbolic evaluation, conditional constant propagation, and dependence analysis. PIM consists of the untyped lambda calculus extended with an algebraic rewriting system that characterizes the behavior of lazy stores and generalized conditionals. A major question left open in the earlier paper was whether there existed a complete equational axiomatization of PIM's semantics. In this paper, we answer this question in the affirmative for PIM's core algebraic component, PIM t , under the assumption of certain reasonable restrictions on term formation. We systematically derive the complete PIM logic as the culmination of a sequence of increasingly powerful equational systems starti...

We show how to combine program slicing and constraint solving in order to obtain better slice accuracy. The method is used in the VALSOFT slicing system. One particular application is the validation of computer-controlled measurement systems. VALSOFT will be used by the Physikalisch-Technische Bundesanstalt for verification of legally required calibration standards. The article describes the VALSOFT slicing system. In particular, we describe how to generate and simplify path conditions based on program slices. A case study shows that the technique can indeed increase slice precision and reveal manipulations of the so-called calibration path.

There is a constant need for practical, efficient and costeffective software evolution techniques. We propose a novel evolution methodology that integrates the concepts of features and component-based software engineering (CBSE). We collect information about a legacy system's features through interviews with key developers, users of the system and analyzing the existing regression test cases. We found that regression test cases are untapped resources, as far as information about system features is concerned.

Program slicing is an effective technique for narrowing the focus of attention to the relevant parts of a program during the debugging process. However, imprecision is a problem in static slices since they are based on all executions that reach a given program point rather than the specific execution under which the program is being debugged. Dynamic slices are precise but require a large amount of run time overhead due to the tracing information that is collected during the program's execution. We present a general approach for improving the precision and quality of static slices by incorporating dynamic information in static slicing, enabling the computation of hybrid slices. The technique exploits dynamic information that is readily available during debugging, namely breakpoint information and the dynamic call graph. The precision of static slicing is improved in hybrid slicing by more accurately estimating the potential paths taken by the program. The breakpoints and call/return po...