Parameter Errors and Allocation Tracking

.vscode/settings.json

@@ -8,6 +8,15 @@
           ]
       }
   },
+  "cmake.ctest.failurePatterns": [
+    {
+      "regexp": "(.+):(\\d+):(\\d+): error: CHECK: (.+)",
+      "file": 1,
+      "line": 2,
+      "column": 3,
+      "message": 4,
+    },
+  ],
   "terminal.integrated.defaultProfile.linux": "CoVer Wrapper Bash",
   "cmake.configureArgs": [
     "-DMPI_HOME=/home/archuser/Desktop/ompi/install",
@@ -18,4 +27,10 @@
     "COVER_WRAP_TARGET_mpicc": "~/Desktop/ompi/install/bin/mpicc",
     "COVER_WRAP_TARGET_mpicxx": "~/Desktop/ompi/install/bin/mpicxx",
   },
+  "terminal.integrated.env.linux": {
+    "COVER_WRAP_TARGET_mpifort": "~/Desktop/ompi/install/bin/mpifort",
+    "COVER_WRAP_TARGET_mpicc": "~/Desktop/ompi/install/bin/mpicc",
+    "COVER_WRAP_TARGET_mpicxx": "~/Desktop/ompi/install/bin/mpicxx",
+  },
+  "cmake.ctest.testSuiteDelimiter": "-|::",
 }

CMakeLists.txt

@@ -76,12 +76,16 @@ target_compile_options (ContractLanguage PUBLIC -fexceptions)
 
 add_llvm_pass_plugin(CoVerPlugin
   Passes/Registrar.cpp
+  Passes/BasicTypes.cpp
   Passes/ContractManager.cpp
   Passes/ContractVerifierPreCall.cpp
   Passes/ContractVerifierPostCall.cpp
   Passes/ContractVerifierRelease.cpp
-  Passes/Instrument.cpp
+  Passes/ContractVerifierParam.cpp
+  Passes/ContractVerifierAlloc.cpp
   Passes/ContractPostProcess.cpp
+  Passes/Intrinsics.cpp
+  Passes/Instrument.cpp
   Utils/ContractPassUtility.cpp
   Include/ContractPassUtility.hpp
 )
@@ -136,6 +140,12 @@ install(
     WORLD_READ
 )
 
+##
+## CoVer Intrinsics definitions
+##
+
+add_subdirectory(Intrinsics)
+
 ##
 ## Dynamic project
 ##
@@ -196,6 +206,7 @@ endif(MPI_C_FOUND AND Python_FOUND)
 
 set(CONTR_PLUGIN_PATH "${CMAKE_INSTALL_PREFIX}/lib/CoVerPlugin.so")
 set(COVER_DYNAMIC_ANALYSER_PATH ${CMAKE_INSTALL_PREFIX}/lib/libCoVerDynamicAnalyzer.a)
+set(COVER_INTRINSICS_LIB_PATH ${CMAKE_INSTALL_PREFIX}/lib/libCoVerIntrinsics.a)
 set(DSA_PLUGIN_PATH "${CMAKE_INSTALL_PREFIX}/lib/DSA.so")
 set(CONTR_INCLUDE_PATH "${CMAKE_INSTALL_PREFIX}/include")
 

Dynamic/Analyses/AllocAnalysis.cpp

