access_node.h

Go to the documentation of this file.

 
#pragma once
 
#include "sdfg/data_flow/data_flow_node.h"
#include "sdfg/graph/graph.h"
 
namespace sdfg {
 
namespace builder {
class SDFGBuilder;
class StructuredSDFGBuilder;
} // namespace builder
 
namespace data_flow {

class AccessNode : public DataFlowNode {
    friend class sdfg::builder::SDFGBuilder;
    friend class sdfg::builder::StructuredSDFGBuilder;
 
protected:
    std::string data_; 

    AccessNode(
        size_t element_id,
        const DebugInfo& debug_info,
        const graph::Vertex vertex,
        DataFlowGraph& parent,
        const std::string& data
    );
 
public:
    AccessNode(const AccessNode& data_node) = delete;
    AccessNode& operator=(const AccessNode&) = delete;
 
    ElementType type_id() const override {
        return ElementType::AccessNode;
    }
 
    static bool classof(const Element& element) {
        return is_a(element.type_id(), ElementType::AccessNode | ElementType::ConstantNode);
    }

    void validate(const Function& function) const override;

    const std::string& data() const;
 
    virtual bool is_constant() const {
        return false;
    }

    void data(const std::string data);

    [[nodiscard]] bool side_effect() const override;

    virtual std::unique_ptr<DataFlowNode>
    clone(size_t element_id, const graph::Vertex vertex, DataFlowGraph& parent) const override;

    void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) override;
 
    EdgeRemoveOption can_remove_out_edge(const DataFlowGraph& graph, const Memlet* memlet) const override;
    EdgeRemoveOption can_remove_in_edge(const DataFlowGraph& graph, const Memlet* memlet) const override;

    static bool identicalBackingData(const AccessNode& src1, const AccessNode& src2);

    static bool has_constant_value(const AccessNode& node, long long constant_number);
};

class ConstantNode : public AccessNode {
    friend class sdfg::builder::SDFGBuilder;
    friend class sdfg::builder::StructuredSDFGBuilder;
 
private:
    std::unique_ptr<types::IType> type_; 

    ConstantNode(
        size_t element_id,
        const DebugInfo& debug_info,
        const graph::Vertex vertex,
        DataFlowGraph& parent,
        const std::string& data,
        const types::IType& type
    );
 
public:
    ConstantNode(const ConstantNode& data_node) = delete;
    ConstantNode& operator=(const ConstantNode&) = delete;
 
    ElementType type_id() const override {
        return ElementType::ConstantNode;
    }
 
    static bool classof(const Element& element) {
        return element.type_id() == ElementType::ConstantNode;
    }

    const types::IType& type() const;
 
    [[nodiscard]] bool side_effect() const override {
        return false;
    }
 
    bool is_constant() const override {
        return true;
    }

    void validate(const Function& function) const override;

    virtual std::unique_ptr<DataFlowNode>
    clone(size_t element_id, const graph::Vertex vertex, DataFlowGraph& parent) const override;
};
 
 
} // namespace data_flow
} // namespace sdfg