research-article

Open access

Formulog: Datalog for SMT-based static analysis

Authors:

Aaron Bembenek,

Michael Greenberg,

Stephen ChongAuthors Info & Claims

Proceedings of the ACM on Programming Languages, Volume 4, Issue OOPSLA

Article No.: 141, Pages 1 - 31

https://doi.org/10.1145/3428209

Published: 13 November 2020 Publication History

Abstract

Satisfiability modulo theories (SMT) solving has become a critical part of many static analyses, including symbolic execution, refinement type checking, and model checking. We propose Formulog, a domain-specific language that makes it possible to write a range of SMT-based static analyses in a way that is both close to their formal specifications and amenable to high-level optimizations and efficient evaluation.

Formulog extends the logic programming language Datalog with a first-order functional language and mechanisms for representing and reasoning about SMT formulas; a novel type system supports the construction of expressive formulas, while ensuring that neither normal evaluation nor SMT solving goes wrong. Our case studies demonstrate that a range of SMT-based analyses can naturally and concisely be encoded in Formulog, and that — thanks to this encoding — high-level Datalog-style optimizations can be automatically and advantageously applied to these analyses.

Supplementary Material

Auxiliary Presentation Video (oopsla20main-p65-p-video.mp4)

Pre-recorded talk for "Formulog: Datalog for SMT-Based Static Analysis" by Aaron Bembenek, Michael Greenberg, and Stephen Chong, presented in the research track of OOPSLA 2020. Formulog is a domain-specific language that makes it possible to write SMT-based static analyses in a way that is close to their mathematical specifications and amenable to high-level optimizations.

Download
387.48 MB

References

[1]

Alex Aiken, Suhabe Bugrara, Isil Dillig, Thomas Dillig, Brian Hackett, and Peter Hawkins. 2007. An Overview of the Saturn Project. In Proceedings of the 7th ACM SIGPLAN-SIGSOFT Workshop on Program Analysis for Software Tools and Engineering. 43-48. https://doi.org/10.1145/1251535.1251543

Digital Library

[2]

Aws Albarghouthi, Paraschos Koutris, Mayur Naik, and Calvin Smith. 2017. Constraint-Based Synthesis of Datalog Programs. In Proceedings of the 23rd International Conference on Principles and Practice of Constraint Programming. 689-706. https://doi.org/10.1007/978-3-319-66158-2_44

[3]

Sergio Antoy and Michael Hanus. 2010. Functional Logic Programming. Commun. ACM 53, 4 ( 2010 ), 74-85. https: //doi.org/10.1145/1721654.1721675

Digital Library

[4]

Krzysztof R Apt, Howard A Blair, and Adrian Walker. 1988. Towards a Theory of Declarative Knowledge. In Foundations of Deductive Databases and Logic Programming. Elsevier, 89-148. https://doi.org/10.1016/B978-0-934613-40-8. 50006-3

[5]

Molham Aref, Balder ten Cate, Todd J Green, Benny Kimelfeld, Dan Olteanu, Emir Pasalic, Todd L Veldhuizen, and Geofrey Washburn. 2015. Design and Implementation of the LogicBlox System. In Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data. 1371-1382. https://doi.org/10.1145/2723372.2742796

Digital Library

[6]

Michael Arntzenius and Neel Krishnaswami. 2020. Seminäive Evaluation for a Higher-Order Functional Language. Proceedings of the ACM on Programming Languages 4, POPL ( 2020 ), 22 : 1-22 : 28. https://doi.org/10.1145/3371090

Digital Library

[7]

Michael Arntzenius and Neelakantan R. Krishnaswami. 2016. Datafun: A Functional Datalog. In Proceedings of the 21st ACM SIGPLAN International Conference on Functional Programming. 214-227. https://doi.org/10.1145/2951913.2951948

Digital Library

[8]

Pavel Avgustinov, Oege De Moor, Michael Peyton Jones, and Max Schäfer. 2016. QL: Object-Oriented Queries on Relational Data. In Proceedings of the 30th European Conference on Object-Oriented Programming. 2 : 1-2 : 25. https://doi.org/10.4230/ LIPIcs.ECOOP. 2016.2

[9]

