/local/lecs/lecs/risc_v0.4.2/sources/build/risc_v0.4.2/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 SgClassDefinition* get_sc_simcontext()
  {
    initialize();
    return sc_simcontext_;
  }
  
  static SgClassDefinition* get_sc_segid()
  {
    initialize();
    return sc_segid_;
  }

  static SgClassDefinition* get_sc_process_b()
  {
    initialize();
    return sc_process_b_;
  }

  static SgFunctionDeclaration* get_sc_curr_proc()
  {
    initialize();
    return sc_get_curr_proc_;
  }
  
  static SgFunctionDeclaration* get_sc_segid_ctor()
  {
    initialize();
    return sc_segid_ctor_;
  }
  
  static SgFunctionDeclaration* get_sc_get_curr_simcontext()
  {
    initialize();
    return sc_get_curr_simcontext_;
  }

  static SgFunctionDeclaration* get_get_upcoming_segment_ids()
  {
    initialize();
    return get_upcoming_segment_ids_;
  }

  static SgFunctionDeclaration* get_set_upcoming_segment_ids()
  {
    initialize();
    return set_upcoming_segment_ids_;
  }

  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_;
  }

  static const SgMemberFunctionDeclaration* get_interface()
  {
    initialize();
    return get_interface_;
  }

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_simcontext_ = NULL;
    sc_segid_ = NULL;
    sc_process_b_ = NULL;
    sc_get_curr_simcontext_ = NULL;
    sc_get_curr_proc_ = NULL;
    sc_segid_ctor_ = NULL;
    get_upcoming_segment_ids_ = NULL;
    set_upcoming_segment_ids_ = 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_);
      COMPARE_NAME(::sc_core::sc_simcontext, simcontext_);
      COMPARE_NAME(::sc_core::sc_segid, segid_);
      COMPARE_NAME(::sc_core::sc_process_b, process_b_);

      // 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);
        }
      }
    }

    std::vector<SgNode*> func_defs
      = NodeQuery::querySubTree(sc_process_b_, V_SgFunctionDeclaration);
    for(std::vector<SgNode*>::iterator
        iter  = func_defs.begin();
        iter != func_defs.end();
        iter++) {
      if(SageInterface::get_name(*iter) == "get_upcoming_segment_ids") {
        get_upcoming_segment_ids_ = isSgMemberFunctionDeclaration(*iter);
        get_upcoming_segment_ids_
          = isSgMemberFunctionDeclaration(
              get_upcoming_segment_ids_
                ->get_declaration_associated_with_symbol());
      }
      if(SageInterface::get_name(*iter) == "set_upcoming_segment_ids") {
        set_upcoming_segment_ids_ = isSgMemberFunctionDeclaration(*iter);
        set_upcoming_segment_ids_
          = isSgMemberFunctionDeclaration(
              set_upcoming_segment_ids_
                ->get_declaration_associated_with_symbol());
      }
    }

    func_defs
      = NodeQuery::querySubTree(sc_simcontext_, V_SgMemberFunctionDeclaration);
    for(std::vector<SgNode*>::iterator
        iter  = func_defs.begin();
        iter != func_defs.end();
        iter++) {
      if(SageInterface::get_name(*iter) == "get_curr_proc") {
        sc_get_curr_proc_ = isSgMemberFunctionDeclaration(*iter);
        sc_get_curr_proc_
          = isSgMemberFunctionDeclaration(
              sc_get_curr_proc_->get_declaration_associated_with_symbol());
      }
    }
    
    func_defs
      = NodeQuery::querySubTree(sc_segid_, V_SgMemberFunctionDeclaration);
    for(std::vector<SgNode*>::iterator
        iter  = func_defs.begin();
        iter != func_defs.end();
        iter++) {
          
      if(SageInterface::get_name(*iter) == "sc_segid") {
        sc_segid_ctor_ = isSgMemberFunctionDeclaration(*iter);
        sc_segid_ctor_
          = isSgMemberFunctionDeclaration(
              sc_segid_ctor_->get_declaration_associated_with_symbol());
      }
    }

    func_defs
      = NodeQuery::querySubTree(sc_port_base_, V_SgMemberFunctionDeclaration);
    for(std::vector<SgNode*>::iterator
        iter  = func_defs.begin();
        iter != func_defs.end();
        iter++) {
      if(SageInterface::get_name(*iter) == "get_interface") {
        get_interface_ = isSgMemberFunctionDeclaration(*iter);
        get_interface_
          = isSgMemberFunctionDeclaration(
              get_interface_->get_declaration_associated_with_symbol());
      }
    }

    for(std::vector<SgNamespaceDefinitionStatement*>::iterator
        namespace_iter  = sc_core_.begin();
        namespace_iter != sc_core_.end();
        namespace_iter++) {

      func_defs = NodeQuery::querySubTree(
                    *namespace_iter, V_SgFunctionDeclaration);

      bool found = false;
      for(std::vector<SgNode*>::iterator
          iter  = func_defs.begin();
          iter != func_defs.end();
          iter++) {

        if(SageInterface::get_name(*iter) == "sc_get_curr_simcontext") {
          sc_get_curr_simcontext_ = isSgFunctionDeclaration(*iter);
          sc_get_curr_simcontext_
            = isSgFunctionDeclaration(
                sc_get_curr_simcontext_
                  ->get_declaration_associated_with_symbol());
          found = true;
        }
      }

      if(found) {
        break;
      }
    }

    SystemCDefinitions::is_initialized_ = true;

  #if 0
    std::cout << "sc_process_b_             " << sc_process_b_ << std::endl;
    std::cout << "sc_simcontext_            " << sc_simcontext_ << std::endl;
    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;
    std::cout << "get_curr_proc_            " << sc_get_curr_proc_ << std::endl;
    std::cout << "get_curr_simcontext_      " << sc_get_curr_simcontext_ << std::endl;
    std::cout << "get_upcoming_segment_ids_ " << get_upcoming_segment_ids_ << std::endl;
    std::cout << "set_upcoming_segment_ids_ " << set_upcoming_segment_ids_ << 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_;
  static SgClassDefinition *sc_simcontext_;
  static SgClassDefinition *sc_segid_;
  static SgClassDefinition *sc_process_b_;

  // 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_;
  static SgFunctionDeclaration *sc_get_curr_simcontext_;
  static SgMemberFunctionDeclaration *sc_get_curr_proc_;
  static SgMemberFunctionDeclaration *sc_segid_ctor_;
  static SgMemberFunctionDeclaration *get_upcoming_segment_ids_;
  static SgMemberFunctionDeclaration *set_upcoming_segment_ids_;
  static SgMemberFunctionDeclaration *get_interface_;

  // 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: */

---