NetlistGraph.hpp

Go to the documentation of this file.

#pragma once
 
#include "netlist/BuildProfile.hpp"
#include "netlist/BuilderOptions.hpp"
#include "netlist/Debug.hpp"
#include "netlist/DirectedGraph.hpp"
#include "netlist/NetlistEdge.hpp"
#include "netlist/NetlistNode.hpp"
#include "netlist/SymbolReference.hpp"
#include "netlist/TextLocation.hpp"
 
#include "slang/ast/SemanticFacts.h"
 
#include <algorithm>
#include <ranges>
#include <regex>
#include <span>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace slang {
namespace ast {
class Compilation;
} // namespace ast
namespace analysis {
class AnalysisManager;
} // namespace analysis
} // namespace slang
 
namespace slang::netlist {

enum class BlackBoxCoverage {
  Outside,
  Boundary,
  Contained,
};

class NetlistGraph : public DirectedGraph<NetlistNode, NetlistEdge> {
public:
  FileTable fileTable;
  SymbolTable symbolTable;

  void build(ast::Compilation &compilation,
             analysis::AnalysisManager &analysisManager,
             BuilderOptions options = {});

  [[nodiscard]] auto lookup(std::string_view name) const -> NetlistNode *;

  [[nodiscard]] auto lookup(std::string_view name, DriverBitRange bounds) const
      -> std::vector<NetlistNode *>;

  [[nodiscard]] auto getDrivers(std::string_view name,
                                DriverBitRange bounds) const
      -> std::vector<NetlistNode *>;

  struct BitDriver {
    DriverBitRange bounds;
    NetlistNode *driver;
  };

  [[nodiscard]] auto getBitDrivers(std::string_view name,
                                   DriverBitRange bounds) const
      -> std::vector<BitDriver>;

  [[nodiscard]] auto getBitDrivers(std::string_view name) const
      -> std::vector<BitDriver>;

  [[nodiscard]] auto getCombFanOut(NetlistNode &node) const
      -> std::vector<NetlistNode *>;

  [[nodiscard]] auto getCombFanIn(NetlistNode &node) const
      -> std::vector<NetlistNode *>;

  struct SensitivitySource {
    NetlistNode *source;
    ast::EdgeKind edgeKind;
 
    auto operator==(SensitivitySource const &) const -> bool = default;
  };

  [[nodiscard]] auto getSensitivity(NetlistNode &node) const
      -> std::vector<SensitivitySource>;

  [[nodiscard]] auto getConstantDrivers(NetlistNode &node) const
      -> std::vector<NetlistNode *>;

  [[nodiscard]] auto findNodes(std::string_view pattern) const
      -> std::vector<NetlistNode *>;

  [[nodiscard]] auto findNodesRegex(std::string_view pattern) const
      -> std::vector<NetlistNode *>;

  [[nodiscard]]
  auto filterNodes(NodeKind kind) const {
    return nodes |
           std::views::filter([kind](std::unique_ptr<NetlistNode> const &p) {
             return p->kind == kind;
           });
  }

  auto addEdge(NetlistNode &sourceNode, NetlistNode &targetNode)
      -> NetlistEdge & {
    return sourceNode.addEdge(targetNode);
  }

  [[nodiscard]] auto getBuildProfile() const -> BuildProfile const & {
    return buildProfile;
  }

  void setBuildProfile(BuildProfile const &profile) { buildProfile = profile; }

  void addBlackBoxPath(std::string path) {
    blackBoxPaths.push_back(std::move(path));
  }

  [[nodiscard]] auto getBlackBoxPaths() const -> std::span<std::string const> {
    return blackBoxPaths;
  }

  [[nodiscard]] auto getBlackBoxCoverage(NetlistNode const &node) const
      -> BlackBoxCoverage;
 
private:
  BuildProfile buildProfile;
  std::vector<std::string> blackBoxPaths;
  mutable bool indexBuilt = false;
  mutable std::unordered_map<std::string, std::vector<NetlistNode *>> nodeIndex;
  void buildIndex() const;
};
 
} // namespace slang::netlist