11 research outputs found
Analysis of Program Differences with Numerical Abstract Interpretation
International audienceWe present work in progress on the static analysis of software patches. Given two syntactically close versions of a program, our analysis can infer a semantic difference, and prove that both programs compute the same outputs when run on the same inputs. Our method is based on abstract interpretation, and parametric in the choice of an abstract domain. At the moment, we focus on numeric properties only, on a toy language. Our method is able to deal with infinite-state programs and unbounded executions, but it is limited to comparing terminating executions, ignoring non terminating ones.We first present a novel concrete collecting semantics, expressing the behaviors of both programs at the same time. We then show how to leverage classic numeric abstract domains, such as polyhedra or octagons, to build an effective static analysis. We also introduce a novel numeric domain to bound differences between the values of the variables in the two programs, which has linear cost, and the right amount of relationality to express useful properties of software patches. We implemented a prototype and experimented on a few small examples from the literature.In future work, we will consider extensions to non purely numeric programs, towards the analysis of realistic patches
A Mechanically Checked Generation of Correlating Programs Directed by Structured Syntactic Differences
International audienceWe present a new algorithm for the construction of a correlating program from the syntactic difference between the original and modified versions of a program. This correlating program exhibits the semantics of the two input programs and can then be used to compute their semantic differences, following an approach of Partush and Yahav [12]. We show that Partush and Yahav's correlating program is unsound on loops that include an early exit. Our algorithm is defined on an imperative language with while-loops, break, and continue. To guarantee its correctness, it is formalized and mechanically checked within the Coq proof assistant. On a series of examples, we experimentally find that the static analyzer dizy is at least as precise on our correlating program as on Partush and Yahav's
Checking Observational Purity of Procedures
Verifying whether a procedure is observationally pure is useful in many
software engineering scenarios. An observationally pure procedure always
returns the same value for the same argument, and thus mimics a mathematical
function. The problem is challenging when procedures use private mutable global
variables, e.g., for memoization of frequently returned answers, and when they
involve recursion.
We present a novel verification approach for this problem. Our approach
involves encoding the procedure's code as a formula that is a disjunction of
path constraints, with the recursive calls being replaced in the formula with
references to a mathematical function symbol. Then, a theorem prover is invoked
to check whether the formula that has been constructed agrees with the function
symbol referred to above in terms of input-output behavior for all arguments.
We evaluate our approach on a set of realistic examples, using the Boogie
intermediate language and theorem prover. Our evaluation shows that the
invariants are easy to construct manually, and that our approach is effective
at verifying observationally pure procedures.Comment: FASE 201
Analysis of Software Patches Using Numerical Abstract Interpretation
International audienceWe present a static analysis for software patches. Given two syntactically close versions of a program, our analysis can infer a semantic difference, and prove that both programs compute the same outputs when run on the same inputs. Our method is based on abstract interpretation, and parametric in the choice of an abstract domain. We focus on numeric properties only. Our method is able to deal with unbounded executions of infinite-state programs, reading from infinite input streams. Yet, it is limited to comparing terminating executions, ignoring non terminating ones.We first present a novel concrete collecting semantics, expressing the behaviors of both programs at the same time. Then, we propose an abstraction of infinite input streams able to prove that programs that read from the same stream compute equal output values. We then show how to leverage classic numeric abstract domains, such as polyhedra or octagons, to build an effective static analysis. We also introduce a novel numeric domain to bound differences between the values of the variables in the two programs, which has linear cost, and the right amount of relationality to express useful properties of software patches.We implemented a prototype and experimented on a few small examples from the literature. Our prototype operates on a toy language, and assumes a joint syntactic representation of two versions of a program given, which distinguishes between common and distinctive parts
Incorporating Data Dependencies and Properties in Difference Verification with Conditions (Technical Report)
Software changes frequently. To efficiently deal with such frequent changes,
software verification tools must be incremental. Most of today's approaches for
incremental verification consider one specific verification approach. One
exception is difference verification with conditions recently proposed by Beyer
et al. Its underlying idea is to determine an overapproximation of those
modified execution paths that may cause a new property violation, which does
not exist in the unchanged program, encode the determined paths into a
condition, and use the condition to restrict the verification to the analysis
of those determined paths. To determine the overapproximation, Beyer et al.
propose a syntax-based difference detector that adds any syntactical path of
the modified program that does not exist in the original program into the
overapproximation. This paper provides a second difference detector diffDP,
which computes a more precise overapproximation by taking data dependencies and
program properties into account when determining the overapproximation of those
modified execution paths that may cause a new property violation. Our
evaluation indeed shows that our more precise difference detector improves the
effectiveness and efficiency of difference verification with condition on
several tasks
Fundamental Approaches to Software Engineering
This open access book constitutes the proceedings of the 25th International Conference on Fundamental Approaches to Software Engineering, FASE 2022, which was held during April 4-5, 2022, in Munich, Germany, as part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2022. The 17 regular papers presented in this volume were carefully reviewed and selected from 64 submissions. The proceedings also contain 3 contributions from the Test-Comp Competition. The papers deal with the foundations on which software engineering is built, including topics like software engineering as an engineering discipline, requirements engineering, software architectures, software quality, model-driven development, software processes, software evolution, AI-based software engineering, and the specification, design, and implementation of particular classes of systems, such as (self-)adaptive, collaborative, AI, embedded, distributed, mobile, pervasive, cyber-physical, or service-oriented applications
Fundamental Approaches to Software Engineering
This open access book constitutes the proceedings of the 25th International Conference on Fundamental Approaches to Software Engineering, FASE 2022, which was held during April 4-5, 2022, in Munich, Germany, as part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2022. The 17 regular papers presented in this volume were carefully reviewed and selected from 64 submissions. The proceedings also contain 3 contributions from the Test-Comp Competition. The papers deal with the foundations on which software engineering is built, including topics like software engineering as an engineering discipline, requirements engineering, software architectures, software quality, model-driven development, software processes, software evolution, AI-based software engineering, and the specification, design, and implementation of particular classes of systems, such as (self-)adaptive, collaborative, AI, embedded, distributed, mobile, pervasive, cyber-physical, or service-oriented applications