Merge branch 'f-Taint' into development

Author: pdschubert

.gitmodules

@@ -9,3 +9,6 @@
 [submodule "external/WALi-OpenNWA"]
 	path = external/WALi-OpenNWA
 	url = https://github.com/pdschubert/WALi-OpenNWA.git
+[submodule "external/json-schema-validator"]
+	path = external/json-schema-validator
+	url = https://github.com/pboettch/json-schema-validator.git

config/TaintConfigSchema.json

@@ -0,0 +1,70 @@
+R"(
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Taint Configuration",
+    "description": "A Taint Configuration",
+    "type": "object",
+    "properties": {
+        "name": {
+            "type": "string",
+            "description": "Name of this taint configuration"
+        },
+        "version": {
+            "type": "number",
+            "description": "Version of this taint configuration"
+        },
+        "functions": {
+            "type": "array",
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "ret": {
+                    "enum": ["source", "sink", "sanitizer"]
+                },
+                "params": {
+                    "properties": {
+                        "source": {
+                            "type": "array",
+                            "properties": {
+                                "type": ["number", "string"]
+                            }
+                        },
+                        "sink": {
+                            "type": "array",
+                            "properties": {
+                                "type": ["number", "string"]
+                            }
+                        },
+                        "sanitizer": {
+                            "type": "array",
+                            "properties": {
+                                "type": ["number", "string"]
+                            }
+                        }
+                    }
+                }
+            },
+            "required": ["name", "params"]
+        },
+        "variables": {
+            "type": "array",
+            "properties": {
+                "scope": {
+                    "type": "string"
+                },
+                "name": {
+                    "type": "string"
+                },
+                "line": {
+                    "type": "number"
+                },
+                "cat": {
+                    "enum": ["source", "sink", "sanitizer"]
+                }
+            },
+            "required": ["scope", "name", "cat"]
+        }
+    }
+}
+)"_json

external/json

@@ -44,7 +44,8 @@ class WholeProgramAnalysis {
   std::unique_ptr<PointerAnalysisTy> PointerInfo;
   std::unique_ptr<CallGraphAnalysisTy> CallGraph;
   std::set<std::string> EntryPoints;
-  std::unique_ptr<ConfigurationTy> Config;
+  ConfigurationTy *Config = nullptr;
+  bool OwnsConfig = false;
   std::string ConfigPath;
   ProblemDescription ProblemDesc;
   Solver DataFlowSolver;
@@ -91,10 +92,9 @@ class WholeProgramAnalysis {
                             IRDB, CallGraphAnalysisType::OTF, EntryPoints,
                             this->TypeHierarchy.get(), this->PointerInfo.get())
                       : std::unique_ptr<CallGraphAnalysisTy>(CallGraph)),
-        EntryPoints(EntryPoints),
-        Config(std::unique_ptr<ConfigurationTy>(Config)), ConfigPath(""),
-        ProblemDesc(&IRDB, TypeHierarchy, CallGraph, PointerInfo, *Config,
-                    EntryPoints),
+        EntryPoints(EntryPoints), Config(Config), OwnsConfig(false),
+        ConfigPath(""), ProblemDesc(&IRDB, TypeHierarchy, CallGraph,
+                                    PointerInfo, *Config, EntryPoints),
         DataFlowSolver(ProblemDesc) {}
 
   template <typename T = ProblemDescription,
@@ -117,12 +117,23 @@ class WholeProgramAnalysis {
                             IRDB, CallGraphAnalysisType::OTF, EntryPoints,
                             this->TypeHierarchy.get(), this->PointerInfo.get())
                       : std::unique_ptr<CallGraphAnalysisTy>(CallGraph)),
-        EntryPoints(EntryPoints),
-        Config(std::make_unique<ConfigurationTy>(ConfigPath)),
-        ConfigPath(ConfigPath), ProblemDesc(&IRDB, TypeHierarchy, CallGraph,
-                                            PointerInfo, *Config, EntryPoints),
+        EntryPoints(EntryPoints), Config(new ConfigurationTy(ConfigPath)),
+        OwnsConfig(true), ConfigPath(ConfigPath),
+        ProblemDesc(&IRDB, TypeHierarchy, CallGraph, PointerInfo, *Config,
+                    EntryPoints),
         DataFlowSolver(ProblemDesc) {}
 