Francois Bancilhon. 1986. Naive Evaluation of Recursively Defined Relations. In On Knowledge Base Management Systems. Springer, 165-178. https://doi.org/10.1007/978-1-4612-4980-1_17

[10]

Francois Bancilhon, David Maier, Yehoshua Sagiv, and Jefrey D Ullman. 1985. Magic Sets and Other Strange Ways to Implement Logic Programs. In Proceedings of the Fifth ACM SIGACT-SIGMOD Symposium on Principles of Database Systems. 1-15. https://doi.org/10.1145/6012.15399

Digital Library

[11]

Clark Barrett, Christopher L. Conway, Morgan Deters, Liana Hadarean, Dejan Jovanović, Tim King, Andrew Reynolds, and Cesare Tinelli. 2011. CVC4. In Proceedings of the 23rd International Conference on Computer Aided Verification. 171-177. https://doi.org/10.1007/978-3-642-22110-1_14

[12]

Clark Barrett, Pascal Fontaine, and Cesare Tinelli. 2016. The Satisfiability Modulo Theories Library (SMT-LIB). www.SMTLIB.org.

[13]

Catriel Beeri and Raghu Ramakrishnan. 1991. On the Power of Magic. The Journal of Logic Programming 10, 3-4 ( 1991 ), 255-299. https://doi.org/10.1016/ 0743-1066 ( 91 ) 90038-Q

Digital Library

[14]

Aaron Bembenek, Michael Greenberg, and Stephen Chong. 2020. Formulog: Datalog for SMT-Based Static Analysis (Extended Version). arXiv: 2009. 08361 [cs.PL]

[15]

Gavin M. Bierman, Andrew D. Gordon, Cătălin Hriţcu, and David Langworthy. 2012. Semantic Subtyping with an SMT Solver. Journal of Functional Programming 22, 1 ( 2012 ), 31-105. https://doi.org/10.1145/1863543.1863560

Digital Library

[16]

Nikolaj Bjørner, Arie Gurfinkel, Ken McMillan, and Andrey Rybalchenko. 2015. Horn Clause Solvers for Program Verification. In Fields of Logic and Computation II. Springer, 24-51. https://doi.org/10.1007/978-3-319-23534-9_2

[17]

Martin Bravenboer and Yannis Smaragdakis. 2009. Strictly Declarative Specification of Sophisticated Points-to Analyses. In Proceedings of the 24th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications. 243-262. https://doi.org/10.1145/1640089.1640108

Digital Library

[18]

Gerhard Brewka, Thomas Eiter, and Mirosław Truszczyński. 2011. Answer Set Programming at a Glance. Commun. ACM 54, 12 ( 2011 ), 92-103. https://doi.org/10.1145/2043174.2043195

Digital Library

[19]

Cristian Cadar, Daniel Dunbar, and Dawson Engler. 2008. KLEE: Unassisted and Automatic Generation of High-Coverage Tests for Complex Systems Programs. In Proceedings of the 8th USENIX Conference on Operating Systems Design and Implementation. 209-224.

[20]

Cristian Cadar and Koushik Sen. 2013. Symbolic Execution for Software Testing: Three Decades Later. Commun. ACM 56, 2 (Feb. 2013 ), 82-90. https://doi.org/10.1145/2408776.2408795

Digital Library

[21]

Mats Carlsson and Per Mildner. 2012. SICStus Prolog-The First 25 years. Theory and Practice of Logic Programming 12, 1-2 ( 2012 ), 35-66. https://doi.org/10.1017/S1471068411000482

Digital Library

[22]

Alessandro Cimatti and Alberto Griggio. 2012. Software Model Checking via IC3. In Proceedings of the 24th International Conference on Computer Aided Verification. 277-293. https://doi.org/10.1007/978-3-642-31424-7_23

Digital Library

[23]

Edmund Clarke, Daniel Kroening, and Flavio Lerda. 2004. A Tool for Checking ANSI-C Programs. In Proceedings of the 10th International Conference on Tools and Algorithms for the Construction and Analysis of Systems. 168-176. https: //doi.org/10.1007/978-3-540-24730-2_15

[24]

