Horn clauses as an intermediate representation for program analysis and transformation

Gange, Graeme; Navas, Jorge A.; Schachte, Peter; Søndergaard, Harald; Stuckey, Peter J.

doi:10.1017/s1471068415000204

Cited by 24 publications

(13 citation statements)

References 30 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…• Horn clauses are a suitable abstraction that is in between binary code and a more high-level programming language. This is in line with recent work (Gange et al 2015) in which the use of Horn Clauses as a universal intermediate language has been advocated. In that work the general idea is to compile a program (written in an arbitrary language) first into Horn clauses, then int max(int x, int y, int z) { if ((x>=y) && (x>=z)) return x; else if ((y>=x) && (y>=z)) return y; else return z; } int max(int x, int y, int z) { int max_xy; if (x>=y) max_xy = x; else max_xy = y; if (max_xy>=z) return max_xy; else return z; } .method public max(III)I .registers 5 0: if-lt v2, v3, 4 1: move v0, v2 2: if-lt v0, v4, 6 3: return v0 4: move v0, v3 5: goto 2 6: move v0, v4 7: goto 3 .end method Figure 1.…”

Section: Introductionsupporting

confidence: 89%

Towards a framework for algorithm recognition in binary code

Mesnard

Payet

Vanhoof

2016

Proceedings of the 18th International Symposium on Principles and Practice of Declarative Programming

View full text Add to dashboard Cite

Algorithm recognition, which is the problem of verifying whether a program implements a given algorithm, is an important topic in program analysis. We propose an approach for algorithm recognition in binary code. For this paper, we have chosen the Dalvik Virtual Machine (DVM) bytecode. Given an algorithm A that is compiled into a DVM method M0, and a DVM program P that includes a series of methods {M1,. .. , Mn}, the approach is able to identify those blocks Mi from P that essentially implement the algorithm A. The technique we propose first translates binary code into Horn clauses. Then we consider programs as implementing the same algorithm if their Horn clause representations can be reduced to a single common set of Horn clauses by means of a sequence of transformations.

show abstract

Section: Introductionsupporting

confidence: 89%

Towards a framework for algorithm recognition in binary code

Mesnard

Payet

Vanhoof

2016

Proceedings of the 18th International Symposium on Principles and Practice of Declarative Programming

View full text Add to dashboard Cite

show abstract

“…The introduced model is the first to exploit the properties of LSSA for register allocation. LSSA and similar representations have been used to establish theoretical connections between programming paradigms [2], as an intermediate form in SSA construction [5], and as a basis for intermediate-level program analysis and optimization [40].…”

Section: Modelmentioning

confidence: 99%

Combinatorial Register Allocation and Instruction Scheduling

Lozano

Carlsson

Blindell

et al. 2019

ACM Trans. Program. Lang. Syst.

View full text Add to dashboard Cite

This paper introduces a combinatorial optimization approach to register allocation and instruction scheduling, two central compiler problems. Combinatorial optimization has the potential to solve these problems optimally and to exploit processor-specific features readily. Our approach is the first to leverage this potential in practice: it captures the complete set of program transformations used in state-of-the-art compilers, scales to mediumsized functions of up to 1000 instructions, and generates executable code. This level of practicality is reached by using constraint programming, a particularly suitable combinatorial optimization technique. Unison, the implementation of our approach, is open source, used in industry, and integrated with the LLVM toolchain.An extensive evaluation confirms that Unison generates better code than LLVM while scaling to mediumsized functions. The evaluation uses systematically selected benchmarks from MediaBench and SPEC CPU2006 and different processor architectures (Hexagon, ARM, MIPS). Mean estimated speedup ranges from 1.1% to 10% and mean code size reduction ranges from 1.3% to 3.8% for the different architectures. A significant part of this improvement is due to the integrated nature of the approach. Executing the generated code on Hexagon confirms that the estimated speedup results in actual speedup. Given a fixed time limit, Unison solves optimally functions of up to 946 instructions, nearly an order of magnitude larger than previous approaches.The results show that our combinatorial approach can be applied in practice to trade compilation time for code quality beyond the usual compiler optimization levels, identify improvement opportunities in heuristic algorithms, and fully exploit processor-specific features. This paper is partially based on preliminary work presented at the Principles and Practice of Constraint Programming (2012) [20]; Languages, Compilers, and Tools for Embedded Systems (2014) [21]; and Compiler Construction (2016) [22] conferences. Compared to the preliminary work, this paper is completely restructured and rewritten, completes the combinatorial model with rematerialization, proposes extensions to capture additional program transformations and processor-specific features, and contributes a more exhaustive evaluation. Additions to the evaluation include more benchmarks and processors, evidence of the fundamental benefit of the integrated approach, an in-depth study of scalability, and actual execution measurements.

show abstract

“…It can also be used as a common intermediate language for exchanging VCs between software verifiers [1,3,9,26] to take advantage of the many special purpose solvers that are available nowadays.…”

Section: Related Work and Conclusionmentioning

confidence: 99%

Semantics-based generation of verification conditions via program specialization

Angelis

Fioravanti

Pettorossi

et al. 2017

Science of Computer Programming

View full text Add to dashboard Cite

We present a method for automatically generating verification conditions for a class of imperative programs and safety properties. Our method is parametric with respect to the semantics of the imperative programming language, as it generates the verification conditions by specializing, using unfold/fold transformation rules, a Horn clause interpreter that encodes that semantics.We define a multi-step operational semantics for a fragment of the C language and compare the verification conditions obtained by using this semantics with those obtained by using a more traditional small-step semantics. The flexibility of the approach is further demonstrated by showing that it is possible to easily take into account alternative operational semantics definitions for modeling additional language features. We have proved that the verification condition generation takes a number of transformation steps that is linear with respect to the size of the imperative program to be verified. Also the size of the verification conditions is linear with respect to the size of the imperative program. Besides the theoretical computational complexity analysis, we also provide an experimental evaluation of the method by generating verification conditions using the multi-step and the small-step semantics for a few hundreds of programs taken from various publicly available benchmarks, and by checking the satisfiability of these verification conditions by using state-of-the-art Horn clause solvers. These experiments show that automated verification of programs from a formal definition of the operational semantics is indeed feasible in practice.

show abstract

Horn clauses as an intermediate representation for program analysis and transformation

Cited by 24 publications

References 30 publications

Towards a framework for algorithm recognition in binary code

Towards a framework for algorithm recognition in binary code

Combinatorial Register Allocation and Instruction Scheduling

Semantics-based generation of verification conditions via program specialization

Contact Info

Product

Resources

About