block.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
 
#include "sdfg/control_flow/interstate_edge.h"
#include "sdfg/control_flow/state.h"
#include "sdfg/data_flow/data_flow_graph.h"
#include "sdfg/structured_control_flow/control_flow_node.h"
#include "sdfg/symbolic/symbolic.h"
 
namespace sdfg {
 
namespace builder {
class StructuredSDFGBuilder;
}
 
namespace structured_control_flow {

class Block : public ControlFlowNode {
    friend class sdfg::builder::StructuredSDFGBuilder;
 
private:
    std::unique_ptr<data_flow::DataFlowGraph> dataflow_;
 
    Block(size_t element_id, const DebugInfo& debug_info, ControlFlowNode* parent);
 
    static constexpr size_t REQUIRED_ELEMENT_IDS = 1;
 
public:
    Block(const Block& block) = delete;
    Block& operator=(const Block&) = delete;
 
    ElementType type_id() const override {
        return ElementType::Block;
    }
 
    static bool classof(const Element& element) {
        return element.type_id() == ElementType::Block;
    }
 
    bool accept(visitor::ActualStructuredSDFGVisitor& visitor) override;
 
    void validate(const Function& function) const override;

    const data_flow::DataFlowGraph& dataflow() const;

    data_flow::DataFlowGraph& dataflow();

    void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) override;
    void replace(const symbolic::ExpressionMapping& replacements) override;
 
    template<typename T>
    T* is_a_library_node() {
        return this->dataflow().is_a_library_node<T>();
    }
};
 
class AssignmentBlock : public ControlFlowNode {
    friend class sdfg::builder::StructuredSDFGBuilder;
 
private:
    control_flow::Assignments assignments_;
 
    AssignmentBlock(
        ElementId element_id,
        const DebugInfo& debug_info,
        ControlFlowNode* parent,
        const control_flow::Assignments& assignments
    );
    AssignmentBlock(ElementId element_id, const DebugInfo& debug_info, ControlFlowNode* parent);
 
    static constexpr size_t REQUIRED_ELEMENT_IDS = 1;
 
public:
    AssignmentBlock(const AssignmentBlock& block) = delete;
    AssignmentBlock& operator=(const AssignmentBlock&) = delete;
 
    ElementType type_id() const override {
        return ElementType::AssignmentBlock;
    }

    bool add_if_not_overwritten(const symbolic::Symbol& target, const symbolic::Expression& expr);
 
    static bool classof(const Element& element) {
        return element.type_id() == ElementType::AssignmentBlock;
    }
 
    bool accept(visitor::ActualStructuredSDFGVisitor& visitor) override;
 
    void validate(const Function& function) const override;

    const control_flow::Assignments& assignments() const;

    control_flow::Assignments& assignments();

    bool empty() const;

    size_t size() const;

    void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) override;
    void replace(const symbolic::ExpressionMapping& replacements) override;
};
 
} // namespace structured_control_flow
} // namespace sdfg