Interprocedural slicing using dependence graphs

Reviewer: Teodor Rus

The behavior of a program is usually defined by the behavior of the process performed by a computer executing a translation of the program. One tool used to study program behavior is the representation of the program by an adequate intermediate representation, such as a control flow graph of the program. Adding edges representing data dependence to this flow graph leads to various kinds of program dependence graphs. This paper approaches the problem of using a suitable program dependence graph (called the system dependence graph) to develop an algorithm to compute program slices crossing procedure call boundaries. This approach is called interprocedural slicing. A slice of a program P with respect to a program point p and a variable x consists of all statements and predicates of the program P that might affect the value of x at p . In the definition of a slice used in this paper, x must be defined or used at p . In order to compute a slice, the program P is represented as a dependence graph containing data and control dependence edges. Two “directly affected” relations are defined on this graph: If the variable x is defined at the point p of the program, then the value of x is directly affected by the values of the variables used at p and by the conditionals and loops that enclose p. If the variable x is used at the point p of the program then the value of x is directly affected by those assignments to x that reach p and by the conditionals and loops that enclose p . Using these relations, a slice of program P at point p and variable x can be computed by a reachability algorithm on the dependence graph of P . The authors consider two versions of the problem of slice computation. In version 1, the slice of the program P with respect to a program point p and a variable x consists of all statements and predicates of the program that might affect the value of x at point p . In version 2, the slice of the program P with respect to a program point p and variable x consists of a reduced program that computes the same sequence of values for x at point p . Since a slice by version 1 is not necessarily a program, the solutions to these two problems differ. For a program without procedure calls (intraprocedural slicing) a solution to version 1 of the problem of slicing also provides a solution to version 2. The reduced program required by version 2 can be obtained from the original program by restricting it to include only statements and predicates that are collected in a slice by version 1. For a program P that contains multiple calls to the same procedure, however, the statements and predicates in a slice defined as in version 1 may yield a syntactically incorrect program: different calls to the same procedure may pass different arguments. This paper addresses version 1 of the interprocedural slicing problem (with the restriction that variable x is used or defined at the point p ) and develops an algorithm that computes slices that cross procedure boundaries. First, the concept of a system dependence graph is developed. The major difficulty in interprocedural slicing is correctly accounting for the context of a called procedure. The paper solves this problem by adding to the system dependence graph edges that represent transitive dependence due to the effects of procedure calls. An attribute grammar facilitates the computation of such dependencies. This approach allows interprocedural slices to be computed in two passes, each of which is cast as a graph reachability problem.