gate.h

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2019 Ruhr University Bochum, Chair for Embedded Security. All Rights reserved.
// Copyright (c) 2019 Marc Fyrbiak, Sebastian Wallat, Max Hoffmann ("ORIGINAL AUTHORS"). All rights reserved.
// Copyright (c) 2021 Max Planck Institute for Security and Privacy. All Rights reserved.
// Copyright (c) 2021 Jörn Langheinrich, Julian Speith, Nils Albartus, René Walendy, Simon Klix ("ORIGINAL AUTHORS"). All Rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
#pragma once
 
#include "hal_core/defines.h"
#include "hal_core/netlist/boolean_function.h"
#include "hal_core/netlist/data_container.h"
#include "hal_core/netlist/endpoint.h"
#include "hal_core/netlist/event_system/event_handler.h"
#include "hal_core/netlist/gate_library/gate_type.h"
 
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <unordered_map>
#include <vector>
 
namespace hal
{
    /* forward declaration */
    class Netlist;
    class Net;
    class Module;
    class Grouping;
    class Endpoint;
    class NetlistInternalManager;
 
    class NETLIST_API Gate : public DataContainer
    {
    public:
        bool operator==(const Gate& other) const;
 
        bool operator!=(const Gate& other) const;
 
        ssize_t get_hash() const;
 
        u32 get_id() const;
 
        Netlist* get_netlist() const;
 
        const std::string& get_name() const;
 
        void set_name(const std::string& name);
 
        GateType* get_type() const;
 
        bool has_location() const;
 
        void set_location_x(i32 x);
 
        i32 get_location_x() const;
 
        void set_location_y(i32 y);
 
        i32 get_location_y() const;
 
        void set_location(const std::pair<i32, i32>& location);
 
        std::pair<i32, i32> get_location() const;
 
        Module* get_module() const;
 
        std::vector<Module*> get_modules(const std::function<bool(Module*)>& filter = nullptr, bool recursive = true) const;
 
        Grouping* get_grouping() const;
 
        BooleanFunction get_boolean_function(const std::string& name) const;
 
        BooleanFunction get_boolean_function(const GatePin* pin = nullptr) const;
 
        std::unordered_map<std::string, BooleanFunction> get_boolean_functions(bool only_custom_functions = false) const;
 
        Result<BooleanFunction> get_resolved_boolean_function(const GatePin* pin, const bool use_net_variables = false) const;
 
        bool add_boolean_function(const std::string& name, const BooleanFunction& func);
 
        bool mark_vcc_gate();
 
        bool mark_gnd_gate();
 
        bool unmark_vcc_gate();
 
        bool unmark_gnd_gate();
 
        bool is_vcc_gate() const;
 
        bool is_gnd_gate() const;
 
        /*
         *      pin specific functions
         */
 
        const std::vector<Net*>& get_fan_in_nets() const;
 
        std::vector<Net*> get_fan_in_nets(const std::function<bool(Net*)>& filter) const;
 
        Net* get_fan_in_net(const std::string& pin_name) const;
 
        Net* get_fan_in_net(const GatePin* pin) const;
 
        bool is_fan_in_net(const Net* net) const;
 
        const std::vector<Endpoint*>& get_fan_in_endpoints() const;
 
        std::vector<Endpoint*> get_fan_in_endpoints(const std::function<bool(Endpoint*)>& filter) const;
 
        Endpoint* get_fan_in_endpoint(const std::string& pin_name) const;
 
        Endpoint* get_fan_in_endpoint(const GatePin* pin) const;
 
        Endpoint* get_fan_in_endpoint(const Net* net) const;
 
        const std::vector<Net*>& get_fan_out_nets() const;
 
        std::vector<Net*> get_fan_out_nets(const std::function<bool(Net*)>& filter) const;
 
        Net* get_fan_out_net(const std::string& pin_name) const;
 
        Net* get_fan_out_net(const GatePin* pin) const;
 
        bool is_fan_out_net(const Net* net) const;
 
        const std::vector<Endpoint*>& get_fan_out_endpoints() const;
 
        std::vector<Endpoint*> get_fan_out_endpoints(const std::function<bool(Endpoint*)>& filter) const;
 
        Endpoint* get_fan_out_endpoint(const std::string& pin_name) const;
 
        Endpoint* get_fan_out_endpoint(const GatePin* pin) const;
 
        Endpoint* get_fan_out_endpoint(const Net* net) const;
 
        std::vector<Gate*> get_unique_predecessors(const std::function<bool(const GatePin* pin, Endpoint* ep)>& filter = nullptr) const;
 
        std::vector<Endpoint*> get_predecessors(const std::function<bool(const GatePin* pin, Endpoint* ep)>& filter = nullptr) const;
 
        Endpoint* get_predecessor(const std::string& pin_name) const;
 
        Endpoint* get_predecessor(const GatePin* pin) const;
 
        std::vector<Gate*> get_unique_successors(const std::function<bool(const GatePin* pin, Endpoint* ep)>& filter = nullptr) const;
 
        std::vector<Endpoint*> get_successors(const std::function<bool(const GatePin* pin, Endpoint* ep)>& filter = nullptr) const;
 
        Endpoint* get_successor(const std::string& pin_name) const;
 
        Endpoint* get_successor(const GatePin* pin) const;
 
        Result<std::vector<std::string>> get_init_data() const;
 
        Result<std::monostate> set_init_data(const std::vector<std::string>& init_data);
 
    private:
        friend class NetlistInternalManager;
        Gate(NetlistInternalManager* mgr, EventHandler* event_handler, u32 id, GateType* gt, const std::string& name, i32 x, i32 y);
 
        Gate(const Gate&)            = delete;
        Gate(Gate&&)                 = delete;
        Gate& operator=(const Gate&) = delete;
        Gate& operator=(Gate&&)      = delete;
 
        BooleanFunction get_lut_function(const GatePin* pin) const;
 
        /* pointer to corresponding netlist parent */
        NetlistInternalManager* m_internal_manager;
 
        /* id of the gate */
        u32 m_id;
 
        /* name of the gate */
        std::string m_name;
 
        /* type of the gate */
        GateType* m_type;
 
        /* location */
        i32 m_x = -1;
        i32 m_y = -1;
 
        /* owning module */
        Module* m_module;
 
        /* grouping */
        Grouping* m_grouping = nullptr;
 
        /* connected nets */
        std::vector<Endpoint*> m_in_endpoints;
        std::vector<Endpoint*> m_out_endpoints;
        std::vector<Net*> m_in_nets;
        std::vector<Net*> m_out_nets;
 
        /* dedicated functions */
        std::unordered_map<std::string, BooleanFunction> m_functions;
 
        EventHandler* m_event_handler;
    };
}    // namespace hal