From 2640f29c8e8c9c56f3e1bff26f31141d1865104a Mon Sep 17 00:00:00 2001 From: Martin Mory Date: Wed, 22 Dec 2021 23:42:08 +0100 Subject: [PATCH 1/4] clang-tidy fixes for IDEGeneralizedLCA --- .../Problems/IDEGeneralizedLCA/AllBot.h | 8 +- .../IDEGeneralizedLCA/BinaryEdgeFunction.h | 26 +- .../Problems/IDEGeneralizedLCA/EdgeValue.h | 125 ++-- .../Problems/IDEGeneralizedLCA/EdgeValueSet.h | 28 +- .../Problems/IDEGeneralizedLCA/GenConstant.h | 16 +- .../IDEGeneralizedLCA/IDEGeneralizedLCA.h | 86 +-- .../IDEGeneralizedLCA/JoinEdgeFunction.h | 22 +- .../LCAEdgeFunctionComposer.h | 10 +- .../MapFactsToCalleeFlowFunction.h | 2 +- .../MapFactsToCallerFlowFunction.h | 2 +- .../IDEGeneralizedLCA/TypecastEdgeFunction.h | 22 +- .../Problems/IDEGeneralizedLCA/AllBot.cpp | 12 +- .../IDEGeneralizedLCA/BinaryEdgeFunction.cpp | 17 +- .../IDEGeneralizedLCA/ConstantHelper.cpp | 17 +- .../Problems/IDEGeneralizedLCA/EdgeValue.cpp | 677 +++++++++--------- .../IDEGeneralizedLCA/EdgeValueSet.cpp | 46 +- .../IDEGeneralizedLCA/GenConstant.cpp | 49 +- .../IDEGeneralizedLCA/IDEGeneralizedLCA.cpp | 221 +++--- .../IDEGeneralizedLCA/JoinEdgeFunction.cpp | 65 +- .../LCAEdgeFunctionComposer.cpp | 4 +- .../MapFactsToCallerFlowFunction.cpp | 5 +- .../TypecastEdgeFunction.cpp | 22 +- .../Problems/IDEGeneralizedLCATest.cpp | 152 ++-- 23 files changed, 843 insertions(+), 791 deletions(-) diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/AllBot.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/AllBot.h index 67d4256a0a..8edbb0e25d 100644 --- a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/AllBot.h +++ b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/AllBot.h @@ -18,11 +18,11 @@ namespace psr { struct AllBot { using type = AllBottom; static std::shared_ptr getInstance(); - static bool isBot(const EdgeFunction *edgeFn, - bool nonRec = false); + static bool isBot(const EdgeFunction *EdgeFn, + bool NonRec = false); static bool - isBot(const std::shared_ptr> &edgeFn, - bool nonRec = false); + isBot(const std::shared_ptr> &EdgeFn, + bool NonRec = false); }; } // namespace psr diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/BinaryEdgeFunction.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/BinaryEdgeFunction.h index 293c9da964..445872c4c9 100644 --- a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/BinaryEdgeFunction.h +++ b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/BinaryEdgeFunction.h @@ -19,31 +19,31 @@ namespace psr { class BinaryEdgeFunction : public EdgeFunction, public std::enable_shared_from_this { - llvm::BinaryOperator::BinaryOps op; - const IDEGeneralizedLCA::l_t cnst; - bool leftConst; - size_t maxSize; + llvm::BinaryOperator::BinaryOps Op; + const IDEGeneralizedLCA::l_t Const; + bool LeftConst; + size_t MaxSize; public: - BinaryEdgeFunction(llvm::BinaryOperator::BinaryOps op, - const IDEGeneralizedLCA::l_t &cnst, bool leftConst, - size_t maxSize) - : op(op), cnst(cnst), leftConst(leftConst), maxSize(maxSize) {} + BinaryEdgeFunction(llvm::BinaryOperator::BinaryOps Op, + const IDEGeneralizedLCA::l_t &Const, bool LeftConst, + size_t MaxSize) + : Op(Op), Const(Const), LeftConst(LeftConst), MaxSize(MaxSize) {} - IDEGeneralizedLCA::l_t computeTarget(IDEGeneralizedLCA::l_t source) override; + IDEGeneralizedLCA::l_t computeTarget(IDEGeneralizedLCA::l_t Source) override; std::shared_ptr> composeWith( - std::shared_ptr> secondFunction) + std::shared_ptr> SecondFunction) override; std::shared_ptr> - joinWith(std::shared_ptr> otherFunction) + joinWith(std::shared_ptr> OtherFunction) override; - bool equal_to(std::shared_ptr> other) + bool equal_to(std::shared_ptr> Other) const override; - void print(std::ostream &OS, bool isForDebug = false) const override; + void print(std::ostream &OS, bool IsForDebug = false) const override; }; } // namespace psr diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.h index 00c2c5a4a3..6a6c393d8d 100644 --- a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.h +++ b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.h @@ -29,91 +29,94 @@ class EdgeValue { enum Type { Top, Integer, String, FloatingPoint }; private: - std::variant value = - nullptr; - Type type; + std::variant + ValVariant = nullptr; + Type VariantType; public: - EdgeValue(const llvm::Value *val); - EdgeValue(const EdgeValue &ev); - EdgeValue(llvm::APInt &&vi); - EdgeValue(const llvm::APInt &vi); - EdgeValue(llvm::APFloat &&vf); - EdgeValue(long long vi); - EdgeValue(int vi); - EdgeValue(double d); - EdgeValue(float d); - EdgeValue(std::string &&vs); + EdgeValue(const llvm::Value *Val); + EdgeValue(const EdgeValue &EV); + EdgeValue(llvm::APInt &&VI); + EdgeValue(const llvm::APInt &VI); + EdgeValue(llvm::APFloat &&VF); + EdgeValue(long long VI); + EdgeValue(int VI); + EdgeValue(double Double); + EdgeValue(float Float); + EdgeValue(std::string &&VS); EdgeValue(std::nullptr_t); ~EdgeValue(); - const static EdgeValue top; - bool tryGetInt(uint64_t &res) const; - bool tryGetFP(double &res) const; - bool tryGetString(std::string &res) const; - bool isTop() const; - bool isNumeric() const; - bool isString() const; - Type getKind() const; + const static EdgeValue TopValue; + [[nodiscard]] bool tryGetInt(uint64_t &Res) const; + [[nodiscard]] bool tryGetFP(double &Res) const; + [[nodiscard]] bool tryGetString(std::string &Res) const; + [[nodiscard]] bool isTop() const; + [[nodiscard]] bool isNumeric() const; + [[nodiscard]] bool isString() const; + [[nodiscard]] Type getKind() const; // std::unique_ptr asObjLLVM(llvm::LLVMContext &ctx) const; - bool sqSubsetEq(const EdgeValue &other) const; - EdgeValue performBinOp(llvm::BinaryOperator::BinaryOps op, - const EdgeValue &other) const; - EdgeValue typecast(Type dest, unsigned bits) const; - EdgeValue &operator=(const EdgeValue &ev); + [[nodiscard]] bool sqSubsetEq(const EdgeValue &Other) const; + [[nodiscard]] EdgeValue performBinOp(llvm::BinaryOperator::BinaryOps Op, + const EdgeValue &Other) const; + [[nodiscard]] EdgeValue typecast(Type Dest, unsigned Bits) const; + EdgeValue &operator=(const EdgeValue &EV); operator bool(); - friend bool operator==(const EdgeValue &v1, const EdgeValue &v2); + friend bool operator==(const EdgeValue &Lhs, const EdgeValue &Rhs); // binary operators - friend EdgeValue operator+(const EdgeValue &v1, const EdgeValue &v2); - friend EdgeValue operator-(const EdgeValue &v1, const EdgeValue &v2); - friend EdgeValue operator*(const EdgeValue &v1, const EdgeValue &v2); - friend EdgeValue operator/(const EdgeValue &v1, const EdgeValue &v2); - friend EdgeValue operator%(const EdgeValue &v1, const EdgeValue &v2); - friend EdgeValue operator&(const EdgeValue &v1, const EdgeValue &v2); - friend EdgeValue operator|(const EdgeValue &v1, const EdgeValue &v2); - friend EdgeValue operator^(const EdgeValue &v1, const EdgeValue &v2); - friend EdgeValue operator<<(const EdgeValue &v1, const EdgeValue &v2); - friend EdgeValue operator>>(const EdgeValue &v1, const EdgeValue &v2); - static int compare(const EdgeValue &v1, const EdgeValue &v2); + friend EdgeValue operator+(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator-(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator*(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator/(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator%(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator&(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator|(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator^(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator<<(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator>>(const EdgeValue &Lhs, const EdgeValue &Rhs); + static int compare(const EdgeValue &Lhs, const EdgeValue &Rhs); // unary operators EdgeValue operator-() const; EdgeValue operator~() const; - friend std::ostream &operator<<(std::ostream &os, const EdgeValue &ev); - static std::string typeToString(Type ty); + friend std::ostream &operator<<(std::ostream &Os, const EdgeValue &EV); + static std::string typeToString(Type Ty); }; class EdgeValueSet; typedef EdgeValueSet ev_t; -ev_t performBinOp(llvm::BinaryOperator::BinaryOps op, const ev_t &v1, - const ev_t &v2, size_t maxSize); -ev_t performTypecast(const ev_t &ev, EdgeValue::Type dest, unsigned bits); -Ordering compare(const ev_t &v1, const ev_t &v2); -ev_t join(const ev_t &v1, const ev_t &v2, size_t maxSize); +ev_t performBinOp(llvm::BinaryOperator::BinaryOps Op, const ev_t &Lhs, + const ev_t &Rhs, size_t MaxSize); +ev_t performTypecast(const ev_t &Ev, EdgeValue::Type Dest, unsigned Bits); +Ordering compare(const ev_t &Lhs, const ev_t &Rhs); +ev_t join(const ev_t &Lhs, const ev_t &Rhs, size_t MaxSize); /// \brief implements square subset equal -bool operator<(const ev_t &v1, const ev_t &v2); -bool isTopValue(const ev_t &v); -std::ostream &operator<<(std::ostream &os, const ev_t &v); +bool operator<(const ev_t &Lhs, const ev_t &Rhs); +bool isTopValue(const ev_t &Val); +std::ostream &operator<<(std::ostream &Os, const ev_t &Val); } // namespace psr namespace std { template <> struct hash { - hash() {} - size_t operator()(const psr::EdgeValue &val) const { - auto hc = hash()(val.getKind()); - uint64_t asInt; - double asFloat; - string asString; - if (val.tryGetInt(asInt)) - return hash()(asInt) * 31 + hc; - else if (val.tryGetFP(asFloat)) - return hash()(round(asFloat)) * 31 + hc; - else if (val.tryGetString(asString)) - return hash()(asString) * 31 + hc; - return hc; + hash() = default; + size_t operator()(const psr::EdgeValue &Val) const { + auto Hash = hash()(Val.getKind()); + uint64_t AsInt; + double AsFloat; + string AsString; + if (Val.tryGetInt(AsInt)) { + return hash()(AsInt) * 31 + Hash; + } + if (Val.tryGetFP(AsFloat)) { + return hash()(round(AsFloat)) * 31 + Hash; + } + if (Val.tryGetString(AsString)) { + return hash()(AsString) * 31 + Hash; + } + return Hash; } }; diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValueSet.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValueSet.h index c12ed1f1ab..372f84e1c3 100644 --- a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValueSet.h +++ b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValueSet.h @@ -18,27 +18,27 @@ namespace psr { class EdgeValueSet { - std::unordered_set underlying; + std::unordered_set Underlying; public: EdgeValueSet(); template - EdgeValueSet(Iter beg, Iter ed) : underlying(beg, ed) {} - EdgeValueSet(std::initializer_list ilist); - auto begin() -> decltype(underlying.begin()); - auto end() -> decltype(underlying.end()); - auto begin() const -> decltype(underlying.begin()); - auto end() const -> decltype(underlying.end()); - int count(const EdgeValue &ev) const; - auto find(const EdgeValue &ev) -> decltype(underlying.find(ev)); - auto find(const EdgeValue &ev) const -> decltype(underlying.find(ev)); + EdgeValueSet(Iter Begin, Iter End) : Underlying(Begin, End) {} + EdgeValueSet(std::initializer_list IList); + auto begin() -> decltype(Underlying.begin()); + auto end() -> decltype(Underlying.end()); + auto begin() const -> decltype(Underlying.begin()); + auto end() const -> decltype(Underlying.end()); + int count(const EdgeValue &EV) const; + auto find(const EdgeValue &EV) -> decltype(Underlying.find(EV)); + auto find(const EdgeValue &EV) const -> decltype(Underlying.find(EV)); size_t size() const; - auto insert(const EdgeValue &ev) -> decltype(underlying.insert(ev)); - auto insert(EdgeValue &&ev) -> decltype(underlying.insert(ev)); + auto insert(const EdgeValue &EV) -> decltype(Underlying.insert(EV)); + auto insert(EdgeValue &&EV) -> decltype(Underlying.insert(EV)); bool empty() const; - bool operator==(const EdgeValueSet &other) const; - bool operator!=(const EdgeValueSet &other) const; + bool operator==(const EdgeValueSet &Other) const; + bool operator!=(const EdgeValueSet &Other) const; }; } // namespace psr diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.h index 047dcbec59..c66d867932 100644 --- a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.h +++ b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.h @@ -17,24 +17,24 @@ namespace psr { class GenConstant : public EdgeFunction, public std::enable_shared_from_this { - IDEGeneralizedLCA::l_t val; - size_t maxSize; + IDEGeneralizedLCA::l_t Val; + size_t MaxSize; public: - GenConstant(const IDEGeneralizedLCA::l_t &val, size_t maxSize); - IDEGeneralizedLCA::l_t computeTarget(IDEGeneralizedLCA::l_t source) override; + GenConstant(const IDEGeneralizedLCA::l_t &Val, size_t MaxSize); + IDEGeneralizedLCA::l_t computeTarget(IDEGeneralizedLCA::l_t Source) override; std::shared_ptr> composeWith( - std::shared_ptr> secondFunction) + std::shared_ptr> SecondFunction) override; std::shared_ptr> - joinWith(std::shared_ptr> otherFunction) + joinWith(std::shared_ptr> OtherFunction) override; - bool equal_to(std::shared_ptr> other) + bool equal_to(std::shared_ptr> Other) const override; - void print(std::ostream &OS, bool isForDebug = false) const override; + void print(std::ostream &OS, bool IsForDebug = false) const override; }; } // namespace psr diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/IDEGeneralizedLCA.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/IDEGeneralizedLCA.h index f208d64ace..7ef9378464 100644 --- a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/IDEGeneralizedLCA.h +++ b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/IDEGeneralizedLCA.h @@ -23,8 +23,8 @@ namespace psr { /// \brief An implementation of a linear constant analysis, similar to -/// IDELinearConstantAnalysis, but with an extended edge-value -/// domain. Instead of using single values, we use a bounded set of cadidates to +/// IDELinearConstantAnalysis, but with an extended edge-Value +/// domain. Instead of using single Values, we use a bounded set of cadidates to /// increase precision. struct IDEGeneralizedLCADomain : LLVMAnalysisDomainDefault { @@ -37,7 +37,7 @@ template class IDETabulationProblem; class IDEGeneralizedLCA : public IDETabulationProblem { - size_t maxSetSize; + size_t MaxSetSize; public: using d_t = typename IDEGeneralizedLCADomain::d_t; @@ -50,11 +50,11 @@ class IDEGeneralizedLCA : public IDETabulationProblem { struct LCAResult { LCAResult() = default; - unsigned line_nr = 0; - std::string src_code; - std::map variableToValue; - std::vector ir_trace; - void print(std::ostream &os); + unsigned LineNo = 0; + std::string SrcNode; + std::map VariableToValue; + std::vector IRTrace; + void print(std::ostream &OS); }; using lca_results_t = std::map>; @@ -66,81 +66,81 @@ class IDEGeneralizedLCA : public IDETabulationProblem { PointsToInfo *PT, std::set EntryPoints, size_t MaxSetSize); - std::shared_ptr> getNormalFlowFunction(n_t curr, - n_t succ) override; + std::shared_ptr> getNormalFlowFunction(n_t Curr, + n_t Succ) override; - std::shared_ptr> getCallFlowFunction(n_t callStmt, - f_t destMthd) override; + std::shared_ptr> getCallFlowFunction(n_t CallStmt, + f_t DestMthd) override; - std::shared_ptr> getRetFlowFunction(n_t callSite, - f_t calleeMthd, - n_t exitStmt, - n_t retSite) override; + std::shared_ptr> getRetFlowFunction(n_t CallSite, + f_t CalleeMthd, + n_t ExitStmt, + n_t RetSite) override; std::shared_ptr> - getCallToRetFlowFunction(n_t callSite, n_t retSite, - std::set callees) override; + getCallToRetFlowFunction(n_t CallSite, n_t RetSite, + std::set Callees) override; std::shared_ptr> - getSummaryFlowFunction(n_t callStmt, f_t destMthd) override; + getSummaryFlowFunction(n_t CallStmt, f_t DestMthd) override; InitialSeeds initialSeeds() override; d_t createZeroValue() const override; - bool isZeroValue(d_t d) const override; + [[nodiscard]] bool isZeroValue(d_t Fact) const override; // in addition provide specifications for the IDE parts std::shared_ptr> - getNormalEdgeFunction(n_t curr, d_t currNode, n_t succ, - d_t succNode) override; + getNormalEdgeFunction(n_t Curr, d_t CurrNode, n_t Succ, + d_t SuccNode) override; - std::shared_ptr> getCallEdgeFunction(n_t callStmt, - d_t srcNode, - f_t destinationMethod, - d_t destNode) override; + std::shared_ptr> getCallEdgeFunction(n_t CallStmt, + d_t SrcNode, + f_t DestinationMethod, + d_t DestNode) override; std::shared_ptr> - getReturnEdgeFunction(n_t callSite, f_t calleeMethod, n_t exitStmt, - d_t exitNode, n_t reSite, d_t retNode) override; + getReturnEdgeFunction(n_t CallSite, f_t CalleeMethod, n_t ExitStmt, + d_t ExitNode, n_t RetSite, d_t RetNode) override; std::shared_ptr> - getCallToRetEdgeFunction(n_t callSite, d_t callNode, n_t retSite, - d_t retSiteNode, std::set callees) override; + getCallToRetEdgeFunction(n_t CallSite, d_t CallNode, n_t RetSite, + d_t RetSiteNode, std::set Callees) override; std::shared_ptr> - getSummaryEdgeFunction(n_t callStmt, d_t callNode, n_t retSite, - d_t retSiteNode) override; + getSummaryEdgeFunction(n_t CallStmt, d_t CallNode, n_t RetSite, + d_t RetSiteNode) override; l_t topElement() override; l_t bottomElement() override; - l_t join(l_t lhs, l_t rhs) override; + l_t join(l_t Lhs, l_t Rhs) override; std::shared_ptr> allTopFunction() override; - void printNode(std::ostream &os, n_t n) const override; + void printNode(std::ostream &OS, n_t Stmt) const override; - void printDataFlowFact(std::ostream &os, d_t d) const override; + void printDataFlowFact(std::ostream &OS, d_t Fact) const override; - void printFunction(std::ostream &os, f_t m) const override; + void printFunction(std::ostream &OS, f_t Func) const override; - void printEdgeFact(std::ostream &os, l_t v) const override; + void printEdgeFact(std::ostream &OS, l_t L) const override; - // void printIDEReport(std::ostream &os, + // void printIDEReport(std::ostream &OS, // SolverResults &SR) override; void emitTextReport(const SolverResults &SR, - std::ostream &os) override; + std::ostream &OS) override; lca_results_t getLCAResults(SolverResults SR); private: - void stripBottomResults(std::unordered_map &res); - bool isEntryPoint(const std::string &name) const; - template std::string VtoString(V v); - bool isStringConstructor(const llvm::Function *F); + void stripBottomResults(std::unordered_map &Res); + [[nodiscard]] bool isEntryPoint(const std::string &Name) const; + template std::string VtoString(V Val); // NOLINT + bool isStringConstructor(const llvm::Function *Func); }; } // namespace psr diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/JoinEdgeFunction.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/JoinEdgeFunction.h index 32ac253712..dee288b8d7 100644 --- a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/JoinEdgeFunction.h +++ b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/JoinEdgeFunction.h @@ -17,28 +17,28 @@ namespace psr { class JoinEdgeFunction : public EdgeFunction, public std::enable_shared_from_this { - std::shared_ptr> frst; - std::shared_ptr> scnd; - size_t maxSize; + std::shared_ptr> First; + std::shared_ptr> Second; + size_t MaxSize; public: JoinEdgeFunction( - const std::shared_ptr> &frst, - const std::shared_ptr> &scnd, - size_t maxSize); - IDEGeneralizedLCA::l_t computeTarget(IDEGeneralizedLCA::l_t source) override; + const std::shared_ptr> &First, + const std::shared_ptr> &Second, + size_t MaxSize); + IDEGeneralizedLCA::l_t computeTarget(IDEGeneralizedLCA::l_t Source) override; std::shared_ptr> composeWith( - std::shared_ptr> secondFunction) + std::shared_ptr> SecondFunction) override; std::shared_ptr> - joinWith(std::shared_ptr> otherFunction) + joinWith(std::shared_ptr> OtherFunction) override; - bool equal_to(std::shared_ptr> other) + bool equal_to(std::shared_ptr> Other) const override; - void print(std::ostream &OS, bool isForDebug = false) const override; + void print(std::ostream &OS, bool IsForDebug = false) const override; const std::shared_ptr> &getFirst() const; const std::shared_ptr> & getSecond() const; diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/LCAEdgeFunctionComposer.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/LCAEdgeFunctionComposer.h index 514ee43dbc..4209fbb441 100644 --- a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/LCAEdgeFunctionComposer.h +++ b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/LCAEdgeFunctionComposer.h @@ -18,20 +18,20 @@ namespace psr { class LCAEdgeFunctionComposer : public EdgeFunctionComposer { - size_t maxSize; + size_t MaxSize; public: LCAEdgeFunctionComposer( std::shared_ptr> F, - std::shared_ptr> G, size_t maxSize); + std::shared_ptr> G, size_t MaxSize); // IDEGeneralizedLCA::l_t - // computeTarget(IDEGeneralizedLCA::l_t source) override; + // computeTarget(IDEGeneralizedLCA::l_t Source) override; std::shared_ptr> composeWith( - std::shared_ptr> secondFunction) + std::shared_ptr> SecondFunction) override; std::shared_ptr> - joinWith(std::shared_ptr> otherFunction) + joinWith(std::shared_ptr> OtherFunction) override; const std::shared_ptr> &getFirst() const; const std::shared_ptr> & diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/MapFactsToCalleeFlowFunction.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/MapFactsToCalleeFlowFunction.h index 9df1719dc9..db09f579b1 100644 --- a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/MapFactsToCalleeFlowFunction.h +++ b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/MapFactsToCalleeFlowFunction.h @@ -31,7 +31,7 @@ class MapFactsToCalleeFlowFunction : public FlowFunction { MapFactsToCalleeFlowFunction(const llvm::CallBase *CallSite, const llvm::Function *Callee); std::set - computeTargets(const llvm::Value *source) override; + computeTargets(const llvm::Value *Source) override; }; } // namespace psr diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/MapFactsToCallerFlowFunction.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/MapFactsToCallerFlowFunction.h index 3e11a1ce32..3d22146e36 100644 --- a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/MapFactsToCallerFlowFunction.h +++ b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/MapFactsToCallerFlowFunction.h @@ -44,7 +44,7 @@ class MapFactsToCallerFlowFunction : public FlowFunction { const llvm::Instruction *ExitStmt, const llvm::Function *Callee); std::set - computeTargets(const llvm::Value *source) override; + computeTargets(const llvm::Value *Source) override; }; } // namespace psr diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/TypecastEdgeFunction.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/TypecastEdgeFunction.h index c6a9e5cae6..8da9fb9c48 100644 --- a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/TypecastEdgeFunction.h +++ b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/TypecastEdgeFunction.h @@ -4,7 +4,7 @@ * available under the terms of LICENSE.txt. * * Contributors: - * Fabian Schiebel and others + * Fabian Schiebel and Others *****************************************************************************/ #ifndef PHASAR_PHASARLLVM_IFDSIDE_PROBLEMS_IDEGENERALIZEDLCA_TYPECASTEDGEFUNCTION_H_ @@ -19,28 +19,28 @@ namespace psr { class TypecastEdgeFunction : public EdgeFunction, public std::enable_shared_from_this { - unsigned bits; - EdgeValue::Type dest; - size_t maxSize; + unsigned Bits; + EdgeValue::Type Dest; + size_t MaxSize; public: - TypecastEdgeFunction(unsigned bits, EdgeValue::Type dest, size_t maxSize) - : bits(bits), dest(dest), maxSize(maxSize) {} + TypecastEdgeFunction(unsigned Bits, EdgeValue::Type Dest, size_t MaxSize) + : Bits(Bits), Dest(Dest), MaxSize(MaxSize) {} - IDEGeneralizedLCA::l_t computeTarget(IDEGeneralizedLCA::l_t source) override; + IDEGeneralizedLCA::l_t computeTarget(IDEGeneralizedLCA::l_t Source) override; std::shared_ptr> composeWith( - std::shared_ptr> secondFunction) + std::shared_ptr> SecondFunction) override; std::shared_ptr> - joinWith(std::shared_ptr> otherFunction) + joinWith(std::shared_ptr> OtherFunction) override; - bool equal_to(std::shared_ptr> other) + bool equal_to(std::shared_ptr> Other) const override; - void print(std::ostream &OS, bool isForDebug = false) const override; + void print(std::ostream &OS, bool IsForDebug = false) const override; }; } // namespace psr diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/AllBot.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/AllBot.cpp index 6607b5a37e..373b0d5dd5 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/AllBot.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/AllBot.cpp @@ -21,16 +21,20 @@ std::shared_ptr AllBot::getInstance() { bool AllBot::isBot(const EdgeFunction *EdgeFn, bool NonRec) { - if (EdgeFn == nullptr) + if (EdgeFn == nullptr) { return false; - if (EdgeFn == getInstance().get()) + } + if (EdgeFn == getInstance().get()) { return true; - if (dynamic_cast(EdgeFn)) + } + if (dynamic_cast(EdgeFn)) { return true; + } if (!NonRec) { - if (auto JoinEFn = dynamic_cast(EdgeFn)) + if (const auto *JoinEFn = dynamic_cast(EdgeFn)) { return isBot(JoinEFn->getFirst(), true) && isBot(JoinEFn->getSecond(), true); + } } return false; } diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/BinaryEdgeFunction.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/BinaryEdgeFunction.cpp index 97c5ef7545..8420985c3a 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/BinaryEdgeFunction.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/BinaryEdgeFunction.cpp @@ -15,15 +15,14 @@ namespace psr { IDEGeneralizedLCA::l_t BinaryEdgeFunction::computeTarget(IDEGeneralizedLCA::l_t Source) { - /*auto ret = leftConst ? performBinOp(op, cnst, source, maxSize) - : performBinOp(op, source, cnst, maxSize); + /*auto ret = leftConst ? performBinOp(op, cnst, source, MaxSize) + : performBinOp(op, source, cnst, MaxSize); std::cout << "Binary(" << source << ") = " << ret << std::endl; return ret;*/ - if (leftConst) { - return performBinOp(op, cnst, Source, maxSize); - } else { - return performBinOp(op, Source, cnst, maxSize); + if (LeftConst) { + return performBinOp(Op, Const, Source, MaxSize); } + return performBinOp(Op, Source, Const, MaxSize); } std::shared_ptr> @@ -39,7 +38,7 @@ BinaryEdgeFunction::composeWith( return shared_from_this(); } return std::make_shared(this->shared_from_this(), - SecondFunction, maxSize); + SecondFunction, MaxSize); } std::shared_ptr> @@ -62,8 +61,8 @@ bool BinaryEdgeFunction::equal_to( return this == Other.get(); } -void BinaryEdgeFunction::print(std::ostream &OS, bool IsForDebug) const { - OS << "Binary_" << op; +void BinaryEdgeFunction::print(std::ostream &OS, bool /*IsForDebug*/) const { + OS << "Binary_" << Op; } } // namespace psr diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/ConstantHelper.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/ConstantHelper.cpp index b3028324db..857f1b8934 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/ConstantHelper.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/ConstantHelper.cpp @@ -17,21 +17,24 @@ namespace psr { bool isConstant(const llvm::Value *Val) { // is constantInt, constantFP or constant string - if (llvm::isa(Val)) // const int + if (llvm::isa(Val)) { // const int return true; - if (llvm::isa(Val)) // const fp + } + if (llvm::isa(Val)) { // const fp return true; - if (llvm::isa(Val)) // NULL + } + if (llvm::isa(Val)) { // NULL return true; - if (auto Gep = llvm::dyn_cast(Val); + } + if (const auto *Gep = llvm::dyn_cast(Val); Gep && Val->getType()->isPointerTy() && Val->getType()->getPointerElementType()->isIntegerTy()) { // const string // val isa GEP - auto Op1 = Gep->getOperand(0); // op1 is pointer-operand - if (auto Glob = llvm::dyn_cast(Op1); + auto *Op1 = Gep->getOperand(0); // op1 is pointer-operand + if (auto *Glob = llvm::dyn_cast(Op1); Glob && Glob->hasInitializer()) { - if (auto Cdat = + if (auto *Cdat = llvm::dyn_cast(Glob->getInitializer())) { return true; // it is definitely a const string } diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp index 07759fe915..24575115e9 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp @@ -22,81 +22,87 @@ namespace psr { std::ostream &printSemantics(const llvm::APFloat &Fl) { if (&Fl.getSemantics() == &llvm::APFloat::IEEEdouble()) { return std::cout << "IEEEdouble"; - } else if (&Fl.getSemantics() == &llvm::APFloat::IEEEhalf()) { + } + if (&Fl.getSemantics() == &llvm::APFloat::IEEEhalf()) { return std::cout << "IEEEhalf"; - } else if (&Fl.getSemantics() == &llvm::APFloat::IEEEquad()) { + } + if (&Fl.getSemantics() == &llvm::APFloat::IEEEquad()) { return std::cout << "IEEEquad"; - } else if (&Fl.getSemantics() == &llvm::APFloat::IEEEsingle()) { + } + if (&Fl.getSemantics() == &llvm::APFloat::IEEEsingle()) { return std::cout << "IEEEsingle"; - } else if (&Fl.getSemantics() == &llvm::APFloat::PPCDoubleDouble()) { + } + if (&Fl.getSemantics() == &llvm::APFloat::PPCDoubleDouble()) { return std::cout << "PPCDoubleDouble"; - } else if (&Fl.getSemantics() == &llvm::APFloat::x87DoubleExtended()) { + } + if (&Fl.getSemantics() == &llvm::APFloat::x87DoubleExtended()) { return std::cout << "x87DoubleExtended"; - } else if (&Fl.getSemantics() == &llvm::APFloat::Bogus()) { + } + if (&Fl.getSemantics() == &llvm::APFloat::Bogus()) { return std::cout << "Bogus"; - } else { - return std::cout << "Sth else"; - } + } + return std::cout << "Sth else"; } -const EdgeValue EdgeValue::top = EdgeValue(nullptr); +const EdgeValue EdgeValue::TopValue = EdgeValue(nullptr); -EdgeValue::EdgeValue(const llvm::Value *Val) : type(Top) { - if (auto Cnst = llvm::dyn_cast(Val)) { - if (Cnst->getType()->isIntegerTy()) { - type = Integer; - value = llvm::APInt(llvm::cast(Cnst)->getValue()); - } else if (Cnst->getType()->isFloatingPointTy()) { - type = FloatingPoint; - auto &CnstFP = llvm::cast(Cnst)->getValueAPF(); +EdgeValue::EdgeValue(const llvm::Value *Val) : VariantType(Top) { + if (const auto *Const = llvm::dyn_cast(Val)) { + if (Const->getType()->isIntegerTy()) { + VariantType = Integer; + ValVariant = + llvm::APInt(llvm::cast(Const)->getValue()); + } else if (Const->getType()->isFloatingPointTy()) { + VariantType = FloatingPoint; + const auto &ConstFP = llvm::cast(Const)->getValueAPF(); - llvm::APFloat Apf(CnstFP); + llvm::APFloat Apf(ConstFP); bool Unused; Apf.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::roundingMode::NearestTiesToEven, &Unused); - value = llvm::APFloat(Apf); - } else if (llvm::isa(Cnst)) { - type = String; - value = std::string(); - } else if (Cnst->getType()->isPointerTy() && - Cnst->getType()->getPointerElementType()->isIntegerTy()) { - type = String; - auto Gep = llvm::cast( - Cnst); // already checked, hence cast instead of dyn_cast - if (auto Glob = + ValVariant = llvm::APFloat(Apf); + } else if (llvm::isa(Const)) { + VariantType = String; + ValVariant = std::string(); + } else if (Const->getType()->isPointerTy() && + Const->getType()->getPointerElementType()->isIntegerTy()) { + VariantType = String; + const auto *Gep = llvm::cast( + Const); // already checked, hence cast instead of dyn_cast + if (const auto *Glob = llvm::dyn_cast(Gep->getOperand(0))) { - value = std::string( + ValVariant = std::string( llvm::cast(Glob->getInitializer()) ->getAsCString() .str()); } else { // inttoptr - value = nullptr; - type = Top; + ValVariant = nullptr; + VariantType = Top; } } else { - value = nullptr; - type = Top; + Val = nullptr; + VariantType = Top; } } else { - value = nullptr; - type = Top; + Val = nullptr; + VariantType = Top; } } -EdgeValue::EdgeValue(const EdgeValue &Ev) : type(Ev.type) { - switch (type) { +EdgeValue::EdgeValue(const EdgeValue &Ev) : VariantType(Ev.VariantType) { + switch (VariantType) { case Top: - value = nullptr; + ValVariant = nullptr; break; case Integer: - value = std::get(Ev.value); + ValVariant = std::get(Ev.ValVariant); break; case FloatingPoint: - value = std::get(Ev.value); + ValVariant = std::get(Ev.ValVariant); break; case String: - value = std::get(Ev.value); + ValVariant = std::get(Ev.ValVariant); break; } } @@ -107,113 +113,118 @@ EdgeValue &EdgeValue::operator=(const EdgeValue &Ev) { return *this; } -EdgeValue::~EdgeValue() { value.~variant(); } +EdgeValue::~EdgeValue() { ValVariant.~variant(); } -EdgeValue::EdgeValue(llvm::APInt &&Vi) : type(EdgeValue::Integer) { - value = llvm::APInt(std::move(Vi)); +EdgeValue::EdgeValue(llvm::APInt &&Vi) : VariantType(EdgeValue::Integer) { + ValVariant = llvm::APInt(std::move(Vi)); } -EdgeValue::EdgeValue(const llvm::APInt &Vi) : type(EdgeValue::Integer) { - value = llvm::APInt(Vi); +EdgeValue::EdgeValue(const llvm::APInt &Vi) : VariantType(EdgeValue::Integer) { + ValVariant = llvm::APInt(Vi); } -EdgeValue::EdgeValue(llvm::APFloat &&Vf) : type(EdgeValue::FloatingPoint) { +EdgeValue::EdgeValue(llvm::APFloat &&Vf) + : VariantType(EdgeValue::FloatingPoint) { llvm::APFloat Fp = llvm::APFloat(std::move(Vf)); bool Unused; Fp.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::roundingMode::NearestTiesToEven, &Unused); - value = Fp; + ValVariant = Fp; } -EdgeValue::EdgeValue(long long Vi) : type(EdgeValue::Integer) { - value = llvm::APInt(llvm::APInt(sizeof(long long) << 3, Vi)); +EdgeValue::EdgeValue(long long Vi) : VariantType(EdgeValue::Integer) { + ValVariant = llvm::APInt(llvm::APInt(sizeof(long long) << 3, Vi)); } -EdgeValue::EdgeValue(int Vi) : type(EdgeValue::Integer) { - value = llvm::APInt(llvm::APInt(sizeof(int) << 3, Vi)); +EdgeValue::EdgeValue(int Vi) : VariantType(EdgeValue::Integer) { + ValVariant = llvm::APInt(llvm::APInt(sizeof(int) << 3, Vi)); } -EdgeValue::EdgeValue(double D) : type(EdgeValue::FloatingPoint) { - value = llvm::APFloat(D); +EdgeValue::EdgeValue(double Double) : VariantType(EdgeValue::FloatingPoint) { + ValVariant = llvm::APFloat(Double); } -EdgeValue::EdgeValue(float D) : type(EdgeValue::FloatingPoint) { - value = llvm::APFloat(D); +EdgeValue::EdgeValue(float Float) : VariantType(EdgeValue::FloatingPoint) { + ValVariant = llvm::APFloat(Float); } -EdgeValue::EdgeValue(std::string &&Vs) : type(EdgeValue::String) { - value = std::string(Vs); +EdgeValue::EdgeValue(std::string &&Vs) : VariantType(EdgeValue::String) { + ValVariant = std::string(Vs); } -EdgeValue::EdgeValue(std::nullptr_t) : type(EdgeValue::Top) {} +EdgeValue::EdgeValue(std::nullptr_t) : VariantType(EdgeValue::Top) {} bool EdgeValue::tryGetInt(uint64_t &Res) const { - if (type != Integer) - return false; - Res = std::get(value).getLimitedValue(); + if (VariantType != Integer) { + return false; + } + Res = std::get(ValVariant).getLimitedValue(); return true; } bool EdgeValue::tryGetFP(double &Res) const { - if (type != FloatingPoint) - return false; - Res = std::get(value).convertToDouble(); + if (VariantType != FloatingPoint) { + return false; + } + Res = std::get(ValVariant).convertToDouble(); return true; } bool EdgeValue::tryGetString(std::string &Res) const { - if (type != String) - return false; - Res = std::get(value); + if (VariantType != String) { + return false; + } + Res = std::get(ValVariant); return true; } -bool EdgeValue::isTop() const { return type == Top; } +bool EdgeValue::isTop() const { return VariantType == Top; } bool EdgeValue::isNumeric() const { - return type == Integer || type == FloatingPoint; + return VariantType == Integer || VariantType == FloatingPoint; } -bool EdgeValue::isString() const { return type == String; } +bool EdgeValue::isString() const { return VariantType == String; } -EdgeValue::Type EdgeValue::getKind() const { return type; } +EdgeValue::Type EdgeValue::getKind() const { return VariantType; } EdgeValue::operator bool() { - switch (type) { + switch (VariantType) { case Integer: - return !std::get(value).isNullValue(); + return !std::get(ValVariant).isNullValue(); case FloatingPoint: - return std::get(value).isNonZero(); + return std::get(ValVariant).isNonZero(); case String: - return !std::get(value).empty(); + return !std::get(ValVariant).empty(); default: break; } return false; } -bool operator==(const EdgeValue &V1, const EdgeValue &V2) { +bool operator==(const EdgeValue &Lhs, const EdgeValue &Rhs) { // std::cout << "Compare edge values" << std::endl; - if (V1.type != V2.type) { + if (Lhs.VariantType != Rhs.VariantType) { // std::cout << "Comparing incompatible types" << std::endl; return false; } - switch (V1.type) { + switch (Lhs.VariantType) { case EdgeValue::Top: return true; case EdgeValue::Integer: // if (v1.value.asInt != v2.value.asInt) // std::cout << "integer unequal" << std::endl; - return std::get(V1.value) == std::get(V2.value); + return std::get(Lhs.ValVariant) == + std::get(Rhs.ValVariant); case EdgeValue::FloatingPoint: { // std::cout << "compare floating points" << std::endl; - auto Cp = std::get(V1.value).compare( - std::get(V2.value)); + auto Cp = std::get(Lhs.ValVariant) + .compare(std::get(Rhs.ValVariant)); if (Cp == llvm::APFloat::cmpResult::cmpEqual) { // std::cout << "FP equal" << std::endl; return true; } - auto D1 = std::get(V1.value).convertToDouble(); - auto D2 = std::get(V2.value).convertToDouble(); + auto D1 = std::get(Lhs.ValVariant).convertToDouble(); + auto D2 = std::get(Rhs.ValVariant).convertToDouble(); const double Epsilon = 0.000001; // std::cout << "Compare " << d1 << " against " << d2 << std::endl; @@ -222,7 +233,8 @@ bool operator==(const EdgeValue &V1, const EdgeValue &V2) { case EdgeValue::String: // if (v1.value.asString != v2.value.asString) // std::cout << "String unequal" << std::endl; - return std::get(V1.value) == std::get(V2.value); + return std::get(Lhs.ValVariant) == + std::get(Rhs.ValVariant); default: // will not happen std::cerr << "FATAL ERROR" << std::endl; return false; @@ -230,196 +242,209 @@ bool operator==(const EdgeValue &V1, const EdgeValue &V2) { } bool EdgeValue::sqSubsetEq(const EdgeValue &Other) const { - return Other.isTop() || Other.type == type; + return Other.isTop() || Other.VariantType == VariantType; } // binary operators -EdgeValue operator+(const EdgeValue &V1, const EdgeValue &V2) { - if (V1.type != V2.type) - return EdgeValue(nullptr); - switch (V1.type) { +EdgeValue operator+(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { case EdgeValue::Integer: - return EdgeValue(std::get(V1.value) + - std::get(V2.value)); + return {std::get(Lhs.ValVariant) + + std::get(Rhs.ValVariant)}; case EdgeValue::FloatingPoint: - return EdgeValue(std::get(V1.value) + - std::get(V2.value)); + return {std::get(Lhs.ValVariant) + + std::get(Rhs.ValVariant)}; case EdgeValue::String: - return EdgeValue(std::get(V1.value) + - std::get(V2.value)); + return {std::get(Lhs.ValVariant) + + std::get(Rhs.ValVariant)}; default: - return EdgeValue(nullptr); + return {nullptr}; } } -EdgeValue operator-(const EdgeValue &V1, const EdgeValue &V2) { - if (V1.type != V2.type) - return EdgeValue(nullptr); - switch (V1.type) { +EdgeValue operator-(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { case EdgeValue::Integer: - return EdgeValue(std::get(V1.value) - - std::get(V1.value)); + return {std::get(Lhs.ValVariant) - + std::get(Lhs.ValVariant)}; case EdgeValue::FloatingPoint: // printSemantics(v1.value.asFP) << " <=> "; // printSemantics(v2.value.asFP) << std::endl; - return EdgeValue(std::get(V1.value) - - std::get(V2.value)); + return {std::get(Lhs.ValVariant) - + std::get(Rhs.ValVariant)}; default: - return EdgeValue(nullptr); + return {nullptr}; } } -EdgeValue operator*(const EdgeValue &V1, const EdgeValue &V2) { - if (V1.type != V2.type) - return EdgeValue(nullptr); - switch (V1.type) { +EdgeValue operator*(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { case EdgeValue::Integer: - return EdgeValue(std::get(V1.value) * - std::get(V2.value)); + return {std::get(Lhs.ValVariant) * + std::get(Rhs.ValVariant)}; case EdgeValue::FloatingPoint: - return EdgeValue(std::get(V1.value) * - std::get(V2.value)); + return {std::get(Lhs.ValVariant) * + std::get(Rhs.ValVariant)}; default: - return EdgeValue(nullptr); + return {nullptr}; } } -EdgeValue operator/(const EdgeValue &V1, const EdgeValue &V2) { - if (V1.type != V2.type) - return EdgeValue(nullptr); - switch (V1.type) { +EdgeValue operator/(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { case EdgeValue::Integer: - return EdgeValue( - std::get(V1.value).sdiv(std::get(V2.value))); + return {std::get(Lhs.ValVariant) + .sdiv(std::get(Rhs.ValVariant))}; case EdgeValue::FloatingPoint: - return EdgeValue(std::get(V1.value) / - std::get(V2.value)); + return {std::get(Lhs.ValVariant) / + std::get(Rhs.ValVariant)}; default: - return EdgeValue(nullptr); + return {nullptr}; } } -EdgeValue operator%(const EdgeValue &V1, const EdgeValue &V2) { - if (V1.type != V2.type) - return EdgeValue(nullptr); - switch (V1.type) { +EdgeValue operator%(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { case EdgeValue::Integer: - return EdgeValue( - std::get(V1.value).srem(std::get(V2.value))); + return {std::get(Lhs.ValVariant) + .srem(std::get(Rhs.ValVariant))}; case EdgeValue::FloatingPoint: { - llvm::APFloat Fl = std::get(V1.value); - Fl.remainder(std::get(V2.value)); - return EdgeValue(std::move(Fl)); + llvm::APFloat Fl = std::get(Lhs.ValVariant); + Fl.remainder(std::get(Rhs.ValVariant)); + return {std::move(Fl)}; } default: - return EdgeValue(nullptr); + return {nullptr}; } } -EdgeValue operator&(const EdgeValue &V1, const EdgeValue &V2) { - if (V1.type != V2.type) - return EdgeValue(nullptr); - switch (V1.type) { +EdgeValue operator&(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { case EdgeValue::Integer: - return EdgeValue(std::get(V1.value) & - std::get(V2.value)); + return {std::get(Lhs.ValVariant) & + std::get(Rhs.ValVariant)}; default: - return EdgeValue(nullptr); + return {nullptr}; } } -EdgeValue operator|(const EdgeValue &V1, const EdgeValue &V2) { - if (V1.type != V2.type) - return EdgeValue(nullptr); - switch (V1.type) { +EdgeValue operator|(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { case EdgeValue::Integer: - return EdgeValue(std::get(V1.value) | - std::get(V2.value)); + return {std::get(Lhs.ValVariant) | + std::get(Rhs.ValVariant)}; default: - return EdgeValue(nullptr); + return {nullptr}; } } -EdgeValue operator^(const EdgeValue &V1, const EdgeValue &V2) { - if (V1.type != V2.type) - return EdgeValue(nullptr); - switch (V1.type) { +EdgeValue operator^(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { case EdgeValue::Integer: - return EdgeValue(std::get(V1.value) ^ - std::get(V2.value)); + return {std::get(Lhs.ValVariant) ^ + std::get(Rhs.ValVariant)}; default: - return EdgeValue(nullptr); + return {nullptr}; } } -EdgeValue operator<<(const EdgeValue &V1, const EdgeValue &V2) { - if (V1.type != V2.type) - return EdgeValue(nullptr); - switch (V1.type) { +EdgeValue operator<<(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { case EdgeValue::Integer: - return EdgeValue(std::get(V1.value) - << std::get(V2.value)); + return {std::get(Lhs.ValVariant) + << std::get(Rhs.ValVariant)}; default: - return EdgeValue(nullptr); + return {nullptr}; } -} - -EdgeValue operator>>(const EdgeValue &V1, const EdgeValue &V2) { - if (V1.type != V2.type) - return EdgeValue(nullptr); - switch (V1.type) { +} +EdgeValue operator>>(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { case EdgeValue::Integer: - return EdgeValue( - std::get(V1.value).ashr(std::get(V2.value))); + return {std::get(Lhs.ValVariant) + .ashr(std::get(Rhs.ValVariant))}; default: - return EdgeValue(nullptr); + return {nullptr}; } } // unary operators EdgeValue EdgeValue::operator-() const { - if (type == Integer) - return EdgeValue(-std::get(value)); - return EdgeValue(nullptr); + if (VariantType == Integer) { + return {-std::get(ValVariant)}; + } + return {nullptr}; } EdgeValue EdgeValue::operator~() const { - if (type == Integer) - return EdgeValue(~std::get(value)); - return EdgeValue(nullptr); + if (VariantType == Integer) { + return {~std::get(ValVariant)}; + } + return {nullptr}; } -int EdgeValue::compare(const EdgeValue &V1, const EdgeValue &V2) { - switch (V1.type) { +int EdgeValue::compare(const EdgeValue &Lhs, const EdgeValue &Rhs) { + switch (Lhs.VariantType) { case EdgeValue::Integer: { - auto V1val = std::get(V1.value).getLimitedValue(); - uint64_t V2val; - double V2valFp; - if (V2.tryGetInt(V2val)) { - return V1val - V2val; - } else if (V2.tryGetFP(V2valFp)) { - return V1val < V2valFp ? -1 : (V1val > V2valFp ? 1 : 0); + auto Lhsval = std::get(Lhs.ValVariant).getLimitedValue(); + uint64_t Rhsval; + double RhsvalFp; + if (Rhs.tryGetInt(Rhsval)) { + return Lhsval - Rhsval; + } + if (Rhs.tryGetFP(RhsvalFp)) { + return Lhsval < RhsvalFp ? -1 : (Lhsval > RhsvalFp ? 1 : 0); } break; } case EdgeValue::FloatingPoint: { - auto V1val = std::get(V1.value).convertToDouble(); - uint64_t V2val; - double V2valFp; - bool IsInt = V2.tryGetInt(V2val); - if (IsInt || V2.tryGetFP(V2valFp)) { - if (IsInt) - V2valFp = V2val; - - return V1val < V2valFp ? -1 : (V1val > V2valFp ? 1 : 0); + auto Lhsval = std::get(Lhs.ValVariant).convertToDouble(); + uint64_t Rhsval; + double RhsvalFp; + bool IsInt = Rhs.tryGetInt(Rhsval); + if (IsInt || Rhs.tryGetFP(RhsvalFp)) { + if (IsInt) { + RhsvalFp = Rhsval; + } + + return Lhsval < RhsvalFp ? -1 : (Lhsval > RhsvalFp ? 1 : 0); } break; } case EdgeValue::String: { - std::string V2val; - if (V2.tryGetString(V2val)) { - return std::get(V1.value).compare(V2val); + std::string Rhsval; + if (Rhs.tryGetString(Rhsval)) { + return std::get(Lhs.ValVariant).compare(Rhsval); } break; } @@ -431,17 +456,17 @@ int EdgeValue::compare(const EdgeValue &V1, const EdgeValue &V2) { } std::ostream &operator<<(std::ostream &Os, const EdgeValue &Ev) { - switch (Ev.type) { + switch (Ev.VariantType) { case EdgeValue::Integer: { std::string S; llvm::raw_string_ostream Ros(S); - Ros << std::get(Ev.value); + Ros << std::get(Ev.ValVariant); return Os << Ros.str(); } case EdgeValue::String: - return Os << "\"" << std::get(Ev.value) << "\""; + return Os << "\"" << std::get(Ev.ValVariant) << "\""; case EdgeValue::FloatingPoint: { - return Os << std::get(Ev.value).convertToDouble(); + return Os << std::get(Ev.ValVariant).convertToDouble(); } default: return Os << ""; @@ -452,36 +477,37 @@ EdgeValue EdgeValue::typecast(Type Dest, unsigned Bits) const { switch (Dest) { case Integer: - switch (type) { + switch (VariantType) { case Integer: - if (std::get(value).getBitWidth() <= Bits) - return *this; - else - return EdgeValue(std::get(value) & ((1 << Bits) - 1)); + if (std::get(ValVariant).getBitWidth() <= Bits) { + return *this; + } + return {std::get(ValVariant) & ((1 << Bits) - 1)}; case FloatingPoint: { bool Unused; llvm::APSInt Ai; - std::get(value).convertToInteger( - Ai, llvm::APFloat::roundingMode::NearestTiesToEven, &Unused); - return EdgeValue(Ai); + std::get(ValVariant) + .convertToInteger(Ai, llvm::APFloat::roundingMode::NearestTiesToEven, + &Unused); + return {Ai}; } default: - return EdgeValue(nullptr); + return {nullptr}; } case FloatingPoint: - switch (type) { + switch (VariantType) { case Integer: - if (Bits > 32) - return EdgeValue((double)std::get(value).getSExtValue()); - else - return EdgeValue((float)std::get(value).getSExtValue()); + if (Bits > 32) { + return {(double)std::get(ValVariant).getSExtValue()}; + } + return {(float)std::get(ValVariant).getSExtValue()}; case FloatingPoint: return *this; default: - return EdgeValue(nullptr); + return {nullptr}; } default: - return EdgeValue(nullptr); + return {nullptr}; } } @@ -499,14 +525,15 @@ EdgeValue EdgeValue::performBinOp(llvm::BinaryOperator::BinaryOps Op, case llvm::BinaryOperator::BinaryOps::SDiv: return *this / Other; case llvm::BinaryOperator::BinaryOps::LShr: { - if (type != Other.type) - return EdgeValue(nullptr); - switch (type) { + if (VariantType != Other.VariantType) { + return {nullptr}; + } + switch (VariantType) { case EdgeValue::Integer: - return EdgeValue(std::get(value).lshr( - std::get(Other.value))); + return {std::get(ValVariant) + .lshr(std::get(Other.ValVariant))}; default: - return EdgeValue(nullptr); + return {nullptr}; } } case llvm::BinaryOperator::BinaryOps::Mul: @@ -523,50 +550,52 @@ EdgeValue EdgeValue::performBinOp(llvm::BinaryOperator::BinaryOps Op, case llvm::BinaryOperator::BinaryOps::FSub: return *this - Other; case llvm::BinaryOperator::BinaryOps::UDiv: { - if (type != Other.type) - return EdgeValue(nullptr); - switch (type) { + if (VariantType != Other.VariantType) { + return {nullptr}; + } + switch (VariantType) { case EdgeValue::Integer: - return EdgeValue(std::get(value).udiv( - std::get(Other.value))); + return {std::get(ValVariant) + .udiv(std::get(Other.ValVariant))}; default: - return EdgeValue(nullptr); + return {nullptr}; } } case llvm::BinaryOperator::BinaryOps::URem: { - if (type != Other.type) - return EdgeValue(nullptr); - switch (type) { + if (VariantType != Other.VariantType) { + return {nullptr}; + } + switch (VariantType) { case EdgeValue::Integer: - return EdgeValue(std::get(value).urem( - std::get(Other.value))); + return {std::get(ValVariant) + .urem(std::get(Other.ValVariant))}; default: - return EdgeValue(nullptr); + return {nullptr}; } } case llvm::BinaryOperator::BinaryOps::Xor: return *this ^ Other; default: - return EdgeValue(nullptr); + return {nullptr}; } } -ev_t performBinOp(llvm::BinaryOperator::BinaryOps Op, const ev_t &V1, - const ev_t &V2, size_t MaxSize) { +ev_t performBinOp(llvm::BinaryOperator::BinaryOps Op, const ev_t &Lhs, + const ev_t &Rhs, size_t MaxSize) { // std::cout << "Perform Binop on " << v1 << " and " << v2 << std::endl; - if (V1.empty() || isTopValue(V1) || V2.empty() || isTopValue(V2)) { + if (Lhs.empty() || isTopValue(Lhs) || Rhs.empty() || isTopValue(Rhs)) { // std::cout << "\t=> " << std::endl; - return {EdgeValue(nullptr)}; + return {{nullptr}}; } ev_t Ret({}); - for (auto &Ev1 : V1) { - for (auto &Ev2 : V2) { + for (const auto &Ev1 : Lhs) { + for (const auto &Ev2 : Rhs) { Ret.insert(Ev1.performBinOp(Op, Ev2)); if (Ret.size() > MaxSize) { // std::cout << "\t=> " << std::endl; - return ev_t({EdgeValue(nullptr)}); + return ev_t({{nullptr}}); } } } @@ -577,89 +606,91 @@ ev_t performBinOp(llvm::BinaryOperator::BinaryOps Op, const ev_t &V1, ev_t performTypecast(const ev_t &Ev, EdgeValue::Type Dest, unsigned Bits) { if (Ev.empty() || isTopValue(Ev)) { // std::cout << "\t=> " << std::endl; - return {EdgeValue(nullptr)}; + return {{nullptr}}; } ev_t Ret({}); - for (auto &V : Ev) { + for (const auto &V : Ev) { auto Tc = V.typecast(Dest, Bits); - if (Tc.isTop()) - return ev_t({EdgeValue(nullptr)}); + if (Tc.isTop()) { + return ev_t({{nullptr}}); + } Ret.insert(Tc); } - return Ret; -} - -Ordering compare(const ev_t &V1, const ev_t &V2) { - auto &Smaller = V1.size() <= V2.size() ? V1 : V2; - auto &Larger = V1.size() > V2.size() ? V1 : V2; - - for (auto &Elem : Smaller) { - if (!Larger.count(Elem)) { - return Ordering::Incomparable; - } - } - return V1.size() == V2.size() - ? Ordering::Equal - : (&Smaller == &V1 ? Ordering::Less : Ordering::Greater); -} - -ev_t join(const ev_t &V1, const ev_t &V2, size_t MaxSize) { - // std::cout << "Join " << v1 << " and " << v2 << std::endl; - if (isTopValue(V1) || isTopValue(V2)) { - // std::cout << "\t=> " << std::endl; - return {EdgeValue(nullptr)}; - } - ev_t Ret(V1.begin(), V1.end()); - - for (auto &Elem : V2) { - Ret.insert(Elem); - if (Ret.size() > MaxSize) { - // std::cout << "\t=> " << std::endl; - return {EdgeValue(nullptr)}; - } - } - // std::cout << "\t=> " << ret << std::endl; - - return Ret; -} - -bool isTopValue(const ev_t &V) { return V.size() == 1 && V.begin()->isTop(); } -std::ostream &operator<<(std::ostream &Os, const ev_t &V) { - Os << "{"; - bool Frst = true; - for (auto &Elem : V) { - if (Frst) - Frst = false; - else - Os << ", "; - Os << Elem; - } - return Os << "}"; -} - -bool operator<(const ev_t &V1, const ev_t &V2) { - if (V1.size() >= V2.size()) { - return V1 != V2 && (V1.empty() || V2 == ev_t({EdgeValue::top})); - } else { - for (auto &Elem : V1) { - if (!V2.count(Elem)) - return false; - } - return true; - } -} - -std::string EdgeValue::typeToString(Type Ty) { - switch (Ty) { - case Integer: - return "Integer"; - case FloatingPoint: - return "FloatingPoint"; - case String: - return "String"; - default: - return "Top"; - } + return Ret; +} + +Ordering compare(const ev_t &Lhs, const ev_t &Rhs) { + const auto &Smaller = Lhs.size() <= Rhs.size() ? Lhs : Rhs; + const auto &Larger = Lhs.size() > Rhs.size() ? Lhs : Rhs; + + for (const auto &Elem : Smaller) { + if (!Larger.count(Elem)) { + return Ordering::Incomparable; + } + } + return Lhs.size() == Rhs.size() + ? Ordering::Equal + : (&Smaller == &Lhs ? Ordering::Less : Ordering::Greater); +} + +ev_t join(const ev_t &Lhs, const ev_t &Rhs, size_t MaxSize) { + // std::cout << "Join " << v1 << " and " << v2 << std::endl; + if (isTopValue(Lhs) || isTopValue(Rhs)) { + // std::cout << "\t=> " << std::endl; + return {{nullptr}}; + } + ev_t Ret(Lhs.begin(), Lhs.end()); + + for (const auto &Elem : Rhs) { + Ret.insert(Elem); + if (Ret.size() > MaxSize) { + // std::cout << "\t=> " << std::endl; + return {{nullptr}}; + } + } + // std::cout << "\t=> " << ret << std::endl; + + return Ret; +} + +bool isTopValue(const ev_t &V) { return V.size() == 1 && V.begin()->isTop(); } +std::ostream &operator<<(std::ostream &Os, const ev_t &V) { + Os << "{"; + bool First = true; + for (const auto &Elem : V) { + if (First) { + First = false; + } else { + Os << ", "; + } + Os << Elem; + } + return Os << "}"; +} + +bool operator<(const ev_t &Lhs, const ev_t &Rhs) { + if (Lhs.size() >= Rhs.size()) { + return Lhs != Rhs && (Lhs.empty() || Rhs == ev_t({EdgeValue::TopValue})); + } + for (const auto &Elem : Lhs) { + if (!Rhs.count(Elem)) { + return false; + } + } + return true; +} + +std::string EdgeValue::typeToString(Type Ty) { + switch (Ty) { + case Integer: + return "Integer"; + case FloatingPoint: + return "FloatingPoint"; + case String: + return "String"; + default: + return "Top"; + } } } // namespace psr diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValueSet.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValueSet.cpp index d1e3b4e639..044f62a83a 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValueSet.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValueSet.cpp @@ -11,47 +11,47 @@ namespace psr { -EdgeValueSet::EdgeValueSet() : underlying({EdgeValue(nullptr)}) {} +EdgeValueSet::EdgeValueSet() : Underlying({EdgeValue(nullptr)}) {} EdgeValueSet::EdgeValueSet(std::initializer_list Ilist) - : underlying(Ilist) {} -auto EdgeValueSet::begin() -> decltype(underlying.begin()) { - return underlying.begin(); + : Underlying(Ilist) {} +auto EdgeValueSet::begin() -> decltype(Underlying.begin()) { + return Underlying.begin(); } -auto EdgeValueSet::end() -> decltype(underlying.end()) { - return underlying.end(); +auto EdgeValueSet::end() -> decltype(Underlying.end()) { + return Underlying.end(); } -auto EdgeValueSet::begin() const -> decltype(underlying.begin()) { - return underlying.begin(); +auto EdgeValueSet::begin() const -> decltype(Underlying.begin()) { + return Underlying.begin(); } -auto EdgeValueSet::end() const -> decltype(underlying.end()) { - return underlying.end(); +auto EdgeValueSet::end() const -> decltype(Underlying.end()) { + return Underlying.end(); } int EdgeValueSet::count(const EdgeValue &Ev) const { - return underlying.count(Ev); + return Underlying.count(Ev); } -auto EdgeValueSet::find(const EdgeValue &Ev) -> decltype(underlying.find(Ev)) { - return underlying.find(Ev); +auto EdgeValueSet::find(const EdgeValue &Ev) -> decltype(Underlying.find(Ev)) { + return Underlying.find(Ev); } auto EdgeValueSet::find(const EdgeValue &Ev) const - -> decltype(underlying.find(Ev)) { - return underlying.find(Ev); + -> decltype(Underlying.find(Ev)) { + return Underlying.find(Ev); } -size_t EdgeValueSet::size() const { return underlying.size(); } +size_t EdgeValueSet::size() const { return Underlying.size(); } auto EdgeValueSet::insert(const EdgeValue &Ev) - -> decltype(underlying.insert(Ev)) { - return underlying.insert(Ev); + -> decltype(Underlying.insert(Ev)) { + return Underlying.insert(Ev); } -auto EdgeValueSet::insert(EdgeValue &&Ev) -> decltype(underlying.insert(Ev)) { - return underlying.insert(Ev); +auto EdgeValueSet::insert(EdgeValue &&Ev) -> decltype(Underlying.insert(Ev)) { + return Underlying.insert(Ev); } -bool EdgeValueSet::empty() const { return underlying.empty(); } +bool EdgeValueSet::empty() const { return Underlying.empty(); } bool EdgeValueSet::operator==(const EdgeValueSet &Other) const { - return underlying == Other.underlying; + return Underlying == Other.Underlying; } bool EdgeValueSet::operator!=(const EdgeValueSet &Other) const { - return underlying != Other.underlying; + return Underlying != Other.Underlying; } } // namespace psr diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.cpp index d648171ce8..fa73dd471d 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.cpp @@ -17,13 +17,13 @@ namespace psr { GenConstant::GenConstant(const IDEGeneralizedLCA::l_t &Val, size_t MaxSize) - : val(Val), maxSize(MaxSize) { + : Val(Val), MaxSize(MaxSize) { // TODO: remove this? /*std::cout << "GenConstant: {"; - bool frst = true; + bool First = true; for (auto &elem : val) { - if (frst) - frst = false; + if (First) + First = false; else std::cout << ", "; std::cout << elem; @@ -31,10 +31,10 @@ GenConstant::GenConstant(const IDEGeneralizedLCA::l_t &Val, size_t MaxSize) std::cout << "}" << std::endl;*/ } IDEGeneralizedLCA::l_t -GenConstant::computeTarget(IDEGeneralizedLCA::l_t Source) { +GenConstant::computeTarget(IDEGeneralizedLCA::l_t /*Source*/) { // std::cout << "GenConstant computation (" << source << ")" // << " = " << val << std::endl; - return val; + return Val; } std::shared_ptr> GenConstant::composeWith( @@ -46,42 +46,45 @@ std::shared_ptr> GenConstant::composeWith( return shared_from_this(); } - if (dynamic_cast(SecondFunction.get())) - return SecondFunction; + if (dynamic_cast(SecondFunction.get())) { + return SecondFunction; + } // return std::make_shared(shared_from_this(), - // secondFunction, maxSize); - return std::make_shared(SecondFunction->computeTarget(val), - maxSize); + // secondFunction, MaxSize); + return std::make_shared(SecondFunction->computeTarget(Val), + MaxSize); } std::shared_ptr> GenConstant::joinWith( std::shared_ptr> Other) { - if (auto OtherConst = dynamic_cast(Other.get())) { - switch (compare(val, OtherConst->val)) { + if (const auto *OtherConst = dynamic_cast(Other.get())) { + switch (compare(Val, OtherConst->Val)) { case Ordering::Equal: + [[fallthrough]]; case Ordering::Greater: return shared_from_this(); case Ordering::Less: return Other; default: - return std::make_shared(join(val, OtherConst->val, maxSize), - maxSize); + return std::make_shared(join(Val, OtherConst->Val, MaxSize), + MaxSize); } } - if (AllBot::isBot(Other)) - return AllBot::getInstance(); - return std::make_shared(shared_from_this(), Other, maxSize); + if (AllBot::isBot(Other)) { + return AllBot::getInstance(); + } + return std::make_shared(shared_from_this(), Other, MaxSize); } bool GenConstant::equal_to( std::shared_ptr> Other) const { - if (auto OtherConst = dynamic_cast(Other.get())) { - return val == OtherConst->val && maxSize == OtherConst->maxSize; + if (const auto *OtherConst = dynamic_cast(Other.get())) { + return Val == OtherConst->Val && MaxSize == OtherConst->MaxSize; } return false; -} -void GenConstant::print(std::ostream &OS, bool IsForDebug) const { - OS << "GenConstantEdgeFn(" << val << ")"; +} +void GenConstant::print(std::ostream &OS, bool /*IsForDebug*/) const { + OS << "GenConstantEdgeFn(" << Val << ")"; } } // namespace psr diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/IDEGeneralizedLCA.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/IDEGeneralizedLCA.cpp index 5da4a3d539..d54fb7b0f4 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/IDEGeneralizedLCA.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/IDEGeneralizedLCA.cpp @@ -37,8 +37,8 @@ namespace psr { template >> -inline std::shared_ptr> flow(Fn fn) { - return makeLambdaFlow(std::forward(fn)); +inline std::shared_ptr> flow(Fn Func) { + return makeLambdaFlow(std::forward(Func)); } IDEGeneralizedLCA::IDEGeneralizedLCA( @@ -47,15 +47,15 @@ IDEGeneralizedLCA::IDEGeneralizedLCA( const LLVMBasedICFG *ICF, PointsToInfo *PT, std::set EntryPoints, size_t MaxSetSize) - : IDETabulationProblem(IRDB, TH, ICF, PT, EntryPoints), - maxSetSize(MaxSetSize) { - this->ZeroValue = createZeroValue(); + : IDETabulationProblem(IRDB, TH, ICF, PT, std::move(EntryPoints)), + MaxSetSize(MaxSetSize) { + this->ZeroValue = IDEGeneralizedLCA::createZeroValue(); } // flow functions std::shared_ptr> IDEGeneralizedLCA::getNormalFlowFunction(IDEGeneralizedLCA::n_t Curr, - IDEGeneralizedLCA::n_t Succ) { + IDEGeneralizedLCA::n_t /*Succ*/) { if (const auto *Store = llvm::dyn_cast(Curr)) { const auto *PointerOp = Store->getPointerOperand(); const auto *ValueOp = Store->getValueOperand(); @@ -84,7 +84,8 @@ IDEGeneralizedLCA::getNormalFlowFunction(IDEGeneralizedLCA::n_t Curr, } return {Source}; }); - } else if (const auto *Load = llvm::dyn_cast(Curr)) { + } + if (const auto *Load = llvm::dyn_cast(Curr)) { return flow( [=](IDEGeneralizedLCA::d_t Source) -> std::set { // std::cout << "LOAD " << llvmIRToString(curr) << std::endl; @@ -92,33 +93,35 @@ IDEGeneralizedLCA::getNormalFlowFunction(IDEGeneralizedLCA::n_t Curr, if (Source == Load->getPointerOperand()) { // std::cout << "GEN" << std::endl; return {Source, Load}; - } else { - // std::cout << "ID" << std::endl; - return {Source}; } + // std::cout << "ID" << std::endl; + return {Source}; }); - } else if (const auto *Gep = llvm::dyn_cast(Curr)) { + } + if (const auto *Gep = llvm::dyn_cast(Curr)) { return flow( [=](IDEGeneralizedLCA::d_t Source) -> std::set { - if (Source == Gep->getPointerOperand()) + if (Source == Gep->getPointerOperand()) { return {Source, Gep}; - else - return {Source}; + } + return {Source}; }); - } else if (const auto *Cast = llvm::dyn_cast(Curr); - Cast && - (Cast->getSrcTy()->isIntegerTy() || - Cast->getSrcTy()->isFloatingPointTy()) && - (Cast->getDestTy()->isIntegerTy() || - Cast->getDestTy()->isFloatingPointTy())) { + } + if (const auto *Cast = llvm::dyn_cast(Curr); + Cast && + (Cast->getSrcTy()->isIntegerTy() || + Cast->getSrcTy()->isFloatingPointTy()) && + (Cast->getDestTy()->isIntegerTy() || + Cast->getDestTy()->isFloatingPointTy())) { return flow( [=](IDEGeneralizedLCA::d_t Source) -> std::set { - if (Source == Cast->getOperand(0)) + if (Source == Cast->getOperand(0)) { return {Source, Cast}; - else - return {Source}; + } + return {Source}; }); - } else if (llvm::isa(Curr)) { + } + if (llvm::isa(Curr)) { const auto *Lhs = Curr->getOperand(0); const auto *Rhs = Curr->getOperand(1); bool LeftConst = isConstant(Lhs); @@ -129,10 +132,10 @@ IDEGeneralizedLCA::getNormalFlowFunction(IDEGeneralizedLCA::n_t Curr, return flow( [=](IDEGeneralizedLCA::d_t Source) -> std::set { if (Source == Lhs || Source == Rhs || - ((BothConst || NoneConst) && isZeroValue(Source))) + ((BothConst || NoneConst) && isZeroValue(Source))) { return {Source, Curr}; - else - return {Source}; + } + return {Source}; }); } /*else if (llvm::isa(curr)) { auto op = curr->getOperand(0); @@ -164,7 +167,7 @@ std::shared_ptr> IDEGeneralizedLCA::getRetFlowFunction(IDEGeneralizedLCA::n_t CallSite, IDEGeneralizedLCA::f_t CalleeMthd, IDEGeneralizedLCA::n_t ExitStmt, - IDEGeneralizedLCA::n_t RetSite) { + IDEGeneralizedLCA::n_t /*RetSite*/) { assert(llvm::isa(CallSite)); // std::cout << "Ret flow: " << llvmIRToString(ExitStmt) << std::endl; /*return std::make_shared( @@ -178,8 +181,8 @@ IDEGeneralizedLCA::getRetFlowFunction(IDEGeneralizedLCA::n_t CallSite, std::shared_ptr> IDEGeneralizedLCA::getCallToRetFlowFunction(IDEGeneralizedLCA::n_t CallSite, - IDEGeneralizedLCA::n_t RetSite, - std::set Callees) { + IDEGeneralizedLCA::n_t /*RetSite*/, + std::set /*Callees*/) { // std::cout << "CTR flow: " << llvmIRToString(CallSite) << std::endl; if (const auto *CS = llvm::dyn_cast(CallSite)) { // check for ctor and then demangle function name and check for @@ -207,8 +210,8 @@ IDEGeneralizedLCA::getCallToRetFlowFunction(IDEGeneralizedLCA::n_t CallSite, } std::shared_ptr> -IDEGeneralizedLCA::getSummaryFlowFunction(IDEGeneralizedLCA::n_t CallStmt, - IDEGeneralizedLCA::f_t DestMthd) { +IDEGeneralizedLCA::getSummaryFlowFunction(IDEGeneralizedLCA::n_t /*CallStmt*/, + IDEGeneralizedLCA::f_t /*DestMthd*/) { // std::cout << "Summary flow: " << llvmIRToString(callStmt) << // std::endl; return nullptr; @@ -246,8 +249,8 @@ IDEGeneralizedLCA::d_t IDEGeneralizedLCA::createZeroValue() const { return LLVMZeroValue::getInstance(); } -bool IDEGeneralizedLCA::isZeroValue(IDEGeneralizedLCA::d_t D) const { - return LLVMZeroValue::getInstance()->isLLVMZeroValue(D); +bool IDEGeneralizedLCA::isZeroValue(IDEGeneralizedLCA::d_t Fact) const { + return LLVMZeroValue::getInstance()->isLLVMZeroValue(Fact); } // edge functions @@ -283,17 +286,19 @@ IDEGeneralizedLCA::getNormalEdgeFunction(IDEGeneralizedLCA::n_t Curr, llvm::dyn_cast(GV->getInitializer())) { auto IntConst = CI->getValue(); return std::make_shared( - l_t({EdgeValue(std::move(IntConst))}), maxSetSize); - } else if (const auto *CF = - llvm::dyn_cast(GV->getInitializer())) { + l_t({EdgeValue(std::move(IntConst))}), MaxSetSize); + } + if (const auto *CF = + llvm::dyn_cast(GV->getInitializer())) { auto FPConst = CF->getValueAPF(); return std::make_shared( - l_t({EdgeValue(std::move(FPConst))}), maxSetSize); - } else if (const auto *CS = llvm::dyn_cast( - GV->getInitializer())) { + l_t({EdgeValue(std::move(FPConst))}), MaxSetSize); + } + if (const auto *CS = + llvm::dyn_cast(GV->getInitializer())) { auto StringConst = CS->getAsCString(); return std::make_shared( - l_t({EdgeValue(StringConst.str())}), maxSetSize); + l_t({EdgeValue(StringConst.str())}), MaxSetSize); } } } @@ -319,7 +324,7 @@ IDEGeneralizedLCA::getNormalEdgeFunction(IDEGeneralizedLCA::n_t Curr, // Case I: Storing a constant value. if (isZeroValue(CurrNode) && isConstant(ValueOperand)) { EdgeValue Ev(ValueOperand); - return std::make_shared(l_t({Ev}), maxSetSize); + return std::make_shared(l_t({Ev}), MaxSetSize); } // Case II: Storing an integer typed value. /*if (currNode != succNode && valueOperand->getType()->isIntegerTy()) { @@ -344,41 +349,42 @@ IDEGeneralizedLCA::getNormalEdgeFunction(IDEGeneralizedLCA::n_t Curr, // binary operators if (const auto *BinOp = llvm::dyn_cast(Curr); BinOp && Curr == SuccNode) { - // BinaryEdgeFunction(op, cnst, leftConst, maxSize) + // BinaryEdgeFunction(op, cnst, leftConst, MaxSize) if (isConstant(Curr->getOperand(0))) { EdgeValue Lcnst(Curr->getOperand(0)); if (isConstant(Curr->getOperand(1)) && isZeroValue(CurrNode)) { // Both const EdgeValue Rcnst(Curr->getOperand(1)); auto Ret = // join({lcnst}, {rcnst}); - performBinOp(BinOp->getOpcode(), {Lcnst}, {Rcnst}, maxSetSize); - return std::make_shared(Ret, maxSetSize); - } else { - // only lhs const - return std::make_shared( - BinOp->getOpcode(), l_t({Lcnst}), true, maxSetSize); + performBinOp(BinOp->getOpcode(), {Lcnst}, {Rcnst}, MaxSetSize); + return std::make_shared(Ret, MaxSetSize); } - } else if (!isConstant(Curr->getOperand(1))) { - // none const - return std::make_shared(bottomElement(), maxSetSize); - } else { - // only rhs const - EdgeValue Rcnst(Curr->getOperand(1)); + // only lhs const return std::make_shared( - BinOp->getOpcode(), l_t({Rcnst}), false, maxSetSize); + BinOp->getOpcode(), l_t({Lcnst}), true, MaxSetSize); + } + if (!isConstant(Curr->getOperand(1))) { + // none const + return std::make_shared(bottomElement(), MaxSetSize); } - } else if (auto Cast = llvm::dyn_cast(Curr); - Cast && Curr == SuccNode) { + // only rhs const + EdgeValue Rcnst(Curr->getOperand(1)); + return std::make_shared( + BinOp->getOpcode(), l_t({Rcnst}), false, MaxSetSize); + } + if (const auto *Cast = llvm::dyn_cast(Curr); + Cast && Curr == SuccNode) { if (Cast->getDestTy()->isIntegerTy()) { - auto DestTy = llvm::cast(Cast->getDestTy()); + const auto *DestTy = llvm::cast(Cast->getDestTy()); return std::make_shared( - DestTy->getBitWidth(), EdgeValue::Integer, maxSetSize); - } else if (Cast->getDestTy()->isFloatingPointTy()) { + DestTy->getBitWidth(), EdgeValue::Integer, MaxSetSize); + } + if (Cast->getDestTy()->isFloatingPointTy()) { auto Bits = Cast->getDestTy()->isFloatTy() ? 32 : 64; return std::make_shared( - Bits, EdgeValue::FloatingPoint, maxSetSize); + Bits, EdgeValue::FloatingPoint, MaxSetSize); } } // std::cout << "FallThrough: identity edge fn" << std::endl; @@ -390,7 +396,7 @@ IDEGeneralizedLCA::getCallEdgeFunction(IDEGeneralizedLCA::n_t CallStmt, IDEGeneralizedLCA::d_t SrcNode, IDEGeneralizedLCA::f_t DestinationMethod, IDEGeneralizedLCA::d_t DestNode) { - const llvm::CallBase *CallSite = llvm::cast(CallStmt); + const auto *CallSite = llvm::cast(CallStmt); if (isZeroValue(SrcNode)) { auto Len = std::min(CallSite->getNumArgOperands(), DestinationMethod->arg_size()); @@ -400,7 +406,7 @@ IDEGeneralizedLCA::getCallEdgeFunction(IDEGeneralizedLCA::n_t CallStmt, const auto *ActualArg = CallSite->getArgOperand(I); // if (isConstant(actualArg)) // -> always const, since srcNode is zero return std::make_shared(l_t({EdgeValue(ActualArg)}), - maxSetSize); + MaxSetSize); } } } @@ -408,19 +414,18 @@ IDEGeneralizedLCA::getCallEdgeFunction(IDEGeneralizedLCA::n_t CallStmt, } std::shared_ptr> -IDEGeneralizedLCA::getReturnEdgeFunction(IDEGeneralizedLCA::n_t CallSite, - IDEGeneralizedLCA::f_t CalleeMethod, - IDEGeneralizedLCA::n_t ExitStmt, - IDEGeneralizedLCA::d_t ExitNode, - IDEGeneralizedLCA::n_t ReSite, - IDEGeneralizedLCA::d_t RetNode) { +IDEGeneralizedLCA::getReturnEdgeFunction( + IDEGeneralizedLCA::n_t /*CallSite*/, + IDEGeneralizedLCA::f_t /*CalleeMethod*/, IDEGeneralizedLCA::n_t ExitStmt, + IDEGeneralizedLCA::d_t ExitNode, IDEGeneralizedLCA::n_t /*RetSite*/, + IDEGeneralizedLCA::d_t /*RetNode*/) { if (isZeroValue(ExitNode)) { if (const auto *RetStmt = llvm::dyn_cast(ExitStmt)) { if (RetStmt->getReturnValue() && isConstant(RetStmt->getReturnValue())) { // std::cout << "Constant return value: " // << llvmIRToShortString(exitStmt) << std::endl; return std::make_shared( - l_t({EdgeValue(RetStmt->getReturnValue())}), maxSetSize); + l_t({EdgeValue(RetStmt->getReturnValue())}), MaxSetSize); } } } @@ -433,9 +438,9 @@ IDEGeneralizedLCA::getReturnEdgeFunction(IDEGeneralizedLCA::n_t CallSite, std::shared_ptr> IDEGeneralizedLCA::getCallToRetEdgeFunction( IDEGeneralizedLCA::n_t CallSite, IDEGeneralizedLCA::d_t CallNode, - IDEGeneralizedLCA::n_t RetSite, IDEGeneralizedLCA::d_t RetSiteNode, - std::set Callees) { - const llvm::CallBase *CS = llvm::cast(CallSite); + IDEGeneralizedLCA::n_t /*RetSite*/, IDEGeneralizedLCA::d_t RetSiteNode, + std::set /*Callees*/) { + const auto *CS = llvm::cast(CallSite); // check for ctor and then demangle function name and check for // std::basic_string @@ -443,21 +448,21 @@ IDEGeneralizedLCA::getCallToRetEdgeFunction( // found correct place and time if (CallNode == getZeroValue() && RetSiteNode == CS->getArgOperand(0)) { // find string literal that is used to initialize the string - if (auto User = llvm::dyn_cast(CS->getArgOperand(1))) { - if (auto GV = + if (auto *User = llvm::dyn_cast(CS->getArgOperand(1))) { + if (auto *GV = llvm::dyn_cast(User->getOperand(0))) { if (!GV->hasInitializer()) { // in this case we don't know the initial value statically // return ALLBOTTOM; return std::make_shared>(bottomElement()); } - if (auto CDA = llvm::dyn_cast( + if (auto *CDA = llvm::dyn_cast( GV->getInitializer())) { if (CDA->isCString()) { // here we statically know the string literal the std::string is // initialized with return std::make_shared( - l_t({EdgeValue(CDA->getAsCString().str())}), maxSetSize); + l_t({EdgeValue(CDA->getAsCString().str())}), MaxSetSize); } } } @@ -469,24 +474,24 @@ IDEGeneralizedLCA::getCallToRetEdgeFunction( } std::shared_ptr> -IDEGeneralizedLCA::getSummaryEdgeFunction(IDEGeneralizedLCA::n_t CallStmt, - IDEGeneralizedLCA::d_t CallNode, - IDEGeneralizedLCA::n_t RetSite, - IDEGeneralizedLCA::d_t RetSiteNode) { +IDEGeneralizedLCA::getSummaryEdgeFunction( + IDEGeneralizedLCA::n_t /*CallStmt*/, IDEGeneralizedLCA::d_t /*CallNode*/, + IDEGeneralizedLCA::n_t /*RetSite*/, + IDEGeneralizedLCA::d_t /*RetSiteNode*/) { // return edge-identity return EdgeIdentity::getInstance(); } -IDEGeneralizedLCA::l_t IDEGeneralizedLCA::topElement() { return l_t({}); } +IDEGeneralizedLCA::l_t IDEGeneralizedLCA::topElement() { return {{}}; } IDEGeneralizedLCA::l_t IDEGeneralizedLCA::bottomElement() { - return l_t({EdgeValue::top}); + return l_t({EdgeValue::TopValue}); } IDEGeneralizedLCA::l_t IDEGeneralizedLCA::join(IDEGeneralizedLCA::l_t Lhs, IDEGeneralizedLCA::l_t Rhs) { // sets are passed by value - return psr::join(Lhs, Rhs, maxSetSize); + return psr::join(Lhs, Rhs, MaxSetSize); } std::shared_ptr> @@ -497,24 +502,24 @@ IDEGeneralizedLCA::allTopFunction() { } void IDEGeneralizedLCA::printNode(std::ostream &Os, - IDEGeneralizedLCA::n_t N) const { - Os << llvmIRToString(N); + IDEGeneralizedLCA::n_t Stmt) const { + Os << llvmIRToString(Stmt); } void IDEGeneralizedLCA::printDataFlowFact(std::ostream &Os, - IDEGeneralizedLCA::d_t D) const { - assert(D && "Invalid dataflow fact"); - Os << llvmIRToString(D); + IDEGeneralizedLCA::d_t Fact) const { + assert(Fact && "Invalid dataflow fact"); + Os << llvmIRToString(Fact); } void IDEGeneralizedLCA::printFunction(std::ostream &Os, - IDEGeneralizedLCA::f_t M) const { - Os << M->getName().str(); + IDEGeneralizedLCA::f_t Func) const { + Os << Func->getName().str(); } void IDEGeneralizedLCA::printEdgeFact(std::ostream &Os, - IDEGeneralizedLCA::l_t V) const { - Os << V; + IDEGeneralizedLCA::l_t L) const { + Os << L; } /*void IDEGeneralizedLCA::printIDEReport( @@ -621,7 +626,7 @@ IDEGeneralizedLCA::lca_results_t IDEGeneralizedLCA::getLCAResults( } LCAResult *LcaRes = &FResults[Lnr]; // Check if it is a new result - if (LcaRes->src_code.empty()) { + if (LcaRes->SrcNode.empty()) { std::string SourceCode = getSrcCodeFromIR(Stmt); // Skip results for line containing only closed braces which is the // case for functions with void return value @@ -629,10 +634,10 @@ IDEGeneralizedLCA::lca_results_t IDEGeneralizedLCA::getLCAResults( FResults.erase(Lnr); continue; } - LcaRes->src_code = SourceCode; - LcaRes->line_nr = Lnr; + LcaRes->SrcNode = SourceCode; + LcaRes->LineNo = Lnr; } - LcaRes->ir_trace.push_back(Stmt); + LcaRes->IRTrace.push_back(Stmt); if (Stmt->isTerminator() && !ICF->isExitInst(Stmt)) { std::cout << "Delete result since stmt is Terminator or Exit!\n"; FResults.erase(Lnr); @@ -663,19 +668,19 @@ IDEGeneralizedLCA::lca_results_t IDEGeneralizedLCA::getLCAResults( // lcaRes->variableToValue.end()) { ValidVarsAtStmt.insert(VarName); AllocatedVars.insert(VarName); - LcaRes->variableToValue[VarName] = Res.second; + LcaRes->VariableToValue[VarName] = Res.second; } else if (AllocatedVars.find(VarName) == AllocatedVars.end()) { ValidVarsAtStmt.insert(VarName); - LcaRes->variableToValue[VarName] = Res.second; + LcaRes->VariableToValue[VarName] = Res.second; } } } // remove no longer valid variables at current IR stmt - for (auto It = LcaRes->variableToValue.begin(); - It != LcaRes->variableToValue.end();) { + for (auto It = LcaRes->VariableToValue.begin(); + It != LcaRes->VariableToValue.end();) { if (ValidVarsAtStmt.find(It->first) == ValidVarsAtStmt.end()) { std::cout << "Erase var: " << It->first << '\n'; - It = LcaRes->variableToValue.erase(It); + It = LcaRes->VariableToValue.erase(It); } else { ++It; } @@ -684,7 +689,7 @@ IDEGeneralizedLCA::lca_results_t IDEGeneralizedLCA::getLCAResults( } // delete entries with no result for (auto It = FResults.begin(); It != FResults.end();) { - if (It->second.variableToValue.empty()) { + if (It->second.VariableToValue.empty()) { It = FResults.erase(It); } else { ++It; @@ -696,16 +701,16 @@ IDEGeneralizedLCA::lca_results_t IDEGeneralizedLCA::getLCAResults( } void IDEGeneralizedLCA::LCAResult::print(std::ostream &Os) { - Os << "Line " << line_nr << ": " << src_code << '\n'; + Os << "Line " << LineNo << ": " << SrcNode << '\n'; Os << "Var(s): "; - for (auto It = variableToValue.begin(); It != variableToValue.end(); ++It) { - if (It != variableToValue.begin()) { + for (auto It = VariableToValue.begin(); It != VariableToValue.end(); ++It) { + if (It != VariableToValue.begin()) { Os << ", "; } Os << It->first << " = " << It->second; } Os << "\nCorresponding IR Instructions:\n"; - for (const auto *Ir : ir_trace) { + for (const auto *Ir : IRTrace) { Os << " " << llvmIRToString(Ir) << '\n'; } } diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/JoinEdgeFunction.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/JoinEdgeFunction.cpp index 0895d0334d..94f3cdc62b 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/JoinEdgeFunction.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/JoinEdgeFunction.cpp @@ -17,46 +17,45 @@ namespace psr { JoinEdgeFunction::JoinEdgeFunction( - const std::shared_ptr> &Frst, - const std::shared_ptr> &Scnd, + const std::shared_ptr> &First, + const std::shared_ptr> &Second, size_t MaxSize) - : frst(Frst), scnd(Scnd), maxSize(MaxSize) { + : First(First), Second(Second), MaxSize(MaxSize) { // check for endless recursion // This only used for debug purposes. So you can safely remove it, but you // also may use it, if there are termination problems std::unordered_set *> Seen; - std::vector *> Q = {Frst.get(), - Scnd.get()}; + std::vector *> Q = {First.get(), + Second.get()}; unsigned Ctr = 0; while (!Q.empty()) { - auto Top = Q.back(); + auto *Top = Q.back(); Ctr++; Q.pop_back(); auto Ins = Seen.insert(Top); - if (!Ins.second && + if (Top != nullptr && !Ins.second && !dynamic_cast *>(Top)) { std::cerr << "WARNING: cyclic dependency! @" << Ctr << "#"; Top->print(std::cerr); std::cerr << std::endl; - this->frst = this->scnd = AllBot::getInstance(); + this->First = this->Second = AllBot::getInstance(); break; - } else { - if (auto TopJoin = dynamic_cast(Top)) { - Q.push_back(TopJoin->frst.get()); - Q.push_back(TopJoin->scnd.get()); - } else if (auto TopComp = dynamic_cast(Top)) { - Q.push_back(TopComp->getFirst().get()); - Q.push_back(TopComp->getSecond().get()); - } + } + if (auto *TopJoin = dynamic_cast(Top)) { + Q.push_back(TopJoin->First.get()); + Q.push_back(TopJoin->Second.get()); + } else if (auto *TopComp = dynamic_cast(Top)) { + Q.push_back(TopComp->getFirst().get()); + Q.push_back(TopComp->getSecond().get()); } } } IDEGeneralizedLCA::l_t JoinEdgeFunction::computeTarget(IDEGeneralizedLCA::l_t Source) { - return join(frst->computeTarget(Source), scnd->computeTarget(Source), - maxSize); + return join(First->computeTarget(Source), Second->computeTarget(Source), + MaxSize); } std::shared_ptr> @@ -72,49 +71,51 @@ JoinEdgeFunction::composeWith( return shared_from_this(); } return std::make_shared(shared_from_this(), - SecondFunction, maxSize); + SecondFunction, MaxSize); } std::shared_ptr> JoinEdgeFunction::joinWith( std::shared_ptr> OtherFunction) { - if (OtherFunction.get() == this) + if (OtherFunction.get() == this) { return shared_from_this(); + } if (AllBot::isBot(OtherFunction)) { return AllBot::getInstance(); } return std::make_shared(shared_from_this(), OtherFunction, - maxSize); + MaxSize); } bool JoinEdgeFunction::equal_to( std::shared_ptr> Other) const { - if (this == Other.get()) + if (this == Other.get()) { return true; - if (auto OtherJoin = dynamic_cast(Other.get())) { - return (frst->equal_to(OtherJoin->frst) && - scnd->equal_to(OtherJoin->scnd)) // join is commutative... - || - (frst->equal_to(OtherJoin->scnd) && scnd->equal_to(OtherJoin->frst)); + } + if (auto *OtherJoin = dynamic_cast(Other.get())) { + return (First->equal_to(OtherJoin->First) && + Second->equal_to(OtherJoin->Second)) // join is commutative... + || (First->equal_to(OtherJoin->Second) && + Second->equal_to(OtherJoin->First)); } return false; } -void JoinEdgeFunction::print(std::ostream &OS, bool IsForDebug) const { +void JoinEdgeFunction::print(std::ostream &OS, bool /*IsForDebug*/) const { OS << "JoinEdgeFn["; - frst->print(OS); + First->print(OS); OS << ", "; - scnd->print(OS); + Second->print(OS); OS << "]"; } const std::shared_ptr> & JoinEdgeFunction::getFirst() const { - return frst; + return First; } const std::shared_ptr> & JoinEdgeFunction::getSecond() const { - return scnd; + return Second; } } // namespace psr diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/LCAEdgeFunctionComposer.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/LCAEdgeFunctionComposer.cpp index 526a135e83..641fa9ae13 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/LCAEdgeFunctionComposer.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/LCAEdgeFunctionComposer.cpp @@ -27,7 +27,7 @@ EdgeFunctionComposer::computeTarget(IDEGeneralizedLCA::l_t source) { LCAEdgeFunctionComposer::LCAEdgeFunctionComposer( std::shared_ptr> F, std::shared_ptr> G, size_t MaxSize) - : EdgeFunctionComposer(F, G), maxSize(MaxSize) {} + : EdgeFunctionComposer(F, G), MaxSize(MaxSize) {} std::shared_ptr> LCAEdgeFunctionComposer::composeWith( @@ -69,7 +69,7 @@ LCAEdgeFunctionComposer::joinWith( return AllBot::getInstance(); } return std::make_shared(shared_from_this(), OtherFunction, - maxSize); + MaxSize); } const std::shared_ptr> & diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/MapFactsToCallerFlowFunction.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/MapFactsToCallerFlowFunction.cpp index a2ef62e198..55fbe7b5c6 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/MapFactsToCallerFlowFunction.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/MapFactsToCallerFlowFunction.cpp @@ -36,7 +36,7 @@ MapFactsToCallerFlowFunction::computeTargets(const llvm::Value *Source) { std::set Res; // Handle C-style varargs functions if (Callee->isVarArg() && !Callee->isDeclaration()) { - const llvm::Instruction *AllocVarArg; + const llvm::Instruction *AllocVarArg = nullptr; // Find the allocation of %struct.__va_list_tag for (const auto &BB : *Callee) { for (const auto &I : BB) { @@ -54,7 +54,8 @@ MapFactsToCallerFlowFunction::computeTargets(const llvm::Value *Source) { } } // Generate the varargs things by using an over-approximation - if (Source == AllocVarArg && Source->getType()->isPointerTy()) { + if (Source != nullptr && Source == AllocVarArg && + Source->getType()->isPointerTy()) { for (unsigned Idx = Formals.size(); Idx < Actuals.size(); ++Idx) { Res.insert(Actuals[Idx]); } diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/TypecastEdgeFunction.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/TypecastEdgeFunction.cpp index 7ee2089788..9000fc67bf 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/TypecastEdgeFunction.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/TypecastEdgeFunction.cpp @@ -15,38 +15,40 @@ namespace psr { IDEGeneralizedLCA::l_t TypecastEdgeFunction::computeTarget(IDEGeneralizedLCA::l_t Source) { - return performTypecast(Source, dest, bits); + return performTypecast(Source, Dest, Bits); } std::shared_ptr> TypecastEdgeFunction::composeWith( std::shared_ptr> SecondFunction) { - if (dynamic_cast *>(SecondFunction.get())) + if (dynamic_cast *>(SecondFunction.get())) { return shared_from_this(); + } return std::make_shared(shared_from_this(), - SecondFunction, maxSize); + SecondFunction, MaxSize); } std::shared_ptr> TypecastEdgeFunction::joinWith( std::shared_ptr> OtherFunction) { return std::make_shared(shared_from_this(), OtherFunction, - maxSize); + MaxSize); } bool TypecastEdgeFunction::equal_to( std::shared_ptr> Other) const { - if (this == Other.get()) + if (this == Other.get()) { return true; - if (auto OtherTC = dynamic_cast(Other.get())) { - return bits == OtherTC->bits && dest == OtherTC->dest; + } + if (const auto *OtherTC = dynamic_cast(Other.get())) { + return Bits == OtherTC->Bits && Dest == OtherTC->Dest; } return false; } -void TypecastEdgeFunction::print(std::ostream &OS, bool IsForDebug) const { - OS << "TypecastEdgeFn[to=" << EdgeValue::typeToString(dest) - << "; bits=" << bits << "]"; +void TypecastEdgeFunction::print(std::ostream &OS, bool /*IsForDebug*/) const { + OS << "TypecastEdgeFn[to=" << EdgeValue::typeToString(Dest) + << "; bits=" << Bits << "]"; } } // namespace psr diff --git a/unittests/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCATest.cpp b/unittests/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCATest.cpp index 3c9d1e3d79..cf3e627055 100644 --- a/unittests/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCATest.cpp +++ b/unittests/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCATest.cpp @@ -35,7 +35,7 @@ typedef std::tuple class IDEGeneralizedLCATest : public ::testing::Test { protected: - const std::string pathToLLFiles = + const std::string PathToLLFiles = unittest::PathToLLTestFiles + "general_linear_constant/"; std::unique_ptr IRDB; @@ -48,9 +48,9 @@ class IDEGeneralizedLCATest : public ::testing::Test { IDEGeneralizedLCATest() {} virtual ~IDEGeneralizedLCATest() {} - void Initialize(const std::string &llFile, size_t maxSetSize = 2) { + void initialize(const std::string &LLFile, size_t MaxSetSize = 2) { IRDB = std::make_unique( - std::vector{pathToLLFiles + llFile}, IRDBOptions::WPA); + std::vector{PathToLLFiles + LLFile}, IRDBOptions::WPA); TH = std::make_unique(*IRDB); PT = std::make_unique(*IRDB); ICFG = std::make_unique(*IRDB, CallGraphAnalysisType::RTA, @@ -58,9 +58,9 @@ class IDEGeneralizedLCATest : public ::testing::Test { TH.get(), PT.get()); LCAProblem = std::make_unique( IRDB.get(), TH.get(), ICFG.get(), PT.get(), - std::set{"main"}, maxSetSize); + std::set{"main"}, MaxSetSize); LCASolver = - std::make_unique>(*LCAProblem.get()); + std::make_unique>(*LCAProblem); LCASolver->solve(); } @@ -75,102 +75,102 @@ class IDEGeneralizedLCATest : public ::testing::Test { // compare results /// \brief compares the computed results with every given tuple (value, /// alloca, inst) - void compareResults(const std::vector &expected) { - for (auto &[val, vrId, instId] : expected) { - auto vr = IRDB->getInstruction(vrId); - auto inst = IRDB->getInstruction(instId); - ASSERT_NE(nullptr, vr); - ASSERT_NE(nullptr, inst); - auto result = LCASolver->resultAt(inst, vr); - std::ostringstream ss; - LCASolver->dumpResults(ss); - EXPECT_EQ(val, result) - << "vr:" << vrId << " inst:" << instId << " LCASolver:" << ss.str(); + void compareResults(const std::vector &Expected) { + for (const auto &[EVal, VrId, InstId] : Expected) { + auto *Vr = IRDB->getInstruction(VrId); + auto *Inst = IRDB->getInstruction(InstId); + ASSERT_NE(nullptr, Vr); + ASSERT_NE(nullptr, Inst); + auto Result = LCASolver->resultAt(Inst, Vr); + std::ostringstream SStr; + LCASolver->dumpResults(SStr); + EXPECT_EQ(EVal, Result) + << "vr:" << VrId << " inst:" << InstId << " LCASolver:" << SStr.str(); } } }; // class Fixture TEST_F(IDEGeneralizedLCATest, SimpleTest) { - Initialize("SimpleTest_c.ll"); - std::vector groundTruth; - groundTruth.push_back({{EdgeValue(10)}, 3, 20}); - groundTruth.push_back({{EdgeValue(15)}, 4, 20}); - compareResults(groundTruth); + initialize("SimpleTest_c.ll"); + std::vector GroundTruth; + GroundTruth.push_back({{EdgeValue(10)}, 3, 20}); + GroundTruth.push_back({{EdgeValue(15)}, 4, 20}); + compareResults(GroundTruth); } TEST_F(IDEGeneralizedLCATest, BranchTest) { - Initialize("BranchTest_c.ll"); - std::vector groundTruth; - groundTruth.push_back({{EdgeValue(25), EdgeValue(43)}, 3, 22}); - groundTruth.push_back({{EdgeValue(24)}, 4, 22}); - compareResults(groundTruth); + initialize("BranchTest_c.ll"); + std::vector GroundTruth; + GroundTruth.push_back({{EdgeValue(25), EdgeValue(43)}, 3, 22}); + GroundTruth.push_back({{EdgeValue(24)}, 4, 22}); + compareResults(GroundTruth); } TEST_F(IDEGeneralizedLCATest, FPtest) { - Initialize("FPtest_c.ll"); - std::vector groundTruth; - groundTruth.push_back({{EdgeValue(4.5)}, 1, 16}); - groundTruth.push_back({{EdgeValue(2.0)}, 2, 16}); - compareResults(groundTruth); + initialize("FPtest_c.ll"); + std::vector GroundTruth; + GroundTruth.push_back({{EdgeValue(4.5)}, 1, 16}); + GroundTruth.push_back({{EdgeValue(2.0)}, 2, 16}); + compareResults(GroundTruth); } TEST_F(IDEGeneralizedLCATest, StringTest) { - Initialize("StringTest_c.ll"); - std::vector groundTruth; - groundTruth.push_back({{EdgeValue("Hello, World")}, 2, 8}); - groundTruth.push_back({{EdgeValue("Hello, World")}, 3, 8}); - compareResults(groundTruth); + initialize("StringTest_c.ll"); + std::vector GroundTruth; + GroundTruth.push_back({{EdgeValue("Hello, World")}, 2, 8}); + GroundTruth.push_back({{EdgeValue("Hello, World")}, 3, 8}); + compareResults(GroundTruth); } TEST_F(IDEGeneralizedLCATest, StringBranchTest) { - Initialize("StringBranchTest_c.ll"); - std::vector groundTruth; - groundTruth.push_back( + initialize("StringBranchTest_c.ll"); + std::vector GroundTruth; + GroundTruth.push_back( {{EdgeValue("Hello, World"), EdgeValue("Hello Hello")}, 3, 15}); - groundTruth.push_back({{EdgeValue("Hello Hello")}, 4, 15}); - compareResults(groundTruth); + GroundTruth.push_back({{EdgeValue("Hello Hello")}, 4, 15}); + compareResults(GroundTruth); } TEST_F(IDEGeneralizedLCATest, StringTestCpp) { - Initialize("StringTest_cpp.ll"); - std::vector groundTruth; - const auto *lastMainInstrution = + initialize("StringTest_cpp.ll"); + std::vector GroundTruth; + const auto *LastMainInstruction = getLastInstructionOf(IRDB->getFunction("main")); - groundTruth.push_back({{EdgeValue("Hello, World")}, + GroundTruth.push_back({{EdgeValue("Hello, World")}, 2, - std::stoi(getMetaDataID(lastMainInstrution))}); - compareResults(groundTruth); + std::stoi(getMetaDataID(LastMainInstruction))}); + compareResults(GroundTruth); } TEST_F(IDEGeneralizedLCATest, FloatDivisionTest) { - Initialize("FloatDivision_c.ll"); - std::vector groundTruth; - groundTruth.push_back({{EdgeValue(nullptr)}, 1, 24}); // i - groundTruth.push_back({{EdgeValue(1.0)}, 2, 24}); // j - groundTruth.push_back({{EdgeValue(-7.0)}, 3, 24}); // k - compareResults(groundTruth); + initialize("FloatDivision_c.ll"); + std::vector GroundTruth; + GroundTruth.push_back({{EdgeValue(nullptr)}, 1, 24}); // i + GroundTruth.push_back({{EdgeValue(1.0)}, 2, 24}); // j + GroundTruth.push_back({{EdgeValue(-7.0)}, 3, 24}); // k + compareResults(GroundTruth); } TEST_F(IDEGeneralizedLCATest, SimpleFunctionTest) { - Initialize("SimpleFunctionTest_c.ll"); - std::vector groundTruth; - groundTruth.push_back({{EdgeValue(48)}, 10, 31}); // i - groundTruth.push_back({{EdgeValue(nullptr)}, 11, 31}); // j - compareResults(groundTruth); + initialize("SimpleFunctionTest_c.ll"); + std::vector GroundTruth; + GroundTruth.push_back({{EdgeValue(48)}, 10, 31}); // i + GroundTruth.push_back({{EdgeValue(nullptr)}, 11, 31}); // j + compareResults(GroundTruth); } TEST_F(IDEGeneralizedLCATest, GlobalVariableTest) { - Initialize("GlobalVariableTest_c.ll"); - std::vector groundTruth; - groundTruth.push_back({{EdgeValue(50)}, 7, 13}); // i - groundTruth.push_back({{EdgeValue(8)}, 10, 13}); // j - compareResults(groundTruth); + initialize("GlobalVariableTest_c.ll"); + std::vector GroundTruth; + GroundTruth.push_back({{EdgeValue(50)}, 7, 13}); // i + GroundTruth.push_back({{EdgeValue(8)}, 10, 13}); // j + compareResults(GroundTruth); } TEST_F(IDEGeneralizedLCATest, Imprecision) { // bl::core::get()->set_logging_enabled(true); - Initialize("Imprecision_c.ll", 2); + initialize("Imprecision_c.ll", 2); // auto xInst = IRDB->getInstruction(0); // foo.x // auto yInst = IRDB->getInstruction(1); // foo.y // auto barInst = IRDB->getInstruction(7); @@ -179,24 +179,24 @@ TEST_F(IDEGeneralizedLCATest, Imprecision) { // std::endl; std::cout << "foo.y = " << LCASolver->resultAt(barInst, yInst) // << std::endl; - std::vector groundTruth; - groundTruth.push_back({{EdgeValue(1), EdgeValue(2)}, 0, 7}); // i - groundTruth.push_back({{EdgeValue(2), EdgeValue(3)}, 1, 7}); // j - compareResults(groundTruth); + std::vector GroundTruth; + GroundTruth.push_back({{EdgeValue(1), EdgeValue(2)}, 0, 7}); // i + GroundTruth.push_back({{EdgeValue(2), EdgeValue(3)}, 1, 7}); // j + compareResults(GroundTruth); } TEST_F(IDEGeneralizedLCATest, ReturnConstTest) { - Initialize("ReturnConstTest_c.ll"); - std::vector groundTruth; - groundTruth.push_back({{EdgeValue(43)}, 7, 8}); // i - compareResults(groundTruth); + initialize("ReturnConstTest_c.ll"); + std::vector GroundTruth; + GroundTruth.push_back({{EdgeValue(43)}, 7, 8}); // i + compareResults(GroundTruth); } TEST_F(IDEGeneralizedLCATest, NullTest) { - Initialize("NullTest_c.ll"); - std::vector groundTruth; - groundTruth.push_back({{EdgeValue("")}, 4, 5}); // foo(null) - compareResults(groundTruth); + initialize("NullTest_c.ll"); + std::vector GroundTruth; + GroundTruth.push_back({{EdgeValue("")}, 4, 5}); // foo(null) + compareResults(GroundTruth); } int main(int argc, char **argv) { From 84b29c241ee9f83bfab245b366db66a1ec7f7713 Mon Sep 17 00:00:00 2001 From: Florian Sattler Date: Fri, 24 Dec 2021 14:42:29 +0100 Subject: [PATCH 2/4] Fixes formatting and lineendings --- .../Problems/IDEGeneralizedLCA/EdgeValue.cpp | 270 +++++++++--------- 1 file changed, 135 insertions(+), 135 deletions(-) diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp index 24575115e9..9d9b57812c 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp @@ -22,26 +22,26 @@ namespace psr { std::ostream &printSemantics(const llvm::APFloat &Fl) { if (&Fl.getSemantics() == &llvm::APFloat::IEEEdouble()) { return std::cout << "IEEEdouble"; - } + } if (&Fl.getSemantics() == &llvm::APFloat::IEEEhalf()) { return std::cout << "IEEEhalf"; - } + } if (&Fl.getSemantics() == &llvm::APFloat::IEEEquad()) { return std::cout << "IEEEquad"; - } + } if (&Fl.getSemantics() == &llvm::APFloat::IEEEsingle()) { return std::cout << "IEEEsingle"; - } + } if (&Fl.getSemantics() == &llvm::APFloat::PPCDoubleDouble()) { return std::cout << "PPCDoubleDouble"; - } + } if (&Fl.getSemantics() == &llvm::APFloat::x87DoubleExtended()) { return std::cout << "x87DoubleExtended"; - } + } if (&Fl.getSemantics() == &llvm::APFloat::Bogus()) { return std::cout << "Bogus"; - } - return std::cout << "Sth else"; + } + return std::cout << "Sth else"; } const EdgeValue EdgeValue::TopValue = EdgeValue(nullptr); @@ -50,7 +50,7 @@ EdgeValue::EdgeValue(const llvm::Value *Val) : VariantType(Top) { if (const auto *Const = llvm::dyn_cast(Val)) { if (Const->getType()->isIntegerTy()) { VariantType = Integer; - ValVariant = + ValVariant = llvm::APInt(llvm::cast(Const)->getValue()); } else if (Const->getType()->isFloatingPointTy()) { VariantType = FloatingPoint; @@ -123,7 +123,7 @@ EdgeValue::EdgeValue(const llvm::APInt &Vi) : VariantType(EdgeValue::Integer) { ValVariant = llvm::APInt(Vi); } -EdgeValue::EdgeValue(llvm::APFloat &&Vf) +EdgeValue::EdgeValue(llvm::APFloat &&Vf) : VariantType(EdgeValue::FloatingPoint) { llvm::APFloat Fp = llvm::APFloat(std::move(Vf)); bool Unused; @@ -155,7 +155,7 @@ EdgeValue::EdgeValue(std::string &&Vs) : VariantType(EdgeValue::String) { EdgeValue::EdgeValue(std::nullptr_t) : VariantType(EdgeValue::Top) {} bool EdgeValue::tryGetInt(uint64_t &Res) const { if (VariantType != Integer) { - return false; + return false; } Res = std::get(ValVariant).getLimitedValue(); return true; @@ -163,7 +163,7 @@ bool EdgeValue::tryGetInt(uint64_t &Res) const { bool EdgeValue::tryGetFP(double &Res) const { if (VariantType != FloatingPoint) { - return false; + return false; } Res = std::get(ValVariant).convertToDouble(); return true; @@ -171,7 +171,7 @@ bool EdgeValue::tryGetFP(double &Res) const { bool EdgeValue::tryGetString(std::string &Res) const { if (VariantType != String) { - return false; + return false; } Res = std::get(ValVariant); return true; @@ -213,11 +213,11 @@ bool operator==(const EdgeValue &Lhs, const EdgeValue &Rhs) { case EdgeValue::Integer: // if (v1.value.asInt != v2.value.asInt) // std::cout << "integer unequal" << std::endl; - return std::get(Lhs.ValVariant) == + return std::get(Lhs.ValVariant) == std::get(Rhs.ValVariant); case EdgeValue::FloatingPoint: { // std::cout << "compare floating points" << std::endl; - auto Cp = std::get(Lhs.ValVariant) + auto Cp = std::get(Lhs.ValVariant) .compare(std::get(Rhs.ValVariant)); if (Cp == llvm::APFloat::cmpResult::cmpEqual) { // std::cout << "FP equal" << std::endl; @@ -233,7 +233,7 @@ bool operator==(const EdgeValue &Lhs, const EdgeValue &Rhs) { case EdgeValue::String: // if (v1.value.asString != v2.value.asString) // std::cout << "String unequal" << std::endl; - return std::get(Lhs.ValVariant) == + return std::get(Lhs.ValVariant) == std::get(Rhs.ValVariant); default: // will not happen std::cerr << "FATAL ERROR" << std::endl; @@ -248,17 +248,17 @@ bool EdgeValue::sqSubsetEq(const EdgeValue &Other) const { // binary operators EdgeValue operator+(const EdgeValue &Lhs, const EdgeValue &Rhs) { if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; + return {nullptr}; } switch (Lhs.VariantType) { case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) + + return {std::get(Lhs.ValVariant) + std::get(Rhs.ValVariant)}; case EdgeValue::FloatingPoint: - return {std::get(Lhs.ValVariant) + + return {std::get(Lhs.ValVariant) + std::get(Rhs.ValVariant)}; case EdgeValue::String: - return {std::get(Lhs.ValVariant) + + return {std::get(Lhs.ValVariant) + std::get(Rhs.ValVariant)}; default: return {nullptr}; @@ -267,16 +267,16 @@ EdgeValue operator+(const EdgeValue &Lhs, const EdgeValue &Rhs) { EdgeValue operator-(const EdgeValue &Lhs, const EdgeValue &Rhs) { if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; + return {nullptr}; } switch (Lhs.VariantType) { case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) - + return {std::get(Lhs.ValVariant) - std::get(Lhs.ValVariant)}; case EdgeValue::FloatingPoint: // printSemantics(v1.value.asFP) << " <=> "; // printSemantics(v2.value.asFP) << std::endl; - return {std::get(Lhs.ValVariant) - + return {std::get(Lhs.ValVariant) - std::get(Rhs.ValVariant)}; default: return {nullptr}; @@ -285,14 +285,14 @@ EdgeValue operator-(const EdgeValue &Lhs, const EdgeValue &Rhs) { EdgeValue operator*(const EdgeValue &Lhs, const EdgeValue &Rhs) { if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; + return {nullptr}; } switch (Lhs.VariantType) { case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) * + return {std::get(Lhs.ValVariant) * std::get(Rhs.ValVariant)}; case EdgeValue::FloatingPoint: - return {std::get(Lhs.ValVariant) * + return {std::get(Lhs.ValVariant) * std::get(Rhs.ValVariant)}; default: return {nullptr}; @@ -301,14 +301,14 @@ EdgeValue operator*(const EdgeValue &Lhs, const EdgeValue &Rhs) { EdgeValue operator/(const EdgeValue &Lhs, const EdgeValue &Rhs) { if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; + return {nullptr}; } switch (Lhs.VariantType) { case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) + return {std::get(Lhs.ValVariant) .sdiv(std::get(Rhs.ValVariant))}; case EdgeValue::FloatingPoint: - return {std::get(Lhs.ValVariant) / + return {std::get(Lhs.ValVariant) / std::get(Rhs.ValVariant)}; default: return {nullptr}; @@ -317,11 +317,11 @@ EdgeValue operator/(const EdgeValue &Lhs, const EdgeValue &Rhs) { EdgeValue operator%(const EdgeValue &Lhs, const EdgeValue &Rhs) { if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; + return {nullptr}; } switch (Lhs.VariantType) { case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) + return {std::get(Lhs.ValVariant) .srem(std::get(Rhs.ValVariant))}; case EdgeValue::FloatingPoint: { llvm::APFloat Fl = std::get(Lhs.ValVariant); @@ -335,11 +335,11 @@ EdgeValue operator%(const EdgeValue &Lhs, const EdgeValue &Rhs) { EdgeValue operator&(const EdgeValue &Lhs, const EdgeValue &Rhs) { if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; + return {nullptr}; } switch (Lhs.VariantType) { case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) & + return {std::get(Lhs.ValVariant) & std::get(Rhs.ValVariant)}; default: return {nullptr}; @@ -348,11 +348,11 @@ EdgeValue operator&(const EdgeValue &Lhs, const EdgeValue &Rhs) { EdgeValue operator|(const EdgeValue &Lhs, const EdgeValue &Rhs) { if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; + return {nullptr}; } switch (Lhs.VariantType) { case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) | + return {std::get(Lhs.ValVariant) | std::get(Rhs.ValVariant)}; default: return {nullptr}; @@ -361,11 +361,11 @@ EdgeValue operator|(const EdgeValue &Lhs, const EdgeValue &Rhs) { EdgeValue operator^(const EdgeValue &Lhs, const EdgeValue &Rhs) { if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; + return {nullptr}; } switch (Lhs.VariantType) { case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) ^ + return {std::get(Lhs.ValVariant) ^ std::get(Rhs.ValVariant)}; default: return {nullptr}; @@ -374,23 +374,23 @@ EdgeValue operator^(const EdgeValue &Lhs, const EdgeValue &Rhs) { EdgeValue operator<<(const EdgeValue &Lhs, const EdgeValue &Rhs) { if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; + return {nullptr}; } switch (Lhs.VariantType) { case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) + return {std::get(Lhs.ValVariant) << std::get(Rhs.ValVariant)}; default: return {nullptr}; } -} +} EdgeValue operator>>(const EdgeValue &Lhs, const EdgeValue &Rhs) { if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; + return {nullptr}; } switch (Lhs.VariantType) { case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) + return {std::get(Lhs.ValVariant) .ashr(std::get(Rhs.ValVariant))}; default: return {nullptr}; @@ -400,14 +400,14 @@ EdgeValue operator>>(const EdgeValue &Lhs, const EdgeValue &Rhs) { // unary operators EdgeValue EdgeValue::operator-() const { if (VariantType == Integer) { - return {-std::get(ValVariant)}; + return {-std::get(ValVariant)}; } return {nullptr}; } EdgeValue EdgeValue::operator~() const { if (VariantType == Integer) { - return {~std::get(ValVariant)}; + return {~std::get(ValVariant)}; } return {nullptr}; } @@ -420,7 +420,7 @@ int EdgeValue::compare(const EdgeValue &Lhs, const EdgeValue &Rhs) { double RhsvalFp; if (Rhs.tryGetInt(Rhsval)) { return Lhsval - Rhsval; - } + } if (Rhs.tryGetFP(RhsvalFp)) { return Lhsval < RhsvalFp ? -1 : (Lhsval > RhsvalFp ? 1 : 0); } @@ -433,7 +433,7 @@ int EdgeValue::compare(const EdgeValue &Lhs, const EdgeValue &Rhs) { bool IsInt = Rhs.tryGetInt(Rhsval); if (IsInt || Rhs.tryGetFP(RhsvalFp)) { if (IsInt) { - RhsvalFp = Rhsval; + RhsvalFp = Rhsval; } return Lhsval < RhsvalFp ? -1 : (Lhsval > RhsvalFp ? 1 : 0); @@ -480,14 +480,14 @@ EdgeValue EdgeValue::typecast(Type Dest, unsigned Bits) const { switch (VariantType) { case Integer: if (std::get(ValVariant).getBitWidth() <= Bits) { - return *this; - } + return *this; + } return {std::get(ValVariant) & ((1 << Bits) - 1)}; case FloatingPoint: { bool Unused; llvm::APSInt Ai; - std::get(ValVariant) - .convertToInteger(Ai, llvm::APFloat::roundingMode::NearestTiesToEven, + std::get(ValVariant) + .convertToInteger(Ai, llvm::APFloat::roundingMode::NearestTiesToEven, &Unused); return {Ai}; } @@ -498,8 +498,8 @@ EdgeValue EdgeValue::typecast(Type Dest, unsigned Bits) const { switch (VariantType) { case Integer: if (Bits > 32) { - return {(double)std::get(ValVariant).getSExtValue()}; - } + return {(double)std::get(ValVariant).getSExtValue()}; + } return {(float)std::get(ValVariant).getSExtValue()}; case FloatingPoint: return *this; @@ -526,11 +526,11 @@ EdgeValue EdgeValue::performBinOp(llvm::BinaryOperator::BinaryOps Op, return *this / Other; case llvm::BinaryOperator::BinaryOps::LShr: { if (VariantType != Other.VariantType) { - return {nullptr}; + return {nullptr}; } switch (VariantType) { case EdgeValue::Integer: - return {std::get(ValVariant) + return {std::get(ValVariant) .lshr(std::get(Other.ValVariant))}; default: return {nullptr}; @@ -551,11 +551,11 @@ EdgeValue EdgeValue::performBinOp(llvm::BinaryOperator::BinaryOps Op, return *this - Other; case llvm::BinaryOperator::BinaryOps::UDiv: { if (VariantType != Other.VariantType) { - return {nullptr}; + return {nullptr}; } switch (VariantType) { case EdgeValue::Integer: - return {std::get(ValVariant) + return {std::get(ValVariant) .udiv(std::get(Other.ValVariant))}; default: return {nullptr}; @@ -563,11 +563,11 @@ EdgeValue EdgeValue::performBinOp(llvm::BinaryOperator::BinaryOps Op, } case llvm::BinaryOperator::BinaryOps::URem: { if (VariantType != Other.VariantType) { - return {nullptr}; + return {nullptr}; } switch (VariantType) { case EdgeValue::Integer: - return {std::get(ValVariant) + return {std::get(ValVariant) .urem(std::get(Other.ValVariant))}; default: return {nullptr}; @@ -612,85 +612,85 @@ ev_t performTypecast(const ev_t &Ev, EdgeValue::Type Dest, unsigned Bits) { for (const auto &V : Ev) { auto Tc = V.typecast(Dest, Bits); if (Tc.isTop()) { - return ev_t({{nullptr}}); - } + return ev_t({{nullptr}}); + } Ret.insert(Tc); } - return Ret; -} - -Ordering compare(const ev_t &Lhs, const ev_t &Rhs) { - const auto &Smaller = Lhs.size() <= Rhs.size() ? Lhs : Rhs; - const auto &Larger = Lhs.size() > Rhs.size() ? Lhs : Rhs; - - for (const auto &Elem : Smaller) { - if (!Larger.count(Elem)) { - return Ordering::Incomparable; - } - } - return Lhs.size() == Rhs.size() - ? Ordering::Equal - : (&Smaller == &Lhs ? Ordering::Less : Ordering::Greater); -} - -ev_t join(const ev_t &Lhs, const ev_t &Rhs, size_t MaxSize) { - // std::cout << "Join " << v1 << " and " << v2 << std::endl; - if (isTopValue(Lhs) || isTopValue(Rhs)) { - // std::cout << "\t=> " << std::endl; - return {{nullptr}}; - } - ev_t Ret(Lhs.begin(), Lhs.end()); - - for (const auto &Elem : Rhs) { - Ret.insert(Elem); - if (Ret.size() > MaxSize) { - // std::cout << "\t=> " << std::endl; - return {{nullptr}}; - } - } - // std::cout << "\t=> " << ret << std::endl; - - return Ret; -} - -bool isTopValue(const ev_t &V) { return V.size() == 1 && V.begin()->isTop(); } -std::ostream &operator<<(std::ostream &Os, const ev_t &V) { - Os << "{"; - bool First = true; - for (const auto &Elem : V) { - if (First) { - First = false; - } else { - Os << ", "; - } - Os << Elem; - } - return Os << "}"; -} - -bool operator<(const ev_t &Lhs, const ev_t &Rhs) { - if (Lhs.size() >= Rhs.size()) { - return Lhs != Rhs && (Lhs.empty() || Rhs == ev_t({EdgeValue::TopValue})); - } - for (const auto &Elem : Lhs) { - if (!Rhs.count(Elem)) { - return false; - } - } - return true; -} - -std::string EdgeValue::typeToString(Type Ty) { - switch (Ty) { - case Integer: - return "Integer"; - case FloatingPoint: - return "FloatingPoint"; - case String: - return "String"; - default: - return "Top"; - } + return Ret; +} + +Ordering compare(const ev_t &Lhs, const ev_t &Rhs) { + const auto &Smaller = Lhs.size() <= Rhs.size() ? Lhs : Rhs; + const auto &Larger = Lhs.size() > Rhs.size() ? Lhs : Rhs; + + for (const auto &Elem : Smaller) { + if (!Larger.count(Elem)) { + return Ordering::Incomparable; + } + } + return Lhs.size() == Rhs.size() + ? Ordering::Equal + : (&Smaller == &Lhs ? Ordering::Less : Ordering::Greater); +} + +ev_t join(const ev_t &Lhs, const ev_t &Rhs, size_t MaxSize) { + // std::cout << "Join " << v1 << " and " << v2 << std::endl; + if (isTopValue(Lhs) || isTopValue(Rhs)) { + // std::cout << "\t=> " << std::endl; + return {{nullptr}}; + } + ev_t Ret(Lhs.begin(), Lhs.end()); + + for (const auto &Elem : Rhs) { + Ret.insert(Elem); + if (Ret.size() > MaxSize) { + // std::cout << "\t=> " << std::endl; + return {{nullptr}}; + } + } + // std::cout << "\t=> " << ret << std::endl; + + return Ret; +} + +bool isTopValue(const ev_t &V) { return V.size() == 1 && V.begin()->isTop(); } +std::ostream &operator<<(std::ostream &Os, const ev_t &V) { + Os << "{"; + bool First = true; + for (const auto &Elem : V) { + if (First) { + First = false; + } else { + Os << ", "; + } + Os << Elem; + } + return Os << "}"; +} + +bool operator<(const ev_t &Lhs, const ev_t &Rhs) { + if (Lhs.size() >= Rhs.size()) { + return Lhs != Rhs && (Lhs.empty() || Rhs == ev_t({EdgeValue::TopValue})); + } + for (const auto &Elem : Lhs) { + if (!Rhs.count(Elem)) { + return false; + } + } + return true; +} + +std::string EdgeValue::typeToString(Type Ty) { + switch (Ty) { + case Integer: + return "Integer"; + case FloatingPoint: + return "FloatingPoint"; + case String: + return "String"; + default: + return "Top"; + } } } // namespace psr From 855e176204bd889b0cd8cf16c4e32f5c62d4464f Mon Sep 17 00:00:00 2001 From: Florian Sattler Date: Fri, 24 Dec 2021 14:45:32 +0100 Subject: [PATCH 3/4] Remove windows lineendings --- .../Problems/IDEGeneralizedLCA/EdgeValue.h | 232 +-- .../Problems/IDEGeneralizedLCA/EdgeValue.cpp | 1392 ++++++++--------- 2 files changed, 812 insertions(+), 812 deletions(-) diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.h index 6a6c393d8d..a6bd86da32 100644 --- a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.h +++ b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.h @@ -1,125 +1,125 @@ -/****************************************************************************** - * Copyright (c) 2020 Fabian Schiebel. - * All rights reserved. This program and the accompanying materials are made - * available under the terms of LICENSE.txt. - * - * Contributors: - * Fabian Schiebel, Alexander Meinhold and others - *****************************************************************************/ - -#ifndef PHASAR_PHASARLLVM_IFDSIDE_PROBLEMS_IDEGENERALIZEDLCA_EDGEVALUE_H_ -#define PHASAR_PHASARLLVM_IFDSIDE_PROBLEMS_IDEGENERALIZEDLCA_EDGEVALUE_H_ - -#include -#include -#include -#include - -#include "llvm/ADT/APSInt.h" -#include "llvm/ADT/Twine.h" -#include "llvm/IR/Constant.h" -#include "llvm/IR/Instructions.h" - -namespace psr { - -enum class Ordering { Less, Greater, Equal, Incomparable }; - -class EdgeValue { -public: - enum Type { Top, Integer, String, FloatingPoint }; - -private: +/****************************************************************************** + * Copyright (c) 2020 Fabian Schiebel. + * All rights reserved. This program and the accompanying materials are made + * available under the terms of LICENSE.txt. + * + * Contributors: + * Fabian Schiebel, Alexander Meinhold and others + *****************************************************************************/ + +#ifndef PHASAR_PHASARLLVM_IFDSIDE_PROBLEMS_IDEGENERALIZEDLCA_EDGEVALUE_H_ +#define PHASAR_PHASARLLVM_IFDSIDE_PROBLEMS_IDEGENERALIZEDLCA_EDGEVALUE_H_ + +#include +#include +#include +#include + +#include "llvm/ADT/APSInt.h" +#include "llvm/ADT/Twine.h" +#include "llvm/IR/Constant.h" +#include "llvm/IR/Instructions.h" + +namespace psr { + +enum class Ordering { Less, Greater, Equal, Incomparable }; + +class EdgeValue { +public: + enum Type { Top, Integer, String, FloatingPoint }; + +private: std::variant - ValVariant = nullptr; - Type VariantType; - -public: - EdgeValue(const llvm::Value *Val); - EdgeValue(const EdgeValue &EV); - EdgeValue(llvm::APInt &&VI); - EdgeValue(const llvm::APInt &VI); - EdgeValue(llvm::APFloat &&VF); - EdgeValue(long long VI); - EdgeValue(int VI); - EdgeValue(double Double); - EdgeValue(float Float); - EdgeValue(std::string &&VS); - EdgeValue(std::nullptr_t); - ~EdgeValue(); - const static EdgeValue TopValue; - [[nodiscard]] bool tryGetInt(uint64_t &Res) const; - [[nodiscard]] bool tryGetFP(double &Res) const; - [[nodiscard]] bool tryGetString(std::string &Res) const; - [[nodiscard]] bool isTop() const; - [[nodiscard]] bool isNumeric() const; - [[nodiscard]] bool isString() const; - [[nodiscard]] Type getKind() const; - // std::unique_ptr asObjLLVM(llvm::LLVMContext &ctx) const; - [[nodiscard]] bool sqSubsetEq(const EdgeValue &Other) const; + ValVariant = nullptr; + Type VariantType; + +public: + EdgeValue(const llvm::Value *Val); + EdgeValue(const EdgeValue &EV); + EdgeValue(llvm::APInt &&VI); + EdgeValue(const llvm::APInt &VI); + EdgeValue(llvm::APFloat &&VF); + EdgeValue(long long VI); + EdgeValue(int VI); + EdgeValue(double Double); + EdgeValue(float Float); + EdgeValue(std::string &&VS); + EdgeValue(std::nullptr_t); + ~EdgeValue(); + const static EdgeValue TopValue; + [[nodiscard]] bool tryGetInt(uint64_t &Res) const; + [[nodiscard]] bool tryGetFP(double &Res) const; + [[nodiscard]] bool tryGetString(std::string &Res) const; + [[nodiscard]] bool isTop() const; + [[nodiscard]] bool isNumeric() const; + [[nodiscard]] bool isString() const; + [[nodiscard]] Type getKind() const; + // std::unique_ptr asObjLLVM(llvm::LLVMContext &ctx) const; + [[nodiscard]] bool sqSubsetEq(const EdgeValue &Other) const; [[nodiscard]] EdgeValue performBinOp(llvm::BinaryOperator::BinaryOps Op, - const EdgeValue &Other) const; - [[nodiscard]] EdgeValue typecast(Type Dest, unsigned Bits) const; - EdgeValue &operator=(const EdgeValue &EV); - - operator bool(); - friend bool operator==(const EdgeValue &Lhs, const EdgeValue &Rhs); - - // binary operators - friend EdgeValue operator+(const EdgeValue &Lhs, const EdgeValue &Rhs); - friend EdgeValue operator-(const EdgeValue &Lhs, const EdgeValue &Rhs); - friend EdgeValue operator*(const EdgeValue &Lhs, const EdgeValue &Rhs); - friend EdgeValue operator/(const EdgeValue &Lhs, const EdgeValue &Rhs); - friend EdgeValue operator%(const EdgeValue &Lhs, const EdgeValue &Rhs); - friend EdgeValue operator&(const EdgeValue &Lhs, const EdgeValue &Rhs); - friend EdgeValue operator|(const EdgeValue &Lhs, const EdgeValue &Rhs); - friend EdgeValue operator^(const EdgeValue &Lhs, const EdgeValue &Rhs); - friend EdgeValue operator<<(const EdgeValue &Lhs, const EdgeValue &Rhs); - friend EdgeValue operator>>(const EdgeValue &Lhs, const EdgeValue &Rhs); - static int compare(const EdgeValue &Lhs, const EdgeValue &Rhs); - - // unary operators - EdgeValue operator-() const; - EdgeValue operator~() const; - friend std::ostream &operator<<(std::ostream &Os, const EdgeValue &EV); - static std::string typeToString(Type Ty); -}; -class EdgeValueSet; -typedef EdgeValueSet ev_t; - -ev_t performBinOp(llvm::BinaryOperator::BinaryOps Op, const ev_t &Lhs, - const ev_t &Rhs, size_t MaxSize); -ev_t performTypecast(const ev_t &Ev, EdgeValue::Type Dest, unsigned Bits); + const EdgeValue &Other) const; + [[nodiscard]] EdgeValue typecast(Type Dest, unsigned Bits) const; + EdgeValue &operator=(const EdgeValue &EV); + + operator bool(); + friend bool operator==(const EdgeValue &Lhs, const EdgeValue &Rhs); + + // binary operators + friend EdgeValue operator+(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator-(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator*(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator/(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator%(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator&(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator|(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator^(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator<<(const EdgeValue &Lhs, const EdgeValue &Rhs); + friend EdgeValue operator>>(const EdgeValue &Lhs, const EdgeValue &Rhs); + static int compare(const EdgeValue &Lhs, const EdgeValue &Rhs); + + // unary operators + EdgeValue operator-() const; + EdgeValue operator~() const; + friend std::ostream &operator<<(std::ostream &Os, const EdgeValue &EV); + static std::string typeToString(Type Ty); +}; +class EdgeValueSet; +typedef EdgeValueSet ev_t; + +ev_t performBinOp(llvm::BinaryOperator::BinaryOps Op, const ev_t &Lhs, + const ev_t &Rhs, size_t MaxSize); +ev_t performTypecast(const ev_t &Ev, EdgeValue::Type Dest, unsigned Bits); Ordering compare(const ev_t &Lhs, const ev_t &Rhs); -ev_t join(const ev_t &Lhs, const ev_t &Rhs, size_t MaxSize); -/// \brief implements square subset equal -bool operator<(const ev_t &Lhs, const ev_t &Rhs); -bool isTopValue(const ev_t &Val); -std::ostream &operator<<(std::ostream &Os, const ev_t &Val); - -} // namespace psr - -namespace std { - -template <> struct hash { - hash() = default; - size_t operator()(const psr::EdgeValue &Val) const { - auto Hash = hash()(Val.getKind()); - uint64_t AsInt; - double AsFloat; - string AsString; - if (Val.tryGetInt(AsInt)) { +ev_t join(const ev_t &Lhs, const ev_t &Rhs, size_t MaxSize); +/// \brief implements square subset equal +bool operator<(const ev_t &Lhs, const ev_t &Rhs); +bool isTopValue(const ev_t &Val); +std::ostream &operator<<(std::ostream &Os, const ev_t &Val); + +} // namespace psr + +namespace std { + +template <> struct hash { + hash() = default; + size_t operator()(const psr::EdgeValue &Val) const { + auto Hash = hash()(Val.getKind()); + uint64_t AsInt; + double AsFloat; + string AsString; + if (Val.tryGetInt(AsInt)) { return hash()(AsInt) * 31 + Hash; } - if (Val.tryGetFP(AsFloat)) { + if (Val.tryGetFP(AsFloat)) { return hash()(round(AsFloat)) * 31 + Hash; } if (Val.tryGetString(AsString)) { return hash()(AsString) * 31 + Hash; - } - return Hash; - } -}; - -} // namespace std - -#endif + } + return Hash; + } +}; + +} // namespace std + +#endif diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp index 9d9b57812c..3f732a9338 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp @@ -1,696 +1,696 @@ -/****************************************************************************** - * Copyright (c) 2020 Fabian Schiebel. - * All rights reserved. This program and the accompanying materials are made - * available under the terms of LICENSE.txt. - * - * Contributors: - * Fabian Schiebel, Alexander Meinhold and others - *****************************************************************************/ - -#include - -#include "llvm/ADT/APFloat.h" -#include "llvm/IR/Constants.h" -#include "llvm/IR/GlobalVariable.h" -#include "llvm/Support/raw_ostream.h" - -#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.h" -#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValueSet.h" - -namespace psr { - -std::ostream &printSemantics(const llvm::APFloat &Fl) { - if (&Fl.getSemantics() == &llvm::APFloat::IEEEdouble()) { - return std::cout << "IEEEdouble"; - } - if (&Fl.getSemantics() == &llvm::APFloat::IEEEhalf()) { - return std::cout << "IEEEhalf"; - } - if (&Fl.getSemantics() == &llvm::APFloat::IEEEquad()) { - return std::cout << "IEEEquad"; - } - if (&Fl.getSemantics() == &llvm::APFloat::IEEEsingle()) { - return std::cout << "IEEEsingle"; - } - if (&Fl.getSemantics() == &llvm::APFloat::PPCDoubleDouble()) { - return std::cout << "PPCDoubleDouble"; - } - if (&Fl.getSemantics() == &llvm::APFloat::x87DoubleExtended()) { - return std::cout << "x87DoubleExtended"; - } - if (&Fl.getSemantics() == &llvm::APFloat::Bogus()) { - return std::cout << "Bogus"; - } - return std::cout << "Sth else"; -} - -const EdgeValue EdgeValue::TopValue = EdgeValue(nullptr); - -EdgeValue::EdgeValue(const llvm::Value *Val) : VariantType(Top) { - if (const auto *Const = llvm::dyn_cast(Val)) { - if (Const->getType()->isIntegerTy()) { - VariantType = Integer; - ValVariant = - llvm::APInt(llvm::cast(Const)->getValue()); - } else if (Const->getType()->isFloatingPointTy()) { - VariantType = FloatingPoint; - const auto &ConstFP = llvm::cast(Const)->getValueAPF(); - - llvm::APFloat Apf(ConstFP); - bool Unused; - Apf.convert(llvm::APFloat::IEEEdouble(), - llvm::APFloat::roundingMode::NearestTiesToEven, &Unused); - ValVariant = llvm::APFloat(Apf); - } else if (llvm::isa(Const)) { - VariantType = String; - ValVariant = std::string(); - } else if (Const->getType()->isPointerTy() && - Const->getType()->getPointerElementType()->isIntegerTy()) { - VariantType = String; - const auto *Gep = llvm::cast( - Const); // already checked, hence cast instead of dyn_cast - if (const auto *Glob = - llvm::dyn_cast(Gep->getOperand(0))) { - ValVariant = std::string( - llvm::cast(Glob->getInitializer()) - ->getAsCString() - .str()); - } else { - // inttoptr - ValVariant = nullptr; - VariantType = Top; - } - } else { - Val = nullptr; - VariantType = Top; - } - } else { - Val = nullptr; - VariantType = Top; - } -} - -EdgeValue::EdgeValue(const EdgeValue &Ev) : VariantType(Ev.VariantType) { - switch (VariantType) { - case Top: - ValVariant = nullptr; - break; - case Integer: - ValVariant = std::get(Ev.ValVariant); - break; - case FloatingPoint: - ValVariant = std::get(Ev.ValVariant); - break; - case String: - ValVariant = std::get(Ev.ValVariant); - break; - } -} - -EdgeValue &EdgeValue::operator=(const EdgeValue &Ev) { - this->~EdgeValue(); - new (this) EdgeValue(Ev); - return *this; -} - -EdgeValue::~EdgeValue() { ValVariant.~variant(); } - -EdgeValue::EdgeValue(llvm::APInt &&Vi) : VariantType(EdgeValue::Integer) { - ValVariant = llvm::APInt(std::move(Vi)); -} - -EdgeValue::EdgeValue(const llvm::APInt &Vi) : VariantType(EdgeValue::Integer) { - ValVariant = llvm::APInt(Vi); -} - -EdgeValue::EdgeValue(llvm::APFloat &&Vf) - : VariantType(EdgeValue::FloatingPoint) { - llvm::APFloat Fp = llvm::APFloat(std::move(Vf)); - bool Unused; - Fp.convert(llvm::APFloat::IEEEdouble(), - llvm::APFloat::roundingMode::NearestTiesToEven, &Unused); - ValVariant = Fp; -} - -EdgeValue::EdgeValue(long long Vi) : VariantType(EdgeValue::Integer) { - ValVariant = llvm::APInt(llvm::APInt(sizeof(long long) << 3, Vi)); -} - -EdgeValue::EdgeValue(int Vi) : VariantType(EdgeValue::Integer) { - ValVariant = llvm::APInt(llvm::APInt(sizeof(int) << 3, Vi)); -} - -EdgeValue::EdgeValue(double Double) : VariantType(EdgeValue::FloatingPoint) { - ValVariant = llvm::APFloat(Double); -} - -EdgeValue::EdgeValue(float Float) : VariantType(EdgeValue::FloatingPoint) { - ValVariant = llvm::APFloat(Float); -} - -EdgeValue::EdgeValue(std::string &&Vs) : VariantType(EdgeValue::String) { - ValVariant = std::string(Vs); -} - -EdgeValue::EdgeValue(std::nullptr_t) : VariantType(EdgeValue::Top) {} -bool EdgeValue::tryGetInt(uint64_t &Res) const { - if (VariantType != Integer) { - return false; - } - Res = std::get(ValVariant).getLimitedValue(); - return true; -} - -bool EdgeValue::tryGetFP(double &Res) const { - if (VariantType != FloatingPoint) { - return false; - } - Res = std::get(ValVariant).convertToDouble(); - return true; -} - -bool EdgeValue::tryGetString(std::string &Res) const { - if (VariantType != String) { - return false; - } - Res = std::get(ValVariant); - return true; -} - -bool EdgeValue::isTop() const { return VariantType == Top; } - -bool EdgeValue::isNumeric() const { - return VariantType == Integer || VariantType == FloatingPoint; -} - -bool EdgeValue::isString() const { return VariantType == String; } - -EdgeValue::Type EdgeValue::getKind() const { return VariantType; } - -EdgeValue::operator bool() { - switch (VariantType) { - case Integer: - return !std::get(ValVariant).isNullValue(); - case FloatingPoint: - return std::get(ValVariant).isNonZero(); - case String: - return !std::get(ValVariant).empty(); - default: - break; - } - return false; -} - -bool operator==(const EdgeValue &Lhs, const EdgeValue &Rhs) { - // std::cout << "Compare edge values" << std::endl; - if (Lhs.VariantType != Rhs.VariantType) { - // std::cout << "Comparing incompatible types" << std::endl; - return false; - } - switch (Lhs.VariantType) { - case EdgeValue::Top: - return true; - case EdgeValue::Integer: - // if (v1.value.asInt != v2.value.asInt) - // std::cout << "integer unequal" << std::endl; - return std::get(Lhs.ValVariant) == - std::get(Rhs.ValVariant); - case EdgeValue::FloatingPoint: { - // std::cout << "compare floating points" << std::endl; - auto Cp = std::get(Lhs.ValVariant) - .compare(std::get(Rhs.ValVariant)); - if (Cp == llvm::APFloat::cmpResult::cmpEqual) { - // std::cout << "FP equal" << std::endl; - return true; - } - auto D1 = std::get(Lhs.ValVariant).convertToDouble(); - auto D2 = std::get(Rhs.ValVariant).convertToDouble(); - - const double Epsilon = 0.000001; - // std::cout << "Compare " << d1 << " against " << d2 << std::endl; - return D1 == D2 || D1 - D2 < Epsilon || D2 - D1 < Epsilon; - } - case EdgeValue::String: - // if (v1.value.asString != v2.value.asString) - // std::cout << "String unequal" << std::endl; - return std::get(Lhs.ValVariant) == - std::get(Rhs.ValVariant); - default: // will not happen - std::cerr << "FATAL ERROR" << std::endl; - return false; - } -} - -bool EdgeValue::sqSubsetEq(const EdgeValue &Other) const { - return Other.isTop() || Other.VariantType == VariantType; -} - -// binary operators -EdgeValue operator+(const EdgeValue &Lhs, const EdgeValue &Rhs) { - if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; - } - switch (Lhs.VariantType) { - case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) + - std::get(Rhs.ValVariant)}; - case EdgeValue::FloatingPoint: - return {std::get(Lhs.ValVariant) + - std::get(Rhs.ValVariant)}; - case EdgeValue::String: - return {std::get(Lhs.ValVariant) + - std::get(Rhs.ValVariant)}; - default: - return {nullptr}; - } -} - -EdgeValue operator-(const EdgeValue &Lhs, const EdgeValue &Rhs) { - if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; - } - switch (Lhs.VariantType) { - case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) - - std::get(Lhs.ValVariant)}; - case EdgeValue::FloatingPoint: - // printSemantics(v1.value.asFP) << " <=> "; - // printSemantics(v2.value.asFP) << std::endl; - return {std::get(Lhs.ValVariant) - - std::get(Rhs.ValVariant)}; - default: - return {nullptr}; - } -} - -EdgeValue operator*(const EdgeValue &Lhs, const EdgeValue &Rhs) { - if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; - } - switch (Lhs.VariantType) { - case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) * - std::get(Rhs.ValVariant)}; - case EdgeValue::FloatingPoint: - return {std::get(Lhs.ValVariant) * - std::get(Rhs.ValVariant)}; - default: - return {nullptr}; - } -} - -EdgeValue operator/(const EdgeValue &Lhs, const EdgeValue &Rhs) { - if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; - } - switch (Lhs.VariantType) { - case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) - .sdiv(std::get(Rhs.ValVariant))}; - case EdgeValue::FloatingPoint: - return {std::get(Lhs.ValVariant) / - std::get(Rhs.ValVariant)}; - default: - return {nullptr}; - } -} - -EdgeValue operator%(const EdgeValue &Lhs, const EdgeValue &Rhs) { - if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; - } - switch (Lhs.VariantType) { - case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) - .srem(std::get(Rhs.ValVariant))}; - case EdgeValue::FloatingPoint: { - llvm::APFloat Fl = std::get(Lhs.ValVariant); - Fl.remainder(std::get(Rhs.ValVariant)); - return {std::move(Fl)}; - } - default: - return {nullptr}; - } -} - -EdgeValue operator&(const EdgeValue &Lhs, const EdgeValue &Rhs) { - if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; - } - switch (Lhs.VariantType) { - case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) & - std::get(Rhs.ValVariant)}; - default: - return {nullptr}; - } -} - -EdgeValue operator|(const EdgeValue &Lhs, const EdgeValue &Rhs) { - if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; - } - switch (Lhs.VariantType) { - case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) | - std::get(Rhs.ValVariant)}; - default: - return {nullptr}; - } -} - -EdgeValue operator^(const EdgeValue &Lhs, const EdgeValue &Rhs) { - if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; - } - switch (Lhs.VariantType) { - case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) ^ - std::get(Rhs.ValVariant)}; - default: - return {nullptr}; - } -} - -EdgeValue operator<<(const EdgeValue &Lhs, const EdgeValue &Rhs) { - if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; - } - switch (Lhs.VariantType) { - case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) - << std::get(Rhs.ValVariant)}; - default: - return {nullptr}; - } -} -EdgeValue operator>>(const EdgeValue &Lhs, const EdgeValue &Rhs) { - if (Lhs.VariantType != Rhs.VariantType) { - return {nullptr}; - } - switch (Lhs.VariantType) { - case EdgeValue::Integer: - return {std::get(Lhs.ValVariant) - .ashr(std::get(Rhs.ValVariant))}; - default: - return {nullptr}; - } -} - -// unary operators -EdgeValue EdgeValue::operator-() const { - if (VariantType == Integer) { - return {-std::get(ValVariant)}; - } - return {nullptr}; -} - -EdgeValue EdgeValue::operator~() const { - if (VariantType == Integer) { - return {~std::get(ValVariant)}; - } - return {nullptr}; -} - -int EdgeValue::compare(const EdgeValue &Lhs, const EdgeValue &Rhs) { - switch (Lhs.VariantType) { - case EdgeValue::Integer: { - auto Lhsval = std::get(Lhs.ValVariant).getLimitedValue(); - uint64_t Rhsval; - double RhsvalFp; - if (Rhs.tryGetInt(Rhsval)) { - return Lhsval - Rhsval; - } - if (Rhs.tryGetFP(RhsvalFp)) { - return Lhsval < RhsvalFp ? -1 : (Lhsval > RhsvalFp ? 1 : 0); - } - break; - } - case EdgeValue::FloatingPoint: { - auto Lhsval = std::get(Lhs.ValVariant).convertToDouble(); - uint64_t Rhsval; - double RhsvalFp; - bool IsInt = Rhs.tryGetInt(Rhsval); - if (IsInt || Rhs.tryGetFP(RhsvalFp)) { - if (IsInt) { - RhsvalFp = Rhsval; - } - - return Lhsval < RhsvalFp ? -1 : (Lhsval > RhsvalFp ? 1 : 0); - } - - break; - } - case EdgeValue::String: { - std::string Rhsval; - if (Rhs.tryGetString(Rhsval)) { - return std::get(Lhs.ValVariant).compare(Rhsval); - } - break; - } - default: - break; - } - - return 0; -} - -std::ostream &operator<<(std::ostream &Os, const EdgeValue &Ev) { - switch (Ev.VariantType) { - case EdgeValue::Integer: { - std::string S; - llvm::raw_string_ostream Ros(S); - Ros << std::get(Ev.ValVariant); - return Os << Ros.str(); - } - case EdgeValue::String: - return Os << "\"" << std::get(Ev.ValVariant) << "\""; - case EdgeValue::FloatingPoint: { - return Os << std::get(Ev.ValVariant).convertToDouble(); - } - default: - return Os << ""; - } -} - -EdgeValue EdgeValue::typecast(Type Dest, unsigned Bits) const { - switch (Dest) { - - case Integer: - switch (VariantType) { - case Integer: - if (std::get(ValVariant).getBitWidth() <= Bits) { - return *this; - } - return {std::get(ValVariant) & ((1 << Bits) - 1)}; - case FloatingPoint: { - bool Unused; - llvm::APSInt Ai; - std::get(ValVariant) - .convertToInteger(Ai, llvm::APFloat::roundingMode::NearestTiesToEven, - &Unused); - return {Ai}; - } - default: - return {nullptr}; - } - case FloatingPoint: - switch (VariantType) { - case Integer: - if (Bits > 32) { - return {(double)std::get(ValVariant).getSExtValue()}; - } - return {(float)std::get(ValVariant).getSExtValue()}; - case FloatingPoint: - return *this; - default: - return {nullptr}; - } - default: - return {nullptr}; - } -} - -EdgeValue EdgeValue::performBinOp(llvm::BinaryOperator::BinaryOps Op, - const EdgeValue &Other) const { - switch (Op) { - case llvm::BinaryOperator::BinaryOps::Add: - case llvm::BinaryOperator::BinaryOps::FAdd: - return *this + Other; - case llvm::BinaryOperator::BinaryOps::And: - return *this & Other; - case llvm::BinaryOperator::BinaryOps::AShr: - return *this >> Other; - case llvm::BinaryOperator::BinaryOps::FDiv: - case llvm::BinaryOperator::BinaryOps::SDiv: - return *this / Other; - case llvm::BinaryOperator::BinaryOps::LShr: { - if (VariantType != Other.VariantType) { - return {nullptr}; - } - switch (VariantType) { - case EdgeValue::Integer: - return {std::get(ValVariant) - .lshr(std::get(Other.ValVariant))}; - default: - return {nullptr}; - } - } - case llvm::BinaryOperator::BinaryOps::Mul: - case llvm::BinaryOperator::BinaryOps::FMul: - return *this * Other; - case llvm::BinaryOperator::BinaryOps::Or: - return *this | Other; - case llvm::BinaryOperator::BinaryOps::Shl: - return *this << Other; - case llvm::BinaryOperator::BinaryOps::SRem: - case llvm::BinaryOperator::BinaryOps::FRem: - return *this % Other; - case llvm::BinaryOperator::BinaryOps::Sub: - case llvm::BinaryOperator::BinaryOps::FSub: - return *this - Other; - case llvm::BinaryOperator::BinaryOps::UDiv: { - if (VariantType != Other.VariantType) { - return {nullptr}; - } - switch (VariantType) { - case EdgeValue::Integer: - return {std::get(ValVariant) - .udiv(std::get(Other.ValVariant))}; - default: - return {nullptr}; - } - } - case llvm::BinaryOperator::BinaryOps::URem: { - if (VariantType != Other.VariantType) { - return {nullptr}; - } - switch (VariantType) { - case EdgeValue::Integer: - return {std::get(ValVariant) - .urem(std::get(Other.ValVariant))}; - default: - return {nullptr}; - } - } - case llvm::BinaryOperator::BinaryOps::Xor: - return *this ^ Other; - default: - return {nullptr}; - } -} - -ev_t performBinOp(llvm::BinaryOperator::BinaryOps Op, const ev_t &Lhs, - const ev_t &Rhs, size_t MaxSize) { - // std::cout << "Perform Binop on " << v1 << " and " << v2 << std::endl; - - if (Lhs.empty() || isTopValue(Lhs) || Rhs.empty() || isTopValue(Rhs)) { - // std::cout << "\t=> " << std::endl; - return {{nullptr}}; - } - ev_t Ret({}); - for (const auto &Ev1 : Lhs) { - for (const auto &Ev2 : Rhs) { - - Ret.insert(Ev1.performBinOp(Op, Ev2)); - if (Ret.size() > MaxSize) { - // std::cout << "\t=> " << std::endl; - return ev_t({{nullptr}}); - } - } - } - // std::cout << "\t=> " << ret << std::endl; - return Ret; -} - -ev_t performTypecast(const ev_t &Ev, EdgeValue::Type Dest, unsigned Bits) { - if (Ev.empty() || isTopValue(Ev)) { - // std::cout << "\t=> " << std::endl; - return {{nullptr}}; - } - ev_t Ret({}); - for (const auto &V : Ev) { - auto Tc = V.typecast(Dest, Bits); - if (Tc.isTop()) { - return ev_t({{nullptr}}); - } - Ret.insert(Tc); - } - return Ret; -} - -Ordering compare(const ev_t &Lhs, const ev_t &Rhs) { - const auto &Smaller = Lhs.size() <= Rhs.size() ? Lhs : Rhs; - const auto &Larger = Lhs.size() > Rhs.size() ? Lhs : Rhs; - - for (const auto &Elem : Smaller) { - if (!Larger.count(Elem)) { - return Ordering::Incomparable; - } - } - return Lhs.size() == Rhs.size() - ? Ordering::Equal - : (&Smaller == &Lhs ? Ordering::Less : Ordering::Greater); -} - -ev_t join(const ev_t &Lhs, const ev_t &Rhs, size_t MaxSize) { - // std::cout << "Join " << v1 << " and " << v2 << std::endl; - if (isTopValue(Lhs) || isTopValue(Rhs)) { - // std::cout << "\t=> " << std::endl; - return {{nullptr}}; - } - ev_t Ret(Lhs.begin(), Lhs.end()); - - for (const auto &Elem : Rhs) { - Ret.insert(Elem); - if (Ret.size() > MaxSize) { - // std::cout << "\t=> " << std::endl; - return {{nullptr}}; - } - } - // std::cout << "\t=> " << ret << std::endl; - - return Ret; -} - -bool isTopValue(const ev_t &V) { return V.size() == 1 && V.begin()->isTop(); } -std::ostream &operator<<(std::ostream &Os, const ev_t &V) { - Os << "{"; - bool First = true; - for (const auto &Elem : V) { - if (First) { - First = false; - } else { - Os << ", "; - } - Os << Elem; - } - return Os << "}"; -} - -bool operator<(const ev_t &Lhs, const ev_t &Rhs) { - if (Lhs.size() >= Rhs.size()) { - return Lhs != Rhs && (Lhs.empty() || Rhs == ev_t({EdgeValue::TopValue})); - } - for (const auto &Elem : Lhs) { - if (!Rhs.count(Elem)) { - return false; - } - } - return true; -} - -std::string EdgeValue::typeToString(Type Ty) { - switch (Ty) { - case Integer: - return "Integer"; - case FloatingPoint: - return "FloatingPoint"; - case String: - return "String"; - default: - return "Top"; - } -} - -} // namespace psr +/****************************************************************************** + * Copyright (c) 2020 Fabian Schiebel. + * All rights reserved. This program and the accompanying materials are made + * available under the terms of LICENSE.txt. + * + * Contributors: + * Fabian Schiebel, Alexander Meinhold and others + *****************************************************************************/ + +#include + +#include "llvm/ADT/APFloat.h" +#include "llvm/IR/Constants.h" +#include "llvm/IR/GlobalVariable.h" +#include "llvm/Support/raw_ostream.h" + +#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.h" +#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValueSet.h" + +namespace psr { + +std::ostream &printSemantics(const llvm::APFloat &Fl) { + if (&Fl.getSemantics() == &llvm::APFloat::IEEEdouble()) { + return std::cout << "IEEEdouble"; + } + if (&Fl.getSemantics() == &llvm::APFloat::IEEEhalf()) { + return std::cout << "IEEEhalf"; + } + if (&Fl.getSemantics() == &llvm::APFloat::IEEEquad()) { + return std::cout << "IEEEquad"; + } + if (&Fl.getSemantics() == &llvm::APFloat::IEEEsingle()) { + return std::cout << "IEEEsingle"; + } + if (&Fl.getSemantics() == &llvm::APFloat::PPCDoubleDouble()) { + return std::cout << "PPCDoubleDouble"; + } + if (&Fl.getSemantics() == &llvm::APFloat::x87DoubleExtended()) { + return std::cout << "x87DoubleExtended"; + } + if (&Fl.getSemantics() == &llvm::APFloat::Bogus()) { + return std::cout << "Bogus"; + } + return std::cout << "Sth else"; +} + +const EdgeValue EdgeValue::TopValue = EdgeValue(nullptr); + +EdgeValue::EdgeValue(const llvm::Value *Val) : VariantType(Top) { + if (const auto *Const = llvm::dyn_cast(Val)) { + if (Const->getType()->isIntegerTy()) { + VariantType = Integer; + ValVariant = + llvm::APInt(llvm::cast(Const)->getValue()); + } else if (Const->getType()->isFloatingPointTy()) { + VariantType = FloatingPoint; + const auto &ConstFP = llvm::cast(Const)->getValueAPF(); + + llvm::APFloat Apf(ConstFP); + bool Unused; + Apf.convert(llvm::APFloat::IEEEdouble(), + llvm::APFloat::roundingMode::NearestTiesToEven, &Unused); + ValVariant = llvm::APFloat(Apf); + } else if (llvm::isa(Const)) { + VariantType = String; + ValVariant = std::string(); + } else if (Const->getType()->isPointerTy() && + Const->getType()->getPointerElementType()->isIntegerTy()) { + VariantType = String; + const auto *Gep = llvm::cast( + Const); // already checked, hence cast instead of dyn_cast + if (const auto *Glob = + llvm::dyn_cast(Gep->getOperand(0))) { + ValVariant = std::string( + llvm::cast(Glob->getInitializer()) + ->getAsCString() + .str()); + } else { + // inttoptr + ValVariant = nullptr; + VariantType = Top; + } + } else { + Val = nullptr; + VariantType = Top; + } + } else { + Val = nullptr; + VariantType = Top; + } +} + +EdgeValue::EdgeValue(const EdgeValue &Ev) : VariantType(Ev.VariantType) { + switch (VariantType) { + case Top: + ValVariant = nullptr; + break; + case Integer: + ValVariant = std::get(Ev.ValVariant); + break; + case FloatingPoint: + ValVariant = std::get(Ev.ValVariant); + break; + case String: + ValVariant = std::get(Ev.ValVariant); + break; + } +} + +EdgeValue &EdgeValue::operator=(const EdgeValue &Ev) { + this->~EdgeValue(); + new (this) EdgeValue(Ev); + return *this; +} + +EdgeValue::~EdgeValue() { ValVariant.~variant(); } + +EdgeValue::EdgeValue(llvm::APInt &&Vi) : VariantType(EdgeValue::Integer) { + ValVariant = llvm::APInt(std::move(Vi)); +} + +EdgeValue::EdgeValue(const llvm::APInt &Vi) : VariantType(EdgeValue::Integer) { + ValVariant = llvm::APInt(Vi); +} + +EdgeValue::EdgeValue(llvm::APFloat &&Vf) + : VariantType(EdgeValue::FloatingPoint) { + llvm::APFloat Fp = llvm::APFloat(std::move(Vf)); + bool Unused; + Fp.convert(llvm::APFloat::IEEEdouble(), + llvm::APFloat::roundingMode::NearestTiesToEven, &Unused); + ValVariant = Fp; +} + +EdgeValue::EdgeValue(long long Vi) : VariantType(EdgeValue::Integer) { + ValVariant = llvm::APInt(llvm::APInt(sizeof(long long) << 3, Vi)); +} + +EdgeValue::EdgeValue(int Vi) : VariantType(EdgeValue::Integer) { + ValVariant = llvm::APInt(llvm::APInt(sizeof(int) << 3, Vi)); +} + +EdgeValue::EdgeValue(double Double) : VariantType(EdgeValue::FloatingPoint) { + ValVariant = llvm::APFloat(Double); +} + +EdgeValue::EdgeValue(float Float) : VariantType(EdgeValue::FloatingPoint) { + ValVariant = llvm::APFloat(Float); +} + +EdgeValue::EdgeValue(std::string &&Vs) : VariantType(EdgeValue::String) { + ValVariant = std::string(Vs); +} + +EdgeValue::EdgeValue(std::nullptr_t) : VariantType(EdgeValue::Top) {} +bool EdgeValue::tryGetInt(uint64_t &Res) const { + if (VariantType != Integer) { + return false; + } + Res = std::get(ValVariant).getLimitedValue(); + return true; +} + +bool EdgeValue::tryGetFP(double &Res) const { + if (VariantType != FloatingPoint) { + return false; + } + Res = std::get(ValVariant).convertToDouble(); + return true; +} + +bool EdgeValue::tryGetString(std::string &Res) const { + if (VariantType != String) { + return false; + } + Res = std::get(ValVariant); + return true; +} + +bool EdgeValue::isTop() const { return VariantType == Top; } + +bool EdgeValue::isNumeric() const { + return VariantType == Integer || VariantType == FloatingPoint; +} + +bool EdgeValue::isString() const { return VariantType == String; } + +EdgeValue::Type EdgeValue::getKind() const { return VariantType; } + +EdgeValue::operator bool() { + switch (VariantType) { + case Integer: + return !std::get(ValVariant).isNullValue(); + case FloatingPoint: + return std::get(ValVariant).isNonZero(); + case String: + return !std::get(ValVariant).empty(); + default: + break; + } + return false; +} + +bool operator==(const EdgeValue &Lhs, const EdgeValue &Rhs) { + // std::cout << "Compare edge values" << std::endl; + if (Lhs.VariantType != Rhs.VariantType) { + // std::cout << "Comparing incompatible types" << std::endl; + return false; + } + switch (Lhs.VariantType) { + case EdgeValue::Top: + return true; + case EdgeValue::Integer: + // if (v1.value.asInt != v2.value.asInt) + // std::cout << "integer unequal" << std::endl; + return std::get(Lhs.ValVariant) == + std::get(Rhs.ValVariant); + case EdgeValue::FloatingPoint: { + // std::cout << "compare floating points" << std::endl; + auto Cp = std::get(Lhs.ValVariant) + .compare(std::get(Rhs.ValVariant)); + if (Cp == llvm::APFloat::cmpResult::cmpEqual) { + // std::cout << "FP equal" << std::endl; + return true; + } + auto D1 = std::get(Lhs.ValVariant).convertToDouble(); + auto D2 = std::get(Rhs.ValVariant).convertToDouble(); + + const double Epsilon = 0.000001; + // std::cout << "Compare " << d1 << " against " << d2 << std::endl; + return D1 == D2 || D1 - D2 < Epsilon || D2 - D1 < Epsilon; + } + case EdgeValue::String: + // if (v1.value.asString != v2.value.asString) + // std::cout << "String unequal" << std::endl; + return std::get(Lhs.ValVariant) == + std::get(Rhs.ValVariant); + default: // will not happen + std::cerr << "FATAL ERROR" << std::endl; + return false; + } +} + +bool EdgeValue::sqSubsetEq(const EdgeValue &Other) const { + return Other.isTop() || Other.VariantType == VariantType; +} + +// binary operators +EdgeValue operator+(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { + case EdgeValue::Integer: + return {std::get(Lhs.ValVariant) + + std::get(Rhs.ValVariant)}; + case EdgeValue::FloatingPoint: + return {std::get(Lhs.ValVariant) + + std::get(Rhs.ValVariant)}; + case EdgeValue::String: + return {std::get(Lhs.ValVariant) + + std::get(Rhs.ValVariant)}; + default: + return {nullptr}; + } +} + +EdgeValue operator-(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { + case EdgeValue::Integer: + return {std::get(Lhs.ValVariant) - + std::get(Lhs.ValVariant)}; + case EdgeValue::FloatingPoint: + // printSemantics(v1.value.asFP) << " <=> "; + // printSemantics(v2.value.asFP) << std::endl; + return {std::get(Lhs.ValVariant) - + std::get(Rhs.ValVariant)}; + default: + return {nullptr}; + } +} + +EdgeValue operator*(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { + case EdgeValue::Integer: + return {std::get(Lhs.ValVariant) * + std::get(Rhs.ValVariant)}; + case EdgeValue::FloatingPoint: + return {std::get(Lhs.ValVariant) * + std::get(Rhs.ValVariant)}; + default: + return {nullptr}; + } +} + +EdgeValue operator/(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { + case EdgeValue::Integer: + return {std::get(Lhs.ValVariant) + .sdiv(std::get(Rhs.ValVariant))}; + case EdgeValue::FloatingPoint: + return {std::get(Lhs.ValVariant) / + std::get(Rhs.ValVariant)}; + default: + return {nullptr}; + } +} + +EdgeValue operator%(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { + case EdgeValue::Integer: + return {std::get(Lhs.ValVariant) + .srem(std::get(Rhs.ValVariant))}; + case EdgeValue::FloatingPoint: { + llvm::APFloat Fl = std::get(Lhs.ValVariant); + Fl.remainder(std::get(Rhs.ValVariant)); + return {std::move(Fl)}; + } + default: + return {nullptr}; + } +} + +EdgeValue operator&(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { + case EdgeValue::Integer: + return {std::get(Lhs.ValVariant) & + std::get(Rhs.ValVariant)}; + default: + return {nullptr}; + } +} + +EdgeValue operator|(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { + case EdgeValue::Integer: + return {std::get(Lhs.ValVariant) | + std::get(Rhs.ValVariant)}; + default: + return {nullptr}; + } +} + +EdgeValue operator^(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { + case EdgeValue::Integer: + return {std::get(Lhs.ValVariant) ^ + std::get(Rhs.ValVariant)}; + default: + return {nullptr}; + } +} + +EdgeValue operator<<(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { + case EdgeValue::Integer: + return {std::get(Lhs.ValVariant) + << std::get(Rhs.ValVariant)}; + default: + return {nullptr}; + } +} +EdgeValue operator>>(const EdgeValue &Lhs, const EdgeValue &Rhs) { + if (Lhs.VariantType != Rhs.VariantType) { + return {nullptr}; + } + switch (Lhs.VariantType) { + case EdgeValue::Integer: + return {std::get(Lhs.ValVariant) + .ashr(std::get(Rhs.ValVariant))}; + default: + return {nullptr}; + } +} + +// unary operators +EdgeValue EdgeValue::operator-() const { + if (VariantType == Integer) { + return {-std::get(ValVariant)}; + } + return {nullptr}; +} + +EdgeValue EdgeValue::operator~() const { + if (VariantType == Integer) { + return {~std::get(ValVariant)}; + } + return {nullptr}; +} + +int EdgeValue::compare(const EdgeValue &Lhs, const EdgeValue &Rhs) { + switch (Lhs.VariantType) { + case EdgeValue::Integer: { + auto Lhsval = std::get(Lhs.ValVariant).getLimitedValue(); + uint64_t Rhsval; + double RhsvalFp; + if (Rhs.tryGetInt(Rhsval)) { + return Lhsval - Rhsval; + } + if (Rhs.tryGetFP(RhsvalFp)) { + return Lhsval < RhsvalFp ? -1 : (Lhsval > RhsvalFp ? 1 : 0); + } + break; + } + case EdgeValue::FloatingPoint: { + auto Lhsval = std::get(Lhs.ValVariant).convertToDouble(); + uint64_t Rhsval; + double RhsvalFp; + bool IsInt = Rhs.tryGetInt(Rhsval); + if (IsInt || Rhs.tryGetFP(RhsvalFp)) { + if (IsInt) { + RhsvalFp = Rhsval; + } + + return Lhsval < RhsvalFp ? -1 : (Lhsval > RhsvalFp ? 1 : 0); + } + + break; + } + case EdgeValue::String: { + std::string Rhsval; + if (Rhs.tryGetString(Rhsval)) { + return std::get(Lhs.ValVariant).compare(Rhsval); + } + break; + } + default: + break; + } + + return 0; +} + +std::ostream &operator<<(std::ostream &Os, const EdgeValue &Ev) { + switch (Ev.VariantType) { + case EdgeValue::Integer: { + std::string S; + llvm::raw_string_ostream Ros(S); + Ros << std::get(Ev.ValVariant); + return Os << Ros.str(); + } + case EdgeValue::String: + return Os << "\"" << std::get(Ev.ValVariant) << "\""; + case EdgeValue::FloatingPoint: { + return Os << std::get(Ev.ValVariant).convertToDouble(); + } + default: + return Os << ""; + } +} + +EdgeValue EdgeValue::typecast(Type Dest, unsigned Bits) const { + switch (Dest) { + + case Integer: + switch (VariantType) { + case Integer: + if (std::get(ValVariant).getBitWidth() <= Bits) { + return *this; + } + return {std::get(ValVariant) & ((1 << Bits) - 1)}; + case FloatingPoint: { + bool Unused; + llvm::APSInt Ai; + std::get(ValVariant) + .convertToInteger(Ai, llvm::APFloat::roundingMode::NearestTiesToEven, + &Unused); + return {Ai}; + } + default: + return {nullptr}; + } + case FloatingPoint: + switch (VariantType) { + case Integer: + if (Bits > 32) { + return {(double)std::get(ValVariant).getSExtValue()}; + } + return {(float)std::get(ValVariant).getSExtValue()}; + case FloatingPoint: + return *this; + default: + return {nullptr}; + } + default: + return {nullptr}; + } +} + +EdgeValue EdgeValue::performBinOp(llvm::BinaryOperator::BinaryOps Op, + const EdgeValue &Other) const { + switch (Op) { + case llvm::BinaryOperator::BinaryOps::Add: + case llvm::BinaryOperator::BinaryOps::FAdd: + return *this + Other; + case llvm::BinaryOperator::BinaryOps::And: + return *this & Other; + case llvm::BinaryOperator::BinaryOps::AShr: + return *this >> Other; + case llvm::BinaryOperator::BinaryOps::FDiv: + case llvm::BinaryOperator::BinaryOps::SDiv: + return *this / Other; + case llvm::BinaryOperator::BinaryOps::LShr: { + if (VariantType != Other.VariantType) { + return {nullptr}; + } + switch (VariantType) { + case EdgeValue::Integer: + return {std::get(ValVariant) + .lshr(std::get(Other.ValVariant))}; + default: + return {nullptr}; + } + } + case llvm::BinaryOperator::BinaryOps::Mul: + case llvm::BinaryOperator::BinaryOps::FMul: + return *this * Other; + case llvm::BinaryOperator::BinaryOps::Or: + return *this | Other; + case llvm::BinaryOperator::BinaryOps::Shl: + return *this << Other; + case llvm::BinaryOperator::BinaryOps::SRem: + case llvm::BinaryOperator::BinaryOps::FRem: + return *this % Other; + case llvm::BinaryOperator::BinaryOps::Sub: + case llvm::BinaryOperator::BinaryOps::FSub: + return *this - Other; + case llvm::BinaryOperator::BinaryOps::UDiv: { + if (VariantType != Other.VariantType) { + return {nullptr}; + } + switch (VariantType) { + case EdgeValue::Integer: + return {std::get(ValVariant) + .udiv(std::get(Other.ValVariant))}; + default: + return {nullptr}; + } + } + case llvm::BinaryOperator::BinaryOps::URem: { + if (VariantType != Other.VariantType) { + return {nullptr}; + } + switch (VariantType) { + case EdgeValue::Integer: + return {std::get(ValVariant) + .urem(std::get(Other.ValVariant))}; + default: + return {nullptr}; + } + } + case llvm::BinaryOperator::BinaryOps::Xor: + return *this ^ Other; + default: + return {nullptr}; + } +} + +ev_t performBinOp(llvm::BinaryOperator::BinaryOps Op, const ev_t &Lhs, + const ev_t &Rhs, size_t MaxSize) { + // std::cout << "Perform Binop on " << v1 << " and " << v2 << std::endl; + + if (Lhs.empty() || isTopValue(Lhs) || Rhs.empty() || isTopValue(Rhs)) { + // std::cout << "\t=> " << std::endl; + return {{nullptr}}; + } + ev_t Ret({}); + for (const auto &Ev1 : Lhs) { + for (const auto &Ev2 : Rhs) { + + Ret.insert(Ev1.performBinOp(Op, Ev2)); + if (Ret.size() > MaxSize) { + // std::cout << "\t=> " << std::endl; + return ev_t({{nullptr}}); + } + } + } + // std::cout << "\t=> " << ret << std::endl; + return Ret; +} + +ev_t performTypecast(const ev_t &Ev, EdgeValue::Type Dest, unsigned Bits) { + if (Ev.empty() || isTopValue(Ev)) { + // std::cout << "\t=> " << std::endl; + return {{nullptr}}; + } + ev_t Ret({}); + for (const auto &V : Ev) { + auto Tc = V.typecast(Dest, Bits); + if (Tc.isTop()) { + return ev_t({{nullptr}}); + } + Ret.insert(Tc); + } + return Ret; +} + +Ordering compare(const ev_t &Lhs, const ev_t &Rhs) { + const auto &Smaller = Lhs.size() <= Rhs.size() ? Lhs : Rhs; + const auto &Larger = Lhs.size() > Rhs.size() ? Lhs : Rhs; + + for (const auto &Elem : Smaller) { + if (!Larger.count(Elem)) { + return Ordering::Incomparable; + } + } + return Lhs.size() == Rhs.size() + ? Ordering::Equal + : (&Smaller == &Lhs ? Ordering::Less : Ordering::Greater); +} + +ev_t join(const ev_t &Lhs, const ev_t &Rhs, size_t MaxSize) { + // std::cout << "Join " << v1 << " and " << v2 << std::endl; + if (isTopValue(Lhs) || isTopValue(Rhs)) { + // std::cout << "\t=> " << std::endl; + return {{nullptr}}; + } + ev_t Ret(Lhs.begin(), Lhs.end()); + + for (const auto &Elem : Rhs) { + Ret.insert(Elem); + if (Ret.size() > MaxSize) { + // std::cout << "\t=> " << std::endl; + return {{nullptr}}; + } + } + // std::cout << "\t=> " << ret << std::endl; + + return Ret; +} + +bool isTopValue(const ev_t &V) { return V.size() == 1 && V.begin()->isTop(); } +std::ostream &operator<<(std::ostream &Os, const ev_t &V) { + Os << "{"; + bool First = true; + for (const auto &Elem : V) { + if (First) { + First = false; + } else { + Os << ", "; + } + Os << Elem; + } + return Os << "}"; +} + +bool operator<(const ev_t &Lhs, const ev_t &Rhs) { + if (Lhs.size() >= Rhs.size()) { + return Lhs != Rhs && (Lhs.empty() || Rhs == ev_t({EdgeValue::TopValue})); + } + for (const auto &Elem : Lhs) { + if (!Rhs.count(Elem)) { + return false; + } + } + return true; +} + +std::string EdgeValue::typeToString(Type Ty) { + switch (Ty) { + case Integer: + return "Integer"; + case FloatingPoint: + return "FloatingPoint"; + case String: + return "String"; + default: + return "Top"; + } +} + +} // namespace psr From da0ed464909ddf457dabed421ce8b8d0fea7d14e Mon Sep 17 00:00:00 2001 From: Florian Sattler Date: Fri, 24 Dec 2021 14:47:06 +0100 Subject: [PATCH 4/4] Fixes next file --- .../IDEGeneralizedLCA/GenConstant.cpp | 172 +++++++++--------- 1 file changed, 86 insertions(+), 86 deletions(-) diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.cpp index fa73dd471d..04216f543a 100644 --- a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.cpp +++ b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.cpp @@ -1,90 +1,90 @@ -/****************************************************************************** - * Copyright (c) 2020 Fabian Schiebel. - * All rights reserved. This program and the accompanying materials are made - * available under the terms of LICENSE.txt. - * - * Contributors: - * Fabian Schiebel and others - *****************************************************************************/ - -#include - -#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/EdgeFunctions.h" -#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/AllBot.h" -#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.h" -#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/JoinEdgeFunction.h" - -namespace psr { - -GenConstant::GenConstant(const IDEGeneralizedLCA::l_t &Val, size_t MaxSize) - : Val(Val), MaxSize(MaxSize) { - // TODO: remove this? - /*std::cout << "GenConstant: {"; - bool First = true; - for (auto &elem : val) { - if (First) - First = false; - else - std::cout << ", "; - std::cout << elem; - } - std::cout << "}" << std::endl;*/ -} -IDEGeneralizedLCA::l_t -GenConstant::computeTarget(IDEGeneralizedLCA::l_t /*Source*/) { - // std::cout << "GenConstant computation (" << source << ")" - // << " = " << val << std::endl; - return Val; -} - -std::shared_ptr> GenConstant::composeWith( - std::shared_ptr> SecondFunction) { - // std::cout << "GenConstant composing" << std::endl; - if (dynamic_cast *>( - SecondFunction.get()) || - dynamic_cast *>(SecondFunction.get())) { - - return shared_from_this(); - } - if (dynamic_cast(SecondFunction.get())) { +/****************************************************************************** + * Copyright (c) 2020 Fabian Schiebel. + * All rights reserved. This program and the accompanying materials are made + * available under the terms of LICENSE.txt. + * + * Contributors: + * Fabian Schiebel and others + *****************************************************************************/ + +#include + +#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/EdgeFunctions.h" +#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/AllBot.h" +#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.h" +#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/JoinEdgeFunction.h" + +namespace psr { + +GenConstant::GenConstant(const IDEGeneralizedLCA::l_t &Val, size_t MaxSize) + : Val(Val), MaxSize(MaxSize) { + // TODO: remove this? + /*std::cout << "GenConstant: {"; + bool First = true; + for (auto &elem : val) { + if (First) + First = false; + else + std::cout << ", "; + std::cout << elem; + } + std::cout << "}" << std::endl;*/ +} +IDEGeneralizedLCA::l_t +GenConstant::computeTarget(IDEGeneralizedLCA::l_t /*Source*/) { + // std::cout << "GenConstant computation (" << source << ")" + // << " = " << val << std::endl; + return Val; +} + +std::shared_ptr> GenConstant::composeWith( + std::shared_ptr> SecondFunction) { + // std::cout << "GenConstant composing" << std::endl; + if (dynamic_cast *>( + SecondFunction.get()) || + dynamic_cast *>(SecondFunction.get())) { + + return shared_from_this(); + } + if (dynamic_cast(SecondFunction.get())) { return SecondFunction; - } - // return std::make_shared(shared_from_this(), - // secondFunction, MaxSize); - return std::make_shared(SecondFunction->computeTarget(Val), - MaxSize); -} - -std::shared_ptr> GenConstant::joinWith( - std::shared_ptr> Other) { - if (const auto *OtherConst = dynamic_cast(Other.get())) { - switch (compare(Val, OtherConst->Val)) { - case Ordering::Equal: + } + // return std::make_shared(shared_from_this(), + // secondFunction, MaxSize); + return std::make_shared(SecondFunction->computeTarget(Val), + MaxSize); +} + +std::shared_ptr> GenConstant::joinWith( + std::shared_ptr> Other) { + if (const auto *OtherConst = dynamic_cast(Other.get())) { + switch (compare(Val, OtherConst->Val)) { + case Ordering::Equal: [[fallthrough]]; - case Ordering::Greater: - return shared_from_this(); - case Ordering::Less: - return Other; - default: - return std::make_shared(join(Val, OtherConst->Val, MaxSize), - MaxSize); - } - } - if (AllBot::isBot(Other)) { + case Ordering::Greater: + return shared_from_this(); + case Ordering::Less: + return Other; + default: + return std::make_shared(join(Val, OtherConst->Val, MaxSize), + MaxSize); + } + } + if (AllBot::isBot(Other)) { return AllBot::getInstance(); - } - return std::make_shared(shared_from_this(), Other, MaxSize); -} - -bool GenConstant::equal_to( - std::shared_ptr> Other) const { - if (const auto *OtherConst = dynamic_cast(Other.get())) { - return Val == OtherConst->Val && MaxSize == OtherConst->MaxSize; - } - return false; + } + return std::make_shared(shared_from_this(), Other, MaxSize); +} + +bool GenConstant::equal_to( + std::shared_ptr> Other) const { + if (const auto *OtherConst = dynamic_cast(Other.get())) { + return Val == OtherConst->Val && MaxSize == OtherConst->MaxSize; + } + return false; +} +void GenConstant::print(std::ostream &OS, bool /*IsForDebug*/) const { + OS << "GenConstantEdgeFn(" << Val << ")"; } -void GenConstant::print(std::ostream &OS, bool /*IsForDebug*/) const { - OS << "GenConstantEdgeFn(" << Val << ")"; -} - -} // namespace psr + +} // namespace psr