Michael Codish, Vitaly Lagoon, and Peter J Stuckey. 2008. Logic Programming with Satisfiability. Theory and Practice of Logic Programming 8, 1 ( 2008 ), 121-128. https://doi.org/10.1017/S1471068407003146

Digital Library

[25]

Patrick Cousot and Radhia Cousot. 1977. Abstract Interpretation: A Unified Lattice Model for Static Analysis of Programs by Construction or Approximation of Fixpoints. In Proceedings of the 4th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages. 238-252. https://doi.org/10.1145/512950.512973

Digital Library

[26]

William Craig. 1957. Three Uses of the Herbrand-Gentzen Theorem in Relating Model Theory and Proof Theory. The Journal of Symbolic Logic 22, 3 ( 1957 ), 269-285. https://doi.org/10.2307/2963594

[27]

Leonardo de Moura and Nikolaj Bjørner. 2008. Z3: An Eficient SMT Solver. In Proceedings of the 14th International Conference on Tools and Algorithms for the Construction and Analysis of Systems. 337-340. https://doi.org/10.1007/978-3-540-78800-3_24

[28]

Giorgio Delzanno and Andreas Podelski. 1999. Model Checking in CLP. In Proceedings of the 5th International Conference on Tools and Algorithms for the Construction and Analysis of Systems. 223-239. https://doi.org/10.1007/3-540-49059-0_16

[29]

David Detlefs, Greg Nelson, and James B. Saxe. 2005. Simplify: A Theorem Prover for Program Checking. J. ACM 52, 3 ( 2005 ), 365-473. https://doi.org/10.1145/1066100.1066102

Digital Library

[30]

Bruno Dutertre. 2014. Yices 2.2. In Proceedings of the 26th International Conference on Computer Aided Verification. 737-744. https://doi.org/10.1007/978-3-319-08867-9_49

Digital Library

[31]

Matthias Felleisen, Robert Bruce Findler, and Matthew Flatt. 2009. Semantics Engineering with PLT Redex (1st ed.). The MIT Press.

Digital Library

[32]

Yu Feng, Xinyu Wang, Isil Dillig, and Thomas Dillig. 2015. Bottom-up Context-Sensitive Pointer Analysis for Java. In Proceedings of the 13th Asian Symposium on Programming Languages and Systems. 465-484. https://doi.org/10.1007/978-3-319-26529-2_25

[33]

Cormac Flanagan. 2004. Automatic Software Model Checking via Constraint Logic. Science of Computer Programming 50, 1-3 ( 2004 ), 253-270. https://doi.org/10.1016/j.scico. 2004. 01.006

Digital Library

[34]

Antonio Flores-Montoya and Eric Schulte. 2020. Datalog Disassembly. In 29th USENIX Security Symposium. 1075-1092.

[35]

Laurent Fribourg and Julian Richardson. 1996. Symbolic Verification with Gap-Order Constraints. In Proceedings of the 6th International Workshop on Logic Programming Synthesis and Transformation. 20-37. https://doi.org/10.1007/3-540-62718-9_2

[36]

Hervé Gallaire and Jack Minker (Eds.). 1978. Logic and Data Bases. Plenum Press.

[37]

Michael Gelfond and Vladimir Lifschitz. 1988. The Stable Model Semantics for Logic Programming. In Proceedings of the 5th International Conference and Symposium on Logic Programming. 1070-1080.

[38]

Sergey Grebenshchikov, Nuno Lopes, Corneliu Popeea, and Andrey Rybalchenko. 2012. Synthesizing Software Verifiers from Proof Rules. In Proceedings of the 33rd ACM SIGPLAN Conference on Programming Language Design and Implementation. 405-416. https://doi.org/10.1145/2254064.2254112

Digital Library

[39]

Neville Grech, Lexi Brent, Bernhard Scholz, and Yannis Smaragdakis. 2019. Gigahorse: Thorough, Declarative Decompilation of Smart Contracts. In Proceedings of the 41st International Conference on Software Engineering. 1176-1186. https: //doi.org/10.1109/ICSE. 2019.00120

Digital Library

[40]

Neville Grech, Michael Kong, Anton Jurisevic, Lexi Brent, Bernhard Scholz, and Yannis Smaragdakis. 2018. Madmax: Surviving Out-of-Gas Conditions in Ethereum Smart Contracts. Proceedings of the ACM on Programming Languages 2, OOPSLA ( 2018 ), 116 : 1-116 : 27. https://doi.org/10.1145/3276486

