Slicing Unconditional Jumps with Unnecessary Control Dependencies

Abstract

Program slicing is an analysis technique that has a wide range of applications, ranging from compilers to clone detection software, and that has been applied to practically all programming languages. Most program slicing techniques are based on a widely extended program representation, the System Dependence Graph (SDG). However, in the presence of unconditional jumps, there exist some situations where most SDG-based slicing techniques are not as accurate as possible, including more code than strictly necessary. In this paper, we identify one of these scenarios, pointing out the cause of the inaccuracy, and describing the initial solution to the problem proposed in the literature, together with an extension, which solves the problem completely. These solutions modify both the SDG generation and the slicing algorithm. Additionally, we propose an alternative solution, that solves the problem by modifying only the SDG generation, leaving the slicing algorithm untouched.

Analysis Techniques for Software Maintenance

“…Most program slicing techniques have the PDG in their basis, but the original definition of the PDG is not able to handle all the features that most modern programming languages offer. Therefore, numerous extensions and enhancements of the PDG have been proposed to represent different programming features such as arbitrary control-flow [65,109], exception handling [6,64,93], interprocedural behaviour [17,41], or concurrency [36,104] among others. In the program slicing area, new proposals are frequently presented as an evolution of a previously existing program representation that lacks the expressiveness needed to manage a particular program feature.…”

“…Although the PDG has been extended several times to represent features like arbitrary control-flow [13,65,109]; exception handling [6,64,92,93]; interprocedural behaviour [16,17,41,110]; or concurrency [36,104]; among others, there is still a largely unaddressed problem that is a source of imprecision and that affects all programming languages: the slicing of composite data structures.…”

“…We have observed that similar ad-hoc solutions have been proposed in the literature once and again to solve the same problem in different contexts. To cite some examples, the SDG has been extended with additional nodes to represent: objects [118,128,202], exceptions [6,62], for-loops [132], list comprehensions [181], composite data structures [72,108,123,186], etc. The need for these ad-hoc solutions are a clear symptom that the SDG should be generalised to account for all those problems.…”

“…This is the beauty of the EDG: it follows (and extends) the same principles of the SDG: a backward traversal of the EDG from the slicing criterion produces a complete well-formed slice. Moreover, all additional slicing restrictions used to improve the precision of slices for particular program structures (like the one introduced for the slice of unconditional jumps [109] or exception handling [62]) can be directly applied to the EDG in the same way they are to the SDG. Other techniques, nevertheless, need to define ad-hoc algorithms for their extensions.…”