The system dependence graph (SDG) is a widely used program representation for the static analysis of programs. In particular, it is the standard way to represent control and flow dependences between the statements of a program. It is at the core of program slicing, a technique that extracts the part of a program that can influence a given program point (the so-called slicing criterion). In this paper, we identify several program slicing situations (e.g., list comprehensions, try-catch and for ) where the representation provided by the SDG is imprecise, and we present an alternative program representation, which is indeed an extension of the SDG, that solves these situations. We call this extension the expression dependence graph (EDG). The EDG redefines the SDG by increasing the granularity of its nodes to abstract syntax tree (AST) nodes. The implications of this change include an improvement in precision, the appearance of new kinds of dependences (besides control and flow dependences), and the possibility of selecting any (sub)expression as the slicing criterion.

Program slicing is a program analysis technique to identify the parts of a program that can influence the values computed at a given program point. Its application to concurrent programs with shared memory revealed a new program dependence between threads called interference and uncovered some problems associated with concurrent executions such as time travel. To solve these problems, a new program representation for slicing concurrent programs was proposed: the threaded System Dependence Graph (tSDG), which aimed at solving the time travel problem and to provide context-sensitive slices for concurrent programs. In this paper, we show that the problem remains unsolved because the tSDG is not context-sensitive in some situations. We give a counterexample for the tSDG and identify situations where the tSDG is imprecise, generating context-insensitive slices for concurrent programs. To solve these imprecisions, we redesign the tSDG to become context-sensitive in those situations, solving the inaccuracy problem and preserving the solution to time travel. The new program representation is always as precise as the previous tSDG, and sometimes it is more precise. That is, the slices computed with the new graph are always smaller or equal than those computed with the previous tSDG.

Program slicing is a technique to extract the part of the program that can affect the values computed at a given program point (known as the slicing criterion). To represent programs, program slicing uses the System Dependence Graph (SDG), for which several extensions like the Java System Dependence Graph (JSysDG) or the Sub-Statement Linear Dependence Graph (SSLDG) exist to deal with Java object-oriented programs. In this paper, we present an incompleteness result proving that these graphs do not produce complete slices in all cases, and specifically when some object variables are selected as the slicing criterion. We first identify the source of the problem: the representation of dependences between partial definitions of objects is ill-defined in these approaches, leading to a loss of completeness in many cases. To solve this limitation, we extend these representations with the addition of a specific flow dependence for object type variables called object-flow dependence. This extension provides a more accurate flow representation between object variables and its data members and it allows us to obtain complete slices when an object variable is selected as the slicing criterion.

Program slicing is a technique for program analysis and transformation with many different applications such as program debugging, program specialisation, and parallelisation. The system dependence graph (SDG), the most commonly used data structure for program slicing, has been extended in several ways to manage exception handling constructs. In this paper, however, we show that the presence of exception-handling constructs can make even the extended SDG produce incorrect and incomplete slices. To solve this situation, we survey the current state of the art and merge and extend different approaches (that treat throws, try-catch, etc.) to produce a version of the SDG that is able to manage all of them, that always produces complete slices, and that increases its precision keeping the same time complexity. An interesting side result is the discovering of a new kind of control dependence: conditional control dependence, which is needed to properly represent catch statements.