/local/lecs/lecs/risc_v0.2.1/sources/build/risc_v0.2.1/src/segment_graph/segment_graph.h

Go to the documentation of this file.

#ifndef SEGMENT_GRAPH_H_INCLUDED_
#define SEGMENT_GRAPH_H_INCLUDED_

#include<iostream>
#include<set>
#include<utility>

#include<boost/graph/adjacency_list.hpp>
#include<boost/graph/graphviz.hpp>
#include<boost/algorithm/string.hpp>

#include "../internal_representation/function.h"
#include "segment.h"
#include "edge.h"

namespace risc {

namespace sg {

class SegmentGraph;

typedef boost::adjacency_list<boost::listS,
        boost::listS, boost::bidirectionalS, Segment, Edge,
        boost::property<boost::vertex_index_t, int> > Graph;
typedef boost::graph_traits<Graph>::vertex_descriptor VertexDescriptor;
typedef boost::graph_traits<Graph>::edge_descriptor EdgeDescriptor;

typedef boost::graph_traits<risc::sg::Graph>::vertex_iterator VertexIterator;

class CachedFunctionAstAttributes;

class SegmentGraph {

public:
  typedef std::set<SgFunctionDefinition*> FunctionCallBoundarySet;
  typedef std::set<VariantT> CCxxKeywordsBoundarySet;

  SegmentGraph(FunctionCallBoundarySet function_boundaries);
  SegmentGraph(CCxxKeywordsBoundarySet keyword_boundaries);
  SegmentGraph(FunctionCallBoundarySet function_boundaries,
      CCxxKeywordsBoundarySet keyword_boundaries);

  void clean_graph();


  void print_graph(std::string filename);


  void print_graph_read_write_access(std::string filename);


  void add_function(Function *function, bool duplicate_segments = false);

  typedef std::set<VertexDescriptor> SegmentSet;

  void read_write_analysis_of_segments();

  void set_all_segments_to_untouched();

private:

  void handle_recursive_calls();


  void separate_variable_declaration_and_initializer_on_demand(
           SgBasicBlock *&bb, bool duplicate_segments);


  void decompose_expression_with_boundary_calls(SgExpression *expr,
           SgBasicBlock *&bb, bool duplicate_segments);


  void create_temp_variable_for_expression(SgExpression *expr,
           SgBasicBlock *&bb);


  SgExpression* decompose_member_function_calls(SgFunctionCallExp *func_call,
                    SgBasicBlock *&bb);


  std::string generate_unique_name(SgNode *node);


  bool is_boundary_stmt(SgStatement const * const current_stmt);


  SgFunctionCallExp* has_function_call_with_boundary(SgExpression *expr,
                         bool duplicate_segments);


  bool should_decompose_function(SgExpression *expr);


  SgFunctionDeclaration* contains_function_call_expression(SgExpression *expr);


  SegmentSet build_graph(
      SgStatement *current_stmt,
      SegmentSet current_segments,
      SegmentSet &break_segments,
      SegmentSet &continue_segments,
      bool duplicate_segments);


  void add_expression_to_segment(SegmentSet segments, SgNode *expr);


  CachedFunctionAstAttributes* build_segment_graph_for_function(
      SgFunctionDefinition *func_def, bool duplicate_segments);


  void insert_loop_edges(VertexDescriptor &loop_vertex,
           SegmentSet &current_segments,
           SegmentSet &continue_segments,
           SegmentSet &leaf_segments_of_loop);

  SegmentSet duplicate_segments(SegmentSet segments);
  SegmentSet duplicate_empty_segments(SegmentSet segments);

  FunctionCallBoundarySet function_boundaries_;
  CCxxKeywordsBoundarySet keyword_boundaries_;

  std::set<VertexDescriptor> recursive_function_calls_;

  static int counter;
public:
  Graph graph_;

  std::set<VertexDescriptor> precached_function_segments_;
};

} // end of namespace sg

} // end of namespace risc

#endif /* SEGMENT_GRAPH_H_INCLUDED_ */

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

---