Iris

Jung, Ralf; Swasey, David; Sieczkowski, Filip; Svendsen, Kasper; Turon, Aaron; Birkedal, Lars; Dreyer, Derek

doi:10.1145/2676726.2676980

Cited by 149 publications

(36 citation statements)

References 48 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Iris is a language-generic framework for higher-order concurrent separation logic [Jung et al 2016[Jung et al , 2017b[Jung et al , 2015, which in the past year has been equipped with tactical support for conducting machine-checked proofs of programs in Coq ] and deployed in several ongoing verification projects [Kaiser et al 2017;Swasey et al 2017;Tassarotti et al 2017;Timany et al 2018]. By virtue of being a separation logic [O'Hearn 2007;Reynolds 2002], Iris comes with built-in support for reasoning modularly about ownership.…”

Section: Rustbelt: An Extensible Semantic Approach To Proving Soundnmentioning

confidence: 99%

RustBelt: securing the foundations of the Rust programming language

Jung

Jourdan

Krebbers

et al. 2017

Proc. ACM Program. Lang.

Self Cite

212

164

View full text Add to dashboard Cite

Rust is a new systems programming language that promises to overcome the seemingly fundamental tradeoff between high-level safety guarantees and low-level control over resource management. Unfortunately, none of Rust's safety claims have been formally proven, and there is good reason to question whether they actually hold. Specifically, Rust employs a strong, ownership-based type system, but then extends the expressive power of this core type system through libraries that internally use unsafe features. In this paper, we give the first formal (and machine-checked) safety proof for a language representing a realistic subset of Rust. Our proof is extensible in the sense that, for each new Rust library that uses unsafe features, we can say what verification condition it must satisfy in order for it to be deemed a safe extension to the language. We have carried out this verification for some of the most important libraries that are used throughout the Rust ecosystem.

show abstract

Section: Rustbelt: An Extensible Semantic Approach To Proving Soundnmentioning

confidence: 99%

RustBelt: securing the foundations of the Rust programming language

Jung

Jourdan

Krebbers

et al. 2017

Proc. ACM Program. Lang.

Self Cite

212

164

View full text Add to dashboard Cite

show abstract

“…Higher-order reasoning is known to be difficult for separation logic, involving the topos of trees of Birkedal et al [2012]. Our current plan is to encode JSIL Logic in Iris [Jung et al 2015], obtaining soundness for free.…”

Section: :4mentioning

confidence: 99%

“…Our immediate next steps are to prove properties of programs using the for−in statement, leveraging on the work of Cox et al [2014], and to extend JSIL Logic with higher-order reasoning by encoding it in Iris [Jung et al 2015], in order to be able to reason about JavaScript getters/setters and arbitrary functions passed as parameters.…”

Section: Javert: Verifying Javascript Programsmentioning

confidence: 99%

“…For all other uses, contact the owner/author(s). 50:2 J. Fragoso Santos, P. Maksimović, D. Naudžiūnienė, T. Wood, P. Gardner programs; the automatic verification tool Infer [Calcagno et al 2015], being developed at Facebook, for reasoning about C, Java, C++ and Objective C programs; and the interactive Coq development for reasoning about, for example, ML-like programs [Krebbers et al 2017] using Iris [Jung et al 2015]. In contrast, separation logic has hardly been used to reason about programs written in dynamic languages in general, and JavaScript in particular.…”

mentioning

confidence: 99%

See 1 more Smart Citation

JaVerT: JavaScript verification toolchain

Santos

Maksimovic

Naudžiūnienė

et al. 2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

The dynamic nature of JavaScript and its complex semantics make it a difficult target for logic-based verification. We introduce JaVerT, a semi-automatic JavaScript Verification Toolchain, based on separation logic and aimed at the specialist developer wanting rich, mechanically verified specifications of critical JavaScript code. To specify JavaScript programs, we design abstractions that capture its key heap structures (for example, prototype chains and function closures), allowing the developer to write clear and succinct specifications with minimal knowledge of the JavaScript internals. To verify JavaScript programs, we develop JaVerT, a verification pipeline consisting of: JS-2-JSIL, a well-tested compiler from JavaScript to JSIL, an intermediate goto language capturing the fundamental dynamic features of JavaScript; JSIL Verify, a semi-automatic verification tool based on a sound JSIL separation logic; and verified axiomatic specifications of the JavaScript internal functions. Using JaVerT, we verify functional correctness properties of: data-structure libraries (key-value map, priority queue) written in an object-oriented style; operations on data structures such as binary search trees (BSTs) and lists; examples illustrating function closures; and test cases from the official ECMAScript test suite. The verification times suggest that reasoning about larger, more complex code using JaVerT is feasible. INTRODUCTIONSeparation logic was developed in order to reason about programs that manipulate data structures in the heap. The reasoning has been shown to be tractable, with compositional techniques that scale [Reynolds 2002] and properly engineered tools applied to real-world code. In particular, separation logic has been used to reason about programs written in static languages: for example, the semi-automatic verification tool Verifast [Jacobs et al. 2011] for reasoning about C and Java Authors' addresses: José Fragoso Santos, Imperial College London, UK, jose.fragoso.santos@imperial.ac.uk; Petar Maksimović, Imperial College London, UK, petar.maksimovic@imperial.ac.uk, Mathematical Institute SASA, Serbia; Daiva Naudžiūnienė, Imperial College London, UK, daiva.naudziuniene@imperial.ac.uk; Thomas Wood, Imperial College London, UK, thomas.wood@imperial.ac.uk; Philippa Gardner, Imperial College London, UK, p.gardner@imperial.ac.uk.Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for third-party components of this work must be honored. For all other uses, contact the owner/author(s). 50:2 J. Fragoso Santos, P. Maksimović, D. Naudžiūnienė, T. Wood, P. Gardner programs; the automatic verification tool Infer [Calcagno et al. 2015], being developed at Facebook, for reasoning about C, Java, C++ and Objective C programs; and the interactive Coq development for reasoning about, f...

show abstract

“…RELATED WORK As already mentioned above, various program logics have recently been proposed to reason about concurrent programs, e.g., CAP [7], iCAP [8], CaReSL [9] , TaDA [23] and IRIS [24]. These are all highly expressive logics, which are able to reason about similar properties as discussed in this paper, but as far as we are aware, there is no tool support for them, while our focus is to make verification of concurrent programs practical.…”

Section: Verification Of a Queue Historymentioning

confidence: 99%

VerCors: A Layered Approach to Practical Verification of Concurrent Software

Amighi

Blom

Huisman

2016

2016 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP)

View full text Add to dashboard Cite

This paper discusses how several concurrent program verification techniques can be combined in a layered approach, where each layer is especially suited to verify one aspect of concurrent programs, thus making verification of concurrent programs practical. At the bottom layer, we use a combination of implicit dynamic frames and CSL-style resource invariants, to reason about data race freedom of programs. We illustrate this on the verification of a lock-free queue implementation. On top of this, layer 2 enables reasoning about resource invariants that express a relationship between thread-local and shared variables. This is illustrated by the verification of a reentrant lock implementation, where thread-locality is used to specify for a thread which locks it holds, while there is a global notion of ownership, expressing for a lock by which thread it is held. Finally, the top layer adds a notion of histories to reason about functional properties. We illustrate how this is used to prove that the lock-free queue preserves the order of elements, without having to reverify the aspects related to data race freedom.

show abstract

Iris

Cited by 149 publications

References 48 publications

RustBelt: securing the foundations of the Rust programming language

RustBelt: securing the foundations of the Rust programming language

JaVerT: JavaScript verification toolchain

VerCors: A Layered Approach to Practical Verification of Concurrent Software

Contact Info

Product

Resources

About