tree_manipulation.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_MANIPULATION_HPP
#define TREE_MANIPULATION_HPP

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

#include <limits>
#include <string>  // for string
#include <utility> // for pair
#include <vector>

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

#define ALGN_BIT_SIZE 64
#define ALGN_UNSIGNED_INT 32
#define ALGN_INT 32
#define ALGN_LONG_LONG_INT 64
#define ALGN_UNSIGNED_LONG_LONG_INT 64
#define ALGN_VOID 8
#define ALGN_BOOLEAN 8
#define ALGN_POINTER_M64 64
#define ALGN_POINTER_M32 32

#define PREC_BIT_SIZE 64
#define PREC_UNSIGNED_INT 32
#define PREC_INT 32
#define PREC_LONG_LONG_INT 64
#define PREC_UNSIGNED_LONG_LONG_INT 64

#define SIZE_VALUE_BIT_SIZE 64
#define SIZE_VALUE_UNSIGNED_INT 32
#define SIZE_VALUE_LONG_LONG_INT 64
#define SIZE_VALUE_UNSIGNED_LONG_LONG_INT 64
#define SIZE_VALUE_INT 32
#define SIZE_VALUE_BOOL 8
#define SIZE_VALUE_FUNCTION 8
#define SIZE_VALUE_POINTER_M32 32
#define SIZE_VALUE_POINTER_M64 64

#define MIN_VALUE_BIT_SIZE (std::numeric_limits<unsigned long long>::min())
#define MIN_VALUE_INT (std::numeric_limits<int>::min())
#define MIN_VALUE_UNSIGNED_INT (std::numeric_limits<unsigned int>::min())
#define MIN_VALUE_LONG_LONG_INT (std::numeric_limits<long long>::min())
#define MIN_VALUE_UNSIGNED_LONG_LONG_INT (std::numeric_limits<unsigned long long>::min())

#define MAX_VALUE_BIT_SIZE (std::numeric_limits<unsigned long long>::max())
#define MAX_VALUE_INT (std::numeric_limits<int>::max())
#define MAX_VALUE_UNSIGNED_INT (std::numeric_limits<unsigned int>::max())
#define MAX_VALUE_LONG_LONG_INT (std::numeric_limits<long long>::max())
#define MAX_VALUE_UNSIGNED_LONG_LONG_INT (std::numeric_limits<unsigned long long>::max())

class tree_manipulation
{
 private:
   tree_managerRef TreeM;

   const application_managerRef AppM;

   const bool reuse;

   const ParameterConstRef parameters;

   const int debug_level;

   static unsigned int goto_label_unique_id;


   tree_nodeRef CreateIntegerCst(const tree_nodeConstRef& type, integer_cst_t value,
                                 const unsigned int integer_cst_nid) const;

 public:
   tree_manipulation(const tree_managerRef& TreeM, const ParameterConstRef& parameters,
                     const application_managerRef _AppM);
   tree_manipulation(const tree_managerRef& TreeM, const ParameterConstRef& parameters, bool _reuse,
                     const application_managerRef _AppM);

   ~tree_manipulation();


   tree_nodeRef create_unary_operation(const tree_nodeConstRef& type, const tree_nodeRef& op, const std::string& srcp,
                                       enum kind operation_kind) const;

   tree_nodeRef create_binary_operation(const tree_nodeConstRef& type, const tree_nodeRef& op0, const tree_nodeRef& op1,
                                        const std::string& srcp, enum kind operation_kind) const;

   tree_nodeRef create_ternary_operation(const tree_nodeConstRef& type, const tree_nodeRef& op0,
                                         const tree_nodeRef& op1, const tree_nodeRef& op2, const std::string& srcp,
                                         enum kind operation_kind) const;

   tree_nodeRef create_quaternary_operation(const tree_nodeConstRef& type, const tree_nodeRef& op0,
                                            const tree_nodeRef& op1, const tree_nodeRef& op2, const tree_nodeRef& op3,
                                            const std::string& srcp, enum kind operation_kind) const;

   tree_nodeRef create_lut_expr(const tree_nodeConstRef& type, const tree_nodeRef& op0, const tree_nodeRef& op1,
                                const tree_nodeRef& op2, const tree_nodeRef& op3, const tree_nodeRef& op4,
                                const tree_nodeRef& op5, const tree_nodeRef& op6, const tree_nodeRef& op7,
                                const tree_nodeRef& op8, const std::string& srcp) const;

