ext_tree_node.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 EXT_TREE_NODE_HPP
#define EXT_TREE_NODE_HPP

#include "custom_map.hpp"  // for unordered_map
#include "tree_common.hpp" // for GET_KIND, blackbox_pragma_K, call_hw_prag...
#include "tree_node.hpp"
#include <list>    // for list
#include <string>  // for string
#include <utility> // for pair

struct null_node : public tree_node
{
   explicit null_node(unsigned int i) : tree_node(i)
   {
   }

   GET_KIND_TEXT(null_node)

   
   GET_KIND(null_node)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0
   };
};

struct gimple_pragma : public gimple_node
{
   explicit gimple_pragma(unsigned int i) : gimple_node(i), is_block(false), is_opening(true)
   {
   }

   bool is_block;

   bool is_opening;

   tree_nodeRef scope;

   tree_nodeRef directive;

   std::string line;

   GET_KIND_TEXT(gimple_pragma)

   
   GET_KIND(gimple_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(gimple_node) = 0,
      GETID(scope),
      GETID(directive)
   };
};

struct profiling_pragma : public tree_node
{
   explicit profiling_pragma(unsigned int i) : tree_node(i)
   {
   }

   GET_KIND_TEXT(profiling_pragma)

   
   GET_KIND(profiling_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0
   };
};

struct statistical_profiling : public profiling_pragma
{
   explicit statistical_profiling(unsigned int i) : profiling_pragma(i)
   {
   }

   GET_KIND_TEXT(statistical_profiling)

   
   GET_KIND(statistical_profiling)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(profiling_pragma) = 0
   };
};

struct map_pragma : public tree_node
{
   explicit map_pragma(unsigned int i) : tree_node(i)
   {
   }

   GET_KIND_TEXT(map_pragma)

   
   GET_KIND(map_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0
   };
};

struct call_hw_pragma : public map_pragma
{
   explicit call_hw_pragma(unsigned int i) : map_pragma(i)
   {
   }

   std::string HW_component;

   std::string ID_implementation;

   GET_KIND_TEXT(call_hw_pragma)

   
   GET_KIND(call_hw_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(map_pragma) = 0
   };
};

struct call_point_hw_pragma : public map_pragma
{
   explicit call_point_hw_pragma(unsigned int i) : map_pragma(i), recursive(false)
   {
   }

   std::string HW_component;

   std::string ID_implementation;

   bool recursive;

   GET_KIND_TEXT(call_point_hw_pragma)

   
   GET_KIND(call_point_hw_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(map_pragma) = 0
   };
};

struct issue_pragma : public tree_node
{
   explicit issue_pragma(unsigned int i) : tree_node(i)
   {
   }

   GET_KIND_TEXT(issue_pragma)

   
   GET_KIND(issue_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0
   };
};

struct blackbox_pragma : public issue_pragma
{
   explicit blackbox_pragma(unsigned int i) : issue_pragma(i)
   {
   }

   GET_KIND_TEXT(blackbox_pragma)

   
   GET_KIND(blackbox_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(issue_pragma) = 0
   };
};

struct omp_pragma : public tree_node
{
   explicit omp_pragma(unsigned int i) : tree_node(i)
   {
   }

   GET_KIND_TEXT(omp_pragma)

   
   GET_KIND(omp_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0
   };
};

struct omp_parallel_pragma : public omp_pragma
{
   explicit omp_parallel_pragma(unsigned int i) : omp_pragma(i), is_shortcut(false)
   {
   }

   CustomUnorderedMapUnstable<std::string, std::string> clauses;

   bool is_shortcut;

   GET_KIND_TEXT(omp_parallel_pragma)

   
   GET_KIND(omp_parallel_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(omp_pragma) = 0
   };
};

struct omp_sections_pragma : public omp_pragma
{
   explicit omp_sections_pragma(unsigned int i) : omp_pragma(i), is_shortcut(false)
   {
   }

   bool is_shortcut;

   GET_KIND_TEXT(omp_sections_pragma)

   
   GET_KIND(omp_sections_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(omp_pragma) = 0
   };
};

struct omp_parallel_sections_pragma : public omp_pragma
{
   explicit omp_parallel_sections_pragma(unsigned int i) : omp_pragma(i)
   {
   }

