Use LatticeDomain<int64_t> instead of int64_t in IDE-LCA

fabianbs96 · fabianbs96 · commit e670cc2e1f25 · 2022-01-05T13:16:40.000+01:00
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDELinearConstantAnalysis.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDELinearConstantAnalysis.h
@@ -19,6 +19,7 @@
 #include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/EdgeFunctionComposer.h"
 #include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/IDETabulationProblem.h"
 #include "phasar/PhasarLLVM/Domain/AnalysisDomain.h"
+#include "phasar/PhasarLLVM/Utils/LatticeDomain.h"
 
 namespace llvm {
 class Instruction;
@@ -31,7 +32,7 @@ namespace psr {
 
 struct IDELinearConstantAnalysisDomain : public LLVMAnalysisDomainDefault {
   // int64_t corresponds to llvm's type of constant integer
-  using l_t = int64_t;
+  using l_t = LatticeDomain<int64_t>;
 };
 
 class LLVMBasedICFG;
@@ -176,10 +177,10 @@ class IDELinearConstantAnalysis
                       public std::enable_shared_from_this<GenConstant> {
   private:
     const unsigned GenConstantId;
-    const l_t IntConst;
+    const int64_t IntConst;
 
   public:
-    explicit GenConstant(l_t IntConst);
+    explicit GenConstant(int64_t IntConst);
 
     l_t computeTarget(l_t Source) override;
 
@@ -253,7 +254,7 @@ class IDELinearConstantAnalysis
    * @param rop right operand
    * @return Result of binary operation
    */
-  static l_t executeBinOperation(unsigned Op, l_t Lop, l_t Rop);
+  static l_t executeBinOperation(unsigned Op, l_t LVal, l_t RVal);
 
   static char opToChar(unsigned Op);
 
diff --git a/include/phasar/PhasarLLVM/Utils/LatticeDomain.h b/include/phasar/PhasarLLVM/Utils/LatticeDomain.h
@@ -13,6 +13,7 @@
 #include "llvm/Support/ErrorHandling.h"
 
 #include <iostream>
+#include <type_traits>
 #include <variant>
 
 namespace psr {
@@ -22,8 +23,7 @@ namespace psr {
 /// the lattice.
 struct Top {};
 
-static inline std::ostream &operator<<(std::ostream &OS,
-                                       [[maybe_unused]] const Top &T) {
+static inline std::ostream &operator<<(std::ostream &OS, Top /*unused*/) {
   return OS << "Top";
 }
 
@@ -32,8 +32,7 @@ static inline std::ostream &operator<<(std::ostream &OS,
 /// of the lattice.
 struct Bottom {};
 
-static inline std::ostream &operator<<(std::ostream &OS,
-                                       [[maybe_unused]] const Bottom &B) {
+static inline std::ostream &operator<<(std::ostream &OS, Bottom /*unused*/) {
   return OS << "Bottom";
 }
 
@@ -42,33 +41,43 @@ template <typename L> using LatticeDomain = std::variant<L, Top, Bottom>;
 
 template <typename L>
 inline std::ostream &operator<<(std::ostream &OS, const LatticeDomain<L> &LD) {
-  if (auto T = std::get_if<Top>(&LD)) {
-    return OS << *T;
-  }
-  if (auto B = std::get_if<Bottom>(&LD)) {
-    return OS << *B;
-  }
-  return OS << std::get<L>(LD);
+  std::visit([&OS](const auto &LVal) { OS << LVal; }, LD);
+  return OS;
 }
 
 template <typename L>
 inline bool operator==(const LatticeDomain<L> &Lhs,
                        const LatticeDomain<L> &Rhs) {
-  if (std::holds_alternative<Top>(Lhs) && std::holds_alternative<Top>(Rhs)) {
-    return true;
-  }
-  if (std::holds_alternative<Bottom>(Lhs) &&
-      std::holds_alternative<Bottom>(Rhs)) {
-    return true;
+  if (Lhs.index() != Rhs.index()) {
+    return false;
   }
+
   if (auto LhsPtr = std::get_if<L>(&Lhs)) {
     if (auto RhsPtr = std::get_if<L>(&Rhs)) {
       return *LhsPtr == *RhsPtr;
     }
   }
+
+  return true;
+}
+
+template <
+    typename L, typename LL,
+    typename = std::void_t<decltype(std::declval<LL>() == std::declval<L>())>>
+inline bool operator==(const LL &Lhs, const LatticeDomain<L> Rhs) {
+  if (const auto *RVal = std::get_if<L>(&Rhs)) {
+    return Lhs == *RVal;
+  }
   return false;
 }
 
+template <
+    typename L, typename LL,
+    typename = std::void_t<decltype(std::declval<LL>() == std::declval<L>())>>
+inline bool operator==(const LatticeDomain<L> Lhs, const LL &Rhs) {
+  return Rhs == Lhs;
+}
+
 template <typename L>
 inline bool operator!=(const LatticeDomain<L> &Lhs,
                        const LatticeDomain<L> &Rhs) {
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDELinearConstantAnalysis.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
@@ -45,11 +45,10 @@ unsigned IDELinearConstantAnalysis::CurrGenConstantId = 0; // NOLINT
 unsigned IDELinearConstantAnalysis::CurrLCAIDId = 0;       // NOLINT
 unsigned IDELinearConstantAnalysis::CurrBinaryId = 0;      // NOLINT
 
-const IDELinearConstantAnalysis::l_t IDELinearConstantAnalysis::TOP =
-    std::numeric_limits<IDELinearConstantAnalysis::l_t>::min();
+const IDELinearConstantAnalysis::l_t IDELinearConstantAnalysis::TOP = Top{};
 
 const IDELinearConstantAnalysis::l_t IDELinearConstantAnalysis::BOTTOM =
-    std::numeric_limits<IDELinearConstantAnalysis::l_t>::max();
+    Bottom{};
 
 IDELinearConstantAnalysis::IDELinearConstantAnalysis(
     const ProjectIRDB *IRDB, const LLVMTypeHierarchy *TH,
@@ -470,8 +469,7 @@ IDELinearConstantAnalysis::LCAEdgeFunctionComposer::joinWith(
   return std::make_shared<AllBottom<l_t>>(BOTTOM);
 }
 
-IDELinearConstantAnalysis::GenConstant::GenConstant(
-    IDELinearConstantAnalysis::l_t IntConst)
+IDELinearConstantAnalysis::GenConstant::GenConstant(int64_t IntConst)
     : GenConstantId(++CurrGenConstantId), IntConst(IntConst) {}
 
 IDELinearConstantAnalysis::l_t
@@ -502,7 +500,7 @@ IDELinearConstantAnalysis::GenConstant::composeWith(
     return std::make_shared<AllBottom<l_t>>(BOTTOM);
   }
 
-  return std::make_shared<GenConstant>(Res);
+  return std::make_shared<GenConstant>(std::get<int64_t>(Res));
 }
 
 std::shared_ptr<EdgeFunction<IDELinearConstantAnalysis::l_t>>
@@ -583,11 +581,6 @@ IDELinearConstantAnalysis::BinOp::computeTarget(l_t Source) {
                 << "Curr Node : " << llvmIRToString(CurrNode));
   LOG_IF_ENABLE(BOOST_LOG_SEV(lg::get(), DEBUG) << ' ');
 
-  llvm::errs() << "BinOp::computeTarget(" << Source << ") with Op: " << Op
-               << ", Lop: " << llvmIRToShortString(Lop)
-               << ", Rop: " << llvmIRToShortString(Rop)
-               << ", at CurrNode: " << llvmIRToString(CurrNode) << '\n';
-
   if (LLVMZeroValue::isLLVMZeroValue(CurrNode) &&
       llvm::isa<llvm::ConstantInt>(Lop) && llvm::isa<llvm::ConstantInt>(Rop)) {
     const auto *Lic = llvm::cast<llvm::ConstantInt>(Lop);
@@ -667,30 +660,28 @@ void IDELinearConstantAnalysis::BinOp::print(std::ostream &OS,
 }
 
 char IDELinearConstantAnalysis::opToChar(const unsigned Op) {
-  char OpAsChar;
   switch (Op) {
   case llvm::Instruction::Add:
-    OpAsChar = '+';
-    break;
+    return '+';
   case llvm::Instruction::Sub:
-    OpAsChar = '-';
-    break;
+    return '-';
   case llvm::Instruction::Mul:
-    OpAsChar = '*';
-    break;
+    return '*';
   case llvm::Instruction::UDiv:
   case llvm::Instruction::SDiv:
-    OpAsChar = '/';
-    break;
+    return '/';
   case llvm::Instruction::URem:
   case llvm::Instruction::SRem:
-    OpAsChar = '%';
-    break;
+    return '%';
+  case llvm::Instruction::And:
+    return '&';
+  case llvm::Instruction::Or:
+    return '|';
+  case llvm::Instruction::Xor:
+    return '^';
   default:
-    OpAsChar = ' ';
-    break;
+    return ' ';
   }
-  return OpAsChar;
 }
 
 bool IDELinearConstantAnalysis::isEntryPoint(
@@ -699,66 +690,72 @@ bool IDELinearConstantAnalysis::isEntryPoint(
 }
 
 IDELinearConstantAnalysis::l_t
-IDELinearConstantAnalysis::executeBinOperation(const unsigned Op, l_t Lop,
-                                               l_t Rop) {
+IDELinearConstantAnalysis::executeBinOperation(const unsigned Op, l_t LVal,
+                                               l_t RVal) {
+
+  auto *LopPtr = std::get_if<int64_t>(&LVal);
+  auto *RopPtr = std::get_if<int64_t>(&RVal);
 
-  if (Lop == BOTTOM || Rop == BOTTOM) {
+  if (!LopPtr || !RopPtr) {
     return BOTTOM;
   }
 
+  auto Lop = *LopPtr;
+  auto Rop = *RopPtr;
+
   // default initialize with BOTTOM (all information)
-  l_t Res = BOTTOM;
+  int64_t Res;
   switch (Op) {
   case llvm::Instruction::Add:
     if (llvm::AddOverflow(Lop, Rop, Res)) {
-      Res = BOTTOM;
+      return BOTTOM;
     }
-    break;
+    return Res;
 
   case llvm::Instruction::Sub:
     if (llvm::SubOverflow(Lop, Rop, Res)) {
-      Res = BOTTOM;
+      return BOTTOM;
     }
-    break;
+    return Res;
 
   case llvm::Instruction::Mul:
     if (llvm::MulOverflow(Lop, Rop, Res)) {
-      Res = BOTTOM;
+      return BOTTOM;
     }
-    break;
+    return Res;
 
   case llvm::Instruction::UDiv:
   case llvm::Instruction::SDiv:
-    /// MIN is TOP, so already handled
-
-    // if (Lop == std::numeric_limits<IDELinearConstantAnalysis::l_t>::min() &&
-    //     Rop == -1) { // Would produce and overflow, as the complement of min
-    //     is
-    //                  // not representable in a signed type.
-    //   return BOTTOM;
-    // }
-    if (Rop == 0) { // Division by zero is UB, so we return TOP
+    if (Lop == std::numeric_limits<int64_t>::min() &&
+        Rop == -1) { // Would produce and overflow, as the complement of min is
+                     // not representable in a signed type.
+      return TOP;
+    }
+    if (Rop == 0) { // Division by zero is UB, so we return Bot
       return BOTTOM;
     }
-    Res = Lop / Rop;
-    break;
+    return Lop / Rop;
 
   case llvm::Instruction::URem:
   case llvm::Instruction::SRem:
-    if (Rop == 0) { // Division by zero is UB, so we return TOP
+    if (Rop == 0) { // Division by zero is UB, so we return Bot
       return BOTTOM;
     }
-    Res = Lop % Rop;
-    break;
-
+    return Lop % Rop;
+
+  case llvm::Instruction::And:
+    return Lop & Rop;
+  case llvm::Instruction::Or:
+    return Lop | Rop;
+  case llvm::Instruction::Xor:
+    return Lop ^ Rop;
   default:
     LOG_IF_ENABLE(BOOST_LOG_SEV(lg::get(), DEBUG)
                   << "Operation not supported by "
                      "IDELinearConstantAnalysis::"
                      "executeBinOperation()");
-    break;
+    return BOTTOM;
   }
-  return Res;
 }
 
 void IDELinearConstantAnalysis::printNode(std::ostream &OS, n_t Stmt) const {
@@ -776,13 +773,7 @@ void IDELinearConstantAnalysis::printFunction(std::ostream &OS,
 }
 
 void IDELinearConstantAnalysis::printEdgeFact(std::ostream &OS, l_t L) const {
-  if (L == BOTTOM) {
-    OS << "Bottom";
-  } else if (L == TOP) {
-    OS << "Top";
-  } else {
-    OS << L;
-  }
+  OS << L;
 }
 
 void IDELinearConstantAnalysis::emitTextReport(
diff --git a/unittests/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDELinearConstantAnalysisTest.cpp b/unittests/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDELinearConstantAnalysisTest.cpp
@@ -23,8 +23,8 @@ class IDELinearConstantAnalysisTest : public ::testing::Test {
       unittest::PathToLLTestFiles + "linear_constant/";
 
   // Function - Line Nr - Variable - Value
-  using LCACompactResult_t =
-      std::tuple<std::string, std::size_t, std::string, int64_t>;
+  using LCACompactResult_t = std::tuple<std::string, std::size_t, std::string,
+                                        IDELinearConstantAnalysisDomain::l_t>;
   std::unique_ptr<ProjectIRDB> IRDB;
 
   void SetUp() override { boost::log::core::get()->set_logging_enabled(false); }
diff --git a/unittests/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDELinearConstantAnalysis_DotTest.cpp b/unittests/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDELinearConstantAnalysis_DotTest.cpp
@@ -24,8 +24,8 @@ class IDELinearConstantAnalysisTest : public ::testing::Test {
   const std::set<std::string> EntryPoints = {"main"};
 
   // Function - Line Nr - Variable - Value
-  using LCACompactResult_t =
-      std::tuple<std::string, std::size_t, std::string, int64_t>;
+  using LCACompactResult_t = std::tuple<std::string, std::size_t, std::string,
+                                        IDELinearConstantAnalysisDomain::l_t>;
   std::unique_ptr<ProjectIRDB> IRDB;
 
   void SetUp() override { boost::log::core::get()->set_logging_enabled(false); }
