tree_manager.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 TREE_MANAGER_HPP
#define TREE_MANAGER_HPP

#include "config_HAVE_UNORDERED.hpp"

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

#include <deque>
#include <iosfwd>
#include <string>  // for string
#include <utility> // for pair

CONSTREF_FORWARD_DECL(Parameter);
struct ssa_name;
struct function_decl;
enum kind : int;
REF_FORWARD_DECL(tree_manager);
CONSTREF_FORWARD_DECL(tree_node);
REF_FORWARD_DECL(tree_node);
REF_FORWARD_DECL(application_manager);
enum class TreeVocabularyTokenTypes_TokenEnum;

#define BUILTIN_SRCP "<built-in>:0:0"

class tree_manager
{
 private:
   CustomUnorderedMapUnstable<std::string, unsigned int> find_cache;

#if HAVE_UNORDERED
   UnorderedMapStd<unsigned int, tree_nodeRef> tree_nodes;
#else
   OrderedMapStd<unsigned int, tree_nodeRef> tree_nodes;
#endif

   std::map<unsigned int, tree_nodeRef> function_decl_nodes;

   std::deque<tree_nodeRef> stack;

   CustomUnorderedSet<tree_nodeRef> already_visited;

   unsigned int n_pl;

   unsigned int added_goto;

   unsigned int removed_pointer_plus;

   unsigned int removable_pointer_plus;

   unsigned int unremoved_pointer_plus;

   int debug_level;

   unsigned int last_node_id;

   CustomUnorderedMapUnstable<std::string, unsigned int> identifiers_unique_table;

   CustomUnorderedMap<std::pair<std::string, unsigned int>, tree_nodeRef> unique_cst_map;

   const ParameterConstRef Param;

   CustomUnorderedMap<ssa_name*, tree_nodeRef> uses_erase_temp;

   unsigned int next_vers;

   unsigned int collapse_into_counter;

   bool check_for_decl(const tree_nodeRef& tn, const tree_managerRef& TM, std::string& symbol_name,
                       std::string& symbol_scope, unsigned int node_id,
                       const CustomUnorderedMap<unsigned int, std::string>& global_type_unql_symbol_table);

   bool check_for_type(const tree_nodeRef& tn, const tree_managerRef& TM, std::string& symbol_name,
                       std::string& symbol_scope,
                       const CustomUnorderedMapUnstable<std::string, unsigned int>& global_type_symbol_table,
                       unsigned int node_id);

   void erase_usage_info(const tree_nodeRef& tn, const tree_nodeRef& stmt);

   void insert_usage_info(const tree_nodeRef& tn, const tree_nodeRef& stmt);

   tree_nodeRef create_unique_const(const std::string& val, const tree_nodeConstRef& type);

 public:
   void RecursiveReplaceTreeNode(tree_nodeRef& tn, const tree_nodeRef old_node, const tree_nodeRef& new_node,
                                 const tree_nodeRef& stmt, bool definition); // NOLINT

   explicit tree_manager(const ParameterConstRef& Param);

   ~tree_manager();

   unsigned int get_implementation_node(unsigned int decl_node) const;

   // ************************+ handlers for tree_nodes structure **************************

   void AddTreeNode(const unsigned int i, const tree_nodeRef& curr);

   tree_nodeRef GetTreeReindex(const unsigned int i);

   const tree_nodeRef CGetTreeReindex(const unsigned int i) const;

   tree_nodeRef GetTreeNode(const unsigned int index) const;

   const tree_nodeRef get_tree_node_const(unsigned int i) const;
   const tree_nodeConstRef CGetTreeNode(const unsigned int i) const;

   bool is_tree_node(unsigned int i) const;

   void create_tree_node(const unsigned int node_id, enum kind tree_node_type,
                         std::map<TreeVocabularyTokenTypes_TokenEnum, std::string>& tree_node_schema);

   unsigned int find(enum kind tree_node_type,
                     const std::map<TreeVocabularyTokenTypes_TokenEnum, std::string>& tree_node_schema);

   unsigned int new_tree_node_id(const unsigned int ask = 0);

   unsigned int get_next_available_tree_node_id() const;

   void add_function(unsigned int index, tree_nodeRef curr);

   unsigned long get_function_decl_node_n() const;

   const CustomUnorderedSet<unsigned int> GetAllFunctions() const;

   unsigned int find_sc_main_node() const;

   unsigned int function_index(const std::string& function_name) const;

   tree_nodeRef GetFunction(const std::string& function_name) const;

   unsigned int function_index_mngl(const std::string& function_name) const;

   void print(std::ostream& os) const;

   void PrintGimple(std::ostream& os, const bool use_uid) const;

   friend std::ostream& operator<<(std::ostream& os, const tree_manager& s)
   {
      s.print(os);
      return os;
   }

   friend std::ostream& operator<<(std::ostream& os, const tree_managerRef& s)
   {
      if(s)
      {
         s->print(os);
      }
      return os;
   }

   void collapse_into(const unsigned int& funID, CustomUnorderedMapUnstable<unsigned int, unsigned int>& stmt_to_bloc,
                      const tree_nodeRef& tn, CustomUnorderedSet<unsigned int>& removed_nodes,
                      const application_managerRef AppM);

   void add_parallel_loop();

   unsigned int get_n_pl() const;

   void merge_tree_managers(const tree_managerRef& source_tree_manager);

   void add_goto();

   unsigned int get_added_goto() const;

   void increment_removed_pointer_plus();

   unsigned int get_removed_pointer_plus() const;

   void increment_removable_pointer_plus();

   unsigned int get_removable_pointer_plus() const;

   void increment_unremoved_pointer_plus();

   unsigned int get_unremoved_pointer_plus() const;

   unsigned int find_identifier_nodeID(const std::string& str) const;

   void add_identifier_node(unsigned int nodeID, const std::string& str)
   {
      identifiers_unique_table[str] = nodeID;
   }
   void add_identifier_node(unsigned int nodeID, const bool& op);

   unsigned int get_next_vers();

   void ReplaceTreeNode(const tree_nodeRef& stmt, const tree_nodeRef& old_node, const tree_nodeRef& new_node);

   tree_nodeRef CreateUniqueIntegerCst(integer_cst_t value, const tree_nodeConstRef& type);

   tree_nodeRef CreateUniqueRealCst(long double value, const tree_nodeConstRef& type);

   bool is_CPP() const;

   bool is_top_function(const function_decl* fd) const;

   bool check_ssa_uses(unsigned int fun_id) const;
};
using tree_managerRef = refcount<tree_manager>;
using tree_managerConstRef = refcount<const tree_manager>;
#endif