   tree_nodeRef op0;

   tree_nodeRef op1;

   GET_KIND_TEXT(omp_parallel_sections_pragma)

   
   GET_KIND(omp_parallel_sections_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(omp_pragma) = 0,
      GETID(op0),
      GETID(op1)
   };
};

struct omp_section_pragma : public omp_pragma
{
   explicit omp_section_pragma(unsigned int i) : omp_pragma(i)
   {
   }

   GET_KIND_TEXT(omp_section_pragma)

   
   GET_KIND(omp_section_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(omp_pragma) = 0
   };
};

struct omp_target_pragma : public omp_pragma
{
   CustomUnorderedMapUnstable<std::string, std::string> clauses;

   explicit omp_target_pragma(unsigned int i);

   GET_KIND_TEXT(omp_target_pragma)

   
   GET_KIND(omp_target_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(omp_pragma) = 0
   };
};

struct omp_task_pragma : public omp_pragma
{
   CustomUnorderedMapUnstable<std::string, std::string> clauses;

   explicit omp_task_pragma(unsigned int i);

   GET_KIND_TEXT(omp_task_pragma)

   
   GET_KIND(omp_task_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(omp_pragma) = 0
   };
};

struct omp_critical_pragma : public omp_pragma
{
   CustomUnorderedMapUnstable<std::string, std::string> clauses;

   explicit omp_critical_pragma(unsigned int i);

   GET_KIND_TEXT(omp_critical_pragma)

   
   GET_KIND(omp_critical_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(omp_pragma) = 0
   };
};

struct omp_atomic_pragma : public omp_pragma
{
   explicit omp_atomic_pragma(unsigned int i) : omp_pragma(i)
   {
   }

   GET_KIND_TEXT(omp_atomic_pragma)

   
   GET_KIND(omp_atomic_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(omp_pragma) = 0
   };
};

struct omp_for_pragma : public omp_pragma
{
   explicit omp_for_pragma(unsigned int i) : omp_pragma(i)
   {
   }

   CustomUnorderedMapUnstable<std::string, std::string> clauses;

   GET_KIND_TEXT(omp_for_pragma)

   
   GET_KIND(omp_for_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(omp_pragma) = 0
   };
};

struct omp_simd_pragma : public omp_pragma
{
   explicit omp_simd_pragma(unsigned int i) : omp_pragma(i)
   {
   }

   CustomUnorderedMapUnstable<std::string, std::string> clauses;

   GET_KIND_TEXT(omp_simd_pragma)

   
   GET_KIND(omp_simd_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(omp_pragma) = 0
   };
};

struct omp_declare_simd_pragma : public omp_pragma
{
   explicit omp_declare_simd_pragma(unsigned int i) : omp_pragma(i)
   {
   }

   CustomUnorderedMapUnstable<std::string, std::string> clauses;

   GET_KIND_TEXT(omp_declare_simd_pragma)

   
   GET_KIND(omp_declare_simd_pragma)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(omp_pragma) = 0
   };
};

struct gimple_while : public gimple_node
{
   explicit gimple_while(unsigned int i) : gimple_node(i)
   {
   }

   tree_nodeRef op0;

   GET_KIND_TEXT(gimple_while)

   
   GET_KIND(gimple_while)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(gimple_node) = 0,
      GETID(op0)
   };
};

struct gimple_for : public gimple_while
{
   explicit gimple_for(unsigned int i) : gimple_while(i)
   {
   }

   tree_nodeRef op1;

   tree_nodeRef op2;

   tree_nodeRef omp_for;

   GET_KIND_TEXT(gimple_for)

   
   GET_KIND(gimple_for)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(gimple_while) = 0,
      GETID(op1),
      GETID(op2)
   };
};

struct gimple_multi_way_if : public gimple_node
{
   explicit gimple_multi_way_if(unsigned int i) : gimple_node(i)
   {
   }

   std::list<std::pair<tree_nodeRef, unsigned int>> list_of_cond;

   void add_cond(const tree_nodeRef& cond, unsigned int bb_ind);

   GET_KIND_TEXT(gimple_multi_way_if)

   
   GET_KIND(gimple_multi_way_if)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(gimple_node) = 0,
      GETID(list_of_cond)
   };
};

#endif