basic_block.hpp

Go to the documentation of this file.

/*
 *
 *                   _/_/_/    _/_/   _/    _/ _/_/_/    _/_/
 *                  _/   _/ _/    _/ _/_/  _/ _/   _/ _/    _/
 *                 _/_/_/  _/_/_/_/ _/  _/_/ _/   _/ _/_/_/_/
 *                _/      _/    _/ _/    _/ _/   _/ _/    _/
 *               _/      _/    _/ _/    _/ _/_/_/  _/    _/
 *
 *             ***********************************************
 *                              PandA Project
 *                     URL: http://panda.dei.polimi.it
 *                       Politecnico di Milano - DEIB
 *                        System Architectures Group
 *             ***********************************************
 *              Copyright (C) 2004-2024 Politecnico di Milano
 *
 *   This file is part of the PandA framework.
 *
 *   The PandA framework is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
#ifndef BASIC_BLOCK_HPP
#define BASIC_BLOCK_HPP

#include "config_HAVE_UNORDERED.hpp"

#include "cdfg_edge_info.hpp" // for CdfgEdgeInfo
#include "edge_info.hpp"      // for EdgeInfoRef
#include "graph.hpp"          // for vertex, EdgeDesc...
#include "graph_info.hpp"     // for GraphInfo
#include "node_info.hpp"      // for NodeInfo
#include "refcount.hpp"       // for refcount, Refcou...
#include <cstddef>            // for size_t
#include <functional>         // for binary_function
#include <list>               // for list
#include <string>             // for string
#include <utility>            // for pair

#include "custom_map.hpp"
#include "custom_set.hpp"

CONSTREF_FORWARD_DECL(application_manager);
class BasicBlocksGraphConstructor;
REF_FORWARD_DECL(bloc);
class FunctionBehavior;
CONSTREF_FORWARD_DECL(Parameter);

#define D_SELECTOR (1 << 7)

#define PD_SELECTOR (1 << 8)

#define J_SELECTOR (1 << 9)

#define PP_SELECTOR (1 << 10)

struct BBNodeInfo : public NodeInfo
{
 public:
   unsigned int loop_id;

   unsigned int cer;

   blocRef block;

   std::list<vertex> statements_list;

   BBNodeInfo();

   explicit BBNodeInfo(blocRef _block);

   void add_operation_node(const vertex op);

   vertex get_first_operation() const;

   vertex get_last_operation() const;

   bool empty() const;

   size_t size() const;

   unsigned int get_bb_index() const;

   const CustomOrderedSet<unsigned int>& get_live_in() const;

   const CustomOrderedSet<unsigned int>& get_live_out() const;
};
using BBNodeInfoRef = refcount<BBNodeInfo>;
using BBNodeInfoConstRef = refcount<const BBNodeInfo>;

struct BBEdgeInfo : public CdfgEdgeInfo
{
 private:
   friend class BasicBlocksGraphConstructor;
   friend class FunctionBehavior;

   unsigned long long epp_value;

 public:
   BBEdgeInfo();

   ~BBEdgeInfo() override;

   bool cdg_edge_T() const;

   bool cdg_edge_F() const;

   bool cfg_edge_T() const;

   bool cfg_edge_F() const;

   bool switch_p() const;

   const CustomOrderedSet<unsigned int> get_labels(const int selector) const;

   void set_epp_value(unsigned long long _epp_value);

   unsigned long long get_epp_value() const;
};
using BBEdgeInfoRef = refcount<BBEdgeInfo>;
using BBEdgeInfoConstRef = refcount<const BBEdgeInfo>;

struct BBGraphInfo : public GraphInfo
{
   const application_managerConstRef AppM;

   const unsigned int function_index;

   CustomUnorderedMap<unsigned int, vertex> bb_index_map;

   vertex entry_vertex;

   vertex exit_vertex;

   BBGraphInfo(const application_managerConstRef AppM, const unsigned int function_index);
};
using BBGraphInfoRef = refcount<BBGraphInfo>;
using BBGraphInfoConstRef = refcount<const BBGraphInfo>;

class BBGraphsCollection : public graphs_collection
{
 private:
   friend class BasicBlocksGraphConstructor;

 public:
   BBGraphsCollection(const BBGraphInfoRef bb_graph_info, const ParameterConstRef parameters);

   ~BBGraphsCollection() override;

   inline EdgeDescriptor AddEdge(const vertex source, const vertex target, const int selector)
   {
      if(ExistsEdge(source, target))
      {
         return AddSelector(source, target, selector);
      }
      else
      {
         return InternalAddEdge(source, target, selector, EdgeInfoRef(new BBEdgeInfo()));
      }
   }
};
using BBGraphsCollectionRef = refcount<BBGraphsCollection>;
using BBGraphsCollectionConstRef = refcount<const BBGraphsCollection>;

struct BBGraph : public graph
{
 public:
   BBGraph(const BBGraphsCollectionRef _g, int selector);

   BBGraph(const BBGraphsCollectionRef _g, int selector, CustomUnorderedSet<vertex>& sub);

   ~BBGraph() override = default;

   void WriteDot(const std::string& file_name, const int detail_level = 0) const;

   void WriteDot(const std::string& file_name, const CustomUnorderedSet<vertex>& annotated,
                 const int detail_level = 0) const;

   size_t num_bblocks() const;

   inline BBNodeInfoRef GetBBNodeInfo(const vertex node)
   {
      return RefcountCast<BBNodeInfo>(graph::GetNodeInfo(node));
   }

   inline const BBNodeInfoConstRef CGetBBNodeInfo(const vertex node) const
   {
      return RefcountCast<const BBNodeInfo>(graph::CGetNodeInfo(node));
   }

   inline BBEdgeInfoRef GetBBEdgeInfo(const EdgeDescriptor e)
   {
      return RefcountCast<BBEdgeInfo>(graph::GetEdgeInfo(e));
   }

   inline const BBEdgeInfoConstRef CGetBBEdgeInfo(const EdgeDescriptor e) const
   {
      return RefcountCast<const BBEdgeInfo>(graph::CGetEdgeInfo(e));
   }

   inline BBGraphInfoRef GetBBGraphInfo()
   {
      return RefcountCast<BBGraphInfo>(graph::GetGraphInfo());
   }

   inline const BBGraphInfoConstRef CGetBBGraphInfo() const
   {
      return RefcountCast<const BBGraphInfo>(graph::CGetGraphInfo());
   }
};
using BBGraphRef = refcount<BBGraph>;
using BBGraphConstRef = refcount<const BBGraph>;

#if !HAVE_UNORDERED
class BBVertexSorter : std::binary_function<vertex, vertex, bool>
{
 private:
   BBGraphConstRef bb_graph;

 public:
   explicit BBVertexSorter(const BBGraphConstRef bb_graph);

   bool operator()(const vertex x, const vertex y) const;
};

class BBEdgeSorter : std::binary_function<EdgeDescriptor, EdgeDescriptor, bool>
{
 private:
   BBGraphConstRef bb_graph;

   BBVertexSorter bb_sorter;

 public:
   explicit BBEdgeSorter(const BBGraphConstRef bb_graph);

   bool operator()(const EdgeDescriptor x, const EdgeDescriptor y) const;
};
#endif

class bb_vertex_order_by_map : std::binary_function<vertex, vertex, bool>
{
 private:
   const std::map<vertex, unsigned int>& ref;

 public:
   explicit bb_vertex_order_by_map(const std::map<vertex, unsigned int>& _ref) : ref(_ref)
   {
   }

   bool operator()(const vertex x, const vertex y) const
   {
      return ref.find(x)->second < ref.find(y)->second;
   }
};
#endif