Digital Library

[41]

Todd J. Green, Shan Shan Huang, Boon Thau Loo, and Wenchao Zhou. 2013. Datalog and Recursive Query Processing. Foundations and Trends in Databases 5, 2 ( 2013 ), 105-195. https://doi.org/10.1561/1900000017

Digital Library

[42]

Salvatore Guarnieri and V Benjamin Livshits. 2009. GATEKEEPER: Mostly Static Enforcement of Security and Reliability Policies for JavaScript Code. In Proceedings of the 18th USENIX Security Symposium. 78-85.

[43]

Ashish Gupta, Inderpal Singh Mumick, and Venkatramanan Siva Subrahmanian. 1993. Maintaining Views Incrementally. ACM SIGMOD Record 22, 2 ( 1993 ), 157-166. https://doi.org/10.1145/170035.170066

Digital Library

[44]

Arie Gurfinkel, Temesghen Kahsai, Anvesh Komuravelli, and Jorge A Navas. 2015. The SeaHorn Verification Framework. In Proceedings of the 27th International Conference on Computer Aided Verification. 343-361. https://doi.org/10.1007/978-3-319-21690-4_20

[45]

Brian Hackett. 2010. Type Safety in the Linux Kernel. Ph.D. Dissertation. Stanford University.

[46]

Thomas A. Henzinger, Ranjit Jhala, Rupak Majumdar, and Grégoire Sutre. 2002. Lazy Abstraction. In Proceedings of the 29th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. 58-70. https://doi.org/10.1145/503272.503279

Digital Library

[47]

Kryštof Hoder and Nikolaj Bjørner. 2012. Generalized Property Directed Reachability. In Proceedings of the 15th International Conference on Theory and Applications of Satisfiability Testing. Springer, 157-171. https://doi.org/10.1007/978-3-642-31612-8_13

Digital Library

[48]

Kryštof Hoder, Nikolaj Bjørner, and Leonardo De Moura. 2011. µ Z-An Eficient Engine for Fixed Points with Constraints. In Proceedings of the 23rd International Conference on Computer Aided Verification. 457-462. https://doi.org/10.1007/978-3-642-22110-1_36

[49]

Joxan Jafar and Jean-Louis Lassez. 1987. Constraint Logic Programming. In Proceedings of the 14th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages. 111-119. https://doi.org/10.1145/41625.41635

Digital Library

[50]

Joxan Jafar and Michael J. Maher. 1994. Constraint Logic Programming: A Survey. The Journal of Logic Programming 19 ( 1994 ), 503-581. https://doi.org/10.1016/ 0743-1066 ( 94 ) 90033-7

[51]

Herbert Jordan, Bernhard Scholz, and Pavle Subotić. 2016. Souflé: On Synthesis of Program Analyzers. In Proceedings of the 28th International Conference on Computer Aided Verification. 422-430. https://doi.org/10.1007/978-3-319-41540-6_23

[52]

Herbert Jordan, Pavle Subotic, David Zhao, and Bernhard Scholz. 2019. A Specialized B-tree for Concurrent Datalog Evaluation. In Proceedings of the 24th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming. 327-339. https://doi.org/10.1145/3293883.3295719

Digital Library

[53]

Lennart C.L. Kats and Eelco Visser. 2010. The Spoofax Language Workbench: Rules for Declarative Specification of Languages and IDEs. In Proceedings of the 25th ACM International Conference on Object-Oriented Programming, Systems, Languages, and Applications. 444-463. https://doi.org/10.1145/1869459.1869497

Digital Library

[54]

James C. King. 1976. Symbolic Execution and Program Testing. Commun. ACM 19, 7 ( 1976 ), 385-394. https://doi.org/10. 1145/360248.360252

Digital Library

[55]

Ali Sinan Köksal, Viktor Kuncak, and Philippe Suter. 2011. Scala to the Power of Z3: Integrating SMT and Programming. In Proceedings of the 23rd International Conference on Automated Deduction. 400-406. https://doi.org/10.1007/978-3-642-22438-6_30

