pointer_analyzers.h

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <string>
#include <unordered_map>
 
#include "sdfg/analysis/base_user_visitor.h"
#include "sdfg/function.h"
 
namespace sdfg::analysis {
template<typename P>
concept EscapePolicy = requires(P& p, const std::string& container, const ControlFlowNode* node, const Element* user) {
    p.on_escape(container, node, user);
};

template<typename P>
concept EscapeDetailsPolicy = EscapePolicy<P> && requires(
                                                     P& p,
                                                     const std::string& container,
                                                     const ControlFlowNode* node,
                                                     const data_flow::LibraryNode& lib_node,
                                                     const structured_control_flow::Return& return_node,
                                                     const data_flow::PointerAccessType& access_type
                                                 ) {
    p.on_ptr_input_into_lib_node(container, node, lib_node, access_type);
    p.on_ptr_returned(container, return_node);
    // p.on_ptr_written_to_memory
    // ..
};

template<EscapePolicy Policy, bool ForceDetailed = false>
class PointerEscapeAnalyzer : public virtual BaseUserAnalyzer {
    const StructuredSDFG& sdfg_;
    Policy& policy_;
 
public:
    PointerEscapeAnalyzer(const StructuredSDFG& sdfg, Policy& policy) : sdfg_(sdfg), policy_(policy) {
    }
 
    void use_as_return_src(const std::string& container, const Return& ret) override {
        if (sdfg_.type(container).type_id() == types::TypeID::Pointer) {
            if constexpr (ForceDetailed || EscapeDetailsPolicy<Policy>) {
                policy_.on_ptr_returned(container, ret);
            } else {
                policy_.on_escape(container, &ret, &ret);
            }
        }
    }
 
    void use_as_symbol_read(
        const std::string& container,
        const ControlFlowNode* node,
        const Element* user,
        SymbolReadLocation loc,
        int loc_index,
        symbolic::Expression expr
    ) override {
        auto& type = sdfg_.type(container);
        if (type.type_id() == types::TypeID::Pointer) {
            policy_.on_escape(container, node, user);
        }
    }
 
    void use_as_src_node(
        const std::string& container,
        const data_flow::AccessNode& node,
        const data_flow::Memlet& edge,
        const Block& block
    ) override {
        auto& type = sdfg_.type(container);
        if (edge.is_src_pointed_to_address_leak(type) || edge.is_src_address_leak()) {
            // pulls a reference to the owned memory area or can alias the entire pointer
 
            if constexpr (ForceDetailed || EscapeDetailsPolicy<Policy>) {
                auto& target_node = edge.dst();
                if (auto* lib_node = dyn_cast<data_flow::LibraryNode*>(&target_node)) {
                    auto meta = lib_node->pointer_access_type(edge);
                    policy_.on_ptr_input_into_lib_node(container, &block, *lib_node, meta);
                } else {
                    // we currently do not have the analysis to track this through tasmklets, so fall back to generic
                    // escape
                    policy_.on_escape(container, &block, &edge);
                }
            } else {
                policy_.on_escape(container, &block, &edge);
                // it may not be, but this is the safest
                // assumption. other passes can forward the original container and fold it into accesses
            }
        }
    }
 
    void use_as_dst_node(
        const std::string& container,
        const data_flow::AccessNode& node,
        const data_flow::Memlet& edge,
        const Block& block
    ) override {
    }
    void use_as_symbol_write(
        const symbolic::Symbol& container, const ControlFlowNode* node, const Element* user, SymbolWriteLocation loc
    ) override {
    }
};
 
template<typename P>
concept OverwritePolicy =
    requires(P& p, const std::string& container, const ControlFlowNode* node, const Element* user) {
        p.on_overwrite(container, node, user);
    };

template<OverwritePolicy Policy>
class PointerOverwriteAnalyzer : public BaseUserAnalyzer {
    const StructuredSDFG& sdfg_;
    Policy& policy_;
 
public:
    PointerOverwriteAnalyzer(const StructuredSDFG& sdfg, Policy& policy) : sdfg_(sdfg), policy_(policy) {
    }
 
    void use_as_dst_node(
        const std::string& container,
        const data_flow::AccessNode& node,
        const data_flow::Memlet& edge,
        const Block& block
    ) override {
        if (edge.is_dst_write()) { // writes to the ptr
            auto& type = sdfg_.type(container);
            if (type.type_id() == types::TypeID::Pointer) {
                policy_.on_overwrite(container, &block, &edge);
            }
        }
    }
 
    void use_as_symbol_write(
        const symbolic::Symbol& container, const ControlFlowNode* node, const Element* user, SymbolWriteLocation loc
    ) override {
        auto name = container->get_name();
        if (sdfg_.type(name).type_id() == types::TypeID::Pointer) {
            policy_.on_overwrite(name, node, user);
        }
    }
 
    void use_as_return_src(const std::string& container, const Return& ret) override {
    }
    void use_as_src_node(
        const std::string& container,
        const data_flow::AccessNode& node,
        const data_flow::Memlet& edge,
        const Block& block
    ) override {
    }
    void use_as_symbol_read(
        const std::string& container,
        const ControlFlowNode* node,
        const Element* user,
        SymbolReadLocation loc,
        int loc_index,
        symbolic::Expression expr
    ) override {
    }
};
 
template<typename P>
concept PointerUsedPolicy =
    requires(P& p, const std::string& container, const ControlFlowNode* node, const data_flow::Memlet* user) {
        p.on_write_via(container, node, user);
        p.on_read_via(container, node, user);
    };

template<PointerUsedPolicy Policy>
class PointerUsedAnalyzer : public BaseUserAnalyzer {
    const StructuredSDFG& sdfg_;
    Policy& policy_;
 
public:
    PointerUsedAnalyzer(const StructuredSDFG& sdfg, Policy& policy) : sdfg_(sdfg), policy_(policy) {
    }
 
    void use_as_src_node(
        const std::string& container,
        const data_flow::AccessNode& node,
        const data_flow::Memlet& edge,
        const Block& block
    ) override {
        if (edge.is_src_pointed_to_read()) {
            policy_.on_read_via(container, &block, &edge);
        }
    }
 
    void use_as_dst_node(
        const std::string& container,
        const data_flow::AccessNode& node,
        const data_flow::Memlet& edge,
        const Block& block
    ) override {
        if (edge.is_dst_pointed_to_write()) {
            policy_.on_write_via(container, &block, &edge);
        }
    }
 
    void use_as_symbol_write(
        const symbolic::Symbol& container, const ControlFlowNode* node, const Element* user, SymbolWriteLocation loc
    ) override {
    }
 
    void use_as_return_src(const std::string& container, const Return& ret) override {
    }
 
    void use_as_symbol_read(
        const std::string& container,
        const ControlFlowNode* node,
        const Element* user,
        SymbolReadLocation loc,
        int loc_index,
        symbolic::Expression expr
    ) override {
    }
};
 
 
} // namespace sdfg::analysis