Add Soufflé backend

Author: ecstatic-morse

Cargo.toml

@@ -3,21 +3,25 @@ name        = "polonius"
 version     = "0.7.0"
 authors     = ["The Rust Project Developers", "Polonius Developers"]
 description = "Core definition for the Rust borrow checker"
-license     = "Apache-2.0/MIT"
-repository  = "https://github.com/rust-lang/polonius"
-readme      = "README.md"
-keywords    = ["compiler", "borrowck", "datalog"]
-edition     = "2018"
+license = "Apache-2.0/MIT"
+repository = "https://github.com/rust-lang-nursery/polonius"
+readme = "README.md"
+keywords = ["compiler", "borrowck", "datalog"]
+edition = "2018"
 
 [dev-dependencies]
 diff            = "0.1.0"
 polonius-parser = { path = "./polonius-parser" }
 
 [dependencies]
-rustc-hash      = "1.0.0"
-polonius-engine = { path = "./polonius-engine" }
-log             = "0.4"
-petgraph        = "0.4.13"
-pico-args       = "0.2"
+rustc-hash = "1.0.0"
+polonius-engine = { path = "polonius-engine" }
+polonius-souffle = { path = "polonius-souffle" }
+log = "0.4"
+petgraph = "0.4.13"
+pico-args = "0.2"
+
+[build-dependencies]
+glob = "0.3.0"
 
 [workspace]

build.rs

@@ -0,0 +1,12 @@
+use glob::glob;
+
+fn main() {
+    // See `polonius-souffle/build.rs` for background.
+    //
+    // FIXME: We should expose these symbols in a single location instead of globbing.
+    for ruleset in glob("rules/*.dl").unwrap() {
+        let stem = ruleset.unwrap();
+        let stem = stem.file_stem().unwrap().to_str().unwrap();
+        println!("cargo:rustc-link-arg=-u__factory_Sf_{}_instance", stem);
+    }
+}

polonius-engine/src/output/mod.rs

@@ -55,6 +55,24 @@ impl Algorithm {
             "Hybrid",
         ]
     }