[56]

Robert Kowalski. 1979. Algorithm = Logic + Control. Commun. ACM 22, 7 ( 1979 ), 424-436. https://doi.org/10.1145/359131. 359136

Digital Library

[57]

Chris Lattner and Vikram Adve. 2004. LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation. In Proceedings of the 2nd IEEE/ACM International Symposium on Code Generation and Optimization. 75-88. https: //doi.org/10.1109/CGO. 2004.1281665

[58]

Chin Soon Lee, Neil D. Jones, and Amir M. Ben-Amram. 2001. The Size-Change Principle for Program Termination. In Proceedings of the 28th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. 81-92. https: //doi.org/10.1145/360204.360210

Digital Library

[59]

V. Benjamin Livshits and Monica S. Lam. 2005. Finding Security Vulnerabilities in Java Applications with Static Analysis. In Proceedings of the 14th USENIX Security Symposium. 271-286.

[60]

Magnus Madsen, Ming-Ho Yee, and Ondřej Lhoták. 2016. From Datalog to Flix: a Declarative Language for Fixed Points on Lattices. In Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation. 194-208. https://doi.org/10.1145/2908080.2908096

Digital Library

[61]

Kenneth L McMillan. 2006. Lazy Abstraction with Interpolants. In Proceedings of the 18th International Conference on Computer Aided Verification. Springer, 123-136. https://doi.org/10.1007/11817963_14

Digital Library

[62]

Dale Miller and Gopalan Nadathur. 1987. A Logic Programming Approach to Manipulating Formulas and Programs. In Proceedings of the 1987 Symposium on Logic Programming. 379-388.

[63]

Mayur Naik. 2011. Chord: A Program Analysis Platform for Java. https://www.seas.upenn.edu/~mhnaik/chord/user_guide/ index.html. Accessed: 2020-04-01.

[64]

Frank Pfenning and Conal Elliott. 1988. Higher-Order Abstract Syntax. In Proceedings of the ACM SIGPLAN 1988 Conference on Programming Language Design and Implementation. 199-208. https://doi.org/10.1145/53990.54010

Digital Library

[65]

Andreas Podelski and Andrey Rybalchenko. 2007. ARMC: The Logical Choice for Software Model Checking with Abstraction Refinement. In Proceedings of the 9th International Symposium on Practical Aspects of Declarative Languages. 245-259. https://doi.org/10.1007/978-3-540-69611-7_16

Digital Library

[66]

Teodor C Przymusinski. 1988. On the Declarative Semantics of Deductive Databases and Logic Programs. In Foundations of Deductive Databases and Logic Programming. Elsevier, 193-216. https://doi.org/10.1016/b978-0-934613-40-8. 50009-9

[67]

Mukund Raghothaman, Jonathan Mendelson, David Zhao, Mayur Naik, and Bernhard Scholz. 2019. Provenance-Guided Synthesis of Datalog Programs. Proceedings of the ACM on Programming Languages 4, POPL ( 2019 ), 1-27. https: //doi.org/10.1145/3371130

Digital Library

[68]

Thomas W. Reps. 1995. Demand Interprocedural Program Analysis Using Logic Databases. In Proceedings of the 3rd ACM SIGSOFT Symposium on Foundations of Software Engineering. 163-196.

[69]

Patrick M. Rondon, Ming Kawaguci, and Ranjit Jhala. 2008. Liquid Types. In Proceedings of the 29th ACM SIGPLAN Conference on Programming Language Design and Implementation. 159-169. https://doi.org/10.1145/1375581.1375602

Digital Library

[70]

Bernhard Scholz, Herbert Jordan, Pavle Subotić, and Till Westmann. 2016. On Fast Large-Scale Program Analysis in Datalog. In Proceedings of the 25th International Conference on Compiler Construction. 196-206. https://doi.org/10.1145/2892208. 2892226

Digital Library

[71]

Yannis Smaragdakis and Martin Bravenboer. 2011. Using Datalog for Fast and Easy Program Analysis. In Datalog Reloaded. Springer, 245-251. https://doi.org/10.1007/978-3-642-24206-9_14

Digital Library

[72]

