Compositional decompilation using LLVM IR

Eklind, Robin (2015) Compositional decompilation using LLVM IR. BSc dissertation, University of Portsmouth.

[img] PDF
Restricted to Registered users only

Download (3356kB)


    Decompilation or reverse compilation is the process of translating low-level machine-readable code into high-level human-readable code. The problem is nontrivial due to the amount of information lost during compilation, but it can be divided into several smaller problems which may be solved independently. This report explores the feasibility of composing a decompilation pipeline from independent components, and the potential of exposing those components to the end-user. The components of the decompilation pipeline are conceptually grouped into three modules. Firstly, the front-end translates a source language (e.g. x86 assembly) into LLVM IR; a platform-independent low-level intermediate representation. Secondly, the middle-end structures the LLVM IR by identifying high-level control flow primitives (e.g. pre-test loops, 2-way conditionals). Lastly, the back-end translates the structured LLVM IR into a high-level target programming language (e.g. Go). The control flow analysis stage of the middle-end uses subgraph isomorphism search algorithms to locate control flow primitives in CFGs, both of which are described using Graphviz DOT files.
    The decompilation pipeline has been proven capable of recovering nested pre-test and post-test loops (e.g. while, do-while), and 1-way and 2-way conditionals (e.g. if, if-else) from LLVM IR. Furthermore, the data-driven design of the control flow analysis stage facilitates extensions to identify new control flow primitives. There is huge potential for future development. The Go output could be made more idiomatic by extending the post-processing stage, using components such as Grind by Russ Cox which moves variable declarations closer to their usage. The languageagnostic aspects of the design will be validated by implementing components in other languages; e.g. data flow analysis in Haskell. Additional back-ends (e.g. Python output) will be implemented to verify that the general decompilation tasks (e.g. control flow analysis, data flow analysis) are handled by the middle-end.

    Item Type: Dissertation
    Departments/Research Groups: Faculty of Technology > School of Computing
    Depositing User: Jane Polwin
    Date Deposited: 03 Dec 2015 16:41
    Last Modified: 03 Dec 2015 16:41

    Actions (login required)

    View Item

    Document Downloads

    More statistics for this item...