+  WholeProgramAnalysis(const WholeProgramAnalysis &) = delete;
+
+  WholeProgramAnalysis(WholeProgramAnalysis &&) = delete;
+
+  ~WholeProgramAnalysis() {
+    if (OwnsConfig) {
+      delete Config;
+      Config = nullptr;
+    }
+  }
+
   void solve() { DataFlowSolver.solve(); }
 
   void operator()() { solve(); }
@@ -158,8 +169,6 @@ class WholeProgramAnalysis {
   CallGraphAnalysisTy *releaseCallGraph() { return CallGraph.release(); }
 
   TypeHierarchyTy *releaseTypeHierarchy() { return TypeHierarchy.release(); }
-
-  ConfigurationTy *releaseConfiguration() { return Config.release(); }
 };
 
 } // namespace psr

external/json-schema-validator

@@ -268,6 +268,10 @@ class LLVMBasedICFG
   [[nodiscard]] std::set<const llvm::Function *>
   getCalleesOfCallAt(const llvm::Instruction *N) const override;
 
+  void forEachCalleeOfCallAt(
+      const llvm::Instruction *I,
+      llvm::function_ref<void(const llvm::Function *)> Callback) const;
+
   /**
    * \return all caller statements/nodes of a given method.
    */

include/phasar/PhasarLLVM/AnalysisStrategy/WholeProgramAnalysis.h

@@ -26,8 +26,8 @@ template <typename N, typename D, typename L> class InitialSeeds {
 
   InitialSeeds() = default;
 
-  template <typename LL = L, typename = typename std::enable_if_t<
-                                 std::is_same_v<LL, BinaryDomain>>>
+  template <typename LL = L,
+            typename = std::enable_if_t<std::is_same_v<LL, BinaryDomain>>>
   InitialSeeds(const std::map<N, std::set<D>> &Seeds) {
     for (const auto &[Node, Facts] : Seeds) {
       for (const auto &Fact : Facts) {
@@ -38,13 +38,15 @@ template <typename N, typename D, typename L> class InitialSeeds {
 
   InitialSeeds(GeneralizedSeeds Seeds) : Seeds(std::move(Seeds)) {}
 
-  template <typename LL = L, typename = typename std::enable_if_t<
-                                 std::is_same_v<LL, BinaryDomain>>>
+  template <typename LL = L,
+            typename = std::enable_if_t<std::is_same_v<LL, BinaryDomain>>>
   void addSeed(N Node, D Fact) {
     addSeed(Node, Fact, BinaryDomain::TOP);
   }
 
-  void addSeed(N Node, D Fact, L Value) { Seeds[Node][Fact] = Value; }
+  void addSeed(N Node, D Fact, L Value) {
+    Seeds[Node][Fact] = std::move(Value);
+  }
 
   [[nodiscard]] size_t countInitialSeeds() const {
     size_t NumSeeds = 0;
@@ -55,12 +57,21 @@ template <typename N, typename D, typename L> class InitialSeeds {
   }
 
   [[nodiscard]] size_t countInitialSeeds(N Node) const {
+    auto Search = Seeds.find(Node);
+    if (Search != Seeds.end()) {
+      return Search->second.size();
+    }
+    return 0;
+  }
+
+  [[nodiscard]] bool containsInitialSeedsFor(N Node) const {
     return Seeds.count(Node);
   }
 
   [[nodiscard]] bool empty() const { return Seeds.empty(); }
 
-  [[nodiscard]] GeneralizedSeeds getSeeds() { return Seeds; }
+  [[nodiscard]] const GeneralizedSeeds &getSeeds() const & { return Seeds; }
+  [[nodiscard]] GeneralizedSeeds getSeeds() && { return std::move(Seeds); }
 
   void dump(std::ostream &OS = std::cerr) {