Matchers.h

Go to the documentation of this file.

#ifndef _MATCHERS_H_
#define _MATCHERS_H_
 
#include <map>
#include <vector>
 
#include "InstanceMatcher.h"
#include "CXXRecordDeclUtils.h"
#include "ModuleInstance.h"
#include "PortMatcher.h"
 
#include "FindConstructor.h"
#include "FindEntryFunctions.h"
#include "FindEvents.h"
#include "FindGlobalEvents.h"
#include "FindNetlist.h"
#include "FindNotify.h"
#include "FindSimTime.h"
#include "FindTLMInterfaces.h"
#include "FindTemplateParameters.h"
#include "FindWait.h"
 
#include "clang/ASTMatchers/ASTMatchers.h"
//#include "matchers/ResetMatcher.h"
 
using namespace systemc_clang;
 
#undef DEBUG_TYPE
#define DEBUG_TYPE "Matchers"
 
namespace sc_ast_matchers {
 
using namespace utils;
//
//
class ModuleDeclarationMatcher : public MatchFinder::MatchCallback {
 public:
  typedef std::vector<InstanceMatcher::InstanceDeclType> InstanceListType;
 
  typedef std::pair<clang::CXXRecordDecl *, ModuleInstance *> ModulePairType;
  typedef std::multimap<clang::CXXRecordDecl *, ModuleInstance *> ModuleMapType;
 
 private:
  ModuleMapType modules_;
 
  // Match nested instances
  InstanceMatcher instance_matcher_;
 
 public:
  const InstanceMatcher &getInstanceMatcher() { return instance_matcher_; }
 
  void registerMatchers(MatchFinder &finder) {
    // Add instance matcher
    instance_matcher_.registerMatchers(finder);
  }
 
  virtual void run(const MatchFinder::MatchResult &result) {}
 
  const ModuleMapType &getFoundModuleDeclarations() const { return modules_; }
 
  void runPortMatcher(ASTContext &context, const clang::CXXRecordDecl *decl,
                      ModuleInstance *add_module) {
    MatchFinder port_registry{};
    PortMatcher port_matcher{};
    port_matcher.registerMatchers(port_registry);
    port_registry.match(*decl, context);
    // decl->dump();
    LLVM_DEBUG(llvm::dbgs() << "========== Port Matcher =============\n";
    port_matcher.dump();
    );
 
    // All the ports for the CXXRecordDecl should be matched.
    // We can populate the ModuleInstance with that information.
    add_module->addPorts(port_matcher.getInputPorts(), "sc_in");
    // Clock ports are also sc_in
    add_module->addPorts(port_matcher.getClockPorts(), "sc_in");
    add_module->addPorts(port_matcher.getOutputPorts(), "sc_out");
    add_module->addPorts(port_matcher.getInOutPorts(), "sc_inout");
    add_module->addPorts(port_matcher.getOtherVars(), "others");
    add_module->addPorts(port_matcher.getSignals(), "sc_signal");
    add_module->addPorts(port_matcher.getInputStreamPorts(), "sc_stream_in");
    add_module->addPorts(port_matcher.getOutputStreamPorts(), "sc_stream_out");
    add_module->addPorts(port_matcher.getSubmodules(), "submodules");
  }
 
  void runModuleDeclarationMatchers(ASTContext &context,
                                    clang::CXXRecordDecl *cxx_decl,
                                    ModuleInstance *add_module_decl) {
    // setInstanceInfo done in pruneMatches
    //
    FindTemplateParameters tparms{cxx_decl};
    add_module_decl->setTemplateParameters(tparms.getTemplateParameters());
    add_module_decl->setTemplateArgs(tparms.getTemplateArgs());
 
    //
    //
    LLVM_DEBUG(llvm::dbgs() << "4. Set the constructor.\n";);
    std::vector<EntryFunctionContainer *> _entryFunctionContainerVector;
    FindConstructor constructor{add_module_decl->getModuleClassDecl(),
                                llvm::dbgs()};
    add_module_decl->addConstructor(&constructor);
 
    //
    //
    // 5. Find  entry functions within one sc_module.
    LLVM_DEBUG(llvm::dbgs() << "5. Set the entry functions\n";);
    FindEntryFunctions findEntries{add_module_decl->getModuleClassDecl(),
                                   llvm::dbgs(), context};
 
    FindEntryFunctions::entryFunctionVectorType *entryFunctions{
        findEntries.getEntryFunctions()};
 
    LLVM_DEBUG(llvm::dbgs() << "6. Set the process\n";);
    add_module_decl->addProcess(entryFunctions);
 
    SensitivityMatcher sens_matcher{};
    MatchFinder matchRegistry{};
    sens_matcher.registerMatchers(matchRegistry);
    if (constructor.getConstructorDecl()) {
      matchRegistry.match(*constructor.getConstructorDecl(), context);
    }
 
    for (size_t i{0}; i < entryFunctions->size(); i++) {
      EntryFunctionContainer *ef{(*entryFunctions)[i]};
 
      EntryFunctionContainer::SenseMapType sensitivity_info{
          sens_matcher.getSensitivityMap()};
      ef->addSensitivityInfo(sensitivity_info);
 
      if (ef->getEntryMethod() == nullptr) {
        LLVM_DEBUG(llvm::dbgs() << "ERROR";);
        continue;
      }
 
      FindWait findWaits{ef->getEntryMethod(), llvm::dbgs()};
      ef->addWaits(findWaits);
 
      FindNotify findNotify{ef->getEntryMethod(), llvm::dbgs()};
      ef->addNotifys(findNotify);
 
      _entryFunctionContainerVector.push_back(ef);
    }
  }
 
