Refining interprocedural change-impact analysis using equivalence relations

Abstract

Change-impact analysis (CIA) is the task of determining the set of program elements impacted by a program change. Precise CIA has great potential to avoid expensive testing and code reviews for (parts of) changes that are refactorings (semantics-preserving). Existing CIA is imprecise because it is coarse-grained, deals with only few refactoring patterns, or is unaware of the change semantics.We formalize the notion of change impact in terms of the trace semantics of two program versions. We show how to leverage equivalence relations to make dataflow-based CIA aware of the change semantics, thereby improving precision in the presence of semantics-preserving changes. We propose an anytime algorithm that allows applying costly equivalence relation inference incrementally to refine the set of impacted statements. We have implemented a prototype in SYMDIFF, and evaluated it on 322 real-world changes from open-source projects and benchmark programs used by prior research. The evaluation results show an average 35% improvement in the size of the set of impacted statements compared to standard dataflow-based techniques. + static unsigned char line_delim = '\n'; 2 int print_product_info(int name , int version) { 3 int locale , printed = 0; 4 -print_header('\n' ); 5 + print_header(line_delim ); // spurious arg impact 6 locale = locale_ok(); // spurious impact 7 if (name) { 8 printed = print_name(locale); 9 } 10 if (version && printed) { 11 printed = print_major_version(locale)); 12 -printed = print_minor_version(locale ,'\n' );

Specification and inference of trace refinement relations

“…Jackson and Ladd [14] describe an approach based on dependencies between input and output variables, but do not offer formal proofs. Gyori et al [13] took steps beyond concrete refinement, using equivalence relations, similar to those of Benton, for dataflow-based change impact analysis. Other works.…”

“…Researchers and practitioners are increasingly aware that verification tools can be impactful if they embrace change through analyses that are compositional and span program versions. Reasoning about similarities and differences between programs goes back to Benton [7], who introduced state-based refinement relations, which were extended by Yang [36] and others [13,34]. However, to our knowledge, refinement relations have not been explored for traces: existing techniques, including bisimulation, cannot capture similarities/differences between how two programs behave over time.We present a novel theory that allows one to perform compositional reasoning about the similarities/differences between how fragments of two different programs behave over time through the use of what we call trace-refinement relations.…”

Lazy Self-composition for Security Verification

“…Our approach has some similarities to other problems related to tainting [19]. In particular, Change-Impact Analysis is the problem of determining what parts of a program are affected due to a change.…”

“…Intuitively, it can be seen as a form of taint analysis, where the change is treated as taint. To solve this, Gyori et al [19] propose a combination of an imprecise type-based approach with a precise semantics-preserving approach. The latter considers the program before and after the change and finds relational equivalences between the two ver-sions.…”

Predicting co‐change probability in software applications using historical metadata

“…A set of software metrics, for example, the C&K metric suite, is used to identify dependencies [2]. The dynamic techniques are based on the total number of distinct messages sent at runtime, method invocations, and aggregation relationships [3–5]. Static code attributes identify the most change prone classes, but not the classes that are most vulnerable to change ripples.…”