loop.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 LOOP_HPP
#define LOOP_HPP

#include "custom_map.hpp"
#include "custom_set.hpp"
#include "graph.hpp"
#include "panda_types.hpp"
#include "refcount.hpp"

#include <cstddef>
#include <list>
#include <utility>

#define SINGLE_EXIT_LOOP 1

#define UNKNOWN_LOOP 2

#define WHILE_LOOP 4

#define FOR_LOOP 8

#define DOALL_LOOP 16

#define DO_WHILE_LOOP 32

#define COUNTABLE_LOOP 64

#define PIPELINABLE_LOOP 128


REF_FORWARD_DECL(BBGraph);
CONSTREF_FORWARD_DECL(Loop);
REF_FORWARD_DECL(Loop);
REF_FORWARD_DECL(Loops);
CONSTREF_FORWARD_DECL(OpGraph);
class OpVertexSet;
REF_FORWARD_DECL(tree_node);

class Loop
{
 private:
   friend class Loops;

   void ComputeLandingPadExits();

   const BBGraphRef g;

   bool is_innermost_loop;

   refcount<Loop> parent_loop;

   CustomOrderedSet<LoopConstRef> children;

   CustomUnorderedSet<vertex> blocks;

   std::list<vertex> exits;

   CustomUnorderedSet<vertex> landing_pads;

   vertex primary_landing_pad_block;

   vertex header_block;

   CustomOrderedSet<vertex> alternative_entries;

   unsigned int loop_id;

   std::map<vertex, CustomUnorderedSet<vertex>> exit_landing_association;

   static unsigned int curr_unused_irreducible_id;

   CustomOrderedSet<std::pair<vertex, vertex>> sp_back_edges;

 public:
   unsigned int depth;

   int loop_type;

   long long footprint_size;

   long long instruction_size;

   vertex body_start;

   unsigned int main_iv;

   tree_nodeRef init;

   unsigned int init_gimple_id;

   unsigned int inc_id;

   integer_cst_t increment;

   tree_nodeRef increment_tn;

   integer_cst_t lower_bound;

   integer_cst_t upper_bound;

   tree_nodeRef upper_bound_tn;

   bool close_interval;

   explicit Loop(const BBGraphRef g);

   Loop(const BBGraphRef _bb_graph, vertex _header_block);

   unsigned int GetId() const;

   bool is_innermost() const;

   bool IsReducible() const;

   vertex GetHeader() const;

   CustomOrderedSet<vertex> get_entries() const
   {
      return alternative_entries;
   }

   void add_entry(vertex v)
   {
      alternative_entries.insert(v);
   }

   const LoopRef Parent() const;

   void add_block(vertex block);

   size_t num_blocks() const;

   const CustomUnorderedSet<vertex>& get_blocks() const;

   // Info on the exit blocks
   size_t num_exits() const;
   std::list<vertex>::const_iterator exit_block_iter_begin() const;
   std::list<vertex>::const_iterator exit_block_iter_end() const;

   // Info on the landing pads
   size_t num_landing_pads() const;

   const CustomUnorderedSet<vertex> GetLandingPadBlocks() const;

   // Return the primary landing pad if it exists, NULL otherwise
   // The primary landing pad is the one that is the unique successor
   // of all the other LPs
   vertex primary_landing_pad() const;

   void SetParent(LoopRef parent);

   void AddChild(LoopRef child);

   const CustomOrderedSet<LoopConstRef>& GetChildren() const;

   void get_recursively_bb(CustomUnorderedSet<vertex>& ret) const;

   OpVertexSet GetRecursivelyOps(const OpGraphConstRef op_graph) const;

   const std::map<vertex, CustomUnorderedSet<vertex>>& get_exit_landing_association() const;

   void add_sp_back_edge(vertex vs, vertex vd)
   {
      std::pair<vertex, vertex> vpair(vs, vd);
      sp_back_edges.insert(vpair);
   }

   bool is_sp_back_edge(vertex vs, vertex vd) const
   {
      std::pair<vertex, vertex> vpair(vs, vd);
      return sp_back_edges.find(vpair) != sp_back_edges.end();
   }

   CustomOrderedSet<std::pair<vertex, vertex>> get_sp_back_edges() const
   {
      return sp_back_edges;
   }

   friend class add_loop_nop;
};
using LoopRef = refcount<Loop>;

#endif // LOOP_HPP