   tree_nodeRef create_extract_bit_expr(const tree_nodeRef& op0, const tree_nodeRef& op1,
                                        const std::string& srcp) const;


   tree_nodeRef create_identifier_node(const std::string& strg) const;


   tree_nodeRef create_parm_decl(const tree_nodeRef& name, const tree_nodeConstRef& type, const tree_nodeRef& scpe,
                                 const tree_nodeConstRef& argt, const tree_nodeRef& smt_ann, const tree_nodeRef& init,
                                 const std::string& srcp, int used, bool register_flag = false,
                                 bool readonly_flag = false) const;

   tree_nodeRef create_translation_unit_decl() const;

   tree_nodeRef create_result_decl(const tree_nodeRef& name, const tree_nodeRef& type, const tree_nodeRef& scpe,
                                   const tree_nodeRef& size, const tree_nodeRef& smt_ann, const tree_nodeRef& init,
                                   const std::string& srcp, unsigned int algn, bool artificial_flag = false) const;

   tree_nodeRef create_var_decl(const tree_nodeRef& name, const tree_nodeConstRef& type, const tree_nodeRef& scpe,
                                const tree_nodeRef& size, const tree_nodeRef& smt_ann, const tree_nodeRef& init,
                                const std::string& srcp, unsigned int algn, int used, bool artificial_flag = false,
                                int use_tmpl = -1, bool static_static_flag = false, bool extern_flag = false,
                                bool static_flag = false, bool register_flag = false, bool readonly_flag = false,
                                const std::string& bit_values = "", bool addr_taken = false,
                                bool addr_not_taken = false) const;


   tree_nodeRef GetVoidType() const;

   tree_nodeRef GetBooleanType() const;

   tree_nodeRef GetSignedIntegerType() const;

   tree_nodeRef GetUnsignedIntegerType() const;

   tree_nodeRef GetUnsignedLongLongType() const;

   tree_nodeRef GetBitsizeType() const;

   tree_nodeRef GetSizeType() const;

   tree_nodeRef GetPointerType(const tree_nodeConstRef& ptd, unsigned long long algn = 0) const;

   tree_nodeRef GetCustomIntegerType(unsigned long long prec, bool unsigned_p) const;

   tree_nodeRef GetFunctionType(const tree_nodeConstRef& returnType, const std::vector<tree_nodeConstRef>& argsT) const;



   tree_nodeRef create_ssa_name(const tree_nodeConstRef& var, const tree_nodeConstRef& type,
                                const tree_nodeConstRef& min, const tree_nodeConstRef& max, bool volatile_flag = false,
                                bool virtual_flag = false) const;


   tree_nodeRef create_phi_node(tree_nodeRef& ssa_res,
                                const std::vector<std::pair<tree_nodeRef, unsigned int>>& list_of_def_edge,
                                unsigned int function_decl_nid, bool virtual_flag = false) const;


   tree_nodeRef create_gimple_modify_stmt(const tree_nodeRef& op0, const tree_nodeRef& op1,
                                          unsigned int function_decl_nid, const std::string& srcp) const;

   tree_nodeRef CreateGimpleAssign(const tree_nodeConstRef& type, const tree_nodeConstRef& min,
                                   const tree_nodeConstRef& max, const tree_nodeRef& op, unsigned int function_decl_nid,
                                   const std::string& srcp) const;

   tree_nodeRef create_gimple_call(const tree_nodeConstRef& called_function, const std::vector<tree_nodeRef>& args,
                                   unsigned int function_decl_nid, const std::string& srcp) const;


   tree_nodeRef create_gimple_cond(const tree_nodeRef& expr, unsigned int function_decl_nid,
                                   const std::string& srcp) const;


   tree_nodeRef create_gimple_return(const tree_nodeConstRef& type, const tree_nodeConstRef& expr,
                                     unsigned int function_decl_nid, const std::string& srcp) const;

   void create_label(const blocRef& block, unsigned int function_decl_nid) const;

   void create_goto(const blocRef& block, unsigned int function_decl_nid, unsigned int label_expr_nid) const;