+
+    pub fn engine(&self) -> Engine {
+        match *self {
+            Self::Naive(eng) | Self::DatafrogOpt(eng) => eng,
+            Self::LocationInsensitive | Self::Compare | Self::Hybrid => Engine::Datafrog,
+        }
+    }
+
+    pub fn souffle_name(&self) -> Option<&'static str> {
+        let ret = match self {
+            Self::Naive(Engine::Souffle) => "naive",
+            Self::DatafrogOpt(Engine::Souffle) => "opt",
+
+            _ => return None,
+        };
+
+        Some(ret)
+    }
 }
 
 impl ::std::str::FromStr for Algorithm {

polonius-souffle/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "polonius-souffle"
+version = "0.1.0"
+edition = "2018"
+authors = ["The Rust Project Developers", "Polonius Developers"]
+description = "Core definition for the Rust borrow checker"
+license = "Apache-2.0/MIT"
+repository = "https://github.com/rust-lang-nursery/polonius"
+readme = "README.md"
+keywords = ["compiler", "borrowck", "datalog"]
+build = "build.rs"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cxx = "1.0.50"
+log = "0.4"
+polonius-engine = { path = "../polonius-engine" }
+
+[build-dependencies]
+cc = "1.0.69"
+cxx-build = "1.0.50"
+glob = "0.3.0"
+is_executable = "1.0.1"
+which = "4.2.1"

polonius-souffle/build.rs

@@ -0,0 +1,109 @@
+use std::collections::HashSet;
+use std::error::Error;
+use std::fs;
+use std::io::{BufWriter, Write};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use glob::glob;
+use which::which;
+
+const RULES_DIR: &str = "../rules";
+const CXX_BRIDGE: &str = "src/ffi.rs";
+
+type Result<T> = ::std::result::Result<T, Box<dyn Error>>;
+
+/// Gets the filename for each "top-level" rulest
+fn get_rulesets() -> Vec<PathBuf> {
+    let result: std::result::Result<Vec<_>, _> =
+        glob(&format!("{}/*.dl", RULES_DIR)).unwrap().collect();
+    result.unwrap()
+}
+fn print_rerun_if_changed() {
+    // Rerun if any C++ file changes
+    for file in glob("shims/*").unwrap() {
+        println!("cargo:rerun-if-changed={}", file.unwrap().to_string_lossy());
+    }
+
+    // Rerun if any datalog file changes.
+    for file in glob(&format!("{}/**/*.dl", RULES_DIR)).unwrap() {
+        println!("cargo:rerun-if-changed={}", file.unwrap().to_string_lossy());
+    }
+
+    // Rerun if our CXX bindings change.
+    println!("cargo:rerun-if-changed={}", CXX_BRIDGE);
+}
+
+fn main() -> Result<()> {
+    print_rerun_if_changed();
+
+    if which("souffle").is_err() {
+        eprintln!("`souffle` not in PATH. Is it installed?");
+        return Err("missing `souffle`".into());
+    }
+
+    let mut cpp_filenames = vec![];
+    let mut known_stems = HashSet::new();
+    for ruleset in get_rulesets() {
+        // Get the common name for this ruleset.
+        let stem = ruleset.file_stem().unwrap().to_str().unwrap();
+
+        // Check that name for duplicates
+        //
+        // Souffle uses a single, global registry for datalog programs, indexed by string.
+        if !known_stems.insert(stem.to_owned()) {
+            eprintln!("Multiple datalog files named `{}`", stem);
+            return Err("Duplicate filenames".into());
+        }
+
+        let cpp_filename = souffle_generate(&ruleset)?;
+        cpp_filenames.push(cpp_filename);
+    }
+
+    for stem in known_stems {
+        // HACK: Souffle adds datalog programs to the registry in the initializer of a global
+        // variable (whose name begins with `__factory_Sf`). Since that global variable is never used
+        // by the Rust program, it is occasionally removed by the linker, its initializer is never
+        // run (!!!), and the program is never registered.
+        //
+        // `-u` marks the symbol as undefined, so that it will not be optimized out.
+        let prog_symbol = format!("__factory_Sf_{}_instance", stem);
+        println!("cargo:rustc-link-arg=-u{}", prog_symbol);
+    }
+
+    let mut cc = cxx_build::bridge(CXX_BRIDGE);
+
+    for file in cpp_filenames {
+        cc.file(&file);
+    }
+
+    cc.cpp(true)
+        .define("__EMBEDDED_SOUFFLE__", None)
+        .include("./shims")
+        .flag("-std=c++17")
+        .flag("-Wno-unused-parameter")
+        .flag("-Wno-parentheses")
+        .try_compile("souffle")?;
+
+    Ok(())
+}
+
+/// Uses Souffle to generate a C++ file for evaluating the given datalog program.
+fn souffle_generate(datalog_filename: &Path) -> Result<PathBuf> {
+    let mut cpp_filename = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+    cpp_filename.push(datalog_filename.with_extension("cpp").file_name().unwrap());
+
+    eprintln!("Generating code for {:?}...", &datalog_filename);
+
+    let result = Command::new("souffle")
+        .arg("--generate")
+        .arg(&cpp_filename)
+        .arg(&datalog_filename)
+        .status()?;
+
+    if !result.success() {
+        return Err("Invalid datalog".into());
+    }
+
+    Ok(cpp_filename)
+}

polonius-souffle/shims/shims.hpp

@@ -0,0 +1,104 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include <souffle/SouffleInterface.h>
+
+#include "polonius-souffle/src/ffi.rs.h"
+#include "rust/cxx.h"
+
+#ifndef __EMBEDDED_SOUFFLE__
+#error "Build script must define __EMBEDDED_SOUFFLE__"
+#endif
+
+/*
+ * Wrappers around generated souffle functions. From Rust, we cannot safely
+ * call functions that accept or return things with move constructors by-value
+ * (e.g.  `std::string`). The usual fix is to move them into a `unique_ptr`
+ * first, or to pass a borrowed version (e.g. `cxx::Str`) from the Rust side
+ * and copy it here.
+ */
+
+namespace souffle {
+
+std::unique_ptr<SouffleProgram>
+ProgramFactory_newInstance(const std::string &name) {
+  std::unique_ptr<SouffleProgram> prog(ProgramFactory::newInstance(name));
+  return prog;
+}
+
+void load_all(SouffleProgram &foo, const std::string &name) {
+  foo.loadAll(name);
+}
+
+void print_all(SouffleProgram &foo, const std::string &name) {
+  foo.printAll(name);
+}
+
+void get_output_relations(const SouffleProgram &prog, rust::Vec<RelationPtr> &out) {
+    auto relations = prog.getOutputRelations();
+    for (auto rel : relations) {
+        RelationPtr ptr{};
+        ptr.ptr = rel;
+        out.push_back(ptr);
+    }
+}
+
+void get_all_relations(const SouffleProgram &prog, rust::Vec<RelationPtr> &out) {
+    auto relations = prog.getAllRelations();
+    for (auto rel : relations) {
+        RelationPtr ptr{};
+        ptr.ptr = rel;
+        out.push_back(ptr);
+    }
+}
+
+std::unique_ptr<std::string> get_name(const Relation& rel) {
+    return std::make_unique<std::string>(rel.getName());
+}
+
+// Fact loading
+
+// This function is copied from the member function on `Program`.
+//
+// We cannot use the original because it requires a reference to both a
+// `Program` and a `Relation`, which have the same lifetime on the Rust side.
+template <typename... Args>
+void insert(const std::tuple<Args...> &t, Relation *rel) {
+    souffle::tuple t1(rel);
+    SouffleProgram::tuple_insert<decltype(t), sizeof...(Args)>::add(t, t1);
+    rel->insert(t1);
+}
+
+void insert_tuple1(Relation &rel, Tuple1 r) {
+  insert(std::make_tuple(r.a), &rel);
+}
+
+void insert_tuple2(Relation &rel, Tuple2 r) {
+  insert(std::make_tuple(r.a, r.b), &rel);
+}
+
+void insert_tuple3(Relation &rel, Tuple3 r) {
+  insert(std::make_tuple(r.a, r.b, r.c), &rel);
+}
+
+void insert_tuple4(Relation &rel, Tuple4 r) {
+  insert(std::make_tuple(r.a, r.b, r.c, r.d), &rel);
+}
+
+DynTuples dump_tuples(const Relation &rel) {
+    DynTuples out{};
+    out.arity = rel.getArity();
+
+    for (auto tuple : rel) {
+        for (unsigned i = 0; i < out.arity; ++i) {
+            out.data.push_back(tuple[i]);
+        }
+    }
+
+    return out;
+}
+
+} // namespace bridge

polonius-souffle/src/facts.rs

@@ -0,0 +1,77 @@
+use std::convert::TryInto;
+use std::pin::Pin;
+
+use log::warn;
+use polonius_engine::{AllFacts, FactTypes};
+
+use crate::ffi::{self, InsertIntoRelation};
+
+fn insert_facts<T>(mut rel: Pin<&mut ffi::Relation>, name: &str, facts: &[T])
+where
+    T: Copy + InsertIntoRelation,
+{
+    debug_assert_eq!(std::mem::size_of::<T>() % std::mem::size_of::<u32>(), 0);
+    let datafrog_arity = std::mem::size_of::<T>() / std::mem::size_of::<u32>();
+
+    let souffle_arity: usize = rel.getArity().try_into().unwrap();
+
+    if souffle_arity != datafrog_arity {
+        panic!(
+            r#"Arity mismatch for "{}". souffle={}, datafrog={}"#,
+            name, souffle_arity, datafrog_arity
+        );
+    }
+
+    for &fact in facts {
+        fact.insert_into_relation(rel.as_mut());
+    }
+}
+
+macro_rules! load_facts {
+    ($prog:ident, $facts:ident; $( $f:ident ),* $(,)?) => {
+        // Exhaustive matching, since new facts must be reflected below as well.
+        let AllFacts {
+            $( ref $f ),*
+        } = $facts;
+        $(
+            let name = stringify!($f);
+            let rel = $prog.as_mut().relation_mut(name);
+            if let Some(rel) = rel {
+                insert_facts(rel, name, $f);
+            } else {
+                warn!("Relation named `{}` not found. Skipping...", name);
+            }
+        )*
+    }
+}
+
+pub fn insert_all_facts<T>(mut prog: Pin<&mut ffi::Program>, facts: &AllFacts<T>)
+where
+    T: FactTypes,
+    T::Origin: Into<u32>,
+    T::Loan: Into<u32>,
+    T::Point: Into<u32>,
+    T::Variable: Into<u32>,
+    T::Path: Into<u32>,
+{
+    load_facts!(prog, facts;
+        loan_issued_at,
+        universal_region,
+        cfg_edge,
+        loan_killed_at,
+        subset_base,
+        loan_invalidated_at,
+        var_used_at,
+        var_defined_at,
+        var_dropped_at,
+        use_of_var_derefs_origin,
+        drop_of_var_derefs_origin,
+        child_path,
+        path_is_var,
+        path_assigned_at_base,
+        path_moved_at_base,
+        path_accessed_at_base,
+        known_placeholder_subset,
+        placeholder,
+    );
+}