Abstraction via Program Transformation

RNDr. Henrich Lauko

Disertační práce

Anotace:

V oblasti autonomní verifikace programů jsou abstrakční techniky nezbytné, protože hrají kritickou roli při snižování složitosti verifikačního procesu na zvládnutelné velikosti. Tyto techniky jsou však obvykle pevně integrovány do nástrojů, což vede k nežádoucí složitosti a opomenutí opakovaně použitelného návrhu. Pokud chce někdo použít konkrétní abstrakci v několika nástrojích, běžným přístupem je implementovat abstrakci zvlášť pro každý nástroj. To však vede k zbytečné duplikaci úsilí a nekonzistentním výsledkům, protože různé implementace se mohou lišit. Tato dizertační práce si klade za cíl řešit tuto výzvu vytvořením řešení pro snížení duplikace a složitosti abstrakce. Hlavním cílem je vytvořit nástrojově nezávislou abstrakci programu a využít ji k návrhu technik analýzy programu, které mohou být aplikovány libovolným nástrojem, čímž se snižuje složitost a umožňuje opakované použití abstrakce. To, co mají nástroje společné, je reprezentace programu, se kterou pracují. Jedna taková reprezentace, která získala popularitu, je mezi-reprezentace LLVM kompilátoru Clang. Tato reprezentace také může sloužit na sdílení informací pro analýzu programu. V této doktorské práci navrhujeme řešení nástrojově nezávislé abstrakce jejím přeformulováním v pojmech mezi-reprezentace. Hlavní myšlenkou představeného přístupu je vyjádřit abstraktní sémantiku v pojmech mezi-reprezentace, čímž se stává abstrakce srozumitelnou pro jakýkoli nástroj, který používá LLVM IR. Tento přístup nazýváme kompilačně založenou abstrakcí, protože podstatou je kompilování abstraktní sémantiky do analyzovaného programu. Přístup kompilačně založené abstrakce má široké uplatnění v oblasti analýzy programů. Tato práce demonstruje její potenciál v přeformulování symbolické exekuce jako programové abstrakce, umožňující explicitním nástrojům provádět symbolickou analýzu nebo dokonce spouštět symbolické programy nativně. Důraz bude také kladen na složitější programové prvky, jako jsou pole jazyka C nebo řetězce, které vyžadují specifičtější abstrakci. Přístup je dále rozšířen i o abstrakci agregátových typů a abstrakci na úrovni knihoven. Kromě toho je věnována pozornost abstrakci dynamické paměti, konkrétně problému nejednoznačného uspořádání dynamické paměti, který často bývá ve verifikačních nástrojích opomíjen. Navíc přístup kompilačně založené abstrakce otevírá nové možnosti pro techniky zpřesňování používané abstrakce. Tato práce zkoumá potenciál instrumentace zpřesňování přímo do programu a zpřesňování syntaktické abstrakce programu s využitím protipříkladů. Závěrem tato práce poskytuje autonomní řešení pro instrumentaci abstrakce do reprezentace programu. Představený přístup se zabývá různými problémy souvisejícími s interakcemi oblastí programu, řízením toku a dynamickou pamětí. Zahrnuje adaptace symbolické exekuce, softwarového ověřování modelů a syntaktického zpřesňování s využitím protipříkladů. Navíc tím, že umožňuje nativní spuštění zkompilované abstrakce, tento přístup nejen zjednodušuje proces návrhu abstrakce programu, ale také zvyšuje efektivitu analýzy programu. Naše hlavní přínosy vyvrcholily ve vývoji nástroje LLVM Abstraction & Refinement Tool – LART. Tento nástroj implementuje všechny prezentované abstrakce a demonstruje, že je technika efektivní jak ve spojení s jinými nástroji, tak při vytváření spustitelných abstrakcí.

Abstract:

In the field of computer-aided verification, abstraction techniques are indispensable as they play a critical role in reducing the complexity of the verification process to manageable sizes. However, these techniques are usually tightly integrated into tools, resulting in undesired complexity and neglect of reusable design. If one wants to employ a particular abstraction in several tools, the common approach is to implement the abstraction separately for each tool. However, this results in unnecessary duplication of an effort and inconsistent results as different implementations may vary. This thesis aims to address this challenge by developing a solution to reduce the duplication and complexity of abstraction. The overarching objective is to create a tool-independent program abstraction and utilize it to design program analysis techniques that can be applied by any tool, thereby reducing its complexity and allowing abstraction reusability. What is common between tools is the program representation they operate with. One such representation that has gained popularity is the LLVM intermediate representation of the Clang compiler. It can serve as a shared source of truth between tools and encode additional information for program analysis. In this doctoral thesis, we propose a solution to tool-independent abstraction by reconceiving it in terms of the intermediate representation. The key idea of the presented approach is to express abstract semantics in terms of intermediate representation, resulting in the abstraction being understandable to any tool which uses LLVM IR. We refer to this approach as compilation-based abstraction, as it essentially compiles abstract semantics into the program being analyzed. The compilation-based abstraction approach has broad applicability in the field of program analysis. This thesis demonstrates its potential in recasting symbolic execution as program abstraction, enabling explicit tools to perform symbolic analysis or even run symbolic programs natively. The focus will also be on more complex program primitives such as C arrays or strings, which require elaborated abstraction. The approach is extended to encompass aggregate types and library-level abstractions. Additionally, attention is given to dynamic memory abstraction, specifically the problem of ambiguous dynamic memory layout, which is often overlooked in analysis tools. Furthermore, the compilation-based abstraction approach opens up new possibilities for refinement techniques that can enhance the precision of the employed abstraction. This thesis explores the potential for instrumenting refinement directly into the program and counterexample-guided syntactic abstraction of program representation. In summary, this thesis provides an autonomous solution for instrumenting abstraction into program representation. The presented approach addresses various issues related to program domain interactions, control flow, and dynamic memory. It includes adaptations of symbolic execution, software model checking, and syntactic refinement loops. Moreover, by enabling the native execution of compiled abstraction, this approach not only streamlines the program abstraction design process but also enhances the efficiency of program analysis. Our main contributions culminated in the development of an LLVM Abstraction & Refinement Tool – LART. This tool implements all discussed abstractions and has been shown to be effective both in conjunction with other tools and in producing natively executable abstractions.

Keywords

program analysis, software verification, model checking, symbolic model checking, abstract execution, divine, llvm, program transformation, compilation, abstraction, refinement, heap analysis, string analysis, lart, C, C++, implementation

Jazyk práce: angličtina

Datum vytvoření / odevzdání či podání práce: 14. 7. 2023

Obhajoba závěrečné práce

• Obhajoba proběhla 20. 2. 2024
• Vedoucí: prof. RNDr. Jiří Barnat, Ph.D.
• Oponent: Prof. Dr. Gidon Ernst, prof. Ing. Tomáš Vojnar, Ph.D.

Masarykova univerzita

Fakulta informatiky

Doktorský studijní program / obor:
Informatika / Technologie a metodologie počítačových systémů