/local/lecs/lecs/risc_v0.3.0/sources/build/risc_v0.3.0/src/tools/systemc_definitions.h

Go to the documentation of this file.

#ifndef SYSTEMC_DEFINITION_H_INCLUDED_
#define SYSTEMC_DEFINITION_H_INCLUDED_

#include "rose.h"

#include "rose_nodes.h"

namespace risc {

namespace tools {

class SystemCDefinitions {

public:

  static SgClassDefinition* get_sc_module()
  {
    initialize();
    return sc_module_;
  }

  static SgClassDefinition* get_sc_port()
  {
    initialize();
    return sc_port_;
  }

  static SgClassDefinition* get_sc_port_base()
  {
    initialize();
    return sc_port_base_;
  }

  static SgClassDefinition* get_sc_in()
  {
    initialize();
    return sc_in_;
  }

  static SgClassDefinition* get_sc_out()
  {
    initialize();
    return sc_out_;
  }

  static SgClassDefinition* get_sc_inout()
  {
    initialize();
    return sc_inout_;
  }

  static SgClassDefinition* get_sc_event()
  {
    initialize();
    return sc_event_;
  }

  static SgClassDefinition* get_sc_event_and_list()
  {
    initialize();
    return sc_event_and_list_;
  }

  static SgClassDefinition* get_sc_event_or_list()
  {
    initialize();
    return sc_event_or_list_;
  }

  static SgClassDefinition* get_sc_prim_channel()
  {
    initialize();
    return sc_prim_channel_;
  }

  static SgClassDefinition* get_sc_interface()
  {
    initialize();
    return sc_interface_;
  }

  static SgClassDefinition* get_sc_channel()
  {
    initialize();
    return sc_channel_;
  }

  static SgClassDefinition* get_sc_in_clk()
  {
    initialize();
    return sc_in_clk_;
  }

  static SgClassDefinition* get_sc_out_clk()
  {
    initialize();
    return sc_out_clk_;
  }

  static SgClassDefinition* get_sc_inout_clk()
  {
    initialize();
    return sc_inout_clk_;
  }

  static SgClassDefinition* get_sc_fifo()
  {
    initialize();
    return sc_fifo_;
  }

  static SgClassDefinition* get_sc_fifo_in()
  {
    initialize();
    return sc_fifo_in_;
  }

  static SgClassDefinition* get_sc_fifo_out()
  {
    initialize();
    return sc_fifo_out_;
  }

  static SgFunctionDefinition* get_sc_main()
  {
    initialize();
    return sc_main_;
  }

  static const std::vector<SgNamespaceDefinitionStatement*>& get_sc_core()
  {
    initialize();
    return sc_core_;
  }

  static const std::vector<SgNamespaceDefinitionStatement*>& get_sc_dt()
  {
    initialize();
    return sc_dt_;
  }

