From Big-Step to Small-Step Semantics and Back with Interpreter Specialisation

  title={From Big-Step to Small-Step Semantics and Back with Interpreter Specialisation},
  author={John P. Gallagher and Manuel V. Hermenegildo and Bishoksan Kafle and Maximiliano Klemen and Pedro L{\'o}pez-Garc{\'i}a and Jos{\'e} Francisco Morales},
We investigate representations of imperative programs as constrained Horn clauses. Starting from operational semantics transition rules, we proceed by writing interpreters as constrained Horn clause programs directly encoding the rules. We then specialise an interpreter with respect to a given source program to achieve a compilation of the source language to Horn clauses (an instance of the first Futamura projection). The process is described in detail for an interpreter for a subset of C… Expand
Analysis and Transformation of Constrained Horn Clauses for Program Verification
Analysis and transformation techniques that originate in the field of constraint logic programming (CLP) to the problem of verifying software systems are surveyed and static analysis techniques for CHCs that may be used for inferring relevant program properties, such as loop invariants are described. Expand
Regular Path Clauses and Their Application in Solving Loops
The approach presented in this paper is to define transformations based on regular path expressions and loop counters that transform multi-path loops to single- path loops, giving rise to recurrences with a single recursive case, and (ii) transformmulti-argument recurrence to single the argument, thus enabling the use of recurrence solvers on the transformedRecurrences. Expand
VeriFly: On-the-fly Assertion Checking via Incrementality
This tool paper presents how the combination of this framework within an integrated development environment (IDE) takes advantage of incrementality to achieve a high level of reactivity when reflecting analysis and verification results back as colorings and tooltips directly on the program text – the tool's VeriFly mode. Expand
Cost Analysis of Smart Contracts Via Parametric Resource Analysis
This work explores the application of a generic approach and tool for cost analysis to the problem of static inference of gas consumption bounds in smart contracts and argues that this approach offers a rapid, flexible, and effective method for the development of cost analyses for smart contracts. Expand
Parallel Logic Programming: A Sequel
This survey provides a review of the research in parallel logic programming covering the period since 2001, thus providing a natural continuation of the previous survey and restricts its attention to parallelization of the major logic programming languages (Prolog, Datalog, Answer Set Programming) and with an emphasis on automated parallelization. Expand
Incremental and Modular Context-sensitive Analysis
The experimental results show that the proposed modular algorithm shows significant improvements, in both time and memory consumption, when compared to existing non-modular, fine-grain incremental analysis techniques, and outperforms traditional modular analysis even when analyzing from scratch. Expand


Semantics-based generation of verification conditions by program specialization
The method is parametric with respect to the semantics of the imperative programming language, as it specializes, by using unfold/fold transformation rules, a Horn clause interpreter that encodes that semantics. Expand
Horn clauses as an intermediate representation for program analysis and transformation*
This work presents a simple LP language that enforces determinism and single-modedness, and shows that it makes a convenient program representation for analysis and transformation. Expand
Analysis of Imperative Programs through Analysis of Constraint Logic Programs
An effective style of writing operational semantics suitable for analysis which is called one-state small-step semantics is proposed, which is able to generate residual programs where the relationship between imperative statements and predicates is straightforward. Expand
A Flexible, (C)LP-Based Approach to the Analysis of Object-Oriented Programs
This work presents a framework for analysis of object-oriented languages in which in a first phase the authors transform the input program into a representation based on Horn clauses, which facilitates on one hand proving the correctness of the transformation attending to a simple condition and on the other allows applying existing analyzers for (constraint) logic programming to automatically derive a safe approximation of the semantics of the original program. Expand
Offline specialisation in Prolog using a hand-written compiler generator
It is demonstrated that the cogen approach is also applicable to the specialisation of logic programs (called partial deduction) and leads to effective specialisers, and using good binding-time annotations, the speed-ups of the specialised programs are comparable to thespeed-ups obtained with online specialisers. Expand
Decompilation of Java bytecode to Prolog by partial evaluation
This paper presents the first modular scheme to enable interpretive decompilation of a realistic programming language to a high-level representation, namely of JBC to Prolog, and introduces two notions of optimality which together require that decompilation does not generate code more than once for each program point. Expand
Rahft: A Tool for Verifying Horn Clauses Using Abstract Interpretation and Finite Tree Automata
Rahft loosely combines three powerful techniques for program verification: program specialisation, abstract interpretation, and trace abstraction refinement in a non-trivial way, with the aim of exploiting their strengths and mitigating their weaknesses through the complementary techniques. Expand
Constraint specialisation in Horn clause verification
A method for specialising the constraints in constrained Horn clauses with respect to a goal by using abstract interpretation to compute a model of a query–answer transformed version of a given set of clauses and a goal. Expand
Program verification via iterated specialization
This work presents a method for verifying properties of imperative programs by using techniques based on the specialization of constraint logic programs (CLP), and improves the precision of program verification with respect to state-of-the-art software model checkers. Expand
Synthesis and Transformation of Logic Programs Using Unfold/Fold Proofs
The unfold/fold proof method can be used to show that the equivalence formula ∀ X (∃ Y F( X , Y )↔∃ Z G( X, Z ) holds in the least Herbrand model of P, and the correctness of the synthesis method derives from the one of the unfold/ fold proof method. Expand