@@ -0,0 +1,61 @@
+#include "AllocAnalysis.h"
+#include "BaseAnalysis.h"
+#include "DynamicAnalysis.h"
+#include "../DynamicUtils.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <utility>
+#include <vector>
+
+int vecContains(std::vector<MemOpFunc_t> vec, void* f) {
+    for (int i = 0; i < vec.size(); i++) {
+        if (vec[i].func == f) return i;
+    }
+    return -1;
+}
+
+Fulfillment AllocAnalysis::functionPreCBImpl(void* const& func, CallsiteInfo const& callsite) {
+    if (func == func_supplier) {
+        uintptr_t ptr = (uintptr_t)callsite.params[idx].value;
+        for (std::pair<uintptr_t, size_t> alloc_ptr : allocated) {
+            if ((uintptr_t)alloc_ptr.first == ptr) return Fulfillment::UNKNOWN;
+            if (ptr >= alloc_ptr.first && ptr < alloc_ptr.first + alloc_ptr.second) return Fulfillment::UNKNOWN;
+        }
+        references.push_back(callsite.location);
+        return Fulfillment::VIOLATED;
+    }
+    return Fulfillment::UNKNOWN;
+}
+
+Fulfillment AllocAnalysis::functionPostCBImpl(void* const& func, CallsiteInfo const& callsite) {
+    if (int idx = vecContains(mem_allocators, func); idx != -1) {
+        MemOpFunc_t const& memop = mem_allocators[idx];
+        uintptr_t alloc = (uintptr_t)(memop.rwOp->idx == 99 ? callsite.retval : callsite.params[memop.rwOp->idx].value);
+        if (memop.rwOp->accType == ParamAccess::DEREF) alloc = (uintptr_t)*(void**)alloc;
+        MathExpr_t const* cur = memop.size;
+        size_t res = cur->isArgValue ? (size_t)callsite.params[cur->value].value : cur->value;
+        while (cur->other != nullptr) {
+            switch (cur->type) {
+                case UNARY_VALUE:
+                    break;
+                case MULT:
+                    res *= cur->other->isArgValue ? (size_t)callsite.params[cur->other->value].value : cur->other->value;
+                    break;
+            }
+            cur = cur->other;
+        }
+        allocated.push_back({alloc, res});
+    }
+    else if (int idx = vecContains(mem_deallocators, func); idx != -1) {
+        MemOpFunc_t const& memop = mem_deallocators[idx];
+        uintptr_t const& target = (uintptr_t)(memop.rwOp->idx == 99 ? callsite.retval : callsite.params[memop.rwOp->idx].value);
+        for (int i = 0; i < allocated.size(); i++) {
+            if (target == allocated[i].first) {
+                allocated.erase(allocated.begin() + i);
+                break;
+            }
+        }
+    }
+    return Fulfillment::UNKNOWN;
+}

Dynamic/Analyses/AllocAnalysis.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "BaseAnalysis.h"
+#include "DynamicAnalysis.h"
+#include <cstddef>
+#include <cstdint>
+
+struct AllocAnalysis : BaseAnalysis<AllocAnalysis> {
+    public:
+        AllocAnalysis(void const* _func_supplier, AllocOp_t* allocop) : idx(allocop->idx), acc(allocop->accType), func_supplier(_func_supplier) {
+            for (int i = 0; i < allocop->num_allocators; i++) {
+                mem_allocators.push_back(allocop->allocators[i]);
+            }
+            for (int i = 0; i < allocop->num_deallocators; i++) {
+                mem_deallocators.push_back(allocop->deallocators[i]);
+            }
+        }
+
+        ANALYSIS_PREAMBLE Fulfillment functionPreCBImpl(void* const& func, CallsiteInfo const& callsite);
+        ANALYSIS_PREAMBLE Fulfillment functionPostCBImpl(void* const& func, CallsiteInfo const& callsite);
+        ANALYSIS_PREAMBLE Fulfillment memoryCBImpl(CodePtr const& location, void const* const& memory, bool const& isWrite) const { return Fulfillment::UNKNOWN; }
+        ANALYSIS_PREAMBLE Fulfillment exitCBImpl(CodePtr const& location) const { return Fulfillment::FULFILLED; }; // Evidently none of the callsites were erroneous 
+
+        constexpr CallBacks requiredCallbacksImpl() const { return {true, true, false, false}; }
+
+    private:
+        // Configuration
+        void const* func_supplier;
+        int const idx;
+        ParamAccess const acc;
+        std::vector<std::pair<uintptr_t, size_t>> allocated;
+        std::vector<MemOpFunc_t> mem_allocators;
+        std::vector<MemOpFunc_t> mem_deallocators;
+};

