Refactored lib/ and unittests/ : building correctly

Author: bsharma021

include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IFDSLinearConstantAnalysis.h

@@ -87,7 +87,7 @@ class IFDSLinearConstantAnalysis
 
   std::shared_ptr<FlowFunction<d_t>> getCallToRetFlowFunction(
       n_t callSite, n_t retSite,
-      std::set<IFDSLinearConstantAnalysis::m_t> callees) override;
+      std::set<IFDSLinearConstantAnalysis::f_t> callees) override;
 
   std::shared_ptr<FlowFunction<d_t>>
   getSummaryFlowFunction(n_t callStmt, f_t destFun) override;

include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Solver/IDESolver.h

@@ -56,7 +56,7 @@
 namespace psr {
 
 // Forward declare the Transformation
-template <typename N, typename D, typename F, typename T, typename V,
+template <typename N, typename D, typename M, typename T, typename V,
           typename I>
 class IFDSToIDETabulationProblem;
 
@@ -68,26 +68,26 @@ class IFDSToIDETabulationProblem;
  * @param <N> The type of nodes in the interprocedural control-flow graph.
  * @param <D> The type of data-flow facts to be computed by the tabulation
  * problem.
- * @param <F> The type of objects used to represent functions.
+ * @param <M> The type of objects used to represent methods.
  * @param <T> The type of user-defined types that the type hierarchy consists of
  * @param <V> The type of values on which points-to information are computed
  * @param <L> The type of values to be computed along flow edges.
  * @param <I> The type of inter-procedural control-flow graph being used.
  */
-template <typename N, typename D, typename F, typename T, typename V,
+template <typename N, typename D, typename M, typename T, typename V,
           typename L, typename I>
 class IDESolver {
 public:
-  using ProblemTy = IDETabulationProblem<N, D, F, T, V, L, I>;
+  using ProblemTy = IDETabulationProblem<N, D, M, T, V, L, I>;
 
-  IDESolver(IDETabulationProblem<N, D, F, T, V, L, I> &tabulationProblem)
+  IDESolver(IDETabulationProblem<N, D, M, T, V, L, I> &tabulationProblem)
       : ideTabulationProblem(tabulationProblem),
         zeroValue(tabulationProblem.getZeroValue()),
         ICF(tabulationProblem.getICFG()),
         SolverConfig(tabulationProblem.getIFDSIDESolverConfig()),
         cachedFlowEdgeFunctions(tabulationProblem),
         allTop(tabulationProblem.allTopFunction()),
-        jumpFn(std::make_shared<JumpFunctions<N, D, F, T, V, L, I>>(
+        jumpFn(std::make_shared<JumpFunctions<N, D, M, T, V, L, I>>(
             allTop, ideTabulationProblem)),
         initialSeeds(tabulationProblem.initialSeeds()) {}
 
@@ -243,8 +243,8 @@ class IDESolver {
       //           });
       N prev = N{};
       N curr = N{};
-      F prevFn = F{};
-      F currFn = F{};
+      M prevFn = M{};
+      M currFn = M{};
       for (unsigned i = 0; i < cells.size(); ++i) {
         curr = cells[i].r;
         currFn = ICF->getFunctionOf(curr);
@@ -315,23 +315,23 @@ class IDESolver {
 
 protected:
   // have a shared point to allow for a copy constructor of IDESolver
-  std::unique_ptr<IFDSToIDETabulationProblem<N, D, F, T, V, I>>
+  std::unique_ptr<IFDSToIDETabulationProblem<N, D, M, T, V, I>>
       transformedProblem;
-  IDETabulationProblem<N, D, F, T, V, L, I> &ideTabulationProblem;
+  IDETabulationProblem<N, D, M, T, V, L, I> &ideTabulationProblem;
   D zeroValue;
   const I *ICF;
   const IFDSIDESolverConfig SolverConfig;
   unsigned PathEdgeCount = 0;
 
-  FlowEdgeFunctionCache<N, D, F, T, V, L, I> cachedFlowEdgeFunctions;
+  FlowEdgeFunctionCache<N, D, M, T, V, L, I> cachedFlowEdgeFunctions;
 
   Table<N, N, std::map<D, std::set<D>>> computedIntraPathEdges;
 
   Table<N, N, std::map<D, std::set<D>>> computedInterPathEdges;
 
   std::shared_ptr<EdgeFunction<L>> allTop;
 
-  std::shared_ptr<JumpFunctions<N, D, F, T, V, L, I>> jumpFn;
+  std::shared_ptr<JumpFunctions<N, D, M, T, V, L, I>> jumpFn;
 
   std::map<std::tuple<N, D, N, D>,
            std::vector<std::shared_ptr<EdgeFunction<L>>>>
@@ -361,17 +361,17 @@ class IDESolver {
   // a modifiable l-value reference within the IDESolver implementation leads
   // to (massive) undefined behavior (and nightmares):
   // https://stackoverflow.com/questions/34240794/understanding-the-warning-binding-r-value-to-l-value-reference
-  IDESolver(IFDSTabulationProblem<N, D, F, T, V, I> &tabulationProblem)
+  IDESolver(IFDSTabulationProblem<N, D, M, T, V, I> &tabulationProblem)
       : transformedProblem(
-            std::make_unique<IFDSToIDETabulationProblem<N, D, F, T, V, I>>(
+            std::make_unique<IFDSToIDETabulationProblem<N, D, M, T, V, I>>(
                 tabulationProblem)),
         ideTabulationProblem(*transformedProblem),
         zeroValue(ideTabulationProblem.getZeroValue()),
         ICF(ideTabulationProblem.getICFG()),
         SolverConfig(ideTabulationProblem.getIFDSIDESolverConfig()),
         cachedFlowEdgeFunctions(ideTabulationProblem),
         allTop(ideTabulationProblem.allTopFunction()),
-        jumpFn(std::make_shared<JumpFunctions<N, D, F, T, V, L, I>>(
+        jumpFn(std::make_shared<JumpFunctions<N, D, M, T, V, L, I>>(
             allTop, ideTabulationProblem)),
         initialSeeds(ideTabulationProblem.initialSeeds()) {}
 
@@ -405,7 +405,7 @@ class IDESolver {
     D d2 = edge.factAtTarget();
     std::shared_ptr<EdgeFunction<L>> f = jumpFunction(edge);
     std::set<N> returnSiteNs = ICF->getReturnSitesOfCallAt(n);
-    std::set<F> callees = ICF->getCalleesOfCallAt(n);
+    std::set<M> callees = ICF->getCalleesOfCallAt(n);
     LOG_IF_ENABLE(BOOST_LOG_SEV(lg, DEBUG) << "Possible callees:");
     for (auto callee : callees) {
       LOG_IF_ENABLE(BOOST_LOG_SEV(lg, DEBUG)
@@ -620,38 +620,38 @@ class IDESolver {
     D d2 = edge.factAtTarget();
     std::shared_ptr<EdgeFunction<L>> f = jumpFunction(edge);
     auto successorInst = ICF->getSuccsOf(n);
-    for (auto f : successorInst) {
+    for (auto m : successorInst) {
       std::shared_ptr<FlowFunction<D>> flowFunction =
-          cachedFlowEdgeFunctions.getNormalFlowFunction(n, f);
+          cachedFlowEdgeFunctions.getNormalFlowFunction(n, m);
       INC_COUNTER("FF Queries", 1, PAMM_SEVERITY_LEVEL::Full);
       std::set<D> res = computeNormalFlowFunction(flowFunction, d1, d2);
       ADD_TO_HISTOGRAM("Data-flow facts", res.size(), 1,
                        PAMM_SEVERITY_LEVEL::Full);
-      saveEdges(n, f, d2, res, false);
+      saveEdges(n, m, d2, res, false);
       for (D d3 : res) {
         std::shared_ptr<EdgeFunction<L>> g =
-            cachedFlowEdgeFunctions.getNormalEdgeFunction(n, d2, f, d3);
+            cachedFlowEdgeFunctions.getNormalEdgeFunction(n, d2, m, d3);
         LOG_IF_ENABLE(BOOST_LOG_SEV(lg, DEBUG)
                       << "Queried Normal Edge Function: " << g->str());
         std::shared_ptr<EdgeFunction<L>> fprime = f->composeWith(g);
         if (SolverConfig.emitESG) {
-          intermediateEdgeFunctions[std::make_tuple(n, d2, f, d3)].push_back(
+          intermediateEdgeFunctions[std::make_tuple(n, d2, m, d3)].push_back(
               fprime);
         }
         LOG_IF_ENABLE(BOOST_LOG_SEV(lg, DEBUG)
                       << "Compose: " << g->str() << " * " << f->str() << " = "
                       << fprime->str());
         LOG_IF_ENABLE(BOOST_LOG_SEV(lg, DEBUG) << ' ');
         INC_COUNTER("EF Queries", 1, PAMM_SEVERITY_LEVEL::Full);
-        propagate(d1, f, d3, fprime, nullptr, false);
+        propagate(d1, m, d3, fprime, nullptr, false);
       }
     }
   }
 
   void propagateValueAtStart(std::pair<N, D> nAndD, N n) {
     PAMM_GET_INSTANCE;
     D d = nAndD.second;
-    F p = ICF->getFunctionOf(n);
+    M p = ICF->getFunctionOf(n);
     for (N c : ICF->getCallsFromWithin(p)) {
       for (auto entry : jumpFn->forwardLookup(d, c)) {
         D dPrime = entry.first;
@@ -668,7 +668,7 @@ class IDESolver {
     PAMM_GET_INSTANCE;
     auto &lg = lg::get();
     D d = nAndD.second;
-    for (F q : ICF->getCalleesOfCallAt(n)) {
+    for (M q : ICF->getCalleesOfCallAt(n)) {
       std::shared_ptr<FlowFunction<D>> callFlowFunction =
           cachedFlowEdgeFunctions.getCallFlowFunction(n, q);
       INC_COUNTER("FF Queries", 1, PAMM_SEVERITY_LEVEL::Full);
@@ -935,11 +935,11 @@ class IDESolver {
                   << ideTabulationProblem.NtoString(edge.getTarget()));
     N n = edge.getTarget(); // an exit node; line 21...
     std::shared_ptr<EdgeFunction<L>> f = jumpFunction(edge);
-    F functionThatNeedsSummary = ICF->getFunctionOf(n);
+    M methodThatNeedsSummary = ICF->getFunctionOf(n);
     D d1 = edge.factAtSource();
     D d2 = edge.factAtTarget();
     // for each of the method's start points, determine incoming calls
-    std::set<N> startPointsOf = ICF->getStartPointsOf(functionThatNeedsSummary);
+    std::set<N> startPointsOf = ICF->getStartPointsOf(methodThatNeedsSummary);
     std::map<N, std::set<D>> inc;
     for (N sP : startPointsOf) {
       // line 21.1 of Naeem/Lhotak/Rodriguez
@@ -961,7 +961,7 @@ class IDESolver {
         // compute return-flow function
         std::shared_ptr<FlowFunction<D>> retFunction =
             cachedFlowEdgeFunctions.getRetFlowFunction(
-                c, functionThatNeedsSummary, n, retSiteC);
+                c, methodThatNeedsSummary, n, retSiteC);
         INC_COUNTER("FF Queries", 1, PAMM_SEVERITY_LEVEL::Full);
         // for each incoming-call value
         for (D d4 : entry.second) {
@@ -1033,12 +1033,12 @@ class IDESolver {
     // condition
     if (SolverConfig.followReturnsPastSeeds && inc.empty() &&
         ideTabulationProblem.isZeroValue(d1)) {
-      std::set<N> callers = ICF->getCallersOf(functionThatNeedsSummary);
+      std::set<N> callers = ICF->getCallersOf(methodThatNeedsSummary);
       for (N c : callers) {
         for (N retSiteC : ICF->getReturnSitesOfCallAt(c)) {
           std::shared_ptr<FlowFunction<D>> retFunction =
               cachedFlowEdgeFunctions.getRetFlowFunction(
-                  c, functionThatNeedsSummary, n, retSiteC);
+                  c, methodThatNeedsSummary, n, retSiteC);
           INC_COUNTER("FF Queries", 1, PAMM_SEVERITY_LEVEL::Full);
           std::set<D> targets = computeReturnFlowFunction(
               retFunction, d1, d2, c, std::set<D>{zeroValue});
@@ -1072,7 +1072,7 @@ class IDESolver {
       if (callers.empty()) {
         std::shared_ptr<FlowFunction<D>> retFunction =
             cachedFlowEdgeFunctions.getRetFlowFunction(
-                nullptr, functionThatNeedsSummary, n, nullptr);
+                nullptr, methodThatNeedsSummary, n, nullptr);
         INC_COUNTER("FF Queries", 1, PAMM_SEVERITY_LEVEL::Full);
         retFunction->computeTargets(d2);
       }
@@ -1361,7 +1361,7 @@ class IDESolver {
     }
 
     std::cout << "\n**********************************************************";
-    std::cout << "\n*          Computed inter-procedural path edges          *";
+    std::cout << "\n*          Computed inter-procedural path egdes          *";
     std::cout
         << "\n**********************************************************\n";
 
@@ -1716,7 +1716,7 @@ class IDESolver {
     LOG_IF_ENABLE(BOOST_LOG_SEV(lg, DEBUG)
                   << "=============================================");
     LOG_IF_ENABLE(BOOST_LOG_SEV(lg, DEBUG)
-                  << "Process inter-procedural path edges");
+                  << "Process inter-procedural path egdes");
     LOG_IF_ENABLE(BOOST_LOG_SEV(lg, DEBUG)
                   << "=============================================");
     cells = computedInterPathEdges.cellVec();

lib/Controller/AnalysisController.cpp

@@ -100,31 +100,31 @@ void AnalysisController::executeWholeProgram() {
       WholeProgramAnalysis<
           IFDSSolver<
               IFDSUninitializedVariables::n_t, IFDSUninitializedVariables::d_t,
-              IFDSUninitializedVariables::m_t, IFDSUninitializedVariables::t_t,
+              IFDSUninitializedVariables::f_t, IFDSUninitializedVariables::t_t,
               IFDSUninitializedVariables::v_t, IFDSUninitializedVariables::i_t>,
           IFDSUninitializedVariables>
           WPA(IRDB, EntryPoints, &PT, &ICF, &TH);
     } break;
     case DataFlowAnalysisType::IFDSConstAnalysis: {
       WholeProgramAnalysis<
           IFDSSolver<IFDSConstAnalysis::n_t, IFDSConstAnalysis::d_t,
-                     IFDSConstAnalysis::m_t, IFDSConstAnalysis::t_t,
+                     IFDSConstAnalysis::f_t, IFDSConstAnalysis::t_t,
                      IFDSConstAnalysis::v_t, IFDSConstAnalysis::i_t>,
           IFDSConstAnalysis>
           WPA(IRDB, EntryPoints, &PT, &ICF, &TH);
     } break;
     case DataFlowAnalysisType::IFDSTaintAnalysis: {
       WholeProgramAnalysis<
           IFDSSolver<IFDSTaintAnalysis::n_t, IFDSTaintAnalysis::d_t,
-                     IFDSTaintAnalysis::m_t, IFDSTaintAnalysis::t_t,
+                     IFDSTaintAnalysis::f_t, IFDSTaintAnalysis::t_t,
                      IFDSTaintAnalysis::v_t, IFDSTaintAnalysis::i_t>,
           IFDSTaintAnalysis>
           WPA(IRDB, AnalysisConfigPath, EntryPoints, &PT, &ICF, &TH);
     } break;
     case DataFlowAnalysisType::IDETaintAnalysis: {
       WholeProgramAnalysis<
           IDESolver<IDETaintAnalysis::n_t, IDETaintAnalysis::d_t,
-                    IDETaintAnalysis::m_t, IDETaintAnalysis::t_t,
+                    IDETaintAnalysis::f_t, IDETaintAnalysis::t_t,
                     IDETaintAnalysis::v_t, IDETaintAnalysis::l_t,
                     IDETaintAnalysis::i_t>,
           IDETaintAnalysis>
@@ -133,7 +133,7 @@ void AnalysisController::executeWholeProgram() {
     case DataFlowAnalysisType::IDETypeStateAnalysis: {
       // WholeProgramAnalysis<
       //     IDESolver<IDETypeStateAnalysis::n_t, IDETypeStateAnalysis::d_t,
-      //               IDETypeStateAnalysis::m_t, IDETypeStateAnalysis::t_t,
+      //               IDETypeStateAnalysis::f_t, IDETypeStateAnalysis::t_t,
       //               IDETypeStateAnalysis::v_t, IDETypeStateAnalysis::l_t,
       //               IDETypeStateAnalysis::i_t>,
       //     IDETypeStateAnalysis>
@@ -142,14 +142,14 @@ void AnalysisController::executeWholeProgram() {
     case DataFlowAnalysisType::IFDSTypeAnalysis: {
       WholeProgramAnalysis<
           IFDSSolver<IFDSTypeAnalysis::n_t, IFDSTypeAnalysis::d_t,
-                     IFDSTypeAnalysis::m_t, IFDSTypeAnalysis::t_t,
+                     IFDSTypeAnalysis::f_t, IFDSTypeAnalysis::t_t,
                      IFDSTypeAnalysis::v_t, IFDSTypeAnalysis::i_t>,
           IFDSTypeAnalysis>
           WPA(IRDB, EntryPoints, &PT, &ICF, &TH);
     } break;
     case DataFlowAnalysisType::IFDSSolverTest: {
       WholeProgramAnalysis<IFDSSolver<IFDSSolverTest::n_t, IFDSSolverTest::d_t,
-                                      IFDSSolverTest::m_t, IFDSSolverTest::t_t,
+                                      IFDSSolverTest::f_t, IFDSSolverTest::t_t,
                                       IFDSSolverTest::v_t, IFDSSolverTest::i_t>,
                            IFDSSolverTest>
           WPA(IRDB, EntryPoints, &PT, &ICF, &TH);
@@ -158,7 +158,7 @@ void AnalysisController::executeWholeProgram() {
       WholeProgramAnalysis<
           IFDSSolver<
               IFDSLinearConstantAnalysis::n_t, IFDSLinearConstantAnalysis::d_t,
-              IFDSLinearConstantAnalysis::m_t, IFDSLinearConstantAnalysis::t_t,
+              IFDSLinearConstantAnalysis::f_t, IFDSLinearConstantAnalysis::t_t,
               IFDSLinearConstantAnalysis::v_t, IFDSLinearConstantAnalysis::i_t>,
           IFDSLinearConstantAnalysis>
           WPA(IRDB, EntryPoints, &PT, &ICF, &TH);
@@ -167,7 +167,7 @@ void AnalysisController::executeWholeProgram() {
       WholeProgramAnalysis<
           IFDSSolver<
               IFDSFieldSensTaintAnalysis::n_t, IFDSFieldSensTaintAnalysis::d_t,
-              IFDSFieldSensTaintAnalysis::m_t, IFDSFieldSensTaintAnalysis::t_t,
+              IFDSFieldSensTaintAnalysis::f_t, IFDSFieldSensTaintAnalysis::t_t,
               IFDSFieldSensTaintAnalysis::v_t, IFDSFieldSensTaintAnalysis::i_t>,
           IFDSFieldSensTaintAnalysis>
           WPA(IRDB, AnalysisConfigPath, EntryPoints, &PT, &ICF, &TH);
@@ -176,15 +176,15 @@ void AnalysisController::executeWholeProgram() {
       WholeProgramAnalysis<
           IDESolver<
               IDELinearConstantAnalysis::n_t, IDELinearConstantAnalysis::d_t,
-              IDELinearConstantAnalysis::m_t, IDELinearConstantAnalysis::t_t,
+              IDELinearConstantAnalysis::f_t, IDELinearConstantAnalysis::t_t,
               IDELinearConstantAnalysis::v_t, IDELinearConstantAnalysis::l_t,
               IDELinearConstantAnalysis::i_t>,
           IDELinearConstantAnalysis>
           WPA(IRDB, EntryPoints, &PT, &ICF, &TH);
     } break;
     case DataFlowAnalysisType::IDESolverTest: {
       WholeProgramAnalysis<
-          IDESolver<IDESolverTest::n_t, IDESolverTest::d_t, IDESolverTest::m_t,
+          IDESolver<IDESolverTest::n_t, IDESolverTest::d_t, IDESolverTest::f_t,
                     IDESolverTest::t_t, IDESolverTest::v_t, IDESolverTest::l_t,
                     IDESolverTest::i_t>,
           IDESolverTest>
@@ -194,7 +194,7 @@ void AnalysisController::executeWholeProgram() {
       WholeProgramAnalysis<
           IntraMonoSolver<IntraMonoFullConstantPropagation::n_t,
                           IntraMonoFullConstantPropagation::d_t,
-                          IntraMonoFullConstantPropagation::m_t,
+                          IntraMonoFullConstantPropagation::f_t,
                           IntraMonoFullConstantPropagation::t_t,
                           IntraMonoFullConstantPropagation::v_t,
                           IntraMonoFullConstantPropagation::i_t>,
@@ -204,15 +204,15 @@ void AnalysisController::executeWholeProgram() {
     case DataFlowAnalysisType::IntraMonoSolverTest: {
       WholeProgramAnalysis<
           IntraMonoSolver<IntraMonoSolverTest::n_t, IntraMonoSolverTest::d_t,
-                          IntraMonoSolverTest::m_t, IntraMonoSolverTest::t_t,
+                          IntraMonoSolverTest::f_t, IntraMonoSolverTest::t_t,
                           IntraMonoSolverTest::v_t, IntraMonoSolverTest::i_t>,
           IntraMonoSolverTest>
           WPA(IRDB, EntryPoints, &PT, &ICF, &TH);
     } break;
     case DataFlowAnalysisType::InterMonoSolverTest: {
       WholeProgramAnalysis<
           InterMonoSolver<InterMonoSolverTest::n_t, InterMonoSolverTest::d_t,
-                          InterMonoSolverTest::m_t, InterMonoSolverTest::t_t,
+                          InterMonoSolverTest::f_t, InterMonoSolverTest::t_t,
                           InterMonoSolverTest::v_t, InterMonoSolverTest::i_t,
                           3>,
           InterMonoSolverTest>
@@ -222,7 +222,7 @@ void AnalysisController::executeWholeProgram() {
       WholeProgramAnalysis<
           InterMonoSolver<
               InterMonoTaintAnalysis::n_t, InterMonoTaintAnalysis::d_t,
-              InterMonoTaintAnalysis::m_t, InterMonoTaintAnalysis::t_t,
+              InterMonoTaintAnalysis::f_t, InterMonoTaintAnalysis::t_t,
               InterMonoTaintAnalysis::v_t, InterMonoTaintAnalysis::i_t, 3>,
           InterMonoTaintAnalysis>
           WPA(IRDB, AnalysisConfigPath, EntryPoints, &PT, &ICF, &TH);

lib/PhasarLLVM/DataFlowSolver/IfdsIde/IFDSFieldSensTaintAnalysis/FlowFunctions/MapTaintedValuesToCallee.cpp

@@ -31,7 +31,7 @@ MapTaintedValuesToCallee::computeTargets(ExtendedValue fact) {
   long varArgIndex = 0L;
 
   const auto sanitizedArgList = DataFlowUtils::getSanitizedArgList(
-      callInst, destMthd, zeroValue.getValue());
+      callInst, destFun, zeroValue.getValue());
 
   for (const auto &argParamTriple : sanitizedArgList) {
 

lib/PhasarLLVM/DataFlowSolver/IfdsIde/IFDSFieldSensTaintAnalysis/Utils/DataFlowUtils.cpp

@@ -692,7 +692,7 @@ const std::vector<
     std::tuple<const llvm::Value *, const std::vector<const llvm::Value *>,
                const llvm::Value *>>
 DataFlowUtils::getSanitizedArgList(const llvm::CallInst *callInst,
-                                   const llvm::Function *destMthd,
+                                   const llvm::Function *destFun,
                                    const llvm::Value *zeroValue) {
   std::vector<
       std::tuple<const llvm::Value *, const std::vector<const llvm::Value *>,
@@ -701,7 +701,7 @@ DataFlowUtils::getSanitizedArgList(const llvm::CallInst *callInst,
 
   for (unsigned i = 0; i < callInst->getNumArgOperands(); ++i) {
     const auto arg = callInst->getOperand(i);
-    const auto param = getNthFunctionArgument(destMthd, i);
+    const auto param = getNthFunctionArgument(destFun, i);
 
     auto argMemLocationSeq = DataFlowUtils::getMemoryLocationSeqFromMatr(arg);