  void matchInstancesInBaseClasses(ASTContext &context) {
    auto instance_map{instance_matcher_.getInstanceMap()};
    for (const auto &inst : instance_map) {
      ModuleInstanceType instance{inst.second};
      clang::CXXRecordDecl *decl{
          dyn_cast<clang::CXXRecordDecl>(inst.second.getInstanceTypeDecl())};
      clang::ValueDecl *vd{
          dyn_cast<clang::ValueDecl>(inst.second.getInstanceDecl())};
 
      auto base_decls{getAllBaseClasses(decl)};
      for (const auto &base_decl : base_decls) {
        LLVM_DEBUG(llvm::dbgs() << "=============================== BASES "
                                << decl->getNameAsString()
                                << " =======================\n";
                   llvm::dbgs() << "Run base instance matcher: "
                                << base_decl->getNameAsString() << " \n";);
 
        InstanceMatcher base_instance_matcher;
        MatchFinder base_instance_reg{};
        base_instance_matcher.registerMatchers(base_instance_reg);
        base_instance_matcher.setParentFieldDecl(vd);
        base_instance_reg.match(*base_decl, context);
        LLVM_DEBUG(llvm::dbgs() << "+ Dump base instance matcher\n";
                   base_instance_matcher.dump();
                   llvm::dbgs() << "+ End dump base instance matcher\n";);
 
        instance_matcher_ = base_instance_matcher;
      }
    }
  }
 
  void processInstanceCXXDecls(ASTContext &context) {
    // Must have found instances.
    // 1. For every module found, check if there is an instance.
    // 2. If there is an instance, then add it into the list.
 
    LLVM_DEBUG(
    llvm::dbgs() << "###### DUMP Instance Matches \n";
    instance_matcher_.dump();
    );
 
    auto instance_map{instance_matcher_.getInstanceMap()};
 
    matchInstancesInBaseClasses(context);
 
    instance_map = instance_matcher_.getInstanceMap();
 
    for (const auto &inst : instance_map) {
      clang::CXXRecordDecl *decl{
          dyn_cast<clang::CXXRecordDecl>(inst.second.getInstanceTypeDecl())};
      auto name{decl->getNameAsString()};
      LLVM_DEBUG(llvm::dbgs() << "class: " << name << "\n";);
    }
 
    for (const auto &inst : instance_map) {
      ModuleInstanceType instance{inst.second};
 
      clang::CXXRecordDecl *decl{
          dyn_cast<clang::CXXRecordDecl>(inst.second.getInstanceTypeDecl())};
      auto name{decl->getNameAsString()};
      LLVM_DEBUG(llvm::dbgs() << "############### ====> INST: " << inst.first
                              << ", name: " << name << ", instance_name: "
                              << inst.second.instance_name << "\n";);
 
      auto add_module{new ModuleInstance(name, decl)};
      add_module->setInstanceInfo(instance);
 
      modules_.insert(std::pair<clang::CXXRecordDecl *, ModuleInstance *>(
          decl, add_module));
 
      LLVM_DEBUG(llvm::dbgs() << "[Running module declaration matchers]\n";);
      runModuleDeclarationMatchers(context, decl, add_module);
      LLVM_DEBUG(llvm::dbgs() << "[Running port matcher]\n";);
      runPortMatcher(context, decl, add_module);
 
      LLVM_DEBUG(llvm::dbgs() << "[Running Base class logic]\n";);
      auto base_decls{getAllBaseClasses(decl)};
      for (const auto &base_decl : base_decls) {
        auto name{base_decl->getNameAsString()};
        ModuleInstance *base_module_instance{
            new ModuleInstance{name, base_decl}};
        LLVM_DEBUG(base_decl->dump();
                   llvm::dbgs()
                   << "Base class: " << base_decl->getNameAsString() << "\n";);
 
        runModuleDeclarationMatchers(
            context, const_cast<clang::CXXRecordDecl *>(base_decl),
            base_module_instance);
        runPortMatcher(context, base_decl, base_module_instance);
        add_module->addBaseInstance(base_module_instance);
        LLVM_DEBUG(llvm::dbgs() << "End base logic loop\n";);
      }
    }
  }
 
  void dump() {
    llvm::outs() << "[DBG] Module instances: " << modules_.size() << "\n";
    for (const auto &i : modules_) {
      auto cxx_decl{i.first};
      // TODO: really awkward
      auto module_decl{i.second};
      auto decl_name{module_decl->getName()};
 
      LLVM_DEBUG(llvm::outs() << "CXXRecordDecl* " << cxx_decl
                              << ", module name: " << decl_name << "\n";);
    }
 
    // Print the instances.
    instance_matcher_.dump();
  }
};
 
};  // namespace sc_ast_matchers
 
#endif