Tamás Szabó, Gábor Bergmann, Sebastian Erdweg, and Markus Voelter. 2018. Incrementalizing Lattice-Based Program Analyses in Datalog. Proceedings of the ACM on Programming Languages 2, OOPSLA ( 2018 ), 139 : 1-139 : 29. https: //doi.org/10.1145/3276509

Digital Library

[73]

Emina Torlak and Rastislav Bodik. 2013. Growing Solver-Aided Languages with Rosette. In Proceedings of the 2013 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming & Software. 135-152. https://doi.org/10.1145/2509578.2509586

Digital Library

[74]

Petar Tsankov, Andrei Dan, Dana Drachsler-Cohen, Arthur Gervais, Florian Buenzli, and Martin Vechev. 2018. Securify: Practical Security Analysis of Smart Contracts. In Proceedings of the 2018 ACM SIGSAC Conference on Computer and Communications Security. 67-82. https://doi.org/10.1145/3243734.3243780

Digital Library

[75]

Richard Uhler and Nirav Dave. 2013. Smten: Automatic Translation of High-Level Symbolic Computations into SMT Queries. In Proceedings of the 25th International Conference on Computer Aided Verification. 678-683. https://doi.org/10.1007/978-3-642-39799-8_45

[76]

Hendrik van Antwerpen, Casper Bach Poulsen, Arjen Rouvoet, and Eelco Visser. 2018. Scopes as Types. Proceedings of the ACM on Programming Languages 2, OOPSLA ( 2018 ), 114 : 1-114 : 30. https://doi.org/10.1145/3276484

Digital Library

[77]

Allen Van Gelder. 1989. Negation as Failure Using Tight Derivations for General Logic Programs. The Journal of Logic Programming 6, 1-2 ( 1989 ), 109-133. https://doi.org/10.1016/ 0743-1066 ( 89 ) 90032-0

Digital Library

[78]

Mark Weiser. 1984. Program Slicing. IEEE Transactions on Software Engineering 4 ( 1984 ), 352-357. https://doi.org/10.1109/ TSE. 1984.5010248

Digital Library

[79]

John Whaley, Dzintars Avots, Michael Carbin, and Monica S. Lam. 2005. Using Datalog with Binary Decision Diagrams for Program Analysis. In Proceedings of the Third Asian Symposium on Programming Languages and Systems. 97-118. https://doi.org/10.1007/11575467_8

Digital Library

[80]

John Whaley and Monica S. Lam. 2004. Cloning-Based Context-Sensitive Pointer Alias Analysis Using Binary Decision Diagrams. In Proceedings of the ACM SIGPLAN 2004 Conference on Programming Language Design and Implementation. 131-144. https://doi.org/10.1145/996841.996859

Digital Library

Cited By

Klopp DErdweg SPacak A(2024)A Typed Multi-level Datalog IR and Its Compiler FrameworkProceedings of the ACM on Programming Languages10.1145/36897678:OOPSLA2(1586-1614)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689767
Bembenek AGreenberg MChong S(2024)Making Formulog Fast: An Argument for Unconventional Datalog EvaluationProceedings of the ACM on Programming Languages10.1145/36897548:OOPSLA2(1219-1248)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689754
Klopp DErdweg SPacak A(2024)Object-Oriented Fixpoint Programming with DatalogProceedings of the ACM on Programming Languages10.1145/36897138:OOPSLA2(60-86)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689713
Show More Cited By

Index Terms

Formulog: Datalog for SMT-based static analysis
1. Software and its engineering
  1. Software notations and tools
    1. Context specific languages
      1. Domain specific languages
    2. General programming languages
      1. Language types
        Constraint and logic languages
  2. Software organization and properties
    1. Software functional properties
      1. Formal methods
        Automated static analysis

Recommendations

From Datalog to flix: a declarative language for fixed points on lattices
PLDI '16

We present Flix, a declarative programming language for specifying and solving least fixed point problems, particularly static program analyses. Flix is inspired by Datalog and extends it with lattices and monotone functions. Using Flix, implementors ...
Static analysis in datalog extensions

