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()
  {
    if (!is_initialized_) initialize();
    return sc_module_;
  }

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

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

  static SgClassDefinition* get_tlm_base_initiator_socket_b()
  {
    if (!is_initialized_) initialize();
    return tlm_base_initiator_socket_b_;
  }

  static SgClassDefinition* get_tlm_base_target_socket_b()
  {
    if (!is_initialized_) initialize();
    return tlm_base_target_socket_b_;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  static SgFunctionDefinition* get_sc_main()
  {
    if (!is_initialized_) initialize();
// RD: in PSG mode, this won't be found, so we delay the error until it's needed
    if (!sc_main_) { // complain if not found (RD, 07/06/18)
      std::cerr << std::endl << "ERROR: Cannot find definition of function '"
                << "sc_main" << "' (in source code). Aborting."
                << std::endl;
      exit(10);
    }
    return sc_main_;
  }

  static SgClassDefinition* get_sc_simcontext()
  {
    if (!is_initialized_) initialize();
    return sc_simcontext_;
  }

  static SgClassDefinition* get_sc_segid()
  {
    if (!is_initialized_) initialize();
    return sc_segid_;
  }

  static SgClassDefinition* get_sc_time()
  {
    if (!is_initialized_) initialize();
    return sc_time_;
  }

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

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

  static SgFunctionDeclaration* get_sc_stop()
  {
    if (!is_initialized_) initialize();
    return sc_stop_;
  }

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

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

  static SgFunctionDeclaration* get_get_upcoming_socket_id()
  {
    if (!is_initialized_) initialize();
    return get_upcoming_socket_id_;
  }

  static SgFunctionDeclaration* get_set_upcoming_socket_id()
  {
    if (!is_initialized_) initialize();
    return set_upcoming_socket_id_;
  }

  static SgFunctionDeclaration* get_increase_offset()
  {
    if (!is_initialized_) initialize();
    return increase_offset_;
  }

  static SgFunctionDeclaration* get_decrease_offset()
  {
    if (!is_initialized_) initialize();
    return decrease_offset_;
  }

  static SgFunctionDeclaration* get_get_offset()
  {
    if (!is_initialized_) initialize();
    return get_offset_;
  }

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

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

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

  static const std::set<SgFunctionDefinition*>& get_sc_next_trigger_funcs()
  {
    if (!is_initialized_) initialize();
    return sc_next_trigger_funcs_;
  }

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

  static const SgMemberFunctionDeclaration* get_base_interface()
  {
    if (!is_initialized_) initialize();
    return get_base_interface_;
  }

  static const SgMemberFunctionDeclaration* get_base_port()
  {
    if (!is_initialized_) initialize();
    return get_base_port_;
  }



private:

  static void initialize();

  /*
   * \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_time_;
  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 SgClassDefinition *tlm_base_initiator_socket_b_;
  static SgClassDefinition *tlm_base_target_socket_b_;

  static SgFunctionDefinition *sc_main_;
  static SgFunctionDeclaration *sc_get_curr_simcontext_;
  static SgFunctionDeclaration *sc_stop_;
  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_upcoming_socket_id_;
  static SgMemberFunctionDeclaration *set_upcoming_socket_id_;

  static SgMemberFunctionDeclaration *increase_offset_;
  static SgMemberFunctionDeclaration *decrease_offset_;
  static SgMemberFunctionDeclaration *get_offset_;

  static SgMemberFunctionDeclaration *get_interface_;
  static SgMemberFunctionDeclaration *get_base_interface_;
  static SgMemberFunctionDeclaration *get_base_port_;

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

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

  static bool is_initialized_;
};

// NEW: efficient type comparison functions (RD, 07/14/18)

inline bool is_type_sc_module(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_module()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_port(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_port()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_port_base(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_port_base()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_in(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_in()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_out(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_out()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_inout(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_inout()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_event(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_event()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_event_and_list(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_event_and_list()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_event_or_list(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_event_or_list()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_prim_channel(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_prim_channel()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_interface(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_interface()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_fifo(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_fifo()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_fifo_in(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_fifo_in()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_fifo_out(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_fifo_out()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_simcontext(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_simcontext()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_segid(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_segid()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_time(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_time()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_process_b(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_process_b()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_channel(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_channel()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_in_clk(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_in_clk()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_out_clk(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_out_clk()
                    ->get_declaration()->get_type();
}

inline bool is_type_sc_inout_clk(SgType *type)
{
  return type->stripTypedefsAndModifiers() ==
              SystemCDefinitions::get_sc_inout_clk()
                    ->get_declaration()->get_type();
}

}; // end of namespace tools

}; // end of namespace risc

#endif /* SYSTEMC_DEFINITION_H_INCLUDED_ */

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