  static const std::set<SgFunctionDefinition*>& get_sc_wait_funcs()
  {
    initialize();
    return sc_wait_funcs_;
  }

private:
  static void initialize()
  {
    if(is_initialized_ == true) {
      return;
    }

    sc_module_ = NULL;
    sc_port_ = NULL;
    sc_port_base_ = NULL;
    sc_in_ = NULL;
    sc_out_ = NULL;
    sc_inout_ = NULL;
    sc_event_ = NULL;
    sc_event_and_list_ = NULL;
    sc_event_or_list_ = NULL;
    sc_prim_channel_ = NULL;
    sc_interface_ = NULL;
    sc_channel_ = NULL;
    sc_in_clk_ = NULL;
    sc_out_clk_ = NULL;
    sc_inout_clk_ = NULL;
    sc_fifo_ = NULL;
    sc_fifo_in_ = NULL;
    sc_fifo_out_ = NULL;

    sc_main_ = NULL;

    const std::vector<SgNode*> &class_defs = RoseNodes::get_class_defs();
    for(std::vector<SgNode*>::const_iterator
        iter  = class_defs.begin();
        iter != class_defs.end();
        iter++) {

      SgClassDefinition* class_def = isSgClassDefinition(*iter);
      std::string qualified_name = class_def->get_qualified_name();

      #define COMPARE_NAME(QualifiedName, Variable) \
      if(qualified_name == #QualifiedName) {        \
        sc_##Variable = class_def;                  \
        continue;                                   \
      }
      COMPARE_NAME(::sc_core::sc_module, module_);
      COMPARE_NAME(::sc_core::sc_port, port_);
      COMPARE_NAME(::sc_core::sc_port_base, port_base_);
      COMPARE_NAME(::sc_core::sc_in, in_);
      COMPARE_NAME(::sc_core::sc_inout, inout_);
      COMPARE_NAME(::sc_core::sc_out, out_);
      COMPARE_NAME(::sc_core::sc_event, event_);
      COMPARE_NAME(::sc_core::sc_event_and_list, event_and_list_);
      COMPARE_NAME(::sc_core::sc_event_or_list, event_or_list_);
      COMPARE_NAME(::sc_core::sc_prim_channel, prim_channel_);
      COMPARE_NAME(::sc_core::sc_interface, interface_);
      COMPARE_NAME(::sc_core::sc_channel, channel_);
      COMPARE_NAME(::sc_core::sc_fifo, fifo_);
      COMPARE_NAME(::sc_core::sc_fifo_in, fifo_in_);
      COMPARE_NAME(::sc_core::sc_fifo_out, fifo_out_);

      // This is a hack! Why? All four types are in the original library
      // typedefs. However, rose has some hiccups with parsing sc_out. There is
      // no definition available. So, I introduced in the SystemC library some
      // 'fake' classes and replaced the typedefs.
      COMPARE_NAME(::sc_core::sc_in_clk, in_clk_);
      COMPARE_NAME(::sc_core::sc_out_clk, out_clk_);
      COMPARE_NAME(::sc_core::sc_inout_clk, inout_clk_);
      #undef COMPARE_NAME
    }

    // Search for the SystemC Namespaces sc_core and sc_dt
    const std::vector<SgNode*> &temp_namespaces
      = risc::tools::RoseNodes::get_namespace_defs();
    for(std::vector<SgNode*>::const_iterator
        iter  = temp_namespaces.begin();
        iter != temp_namespaces.end();
        iter++) {

      SgNamespaceDefinitionStatement *namespace_def
        = isSgNamespaceDefinitionStatement(*iter);
      std::string qualified_name = namespace_def->get_qualified_name();

      #define COMPARE_NAME(QualifiedName, Variable) \
      if(qualified_name == #QualifiedName) {        \
        sc_##Variable.push_back(namespace_def);     \
        continue;                                   \
      }
      COMPARE_NAME(::sc_core, core_);
      COMPARE_NAME(::sc_dt, dt_);
      #undef COMPARE_NAME
    }

    // Search for all wait functions
    const std::vector<SgNode*> &temp_wait_func_def
      = risc::tools::RoseNodes::get_func_defs();

    for(std::vector<SgNode*>::const_iterator
        iter  = temp_wait_func_def.begin();
        iter != temp_wait_func_def.end();
        iter++) {

      SgFunctionDefinition *func_def = isSgFunctionDefinition(*iter);
      std::string qualified_name
        = func_def->get_declaration()->get_qualified_name();

      #define COMPARE_NAME(QualifiedName, Variable) \
      if(qualified_name == #QualifiedName) {        \
        sc_##Variable = func_def;                   \
        continue;                                   \
      }
      COMPARE_NAME(::sc_main, main_);
      #undef COMPARE_NAME

      SgClassDefinition *enclosing_class_def
        = SageInterface::getEnclosingClassDefinition(func_def);

      // Here, we are searching for the wait functions in sc_module
      if(enclosing_class_def == sc_module_) {
        if(SageInterface::get_name(func_def) == "wait") {
          sc_wait_funcs_.insert(func_def);
        }
      }

      if(enclosing_class_def == sc_prim_channel_) {
        if(SageInterface::get_name(func_def) == "wait") {
          sc_wait_funcs_.insert(func_def);
        }
      }
    }

    SystemCDefinitions::is_initialized_ = true;

  #if 0
    std::cout << "sc_module_         " << sc_module_ << std::endl;
    std::cout << "sc_port_           " << sc_port_  << std::endl;
    std::cout << "sc_port_base_      " << sc_port_base_ << std::endl;
    std::cout << "sc_in_             " << sc_in_ << std::endl;
    std::cout << "sc_inout_          " << sc_inout_ << std::endl;
    std::cout << "sc_out_            " << sc_out_ << std::endl;
    std::cout << "sc_event_          " << sc_event_ << std::endl;
    std::cout << "sc_event_and_list_ " << sc_event_and_list_ << std::endl;
    std::cout << "sc_event_or_list_  " << sc_event_or_list_ << std::endl;
    std::cout << "sc_prim_channel_   " << sc_prim_channel_ << std::endl;
    std::cout << "sc_channel_        " << sc_channel_ << std::endl;
    std::cout << "sc_in_clk_         " << sc_in_clk_ << std::endl;
    std::cout << "sc_out_clk_        " << sc_out_clk_ << std::endl;
    std::cout << "sc_inout_clk_      " << sc_inout_clk_ << std::endl;
    std::cout << "sc_fifo_           " << sc_fifo_ << std::endl;
    std::cout << "sc_fifo_in_        " << sc_fifo_in_ << std::endl;
    std::cout << "sc_fifo_out_       " << sc_fifo_out_ << std::endl;
    std::cout << "sc_main_:          " << sc_main_ << std::endl;
    std::cout << "sc_core_           " << sc_core_.size() << std::endl;
    std::cout << "sc_dt_             " << sc_dt_.size() << std::endl;
    std::cout << "sc_wait_funcs_:    " << sc_wait_funcs_.size() << std::endl;
  #endif
  }

  /*
   * \brief Pointer to the sc_module definition in the rose ast tree
   */
  static SgClassDefinition *sc_module_;
  static SgClassDefinition *sc_port_;
  static SgClassDefinition *sc_port_base_;
  static SgClassDefinition *sc_in_;
  static SgClassDefinition *sc_out_;
  static SgClassDefinition *sc_inout_;
  static SgClassDefinition *sc_event_;
  static SgClassDefinition *sc_event_and_list_;
  static SgClassDefinition *sc_event_or_list_;
  static SgClassDefinition *sc_prim_channel_;
  static SgClassDefinition *sc_interface_;
  static SgClassDefinition *sc_fifo_;
  static SgClassDefinition *sc_fifo_in_;
  static SgClassDefinition *sc_fifo_out_;

  // This is a hack. Please see the comment in the source file.
  static SgClassDefinition *sc_channel_;
  static SgClassDefinition *sc_in_clk_;
  static SgClassDefinition *sc_out_clk_;
  static SgClassDefinition *sc_inout_clk_;

  static SgFunctionDefinition *sc_main_;

  // Namespace of systemc
  static std::vector<SgNamespaceDefinitionStatement*> sc_core_;
  static std::vector<SgNamespaceDefinitionStatement*> sc_dt_;

  // Wait functions
  static std::set<SgFunctionDefinition*> sc_wait_funcs_;

  static bool is_initialized_;
};

}; // end of namespace tools

}; // end of namespace risc

#endif /* SYSTEMC_DEFINITION_H_INCLUDED_ */

/* ex: set softtabstop=2 tabstop=2 shiftwidth=2 expandtab: */

---