   tree_nodeRef create_function_decl(const std::string& function_name, const tree_nodeRef& scpe,
                                     const std::vector<tree_nodeConstRef>& argsT, const tree_nodeConstRef& returnType,
                                     const std::string& srcp, bool with_body) const;


   blocRef create_basic_block(std::map<unsigned int, blocRef>& list_of_bloc, std::vector<unsigned int> predecessors,
                              std::vector<unsigned int> successors, std::vector<tree_nodeRef> stmt, unsigned int number,
                              unsigned int true_edge = 0, unsigned int false_edge = 0,
                              std::vector<tree_nodeRef> phi = std::vector<tree_nodeRef>()) const;

   void bb_add_stmts(blocRef& bb, const std::vector<tree_nodeRef>& stmt) const;

   void bb_add_stmt(blocRef& bb, const tree_nodeRef& stmt) const;

   void bb_add_successors(blocRef& bb, const std::vector<unsigned int>& successors) const;

   void bb_add_successor(blocRef& bb, const unsigned int& successor) const;

   void bb_add_predecessors(blocRef& bb, const std::vector<unsigned int>& predecessors) const;

   void bb_add_predecessor(blocRef& bb, const unsigned int& predecessor) const;

   void bb_remove_successors(blocRef& bb, const std::vector<unsigned int>& successors) const;

   void bb_remove_successor(blocRef& bb, const unsigned int& successor) const;

   void bb_remove_predecessors(blocRef& bb, const std::vector<unsigned int>& predecessors) const;

   void bb_remove_predecessor(blocRef& bb, const unsigned int& predecessor) const;

   void bb_remove_all_predecessors(blocRef& bb) const;

   void bb_remove_all_successors(blocRef& bb) const;

   void bb_set_false_edge(blocRef& bb, const unsigned int& false_edge_index) const;

   void bb_set_true_edge(blocRef& bb, const unsigned int& true_edge_index) const;


   tree_nodeRef CreateNotExpr(const tree_nodeConstRef& condition, const blocRef& block,
                              unsigned int function_decl_nid) const;

   tree_nodeRef CreateAndExpr(const tree_nodeConstRef& first_condition, const tree_nodeConstRef& second_condition,
                              const blocRef& block, unsigned int function_decl_nid) const;

   tree_nodeRef CreateOrExpr(const tree_nodeConstRef& first_condition, const tree_nodeConstRef& second_condition,
                             const blocRef& block, unsigned int function_decl_nid) const;

   tree_nodeRef ExtractCondition(const tree_nodeRef& condition, const blocRef& block,
                                 unsigned int function_decl_nid) const;

   tree_nodeRef CreateNopExpr(const tree_nodeConstRef& operand, const tree_nodeConstRef& type,
                              const tree_nodeConstRef& min, const tree_nodeConstRef& max,
                              unsigned int function_decl_nid) const;

   tree_nodeRef CreateUnsigned(const tree_nodeConstRef& signed_type) const;

   tree_nodeRef CreateEqExpr(const tree_nodeConstRef& first_operand, const tree_nodeConstRef& second_operand,
                             const blocRef& block, unsigned int function_decl_nid) const;

   tree_nodeRef CreateCallExpr(const tree_nodeConstRef& called_function, const std::vector<tree_nodeRef>& args,
                               const std::string& srcp) const;

   tree_nodeRef CreateAddrExpr(const tree_nodeConstRef& tn, const std::string& srcp) const;

   tree_nodeRef CreateGimpleAssignAddrExpr(const tree_nodeConstRef& tn, unsigned int function_decl_nid,
                                           const std::string& srcp) const;

   tree_nodeRef CreateVectorBooleanType(const unsigned long long number_of_elements) const;

   tree_nodeRef CloneFunction(const tree_nodeRef& tn, const std::string& funNameSuffix);

   unsigned int InlineFunctionCall(const tree_nodeRef& call_node, const tree_nodeRef& caller_node);

   bool VersionFunctionCall(const tree_nodeRef& call_node, const tree_nodeRef& caller_node,
                            const std::string& version_suffix);
};

using tree_manipulationRef = refcount<tree_manipulation>;
using tree_manipulationConstRef = refcount<const tree_manipulation>;

#endif /* TREE_MANIPULATION_HPP */