{"title":"Partial Solutions to VerifyThis 2016 Challenges 2 and 3 with VeriFast","authors":"B. Jacobs","doi":"10.1145/2955811.2955818","DOIUrl":"https://doi.org/10.1145/2955811.2955818","url":null,"abstract":"We describe our partial solutions, using our VeriFast separation-logic based tool for modular formal verification of C and Java programs, to Challenges 2 and 3 of the VerifyThis 2016 Verification Competition, involving the verification of crash-freedom and certain correctness properties of code fragments implementing constant-space tree traversal and a tree barrier.","PeriodicalId":376722,"journal":{"name":"Proceedings of the 18th Workshop on Formal Techniques for Java-like Programs","volume":"270 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"129356020","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"An Extended Buffered Memory Model With Full Reorderings","authors":"G. Cabon, D. Cachera, David Pichardie","doi":"10.1145/2955811.2955816","DOIUrl":"https://doi.org/10.1145/2955811.2955816","url":null,"abstract":"Modern multicore processor architectures and compilers of shared-memory concurrent programming languages provide only weak memory consistency guarantees. A memory model specifies which write action can be seen by a read action between concurrent threads. The most well known memory model is the sequentially consistent (SC) model but, to improve performance, modern architectures and languages employ relaxed memory models where a read may not see the most recent write that has been performed by other threads. These models come in different formalization styles (axiomatic, operational) and have their own advantages and disadvantages. In a POPL'13 paper, Demange et al [12], proposed an alternative style that is fully characterized in terms of the reorderings it allows. This Buffered Memory Model (BMM) targets the Java programming language. It is strictly less relaxed than the Java Memory Model. It is shown equivalent to an operational model but is restricted to TSO relaxations. This paper extends the BMM in order to allow more reorderings. We present the new set of memory event reorderings rules that fully characterize the model and an alternative operational model that is again shown equivalent.","PeriodicalId":376722,"journal":{"name":"Proceedings of the 18th Workshop on Formal Techniques for Java-like Programs","volume":"47 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130521811","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Towards Modular Reasoning for Context-Oriented Programs","authors":"Tomoyuki Aotani, Gary T. Leavens","doi":"10.1145/2955811.2955819","DOIUrl":"https://doi.org/10.1145/2955811.2955819","url":null,"abstract":"Context-oriented programming (COP) is an approach to modularity for applications whose behavior may vary depending on the status of the environment in which they execute and the software's own state. Languages supporting COP provide partial methods to modularly define behavioral variations of methods specific to a context, layers to group the partial methods and layer activation mechanisms to dynamically compose layers. Because the behavior of these partial methods often differs from that of the base methods they override, reasoning about context-oriented programs seems to require a case analysis based on partial methods and context information from the entire program, which is not scalable. In this paper we explain a new language feature, layer interfaces, which allows modular specification and verification of context-oriented programs. We demonstrate these techniques by using examples.","PeriodicalId":376722,"journal":{"name":"Proceedings of the 18th Workshop on Formal Techniques for Java-like Programs","volume":"11 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128457928","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Towards a model of corecursion with default","authors":"D. Ancona, Francesco Dagnino, E. Zucca","doi":"10.1145/2955811.2955820","DOIUrl":"https://doi.org/10.1145/2955811.2955820","url":null,"abstract":"We face the problem of providing a denotational semantics for corecursive methods with default, a programming feature for manipulating cyclic structures without ad-hoc machinery. To this aim, we study new lattices for which the theorem of Kleene is applicable so that the semantics of a corecursive method with default corresponds to the greatest fixed point computed as the greatest lower bound of a descending chain. The proposed definition allows us to prove correctness of some kinds of corecursive methods. This solution is only partly satisfactory, and a different and more general approach is currently under development.","PeriodicalId":376722,"journal":{"name":"Proceedings of the 18th Workshop on Formal Techniques for Java-like Programs","volume":"7 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126414965","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Coupling catch clauses with local declarations","authors":"P. Giannini, M. Servetto, E. Zucca","doi":"10.1145/2955811.2955817","DOIUrl":"https://doi.org/10.1145/2955811.2955817","url":null,"abstract":"We propose an alternative to the usual try-catch construct, where catch clauses are coupled with the declaration of a local variable, rather than with an arbitrary expression. That is, in case initialization of the local variable fails, they provide an alternative computation which does not depend on such variable. This alternative mechanism subsumes the standard one and allows a more natural and functional programming style. We illustrate such advantages by some paradigmatic examples. The proposal is formalized as an extension of Featherweight Java (FJ) with a type system which can be proved to be sound.","PeriodicalId":376722,"journal":{"name":"Proceedings of the 18th Workshop on Formal Techniques for Java-like Programs","volume":"28 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115326295","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"A formal account of SSA in Java-like languages","authors":"D. Ancona, A. Corradi","doi":"10.1145/2955811.2955813","DOIUrl":"https://doi.org/10.1145/2955811.2955813","url":null,"abstract":"Static Single Assignment (SSA) intermediate representation is widely used to optimize and compile code in imperative and object-oriented languages, but it can also be useful for static type analysis. We introduce FJSSA, a Java-like imperative calculus supporting programs in SSA form; we define its big-step operational semantics, and a judgment to statically check whether a program is in SSA form, and prove its soundness. FJSSA provides a formal basis for type analysis of programs in SSA form in object-oriented languages.","PeriodicalId":376722,"journal":{"name":"Proceedings of the 18th Workshop on Formal Techniques for Java-like Programs","volume":"23 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127882223","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"A Note on the Soundness of Difference Propagation","authors":"Jens Dietrich, N. Hollingum, Bernhard Scholz","doi":"10.1145/2955811.2955814","DOIUrl":"https://doi.org/10.1145/2955811.2955814","url":null,"abstract":"Difference propagation is an algorithm widely used in points-to and alias analysis. To the best of our knowledge, the soundness of the version of the algorithm used for the static analysis of Java programs has not yet been proven. An attempt to do this yields a surprise: when the algorithm is used to compute field sensitive points-to for Java programs, soundness cannot be guaranteed when self-loads (statements of the kind x=x.f) are present. We discuss such a scenario and suggest a modification of the algorithm that is sufficient to prove soundness.","PeriodicalId":376722,"journal":{"name":"Proceedings of the 18th Workshop on Formal Techniques for Java-like Programs","volume":"66 ","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"120875990","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"A Mechanical Soundness Proof for Subtyping Over Recursive Types","authors":"T. Jones, David J. Pearce","doi":"10.1145/2955811.2955812","DOIUrl":"https://doi.org/10.1145/2955811.2955812","url":null,"abstract":"Structural type systems provide an interesting alternative to the more common nominal typing scheme. Several existing languages employ structural types in some form, including Modula-3, Scala and various extensions proposed for Java. However, formalising a recursive structural type system is challenging. In particular, the need to use structural coinduction remains a hindrance for many. We formalise in Agda a simple recursive and structural type system with products and unions. Agda proves useful here because it has explicit support for coinduction and will raise an error if this is misused. The implementation distinguishes between inductively and coinductively defined types: the former corresponds to a finite representation, such as found in source code or the internals of a compiler, while the latter corresponds to a mathematical ideal with which we can coinductively define relations and proofs that are easily applied back to the inductive interpretation. As an application of this, we provide a mechanised proof of subtyping soundness against a semantic embedding of the types into Agda.","PeriodicalId":376722,"journal":{"name":"Proceedings of the 18th Workshop on Formal Techniques for Java-like Programs","volume":"62 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"132019983","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
S. Drossopoulou, J. Noble, Mark S. Miller, Toby C. Murray
{"title":"Permission and Authority Revisited towards a formalisation","authors":"S. Drossopoulou, J. Noble, Mark S. Miller, Toby C. Murray","doi":"10.1145/2955811.2955821","DOIUrl":"https://doi.org/10.1145/2955811.2955821","url":null,"abstract":"Miller's notions of permissions and authority are foundational to the analysis of object-capability programming. Informal definitions of these concepts were given in Miller's thesis. In this paper we propose precise definitions for permissions and authority, based on a small object-oriented calculus. We quantify their bounds (current, eventual, behavioural, topological), and delineate the relationships between these definitions.","PeriodicalId":376722,"journal":{"name":"Proceedings of the 18th Workshop on Formal Techniques for Java-like Programs","volume":"56 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-07-17","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127619495","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Generating Concurrency Checks Automatically","authors":"J. Hoyland, M. Hague","doi":"10.1145/2955811.2955815","DOIUrl":"https://doi.org/10.1145/2955811.2955815","url":null,"abstract":"This article introduces ATAB, a tool that automatically generates pairwise reachability checks for action trees. Action trees can be used to study the behaviour of real-world concurrent programs. ATAB encodes pairwise reachability checks into alternating tree automata (ATA) that determine whether an action tree has a schedule where any pair of given points in the program are simultaneously reachable. Because the pairwise reachability problem is undecidable in general ATAB operates under a restricted form of lock-based concurrency. ATAB produces ATA that are more compact and more efficiently checkable than those that have been previously used. The process is entirely automated, which simplifies the process of encoding checks for more complex action trees. The ATA produced are easier to scale to large numbers of locks than previous constructions.","PeriodicalId":376722,"journal":{"name":"Proceedings of the 18th Workshop on Formal Techniques for Java-like Programs","volume":"118 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2016-04-22","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121092248","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}