Dynamic/Analyses/BaseAnalysis.h

@@ -6,7 +6,8 @@
 enum struct Fulfillment { FULFILLED, UNKNOWN, VIOLATED, INACTIVE };
 
 struct CallBacks {
-    bool FUNCTION;
+    bool FUNCTION_PRE;
+    bool FUNCTION_POST;
     bool MEMORY_R;
     bool MEMORY_W;
 };
@@ -19,7 +20,8 @@ class BaseAnalysis {
     public:
         // Event handlers. Return non-unknown if analysis is resolved and no longer needs to be analysed.
         // onFunctionCall does not forward return address, as it is included in callsiteinfo
-        inline Fulfillment onFunctionCall(CodePtr const& location, void* const& func, CallsiteInfo const& callsite) { return static_cast<T*>(this)->functionCBImpl(func, callsite); };
+        inline Fulfillment onFunctionCallPre(CodePtr const& location, void* const& func, CallsiteInfo const& callsite) { return static_cast<T*>(this)->functionPreCBImpl(func, callsite); };
+        inline Fulfillment onFunctionCallPost(CodePtr const& location, void* const& func, CallsiteInfo const& callsite) { return static_cast<T*>(this)->functionPostCBImpl(func, callsite); };
         inline Fulfillment onMemoryAccess(CodePtr const& location, void const* const& memory, bool const& isWrite) { return static_cast<T*>(this)->memoryCBImpl(std::forward<CodePtr const>(location), memory, isWrite); };
         inline Fulfillment onProgramExit(CodePtr const& location) { return static_cast<T*>(this)->exitCBImpl(std::forward<void const* const>(location)); };
 

Dynamic/Analyses/ParamAnalysis.cpp

@@ -0,0 +1,59 @@
+#include "ParamAnalysis.h"
+#include "BaseAnalysis.h"
+#include "DynamicAnalysis.h"
+#include "../DynamicUtils.h"
+
+#include <cstdint>
+#include <vector>
+
+static constexpr int64_t sign_extend(uintptr_t const ptr, int const size) {
+    switch (size) {
+        case 8: return (int64_t)(int8_t)ptr; break;
+        case 16: return (int64_t)(int16_t)ptr; break;
+        case 32: return (int64_t)(int32_t)ptr; break;
+    }
+    return ptr;
+}
+
+Fulfillment ParamAnalysis::functionPreCBImpl(void* const& func, CallsiteInfo const& callsite) {
+    if (func != func_supplier) return Fulfillment::UNKNOWN;
+
+    void const* act_callp = callsite.params[idx].value;
+    if (callval_need_deref) {
+        act_callp = (const void*)(*(void**)act_callp);
+    }
+    int64_t const int_callp = sign_extend((uintptr_t)act_callp, callsite.params[idx].size);
+    for (const ParamReq_t* req : param_requirements) {
+        void const* act_req = req->isArg ? callsite.params[(int64_t)req->value].value: req->value;
+        if (req->reqval_need_deref) {
+            act_req = (const void*)*(void**)act_req;
+        }
+        int64_t const int_req = sign_extend((uintptr_t)act_req, callsite.params[idx].size);
+        switch (req->comparator) {
+            case Comparator::EXEQ:
+                // EXEQ is the exception (pun), it overrides other forbidden values.
+                if (act_callp == act_req || int_callp == int_req) return Fulfillment::FULFILLED;
+                continue;
+            case Comparator::EQ:
+                if (act_callp == act_req && int_callp == int_req) continue;
+                references.push_back(callsite.location); return Fulfillment::VIOLATED;
+            case Comparator::NEQ:
+                if (act_callp != act_req && int_callp != int_req) continue;
+                references.push_back(callsite.location); return Fulfillment::VIOLATED;
+            // Smaller/Larger comparisons dont make sense for pointers. Assume ints from here
+            case Comparator::GTEQ:
+                if (int_callp >= int_req) continue;
+                references.push_back(callsite.location); return Fulfillment::VIOLATED;
+            case Comparator::GT:
+                if (int_callp >  int_req) continue;
+                references.push_back(callsite.location); return Fulfillment::VIOLATED;
+            case Comparator::LTEQ:
+                if (int_callp <= int_req) continue;
+                references.push_back(callsite.location); return Fulfillment::VIOLATED;
+            case Comparator::LT:
+                if (int_callp <  int_req) continue;
+                references.push_back(callsite.location); return Fulfillment::VIOLATED;
+        }
+    }
+    return Fulfillment::UNKNOWN;
+}

Dynamic/Analyses/ParamAnalysis.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "BaseAnalysis.h"
+#include "DynamicAnalysis.h"
+#include <vector>
+
+struct ParamAnalysis : BaseAnalysis<ParamAnalysis> {
+    public:
+        ParamAnalysis(void const* _func_supplier, ParamOp_t* paramop) : idx(paramop->idx), func_supplier(_func_supplier), callval_need_deref(paramop->callval_need_deref) {
+            for (int i = 0; i < paramop->num_reqs; i++) {
+                param_requirements.push_back(&paramop->requirements[i]);
+            }
+        }
+
+        ANALYSIS_PREAMBLE Fulfillment functionPreCBImpl(void* const& func, CallsiteInfo const& callsite);
+        ANALYSIS_PREAMBLE Fulfillment functionPostCBImpl(void* const& func, CallsiteInfo const& callsite) { return Fulfillment::UNKNOWN; };
+        ANALYSIS_PREAMBLE Fulfillment memoryCBImpl(CodePtr const& location, void const* const& memory, bool const& isWrite) const { return Fulfillment::UNKNOWN; }
+        ANALYSIS_PREAMBLE Fulfillment exitCBImpl(CodePtr const& location) const { return Fulfillment::FULFILLED; }; // Evidently none of the callsites were erroneous 
+
+        constexpr CallBacks requiredCallbacksImpl() const { return {true, false, false, false}; }
+
+    private:
+        // Configuration
+        void const* func_supplier;
+        int const idx;
+        bool const callval_need_deref;
+        std::vector<ParamReq_t const*> param_requirements;
+};

Dynamic/Analyses/PostCallAnalysis.cpp

@@ -22,7 +22,7 @@ PostCallAnalysis::PostCallAnalysis(void const* _func_supplier, CallTagOp_t* call
     target_funcs = DynamicUtils::getFunctionsForTag(callop->target_tag);
 }
 
-Fulfillment PostCallAnalysis::functionCBImpl(void* const& func, CallsiteInfo const& callsite) {
+Fulfillment PostCallAnalysis::functionPreCBImpl(void* const& func, CallsiteInfo const& callsite) {
     for (void const* const& target_func : target_funcs) {
         if (target_func == func) {
             // Target function found, maybe analysis success

Dynamic/Analyses/PostCallAnalysis.h

@@ -10,11 +10,12 @@ struct PostCallAnalysis : public BaseAnalysis<PostCallAnalysis> {
         PostCallAnalysis(void const* func_supplier, CallOp_t* callop);
         PostCallAnalysis(void const* func_supplier, CallTagOp_t* callop);
 
-        inline __attribute__((always_inline)) Fulfillment functionCBImpl(void* const& func, CallsiteInfo const& callsite);
-        inline __attribute__((always_inline)) Fulfillment memoryCBImpl(CodePtr const& location, void const* const& memory, bool const& isWrite) const { return Fulfillment::UNKNOWN; }
-        inline __attribute__((always_inline)) Fulfillment exitCBImpl(CodePtr const& location);
+        ANALYSIS_PREAMBLE Fulfillment functionPreCBImpl(void* const& func, CallsiteInfo const& callsite);
+        ANALYSIS_PREAMBLE Fulfillment functionPostCBImpl(void* const& func, CallsiteInfo const& callsite) { return Fulfillment::UNKNOWN; };
+        ANALYSIS_PREAMBLE Fulfillment memoryCBImpl(CodePtr const& location, void const* const& memory, bool const& isWrite) const { return Fulfillment::UNKNOWN; }
+        ANALYSIS_PREAMBLE Fulfillment exitCBImpl(CodePtr const& location);
 
-        constexpr CallBacks requiredCallbacksImpl() const { return {true, false, false}; }
+        constexpr CallBacks requiredCallbacksImpl() const { return {true, false, false, false}; }
 
     private:
         void SharedInit(void const* _func_supplier, const char* target_str, CallParam_t *params, int64_t num_params);

Dynamic/Analyses/PreCallAnalysis.cpp

@@ -22,7 +22,7 @@ PreCallAnalysis::PreCallAnalysis(void const* _func_supplier, CallTagOp_t* callop
     target_funcs = DynamicUtils::getFunctionsForTag(callop->target_tag);
 }
 
-Fulfillment PreCallAnalysis::functionCBImpl(void* const& func, CallsiteInfo const& callsite) {
+Fulfillment PreCallAnalysis::functionPreCBImpl(void* const& func, CallsiteInfo const& callsite) {
     for (void const* const& target_func : target_funcs) {
         if (target_func == func) {
             // Possible match for precall

Dynamic/Analyses/PreCallAnalysis.h

@@ -12,11 +12,12 @@ struct PreCallAnalysis : BaseAnalysis<PreCallAnalysis> {
         PreCallAnalysis(void const* func_supplier, CallOp_t* callop);
         PreCallAnalysis(void const* func_supplier, CallTagOp_t* callop);
 
-        inline __attribute__((always_inline)) Fulfillment functionCBImpl(void* const& func, CallsiteInfo const& callsite);
-        inline __attribute__((always_inline)) Fulfillment memoryCBImpl(CodePtr const& location, void const* const& memory, bool const& isWrite) const { return Fulfillment::UNKNOWN; }
-        inline __attribute__((always_inline)) Fulfillment exitCBImpl(CodePtr const& location) const { return Fulfillment::INACTIVE; };
+        ANALYSIS_PREAMBLE Fulfillment functionPreCBImpl(void* const& func, CallsiteInfo const& callsite);
+        ANALYSIS_PREAMBLE Fulfillment functionPostCBImpl(void* const& func, CallsiteInfo const& callsite) { return Fulfillment::UNKNOWN; };
+        ANALYSIS_PREAMBLE Fulfillment memoryCBImpl(CodePtr const& location, void const* const& memory, bool const& isWrite) const { return Fulfillment::UNKNOWN; }
+        ANALYSIS_PREAMBLE Fulfillment exitCBImpl(CodePtr const& location) const { return Fulfillment::INACTIVE; };
 
-        constexpr CallBacks requiredCallbacksImpl() const { return {true, false, false}; }
+        constexpr CallBacks requiredCallbacksImpl() const { return {true, false, false, false}; }
 
     private:
         void SharedInit(void const* _func_supplier, const char* target_str, CallParam_t *params, int64_t num_params);

Dynamic/Analyses/ReleaseAnalysis.cpp

@@ -50,10 +50,10 @@ ReleaseAnalysis::ReleaseAnalysis(void const* _func_supplier, ReleaseOp_t* rOP) {
 CallBacks ReleaseAnalysis::requiredCallbacksImpl() const {
     if (!forbIsRW) return {true, false, false};
     RWOp_t* rwOp = (RWOp_t*)forbiddenOp;
-    return {true, !rwOp->isWrite, rwOp->isWrite};
+    return {true, false, !rwOp->isWrite, rwOp->isWrite};
 }
 
-Fulfillment ReleaseAnalysis::functionCBImpl(void* const& func, CallsiteInfo const& callsite) {
+Fulfillment ReleaseAnalysis::functionPreCBImpl(void* const& func, CallsiteInfo const& callsite) {
     if (!forbiddenCallsites.empty()) {
         // First, check if release
         for (void const* const& rel_func : rel_funcs) {

Dynamic/Analyses/ReleaseAnalysis.h

@@ -8,9 +8,10 @@
 struct ReleaseAnalysis : BaseAnalysis<ReleaseAnalysis> {
     public:
         ReleaseAnalysis(void const* func_supplier, ReleaseOp_t* rOP);
-        inline __attribute__((always_inline)) Fulfillment functionCBImpl(void* const& func, CallsiteInfo const& callsite);
-        inline __attribute__((always_inline)) Fulfillment memoryCBImpl(CodePtr const& location, void const* const& memory, bool const& isWrite);
-        inline __attribute__((always_inline)) Fulfillment exitCBImpl(CodePtr const& location) const { return Fulfillment::FULFILLED; };
+        ANALYSIS_PREAMBLE Fulfillment functionPreCBImpl(void* const& func, CallsiteInfo const& callsite);
+        ANALYSIS_PREAMBLE Fulfillment functionPostCBImpl(void* const& func, CallsiteInfo const& callsite) { return Fulfillment::UNKNOWN; };
+        ANALYSIS_PREAMBLE Fulfillment memoryCBImpl(CodePtr const& location, void const* const& memory, bool const& isWrite);
+        ANALYSIS_PREAMBLE Fulfillment exitCBImpl(CodePtr const& location) const { return Fulfillment::FULFILLED; };
 
         CallBacks requiredCallbacksImpl() const;
 

Dynamic/CMakeLists.txt

@@ -1,4 +1,6 @@
 add_library(CoVerDynamicAnalyzer STATIC
+  Analyses/ParamAnalysis.cpp
+  Analyses/AllocAnalysis.cpp
   Analyses/PostCallAnalysis.cpp
   Analyses/PreCallAnalysis.cpp
   Analyses/ReleaseAnalysis.cpp
@@ -7,14 +9,24 @@ add_library(CoVerDynamicAnalyzer STATIC
 )
 
 set_property(TARGET CoVerDynamicAnalyzer PROPERTY CXX_STANDARD 20)
-set_property(TARGET CoVerDynamicAnalyzer PROPERTY UNITY_BUILD ON)
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set_property(TARGET CoVerDynamicAnalyzer PROPERTY UNITY_BUILD OFF)
+else()
+    set_property(TARGET CoVerDynamicAnalyzer PROPERTY UNITY_BUILD ON)
+endif()
 target_include_directories(CoVerDynamicAnalyzer PUBLIC ../Include/)
 
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(FFI REQUIRED libffi)
+target_include_directories(CoVerDynamicAnalyzer PRIVATE "${FFI_INCLUDE_DIRS}")
+
 set_property(TARGET CoVerDynamicAnalyzer PROPERTY CXX_VISIBILITY_PRESET hidden)
 set_property(TARGET CoVerDynamicAnalyzer PROPERTY C_VISIBILITY_PRESET hidden)
 set_property(TARGET CoVerDynamicAnalyzer PROPERTY VISIBILITY_INLINES_HIDDEN ON)
 
-target_compile_options(CoVerDynamicAnalyzer PUBLIC -fno-rtti -fno-exceptions -fomit-frame-pointer -fno-stack-protector)
+target_compile_options(CoVerDynamicAnalyzer PUBLIC -fno-rtti -fno-exceptions -fomit-frame-pointer -fno-stack-protector -fno-math-errno -fno-trapping-math)
+target_link_libraries(CoVerDynamicAnalyzer libffi)
+target_include_directories(CoVerDynamicAnalyzer PRIVATE "${FFI_LIBRARIES}")
 
 if (CMAKE_ADDR2LINE)
   target_compile_definitions(CoVerDynamicAnalyzer PUBLIC CMAKE_ADDR2LINE="${CMAKE_ADDR2LINE}")