We consider the problems of containment, equivalence, satisfiability and query-reachability for datalog programs with negation. These problems are important for optimizing datalog programs. We show that both query-reachability and satisfiability are ...
Truncating abstraction of bit-vector operations for BDD-based SMT solvers
Abstract
During the last few years, BDD-based SMT solvers proved to be competitive in deciding satisfiability of quantified bit-vector formulas. However, these solvers usually do not perform well on input formulas with complicated arithmetic. Hitherto, ...

Comments

Information & Contributors

Information

Published In

cover image Proceedings of the ACM on Programming Languages

Proceedings of the ACM on Programming Languages Volume 4, Issue OOPSLA

November 2020

3108 pages

EISSN:2475-1421

DOI:10.1145/3436718

Issue’s Table of Contents

Copyright © 2020 Owner/Author.

This work is licensed under a Creative Commons Attribution International 4.0 License.

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 13 November 2020

Published in PACMPL Volume 4, Issue OOPSLA

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Badges

Author Tags

Qualifiers

Research-article

Funding Sources

Defense Advanced Research Projects Agency

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

16
Total Citations
View Citations
1,190
Total Downloads

Downloads (Last 12 months)306
Downloads (Last 6 weeks)43

Reflects downloads up to 09 Nov 2024

Other Metrics

View Author Metrics

Citations

Cited By

Klopp DErdweg SPacak A(2024)A Typed Multi-level Datalog IR and Its Compiler FrameworkProceedings of the ACM on Programming Languages10.1145/36897678:OOPSLA2(1586-1614)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689767
Bembenek AGreenberg MChong S(2024)Making Formulog Fast: An Argument for Unconventional Datalog EvaluationProceedings of the ACM on Programming Languages10.1145/36897548:OOPSLA2(1219-1248)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689754
Klopp DErdweg SPacak A(2024)Object-Oriented Fixpoint Programming with DatalogProceedings of the ACM on Programming Languages10.1145/36897138:OOPSLA2(60-86)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689713
Klopp DPacak AErdweg SChiba SThüm T(2024)Separate Compilation and Partial Linking: Modules for Datalog IRProceedings of the 23rd ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences10.1145/3689484.3690737(94-106)Online publication date: 21-Oct-2024
https://dl.acm.org/doi/10.1145/3689484.3690737
Sahebolamri ABarrett LMoore SMicinski K(2023)Bring Your Own Data Structures to DatalogProceedings of the ACM on Programming Languages10.1145/36228407:OOPSLA2(1198-1223)Online publication date: 16-Oct-2023
https://dl.acm.org/doi/10.1145/3622840
Pacak AErdweg S(2023)Interactive Debugging of Datalog ProgramsProceedings of the ACM on Programming Languages10.1145/36228247:OOPSLA2(745-772)Online publication date: 16-Oct-2023
https://dl.acm.org/doi/10.1145/3622824
Liu YMechtaev SSubotić PRoychoudhury AChandra SBlincoe KTonella P(2023)Program Repair Guided by Datalog-Defined Static AnalysisProceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering10.1145/3611643.3616363(1216-1228)Online publication date: 30-Nov-2023
https://dl.acm.org/doi/10.1145/3611643.3616363
Augustsson LBreitner JClaessen KJhala RPeyton Jones SShivers OSteele Jr. GSweeney T(2023)The Verse Calculus: A Core Calculus for Deterministic Functional Logic ProgrammingProceedings of the ACM on Programming Languages10.1145/36078457:ICFP(417-447)Online publication date: 31-Aug-2023
https://dl.acm.org/doi/10.1145/3607845
Zhang YWang YFlatt OCao DZucker PRosenthal ETatlock ZWillsey M(2023)Better Together: Unifying Datalog and Equality SaturationProceedings of the ACM on Programming Languages10.1145/35912397:PLDI(468-492)Online publication date: 6-Jun-2023
https://dl.acm.org/doi/10.1145/3591239
Bembenek AGreenberg MChong S(2023)From SMT to ASP: Solver-Based Approaches to Solving Datalog Synthesis-as-Rule-Selection ProblemsProceedings of the ACM on Programming Languages10.1145/35712007:POPL(185-217)Online publication date: 11-Jan-2023
https://dl.acm.org/doi/10.1145/3571200
Show More Cited By

View Options

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Get Access

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Article

Media

Figures

Other

Tables

View Issue’s Table of Contents