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 TREE_NODE_HPP
#define TREE_NODE_HPP

#include "config_HAVE_FROM_PRAGMA_BUILT.hpp"
#include "config_HAVE_UNORDERED.hpp"

#include <cstddef>    // for size_t
#include <functional> // for binary_function
#include <iosfwd>     // for ostream
#include <list>       // for list
#include <memory>     // for allocator_traits...
#include <string>     // for string
#include <utility>    // for pair
#include <vector>     // for vector

#include "custom_map.hpp" // for CustomMap
#include "custom_set.hpp"
#include "exceptions.hpp" // for throw_error
#include "panda_types.hpp"
#include "refcount.hpp"    // for GetPointer, refc...
#include "tree_common.hpp" // for GET_KIND, BINARY...

REF_FORWARD_DECL(bloc);
REF_FORWARD_DECL(tree_manager);
CONSTREF_FORWARD_DECL(tree_node);
REF_FORWARD_DECL(tree_node);
REF_FORWARD_DECL(Range);
template <class value>
class TreeNodeMap;
enum class TreeVocabularyTokenTypes_TokenEnum;

#define GET_KIND_TEXT(meth)                   \
   std::string get_kind_text() const override \
   {                                          \
      return std::string(#meth);              \
   }

#define NON_LEAF_TREE_NODES                                                                                            \
   (tree_node)(WeightedNode)(attr)(srcp)(PointToSolution)(decl_node)(expr_node)(gimple_node)(unary_expr)(binary_expr)( \
       ternary_expr)(quaternary_expr)(type_node)(memory_tag)(cst_node)

#define VISITED_OBJ_SEQ1 \
   NON_LEAF_TREE_NODES UNARY_EXPRESSION_TREE_NODES BINARY_EXPRESSION_TREE_NODES TERNARY_EXPRESSION_TREE_NODES
#define VISITED_OBJ_SEQ2                                                                                    \
   QUATERNARY_EXPRESSION_TREE_NODES GIMPLE_NODES MISCELLANEOUS_EXPR_TREE_NODES MISCELLANEOUS_OBJ_TREE_NODES \
       TYPE_NODE_TREE_NODES CONST_OBJ_TREE_NODES DECL_NODE_TREE_NODES BASIC_BLOCK_TREE_NODES                \
           PANDA_EXTENSION_TREE_NODES

#define OBJ_SPECIALIZED_SEQ                                                                                           \
   (tree_node)(WeightedNode)(attr)(srcp)(decl_node)(expr_node)(gimple_node)(unary_expr)(binary_expr)(ternary_expr)(   \
       quaternary_expr)(type_node)(memory_tag)(cst_node)(error_mark)(array_type)(gimple_asm)(baselink)(gimple_bind)(  \
       binfo)(block)(call_expr)(aggr_init_expr)(gimple_call)(case_label_expr)(cast_expr)(complex_cst)(complex_type)(  \
       gimple_cond)(const_decl)(constructor)(enumeral_type)(expr_stmt)(field_decl)(function_decl)(function_type)(     \
       gimple_assign)(gimple_goto)(handler)(identifier_node)(integer_cst)(integer_type)(gimple_label)(lut_expr)(      \
       method_type)(namespace_decl)(overload)(parm_decl)(gimple_phi)(pointer_type)(real_cst)(real_type)(record_type)( \
       reference_type)(result_decl)(gimple_return)(return_stmt)(type_pack_expansion)(expr_pack_expansion)(scope_ref)( \
       ssa_name)(statement_list)(string_cst)(gimple_switch)(template_decl)(template_parm_index)(tree_list)(tree_vec)( \
       try_block)(type_decl)(union_type)(var_decl)(vector_cst)(vector_type)(type_argument_pack)(                      \
       nontype_argument_pack)(target_expr)(target_mem_ref)(target_mem_ref461)(bloc)(null_node)(gimple_pragma)(        \
       issue_pragma)(blackbox_pragma)(profiling_pragma)(statistical_profiling)(map_pragma)(call_hw_pragma)(           \
       call_point_hw_pragma)(omp_pragma)(omp_critical_pragma)(omp_declare_simd_pragma)(omp_for_pragma)(               \
       omp_parallel_pragma)(omp_sections_pragma)(omp_parallel_sections_pragma)(omp_section_pragma)(omp_simd_pragma)(  \
       omp_target_pragma)(omp_task_pragma)(gimple_while)(gimple_for)(gimple_multi_way_if)(tree_reindex)

#define OBJ_NOT_SPECIALIZED_SEQ                                                                                  \
   (translation_unit_decl)(label_decl)(void_type)(template_type_parm)(set_type)(qual_union_type)(offset_type)(   \
       lang_type)(CharType)(nullptr_type)(boolean_type)(typename_type)(none)(vec_new_expr)                       \
       UNARY_EXPRESSION_TREE_NODES BINARY_EXPRESSION_TREE_NODES TERNARY_EXPRESSION_TREE_NODES(ctor_initializer)( \
           trait_expr)(template_id_expr)(placeholder_expr)(new_expr)(gimple_resx)(gimple_predict)(gimple_nop)    \
           QUATERNARY_EXPRESSION_TREE_NODES(modop_expr)(PointToSolution)(omp_atomic_pragma)(using_decl)(void_cst)

#include "visitor.hpp"

class tree_node_visitor : public object_visitor
{
};

class tree_node
{
 public:
   const unsigned int index;

   explicit tree_node(unsigned int i) : index(i)
   {
   }

   virtual ~tree_node() = default;

   virtual enum kind get_kind() const = 0;

   virtual std::string get_kind_text() const = 0;

   virtual void visit(tree_node_visitor* const v) const;

   friend std::ostream& operator<<(std::ostream& os, const tree_node* tn);

   friend std::ostream& operator<<(std::ostream& os, const tree_nodeRef& tn);

   std::string ToString() const;

   static enum kind get_kind(const std::string& name);

   static std::string GetString(const enum kind k);
};

using tree_nodeRef = refcount<tree_node>;
using tree_nodeConstRef = refcount<const tree_node>;

class TreeNodeConstSorter : std::binary_function<tree_nodeConstRef, tree_nodeConstRef, bool>
{
 public:
   TreeNodeConstSorter();

   bool operator()(const tree_nodeConstRef& x, const tree_nodeConstRef& y) const;
};

#if HAVE_UNORDERED
struct TreeNodeConstHash : public std::unary_function<tree_nodeConstRef, size_t>
{
   size_t operator()(tree_nodeConstRef tn) const
   {
      std::hash<unsigned int> hasher;
      return hasher(tn->index);
   }
};

struct TreeNodeConstEqualTo : public std::binary_function<tree_nodeConstRef, tree_nodeConstRef, bool>
{
 public:
   TreeNodeConstEqualTo();

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

class TreeNodeConstSet : public CustomUnorderedSet<tree_nodeConstRef, TreeNodeConstHash, TreeNodeConstEqualTo>
{
};
#else

class TreeNodeConstSet : public OrderedSetStd<tree_nodeConstRef, TreeNodeConstSorter>
{
 public:
   TreeNodeConstSet();
};
#endif

#if HAVE_UNORDERED
struct TreeNodeHash : public std::unary_function<tree_nodeRef, size_t>
{
   size_t operator()(tree_nodeRef tn) const
   {
      std::hash<unsigned int> hasher;
      return hasher(tn->index);
   }
};

class TreeNodeSet : public UnorderedSetStd<tree_nodeRef, TreeNodeHash, TreeNodeConstEqualTo>
{
};
#else
class TreeNodeSorter : std::binary_function<tree_nodeRef, tree_nodeRef, bool>
{
 public:
   TreeNodeSorter();

   bool operator()(const tree_nodeRef& x, const tree_nodeRef& y) const;
};

class TreeNodeSet : public OrderedSetStd<tree_nodeRef, TreeNodeSorter>
{
 public:
   TreeNodeSet();
};
#endif

#if HAVE_UNORDERED
template <typename value>
class TreeNodeMap : public UnorderedMapStd<tree_nodeRef, value, TreeNodeHash, TreeNodeConstEqualTo>
{
};
#else
template <typename value>
class TreeNodeMap : public OrderedMapStd<tree_nodeRef, value, TreeNodeSorter>
{
};
#endif

#ifndef NDEBUG
#define GET_NODE(t)                                                                                           \
   ((t) ? ((t)->get_kind() == tree_reindex_K ? (GetPointerS<tree_reindex>(t))->actual_tree_node :             \
                                               throw_error(t, #t, __PRETTY_FUNCTION__, __FILE__, __LINE__)) : \
          throw_error(t, #t, __PRETTY_FUNCTION__, __FILE__, __LINE__))
#define GET_CONST_NODE(t)                                                                                     \
   ((t) ? ((t)->get_kind() == tree_reindex_K ? (GetPointerS<const tree_reindex>(t))->actual_tree_node :       \
                                               throw_error(t, #t, __PRETTY_FUNCTION__, __FILE__, __LINE__)) : \
          throw_error(t, #t, __PRETTY_FUNCTION__, __FILE__, __LINE__))
#else
#define GET_NODE(t) (GetPointerS<tree_reindex>(t))->actual_tree_node
#define GET_CONST_NODE(t) (GetPointerS<const tree_reindex>(t))->actual_tree_node
#endif

#define GET_INDEX_NODE(t) (GET_NODE(t))->index
// unsigned int GET_INDEX_NODE(const tree_nodeRef& t);
#define GET_INDEX_CONST_NODE(t) (GET_CONST_NODE(t))->index
// unsigned int GET_INDEX_CONST_NODE(const tree_nodeConstRef& t);

#define CASE_UNARY_EXPRESSION       \
   abs_expr_K:                      \
   case addr_expr_K:                \
   case alignof_expr_K:             \
   case arrow_expr_K:               \
   case bit_not_expr_K:             \
   case buffer_ref_K:               \
   case card_expr_K:                \
   case cleanup_point_expr_K:       \
   case conj_expr_K:                \
   case convert_expr_K:             \
   case exit_expr_K:                \
   case fix_ceil_expr_K:            \
   case fix_floor_expr_K:           \
   case fix_round_expr_K:           \
   case fix_trunc_expr_K:           \
   case float_expr_K:               \
   case imagpart_expr_K:            \
   case indirect_ref_K:             \
   case misaligned_indirect_ref_K:  \
   case loop_expr_K:                \
   case negate_expr_K:              \
   case non_lvalue_expr_K:          \
   case nop_expr_K:                 \
   case paren_expr_K:               \
   case realpart_expr_K:            \
   case reference_expr_K:           \
   case reinterpret_cast_expr_K:    \
   case sizeof_expr_K:              \
   case static_cast_expr_K:         \
   case throw_expr_K:               \
   case truth_not_expr_K:           \
   case unsave_expr_K:              \
   case va_arg_expr_K:              \
   case view_convert_expr_K:        \
   case reduc_max_expr_K:           \
   case reduc_min_expr_K:           \
   case reduc_plus_expr_K:          \
   case vec_unpack_hi_expr_K:       \
   case vec_unpack_lo_expr_K:       \
   case vec_unpack_float_hi_expr_K: \
   case vec_unpack_float_lo_expr_K

#define CASE_NON_ADDR_UNARY_EXPRESSION \
   abs_expr_K:                         \
   case alignof_expr_K:                \
   case arrow_expr_K:                  \
   case bit_not_expr_K:                \
   case buffer_ref_K:                  \
   case card_expr_K:                   \
   case cleanup_point_expr_K:          \
   case conj_expr_K:                   \
   case convert_expr_K:                \
   case exit_expr_K:                   \
   case fix_ceil_expr_K:               \
   case fix_floor_expr_K:              \
   case fix_round_expr_K:              \
   case fix_trunc_expr_K:              \
   case float_expr_K:                  \
   case imagpart_expr_K:               \
   case indirect_ref_K:                \
   case misaligned_indirect_ref_K:     \
   case loop_expr_K:                   \
   case negate_expr_K:                 \
   case non_lvalue_expr_K:             \
   case nop_expr_K:                    \
   case realpart_expr_K:               \
   case reference_expr_K:              \
   case reinterpret_cast_expr_K:       \
   case sizeof_expr_K:                 \
   case static_cast_expr_K:            \
   case throw_expr_K:                  \
   case truth_not_expr_K:              \
   case unsave_expr_K:                 \
   case va_arg_expr_K:                 \
   case view_convert_expr_K:           \
   case reduc_max_expr_K:              \
   case reduc_min_expr_K:              \
   case reduc_plus_expr_K:             \
   case vec_unpack_hi_expr_K:          \
   case vec_unpack_lo_expr_K:          \
   case vec_unpack_float_hi_expr_K:    \
   case vec_unpack_float_lo_expr_K

#define CASE_BINARY_EXPRESSION     \
   assert_expr_K:                  \
   case bit_and_expr_K:            \
   case bit_ior_expr_K:            \
   case bit_xor_expr_K:            \
   case catch_expr_K:              \
   case ceil_div_expr_K:           \
   case ceil_mod_expr_K:           \
   case complex_expr_K:            \
   case compound_expr_K:           \
   case eh_filter_expr_K:          \
   case eq_expr_K:                 \
   case exact_div_expr_K:          \
   case fdesc_expr_K:              \
   case floor_div_expr_K:          \
   case floor_mod_expr_K:          \
   case ge_expr_K:                 \
   case gt_expr_K:                 \
   case goto_subroutine_K:         \
   case in_expr_K:                 \
   case init_expr_K:               \
   case le_expr_K:                 \
   case lrotate_expr_K:            \
   case lshift_expr_K:             \
   case lt_expr_K:                 \
   case max_expr_K:                \
   case mem_ref_K:                 \
   case min_expr_K:                \
   case minus_expr_K:              \
   case modify_expr_K:             \
   case mult_expr_K:               \
   case mult_highpart_expr_K:      \
   case ne_expr_K:                 \
   case ordered_expr_K:            \
   case plus_expr_K:               \
   case pointer_plus_expr_K:       \
   case postdecrement_expr_K:      \
   case postincrement_expr_K:      \
   case predecrement_expr_K:       \
   case preincrement_expr_K:       \
   case range_expr_K:              \
   case rdiv_expr_K:               \
   case round_div_expr_K:          \
   case round_mod_expr_K:          \
   case rrotate_expr_K:            \
   case rshift_expr_K:             \
   case set_le_expr_K:             \
   case trunc_div_expr_K:          \
   case trunc_mod_expr_K:          \
   case truth_and_expr_K:          \
   case truth_andif_expr_K:        \
   case truth_or_expr_K:           \
   case truth_orif_expr_K:         \
   case truth_xor_expr_K:          \
   case try_catch_expr_K:          \
   case try_finally_K:             \
   case uneq_expr_K:               \
   case ltgt_expr_K:               \
   case unge_expr_K:               \
   case ungt_expr_K:               \
   case unle_expr_K:               \
   case unlt_expr_K:               \
   case unordered_expr_K:          \
   case widen_sum_expr_K:          \
   case widen_mult_expr_K:         \
   case with_size_expr_K:          \
   case vec_lshift_expr_K:         \
   case vec_rshift_expr_K:         \
   case widen_mult_hi_expr_K:      \
   case widen_mult_lo_expr_K:      \
   case vec_pack_trunc_expr_K:     \
   case vec_pack_sat_expr_K:       \
   case vec_pack_fix_trunc_expr_K: \
   case vec_extracteven_expr_K:    \
   case vec_extractodd_expr_K:     \
   case vec_interleavehigh_expr_K: \
   case vec_interleavelow_expr_K:  \
   case extract_bit_expr_K:        \
   case sat_plus_expr_K:           \
   case sat_minus_expr_K:          \
   case extractvalue_expr_K:       \
   case extractelement_expr_K:     \
   case frem_expr_K

#define CASE_TERNARY_EXPRESSION \
   component_ref_K:             \
   case bit_field_ref_K:        \
   case bit_ior_concat_expr_K:  \
   case vtable_ref_K:           \
   case with_cleanup_expr_K:    \
   case obj_type_ref_K:         \
   case save_expr_K:            \
   case cond_expr_K:            \
   case vec_cond_expr_K:        \
   case vec_perm_expr_K:        \
   case dot_prod_expr_K:        \
   case ternary_plus_expr_K:    \
   case ternary_pm_expr_K:      \
   case ternary_mp_expr_K:      \
   case ternary_mm_expr_K:      \
   case fshl_expr_K:            \
   case fshr_expr_K:            \
   case insertvalue_expr_K:     \
   case insertelement_expr_K

#define CASE_QUATERNARY_EXPRESSION \
   array_range_ref_K:              \
   case array_ref_K

#define CASE_TYPE_NODES        \
   array_type_K:               \
   case boolean_type_K:        \
   case CharType_K:            \
   case nullptr_type_K:        \
   case type_pack_expansion_K: \
   case complex_type_K:        \
   case enumeral_type_K:       \
   case function_type_K:       \
   case integer_type_K:        \
   case lang_type_K:           \
   case method_type_K:         \
   case offset_type_K:         \
   case pointer_type_K:        \
   case qual_union_type_K:     \
   case real_type_K:           \
   case record_type_K:         \
   case reference_type_K:      \
   case set_type_K:            \
   case template_type_parm_K:  \
   case typename_type_K:       \
   case union_type_K:          \
   case vector_type_K:         \
   case void_type_K:           \
   case type_argument_pack_K

#define CASE_PRAGMA_NODES               \
   issue_pragma_K:                      \
   case blackbox_pragma_K:              \
   case profiling_pragma_K:             \
   case statistical_profiling_K:        \
   case map_pragma_K:                   \
   case call_hw_pragma_K:               \
   case call_point_hw_pragma_K:         \
   case omp_pragma_K:                   \
   case null_node_K:                    \
   case omp_atomic_pragma_K:            \
   case omp_critical_pragma_K:          \
   case omp_declare_simd_pragma_K:      \
   case omp_for_pragma_K:               \
   case omp_parallel_pragma_K:          \
   case omp_sections_pragma_K:          \
   case omp_parallel_sections_pragma_K: \
   case omp_section_pragma_K:           \
   case omp_simd_pragma_K:              \
   case omp_target_pragma_K:            \
   case omp_task_pragma_K

#define CASE_FAKE_NODES     \
   last_tree_K:             \
   case none_K:             \
   case placeholder_expr_K: \
   case tree_reindex_K

#define CASE_CPP_NODES           \
   baselink_K:                   \
   case ctor_initializer_K:      \
   case do_stmt_K:               \
   case expr_stmt_K:             \
   case if_stmt_K:               \
   case for_stmt_K:              \
   case handler_K:               \
   case modop_expr_K:            \
   case new_expr_K:              \
   case overload_K:              \
   case return_stmt_K:           \
   case scope_ref_K:             \
   case template_id_expr_K:      \
   case template_parm_index_K:   \
   case trait_expr_K:            \
   case try_block_K:             \
   case vec_new_expr_K:          \
   case while_stmt_K:            \
   case nontype_argument_pack_K: \
   case cast_expr_K:             \
   case expr_pack_expansion_K

#define CASE_DECL_NODES          \
   const_decl_K:                 \
   case field_decl_K:            \
   case function_decl_K:         \
   case label_decl_K:            \
   case namespace_decl_K:        \
   case parm_decl_K:             \
   case result_decl_K:           \
   case translation_unit_decl_K: \
   case type_decl_K:             \
   case using_decl_K:            \
   case var_decl_K:              \
   case template_decl_K

#define CASE_CST_NODES \
   complex_cst_K:      \
   case integer_cst_K: \
   case real_cst_K:    \
   case string_cst_K:  \
   case vector_cst_K:  \
   case void_cst_K

#define CASE_GIMPLE_NODES      \
   gimple_asm_K:               \
   case gimple_assign_K:       \
   case gimple_bind_K:         \
   case gimple_call_K:         \
   case gimple_cond_K:         \
   case gimple_for_K:          \
   case gimple_goto_K:         \
   case gimple_label_K:        \
   case gimple_multi_way_if_K: \
   case gimple_nop_K:          \
   case gimple_phi_K:          \
   case gimple_pragma_K:       \
   case gimple_predict_K:      \
   case gimple_resx_K:         \
   case gimple_return_K:       \
   case gimple_switch_K:       \
   case gimple_while_K

#define CREATE_TREE_NODE_CLASS(class_name, superclass)               \
   struct class_name : public superclass                             \
   {                                                                 \
      GET_KIND_TEXT(class_name)                                      \
      GET_KIND(class_name)                                           \
      virtual void visit(tree_node_visitor* const v) const override; \
      enum                                                           \
      {                                                              \
         GETID(superclass) = 0                                       \
      };                                                             \
      explicit class_name(unsigned int i) : superclass(i)            \
      {                                                              \
      }                                                              \
   }

struct WeightedNode : public tree_node
{
   enum
   {
      GETID(tree_node) = 0
   };

   explicit WeightedNode(unsigned int i);

   void visit(tree_node_visitor* const v) const override;
};

struct attr
{
   CustomOrderedSet<TreeVocabularyTokenTypes_TokenEnum> list_attr;

   virtual ~attr();

   void add(const TreeVocabularyTokenTypes_TokenEnum a)
   {
      list_attr.insert(a);
   }

   bool is_constructor() const;

   bool is_destructor() const;

   bool is_member() const;

   bool is_call() const;

   bool is_new() const;

   bool is_public() const;

   bool is_private() const;

   bool is_protected() const;

   bool is_bitfield() const;

   virtual void visit(tree_node_visitor* const v) const;
};

struct srcp
{
   std::string include_name;

   unsigned int line_number;

   unsigned int column_number;

   srcp() : line_number(0), column_number(0)
   {
   }

   virtual ~srcp();

   virtual void visit(tree_node_visitor* const v) const;
};

struct decl_node : public srcp, public tree_node
{
   tree_nodeRef name;

   tree_nodeRef mngl;

   tree_nodeRef orig;

   tree_nodeRef type;

   tree_nodeRef scpe;

   tree_nodeRef attributes;

   bool artificial_flag;

   bool packed_flag;

   bool operating_system_flag;

   bool library_system_flag;

   bool libbambu_flag;

   tree_nodeRef chan;

   bool C_flag;

   unsigned int uid;

   explicit decl_node(unsigned int i);

   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(srcp) = 0,
      GETID(tree_node),
      GETID(name),
      GETID(mngl),
      GETID(orig),
      GETID(type),
      GETID(scpe),
      GETID(chan),
      GETID(attributes)
   };
};

struct expr_node : public srcp, public WeightedNode
{
   explicit expr_node(unsigned int i) : WeightedNode(i)
   {
   }

   tree_nodeRef type;

   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(srcp) = 0,
      GETID(WeightedNode),
      GETID(type)
   };
};

struct PointToSolution
{
   bool anything;

   bool escaped;

   bool ipa_escaped;

   bool nonlocal;

   bool null;

   std::vector<tree_nodeRef> variables;

   PointToSolution();

   virtual ~PointToSolution();

   void Add(const std::string& variable);

   void Add(const tree_nodeRef& variable);

   bool is_a_singleton() const;

   bool is_fully_resolved() const;

   std::string ToString() const;

   virtual void visit(tree_node_visitor* const v) const;

   enum
   {
      GETID(variables) = 0
   };
};
using PointToSolutionRef = refcount<PointToSolution>;

struct gimple_node : public srcp, public WeightedNode
{
   explicit gimple_node(unsigned int i);

   tree_nodeRef memuse;

   tree_nodeRef memdef;

   tree_nodeRef vdef;

   void SetVdef(const tree_nodeRef& vdef);

   TreeNodeSet vuses;

   bool AddVuse(const tree_nodeRef& vuse);

   TreeNodeSet vovers;

   bool AddVover(const tree_nodeRef& vover);

   std::vector<tree_nodeRef> pragmas;

   PointToSolutionRef use_set;

   PointToSolutionRef clobbered_set;

   tree_nodeRef scpe;

   unsigned int bb_index;

   std::string operation;

   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(srcp) = 0,
      GETID(WeightedNode),
      GETID(memuse),
      GETID(memdef),
      GETID(vuses),
      GETID(vdef),
      GETID(vovers),
      GETID(pragmas),
      GETID(use_set),
      GETID(clobbered_set),
      GETID(scpe)
   };

   bool artificial;

   bool keep;
};

struct unary_expr : public expr_node
{
   explicit unary_expr(unsigned int i) : expr_node(i)
   {
   }

   tree_nodeRef op;

   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(expr_node) = 0,
      GETID(op)
   };
};

struct binary_expr : public expr_node
{
   explicit binary_expr(unsigned int i) : expr_node(i)
   {
   }

   tree_nodeRef op0;

   tree_nodeRef op1;

   void visit(tree_node_visitor* const v) const override;

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

struct ternary_expr : public expr_node
{
   explicit ternary_expr(unsigned int i) : expr_node(i)
   {
   }

   tree_nodeRef op0;

   tree_nodeRef op1;

   tree_nodeRef op2;

   void visit(tree_node_visitor* const v) const override;

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

struct quaternary_expr : public expr_node
{
   explicit quaternary_expr(unsigned int i) : expr_node(i)
   {
   }

   tree_nodeRef op0;

   tree_nodeRef op1;

   tree_nodeRef op2;

   tree_nodeRef op3;

   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(expr_node) = 0,
      GETID(op0),
      GETID(op1),
      GETID(op2),
      GETID(op3)
   };
};

struct type_node : public tree_node
{
   explicit type_node(unsigned int i);

   TreeVocabularyTokenTypes_TokenEnum qual;

   tree_nodeRef name;

   tree_nodeRef unql;

   tree_nodeRef size;

   tree_nodeRef scpe;

   unsigned int algn;

   bool packed_flag;

   bool system_flag;

   bool libbambu_flag;

   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0,
      GETID(name),
      GETID(unql),
      GETID(size),
      GETID(scpe)
   };
};

struct memory_tag : public decl_node
{
   explicit memory_tag(unsigned int i) : decl_node(i)
   {
   }

   std::vector<tree_nodeRef> list_of_aliases;

   void add_alias(const tree_nodeRef a)
   {
      list_of_aliases.push_back(a);
   }

   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(decl_node) = 0,
      GETID(list_of_aliases)
   };
};

struct cst_node : tree_node
{
   explicit cst_node(unsigned int i) : tree_node(i)
   {
   }

   tree_nodeRef type;

   void visit(tree_node_visitor* const v) const override;

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

struct error_mark : tree_node
{
   explicit error_mark(unsigned int i) : tree_node(i)
   {
   }

   GET_KIND_TEXT(error_mark)

   
   GET_KIND(error_mark)
   void visit(tree_node_visitor* const v) const override;

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

CREATE_TREE_NODE_CLASS(abs_expr, unary_expr);

CREATE_TREE_NODE_CLASS(addr_expr, unary_expr);

CREATE_TREE_NODE_CLASS(array_range_ref, quaternary_expr);

CREATE_TREE_NODE_CLASS(array_ref, quaternary_expr);

struct array_type : public type_node
{
   explicit array_type(unsigned int i) : type_node(i)
   {
   }

   /*type_node fields are in the parent class: type_node*/

   tree_nodeRef elts;

   tree_nodeRef domn;

   GET_KIND_TEXT(array_type)

   
   GET_KIND(array_type)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(type_node) = 0,
      GETID(elts),
      GETID(domn)
   };
};

CREATE_TREE_NODE_CLASS(alignof_expr, unary_expr);

CREATE_TREE_NODE_CLASS(arrow_expr, unary_expr);

struct gimple_asm : public gimple_node
{
   explicit gimple_asm(unsigned int i) : gimple_node(i), volatile_flag(false)
   {
   }

   bool volatile_flag;

   std::string str;

   tree_nodeRef out;

   tree_nodeRef in;

   tree_nodeRef clob;

   GET_KIND_TEXT(gimple_asm)

   
   GET_KIND(gimple_asm)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(gimple_node) = 0,
      GETID(out),
      GETID(in),
      GETID(clob)
   };
};

CREATE_TREE_NODE_CLASS(assert_expr, binary_expr);

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

   tree_nodeRef type;

   GET_KIND_TEXT(baselink)

   
   GET_KIND(baselink)

   
   void visit(tree_node_visitor* const v) const override;

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

struct gimple_bind : public expr_node
{
   explicit gimple_bind(unsigned int i) : expr_node(i)
   {
   }

   std::vector<tree_nodeRef> list_of_vars;

   tree_nodeRef body;

   void add_vars(const tree_nodeRef& a)
   {
      list_of_vars.push_back(a);
   }

   GET_KIND_TEXT(gimple_bind)

   
   GET_KIND(gimple_bind)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(expr_node) = 0,
      GETID(list_of_vars),
      GETID(body)
   };
};

struct binfo : public tree_node
{
   explicit binfo(unsigned int i) : tree_node(i), virt_flag(false), bases(0)
   {
   }

   tree_nodeRef type;

   bool virt_flag;

   int bases;

   std::vector<std::pair<TreeVocabularyTokenTypes_TokenEnum, tree_nodeRef>> list_of_access_binf;

   tree_nodeRef get_base(size_t i) const
   {
      return list_of_access_binf[i].second;
   }

   size_t get_baseinfo_size() const
   {
      return list_of_access_binf.size();
   }

   void add_access_binf(const tree_nodeRef& binf, TreeVocabularyTokenTypes_TokenEnum access);

   GET_KIND_TEXT(binfo)

   
   GET_KIND(binfo)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0,
      GETID(type),
      GETID(list_of_access_binf)
   };
};

CREATE_TREE_NODE_CLASS(bit_and_expr, binary_expr);

CREATE_TREE_NODE_CLASS(bit_field_ref, ternary_expr);

CREATE_TREE_NODE_CLASS(bit_ior_expr, binary_expr);

CREATE_TREE_NODE_CLASS(bit_ior_concat_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(bit_not_expr, unary_expr);

CREATE_TREE_NODE_CLASS(bit_xor_expr, binary_expr);

struct block : public tree_node
{
   explicit block(unsigned int i) : tree_node(i), bl_flag(false)
   {
   }

   bool bl_flag;

   std::string bl;

   GET_KIND_TEXT(block)

   
   GET_KIND(block)

   
   void visit(tree_node_visitor* const v) const override;

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

CREATE_TREE_NODE_CLASS(boolean_type, type_node);

CREATE_TREE_NODE_CLASS(buffer_ref, unary_expr);

struct call_expr : public expr_node
{
   explicit call_expr(unsigned int i);

   tree_nodeRef fn;

   std::vector<tree_nodeRef> args;

   void AddArg(const tree_nodeRef& arg);

   GET_KIND_TEXT(call_expr)

   
   GET_KIND(call_expr)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(expr_node) = 0,
      GETID(type),
      GETID(fn),
      GETID(args)
   };
};

struct aggr_init_expr : public call_expr
{
   explicit aggr_init_expr(unsigned int i);

   int ctor;

   tree_nodeRef slot;

   GET_KIND_TEXT(aggr_init_expr)

   
   GET_KIND(aggr_init_expr)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(call_expr) = 0,
      GETID(ctor),
      GETID(slot)
   };
};

struct gimple_call : public gimple_node
{
   explicit gimple_call(unsigned int i);

   tree_nodeRef fn;

   std::vector<tree_nodeRef> args;

   void AddArg(const tree_nodeRef& arg);

   GET_KIND_TEXT(gimple_call)

   
   GET_KIND(gimple_call)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(gimple_node) = 0,
      GETID(type),
      GETID(fn),
      GETID(args)
   };
};

CREATE_TREE_NODE_CLASS(card_expr, unary_expr);

struct case_label_expr : public expr_node
{
   explicit case_label_expr(unsigned int i) : expr_node(i), default_flag(false)
   {
   }

   tree_nodeRef op0;

   tree_nodeRef op1;

   bool default_flag;

   tree_nodeRef got;

   GET_KIND_TEXT(case_label_expr)

   
   GET_KIND(case_label_expr)

   
   void visit(tree_node_visitor* const v) const override;

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

struct cast_expr : public expr_node
{
   explicit cast_expr(unsigned int i) : expr_node(i)
   {
   }

   tree_nodeRef op;

   GET_KIND_TEXT(cast_expr)

   
   GET_KIND(cast_expr)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(expr_node) = 0,
      GETID(op)
   };
};

CREATE_TREE_NODE_CLASS(catch_expr, binary_expr);

CREATE_TREE_NODE_CLASS(ceil_div_expr, binary_expr);

CREATE_TREE_NODE_CLASS(ceil_mod_expr, binary_expr);

CREATE_TREE_NODE_CLASS(CharType, type_node);

CREATE_TREE_NODE_CLASS(nullptr_type, type_node);

struct type_pack_expansion : public type_node
{
   explicit type_pack_expansion(unsigned int i) : type_node(i)
   {
   }

   tree_nodeRef op;

   tree_nodeRef param_packs;

   tree_nodeRef arg;

   GET_KIND_TEXT(type_pack_expansion)

   
   GET_KIND(type_pack_expansion)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(type_node) = 0,
      GETID(op),
      GETID(param_packs),
      GETID(arg)
   };
};

struct expr_pack_expansion : public expr_node
{
   explicit expr_pack_expansion(unsigned int i) : expr_node(i)
   {
   }

   tree_nodeRef op;

   tree_nodeRef param_packs;

   tree_nodeRef arg;

   GET_KIND_TEXT(expr_pack_expansion)

   
   GET_KIND(expr_pack_expansion)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(expr_node) = 0,
      GETID(op),
      GETID(param_packs),
      GETID(arg)
   };
};

CREATE_TREE_NODE_CLASS(cleanup_point_expr, unary_expr);

struct complex_cst : public cst_node
{
   explicit complex_cst(unsigned int i) : cst_node(i)
   {
   }

   tree_nodeRef real;

   tree_nodeRef imag;

   GET_KIND_TEXT(complex_cst)

   
   GET_KIND(complex_cst)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(cst_node) = 0,
      GETID(real),
      GETID(imag)
   };
};

CREATE_TREE_NODE_CLASS(complex_expr, binary_expr);

struct complex_type : public type_node
{
   explicit complex_type(unsigned int i) : type_node(i), unsigned_flag(false), real_flag(false)
   {
   }

   bool unsigned_flag;

   bool real_flag;

   GET_KIND_TEXT(complex_type)

   
   GET_KIND(complex_type)

   
   void visit(tree_node_visitor* const v) const override;

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

CREATE_TREE_NODE_CLASS(component_ref, ternary_expr);

CREATE_TREE_NODE_CLASS(compound_expr, binary_expr);

CREATE_TREE_NODE_CLASS(cond_expr, ternary_expr);

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

   tree_nodeRef op0;

   GET_KIND_TEXT(gimple_cond)

   
   GET_KIND(gimple_cond)

   
   void visit(tree_node_visitor* const v) const override;

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

CREATE_TREE_NODE_CLASS(conj_expr, unary_expr);

struct const_decl : public decl_node
{
   explicit const_decl(unsigned int i) : decl_node(i)
   {
   }

   /*decl_node fields are in the parent class*/

   tree_nodeRef cnst;

   GET_KIND_TEXT(const_decl)

   
   GET_KIND(const_decl)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(decl_node) = 0,
      GETID(cnst)
   };
};

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

   tree_nodeRef type;

   std::vector<std::pair<tree_nodeRef, tree_nodeRef>> list_of_idx_valu;

   void add_idx_valu(const tree_nodeRef& idx, const tree_nodeRef& valu)
   {
      list_of_idx_valu.push_back(std::pair<tree_nodeRef, tree_nodeRef>(idx, valu));
   }

   void add_valu(const tree_nodeRef& valu)
   {
      list_of_idx_valu.push_back(std::pair<tree_nodeRef, tree_nodeRef>(tree_nodeRef(), valu));
   }

   GET_KIND_TEXT(constructor)

   
   GET_KIND(constructor)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0,
      GETID(type),
      GETID(list_of_idx_valu)
   };
};

CREATE_TREE_NODE_CLASS(convert_expr, unary_expr);

CREATE_TREE_NODE_CLASS(ctor_initializer, tree_node);

CREATE_TREE_NODE_CLASS(eh_filter_expr, binary_expr);

struct enumeral_type : public type_node
{
   explicit enumeral_type(unsigned int i) : type_node(i), prec(0), unsigned_flag(false)
   {
   }

   /*type_node fields are in the parent class*/

   unsigned int prec;

   bool unsigned_flag;

   tree_nodeRef min;

   tree_nodeRef max;

   tree_nodeRef csts;

   GET_KIND_TEXT(enumeral_type)

   
   GET_KIND(enumeral_type)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(type_node) = 0,
      GETID(min),
      GETID(max),
      GETID(csts)
   };
};

CREATE_TREE_NODE_CLASS(eq_expr, binary_expr);

CREATE_TREE_NODE_CLASS(exact_div_expr, binary_expr);

CREATE_TREE_NODE_CLASS(exit_expr, unary_expr);

struct expr_stmt : public tree_node
{
   explicit expr_stmt(unsigned int i) : tree_node(i), line(-1)
   {
   }

   int line;

   tree_nodeRef expr;

   tree_nodeRef next;

   GET_KIND_TEXT(expr_stmt)

   
   GET_KIND(expr_stmt)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0,
      GETID(expr),
      GETID(next)
   };
};

CREATE_TREE_NODE_CLASS(fdesc_expr, binary_expr);

struct field_decl : public decl_node, public attr
{
   explicit field_decl(unsigned int i) : decl_node(i), algn(0)
   {
   }

   /*decl_node fields are in the parent class: decl_node*/
   /*attr fields are in the parent class: attr*/

   tree_nodeRef init;

   tree_nodeRef size;

   unsigned int algn;

   tree_nodeRef bpos;

   tree_nodeRef smt_ann;

   integer_cst_t offset();

   GET_KIND_TEXT(field_decl)

   
   GET_KIND(field_decl)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(decl_node) = 0,
      GETID(attr),
      GETID(init),
      GETID(size),
      GETID(bpos),
      GETID(smt_ann)
   };
};

CREATE_TREE_NODE_CLASS(fix_ceil_expr, unary_expr);

CREATE_TREE_NODE_CLASS(fix_floor_expr, unary_expr);

CREATE_TREE_NODE_CLASS(fix_round_expr, unary_expr);

CREATE_TREE_NODE_CLASS(fix_trunc_expr, unary_expr);

CREATE_TREE_NODE_CLASS(float_expr, unary_expr);

CREATE_TREE_NODE_CLASS(floor_div_expr, binary_expr);

CREATE_TREE_NODE_CLASS(floor_mod_expr, binary_expr);

struct function_decl : public decl_node, public attr
{
   explicit function_decl(unsigned int i);

   bool operator_flag;

   std::vector<std::string> list_of_op_names;

   bool fixd_flag;

   bool virt_flag;

   bool reverse_restrict_flag;

   bool writing_memory;

   bool reading_memory;

   bool pipeline_enabled;

   bool simple_pipeline;

   int initiation_time;

#if HAVE_FROM_PRAGMA_BUILT
   size_t omp_for_wrapper;

   bool omp_body_loop;

   std::string omp_critical;

   bool omp_atomic;
#endif

   int fixd;

   int virt;

   tree_nodeRef fn;

   std::string bit_values;

   RangeRef range;

   tree_nodeRef tmpl_parms;

   tree_nodeRef tmpl_args;

   std::vector<tree_nodeRef> list_of_args;

   bool undefined_flag;

   bool builtin_flag;

   bool hwcall_flag;

   bool static_flag;

   tree_nodeRef body;

   tree_nodeRef inline_body;

   void add(std::string a)
   {
      list_of_op_names.push_back(a);
   }

   void AddArg(const tree_nodeRef& a);

   bool is_constructor();

   bool is_destructor();

   bool is_operator() const;

   bool is_public();

   bool is_private();

   bool is_protected();

   bool is_pipelined();

   void set_pipelining(bool v);

   bool is_simple_pipeline();

   void set_simple_pipeline(bool v);

   int get_initiation_time();

   void set_initiation_time(int time);

   GET_KIND_TEXT(function_decl)

   
   GET_KIND(function_decl)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(decl_node) = 0,
      GETID(attr),
      GETID(fn),
      GETID(tmpl_parms),
      GETID(tmpl_args),
      GETID(list_of_args),
      GETID(body),
      GETID(inline_body)
   };
};

struct function_type : public type_node
{
   explicit function_type(unsigned int i) : type_node(i), varargs_flag(false)
   {
   }

   bool varargs_flag;

   tree_nodeRef retn;

   tree_nodeRef prms;

   GET_KIND_TEXT(function_type)

   
   GET_KIND(function_type)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(type_node) = 0,
      GETID(retn),
      GETID(prms)
   };
};

CREATE_TREE_NODE_CLASS(ge_expr, binary_expr);

struct gimple_assign : public gimple_node
{
   explicit gimple_assign(unsigned int i);

   tree_nodeRef op0;

   tree_nodeRef op1;

   tree_nodeRef predicate;

   bool init_assignment;

   bool clobber;

   bool temporary_address;

   GET_KIND_TEXT(gimple_assign)

   
   GET_KIND(gimple_assign)

   
   void visit(tree_node_visitor* const v) const override;

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

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

   GET_KIND_TEXT(gimple_nop)

   
   GET_KIND(gimple_nop)

   
   void visit(tree_node_visitor* const v) const override;

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

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

   tree_nodeRef op;

   GET_KIND_TEXT(gimple_goto)

   
   GET_KIND(gimple_goto)

   
   void visit(tree_node_visitor* const v) const override;

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

CREATE_TREE_NODE_CLASS(goto_subroutine, binary_expr);

CREATE_TREE_NODE_CLASS(gt_expr, binary_expr);

struct handler : public tree_node
{
   explicit handler(unsigned int i) : tree_node(i), line(-1)
   {
   }

   int line;

   tree_nodeRef body;

   GET_KIND_TEXT(handler)

   
   GET_KIND(handler)

   
   void visit(tree_node_visitor* const v) const override;

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

struct identifier_node : public tree_node
{
   identifier_node(unsigned int node_id, std::string _strg, tree_manager* TM);
   identifier_node(unsigned int node_id, bool _operator_flag, tree_manager* TM);

   const bool operator_flag;

   std::string strg;

   GET_KIND_TEXT(identifier_node)

   
   GET_KIND(identifier_node)

   
   void visit(tree_node_visitor* const v) const override;

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

CREATE_TREE_NODE_CLASS(imagpart_expr, unary_expr);

CREATE_TREE_NODE_CLASS(indirect_ref, unary_expr);

CREATE_TREE_NODE_CLASS(misaligned_indirect_ref, unary_expr);

CREATE_TREE_NODE_CLASS(in_expr, binary_expr);

CREATE_TREE_NODE_CLASS(init_expr, binary_expr);

struct integer_cst : public cst_node
{
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
   explicit integer_cst(unsigned int i) : cst_node(i), value(0)
   {
   }
#pragma GCC diagnostic pop

   integer_cst_t value;

   GET_KIND_TEXT(integer_cst)

   
   GET_KIND(integer_cst)

   
   void visit(tree_node_visitor* const v) const override;

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

struct integer_type : public type_node
{
   explicit integer_type(unsigned int i) : type_node(i), prec(0), unsigned_flag(false)
   {
   }

   /*type_node fields are in the parent class: type_node*/

   unsigned int prec;

   std::string str;

   bool unsigned_flag;

   tree_nodeRef min;

   tree_nodeRef max;

   GET_KIND_TEXT(integer_type)

   
   GET_KIND(integer_type)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(type_node) = 0,
      GETID(min),
      GETID(max)
   };
};

CREATE_TREE_NODE_CLASS(label_decl, decl_node);

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

   tree_nodeRef op;

   GET_KIND_TEXT(gimple_label)

   
   GET_KIND(gimple_label)

   
   void visit(tree_node_visitor* const v) const override;

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

CREATE_TREE_NODE_CLASS(lang_type, type_node);

CREATE_TREE_NODE_CLASS(le_expr, binary_expr);

CREATE_TREE_NODE_CLASS(loop_expr, unary_expr);

CREATE_TREE_NODE_CLASS(lrotate_expr, binary_expr);

CREATE_TREE_NODE_CLASS(lshift_expr, binary_expr);

CREATE_TREE_NODE_CLASS(lt_expr, binary_expr);

CREATE_TREE_NODE_CLASS(ltgt_expr, binary_expr);

CREATE_TREE_NODE_CLASS(max_expr, binary_expr);

CREATE_TREE_NODE_CLASS(mem_ref, binary_expr);

struct method_type : public function_type
{
   explicit method_type(unsigned int i) : function_type(i)
   {
   }

   // type_node fields are in the parent class: type_node
   // return type and parameters are in the parent class function_type

   tree_nodeRef clas;

   GET_KIND_TEXT(method_type)

   
   GET_KIND(method_type)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(function_type) = 0,
      GETID(clas)
   };
};

CREATE_TREE_NODE_CLASS(min_expr, binary_expr);

CREATE_TREE_NODE_CLASS(minus_expr, binary_expr);

CREATE_TREE_NODE_CLASS(modify_expr, binary_expr);

CREATE_TREE_NODE_CLASS(modop_expr, expr_node);

CREATE_TREE_NODE_CLASS(mult_expr, binary_expr);

CREATE_TREE_NODE_CLASS(mult_highpart_expr, binary_expr);

struct namespace_decl : public decl_node
{
   explicit namespace_decl(unsigned int i) : decl_node(i)
   {
   }

   /*decl_node fields are in the parent class*/

   tree_nodeRef dcls;

   GET_KIND_TEXT(namespace_decl)

   
   GET_KIND(namespace_decl)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(decl_node) = 0,
      GETID(dcls)
   };
};

CREATE_TREE_NODE_CLASS(ne_expr, binary_expr);

CREATE_TREE_NODE_CLASS(negate_expr, unary_expr);

CREATE_TREE_NODE_CLASS(new_expr, expr_node);

CREATE_TREE_NODE_CLASS(non_lvalue_expr, unary_expr);

CREATE_TREE_NODE_CLASS(nop_expr, unary_expr);

CREATE_TREE_NODE_CLASS(obj_type_ref, ternary_expr);

CREATE_TREE_NODE_CLASS(offset_type, type_node);

CREATE_TREE_NODE_CLASS(ordered_expr, binary_expr);

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

   tree_nodeRef crnt;

   tree_nodeRef chan;

   GET_KIND_TEXT(overload)

   
   GET_KIND(overload)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0,
      GETID(crnt),
      GETID(chan)
   };
};

struct parm_decl : public decl_node
{
   explicit parm_decl(unsigned int i);

   /*decl_node fields are in the parent class: decl_node*/

   tree_nodeRef argt;

   tree_nodeRef size;

   unsigned int algn;

   int used;

   bool register_flag;

   bool readonly_flag;

   tree_nodeRef smt_ann;

   RangeRef range;

   GET_KIND_TEXT(parm_decl)

   
   GET_KIND(parm_decl)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(decl_node) = 0,
      GETID(argt),
      GETID(size),
      GETID(smt_ann)
   };
};

struct gimple_phi : public gimple_node
{
 public:
   friend class tree_manager;
   friend class string_cst_fix;
   friend class parm2ssa;

   using DefEdge = std::pair<tree_nodeRef, unsigned int>;

   using DefEdgeList = std::list<DefEdge>;

 private:
   DefEdgeList list_of_def_edge;

   bool updated_ssa_uses;

 public:
   explicit gimple_phi(unsigned int i);

   tree_nodeRef res;

   bool virtual_flag;

   const DefEdgeList& CGetDefEdgesList() const;

   void RemoveDefEdge(const tree_managerRef& TM, const DefEdge& to_be_removed);

   void AddDefEdge(const tree_managerRef& TM, const DefEdge& def_edge);

   void ReplaceDefEdge(const tree_managerRef& TM, const DefEdge& old_def_edge, const DefEdge& new_def_edge);

   void SetDefEdgeList(const tree_managerRef& TM, DefEdgeList new_list_of_def_edge);

   GET_KIND_TEXT(gimple_phi)

   
   GET_KIND(gimple_phi)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(gimple_node) = 0,
      GETID(res),
      GETID(list_of_def_edge)
   };

   void SetSSAUsesComputed();
};

struct gimple_predict : public gimple_node
{
   explicit gimple_predict(unsigned int index);

   GET_KIND_TEXT(gimple_predict)

   
   GET_KIND(gimple_predict)

   
   void visit(tree_node_visitor* const v) const override;

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

CREATE_TREE_NODE_CLASS(placeholder_expr, expr_node);

CREATE_TREE_NODE_CLASS(plus_expr, binary_expr);

CREATE_TREE_NODE_CLASS(pointer_plus_expr, binary_expr);

struct pointer_type : public type_node
{
   explicit pointer_type(unsigned int i) : type_node(i)
   {
   }

   /*type_node fields are in the parent class*/

   tree_nodeRef ptd;

   GET_KIND_TEXT(pointer_type)

   
   GET_KIND(pointer_type)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(type_node) = 0,
      GETID(ptd)
   };
};

CREATE_TREE_NODE_CLASS(postdecrement_expr, binary_expr);

CREATE_TREE_NODE_CLASS(postincrement_expr, binary_expr);

CREATE_TREE_NODE_CLASS(predecrement_expr, binary_expr);

CREATE_TREE_NODE_CLASS(preincrement_expr, binary_expr);

CREATE_TREE_NODE_CLASS(qual_union_type, type_node);

CREATE_TREE_NODE_CLASS(range_expr, binary_expr);

CREATE_TREE_NODE_CLASS(paren_expr, unary_expr);

CREATE_TREE_NODE_CLASS(rdiv_expr, binary_expr);

struct real_cst : public cst_node
{
   explicit real_cst(unsigned int i) : cst_node(i), overflow_flag(false)
   {
   }

   bool overflow_flag;

   std::string valr;

   std::string valx;

   GET_KIND_TEXT(real_cst)

   
   GET_KIND(real_cst)

   
   void visit(tree_node_visitor* const v) const override;

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

CREATE_TREE_NODE_CLASS(realpart_expr, unary_expr);

struct real_type : public type_node
{
   explicit real_type(unsigned int i) : type_node(i), prec(0)
   {
   }

   /*type_node fields are in the parent class*/

   unsigned int prec;

   GET_KIND_TEXT(real_type)

   
   GET_KIND(real_type)

   
   void visit(tree_node_visitor* const v) const override;

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

struct record_type : public type_node
{
   explicit record_type(unsigned int i) : type_node(i), spec_flag(false), ptrmem_flag(false), struct_flag(false)
   {
   }

   std::vector<tree_nodeRef> list_of_flds;

   std::vector<tree_nodeRef> list_of_fncs;

   tree_nodeRef ptd;

   tree_nodeRef cls;

   tree_nodeRef bfld;

   tree_nodeRef binf;

   bool spec_flag;

   bool ptrmem_flag;

   bool struct_flag;

   tree_nodeRef vfld;

   tree_nodeRef tmpl_parms;

   tree_nodeRef tmpl_args;

   void add_flds(const tree_nodeRef& a)
   {
      list_of_flds.push_back(a);
   }

   void add_fncs(const tree_nodeRef& a)
   {
      list_of_fncs.push_back(a);
   }

   tree_nodeRef get_field(integer_cst_t offset);

   std::string get_maybe_name() const;

   GET_KIND_TEXT(record_type)

   
   GET_KIND(record_type)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(type_node) = 0,
      GETID(vfld),
      GETID(list_of_flds),
      GETID(list_of_fncs),
      GETID(ptd),
      GETID(cls),
      GETID(bfld),
      GETID(binf),
      GETID(tmpl_parms),
      GETID(tmpl_args)
   };
};

CREATE_TREE_NODE_CLASS(reduc_max_expr, unary_expr);
CREATE_TREE_NODE_CLASS(reduc_min_expr, unary_expr);
CREATE_TREE_NODE_CLASS(reduc_plus_expr, unary_expr);

CREATE_TREE_NODE_CLASS(reference_expr, unary_expr);

struct reference_type : public type_node
{
   explicit reference_type(unsigned int i) : type_node(i)
   {
   }

   /*type_node fields are in the parent class*/

   tree_nodeRef refd;

   GET_KIND_TEXT(reference_type)

   
   GET_KIND(reference_type)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(type_node) = 0,
      GETID(refd)
   };
};

CREATE_TREE_NODE_CLASS(reinterpret_cast_expr, unary_expr);

struct result_decl : public decl_node
{
   explicit result_decl(unsigned int i) : decl_node(i), algn(0)
   {
   }

   /*decl_node fields are in the parent class*/

   tree_nodeRef init;

   tree_nodeRef size;

   unsigned int algn;

   tree_nodeRef smt_ann;

   GET_KIND_TEXT(result_decl)

   
   GET_KIND(result_decl)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(decl_node) = 0,
      GETID(init),
      GETID(size),
      GETID(smt_ann)
   };
};

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

   GET_KIND_TEXT(gimple_resx)

   
   GET_KIND(gimple_resx)

   
   void visit(tree_node_visitor* const v) const override;

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

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

   tree_nodeRef op;

   GET_KIND_TEXT(gimple_return)

   
   GET_KIND(gimple_return)

   
   void visit(tree_node_visitor* const v) const override;

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

struct return_stmt : public tree_node
{
   explicit return_stmt(unsigned int i) : tree_node(i), line(-1)
   {
   }

   int line;

   tree_nodeRef expr;

   GET_KIND_TEXT(return_stmt)

   
   GET_KIND(return_stmt)

   
   void visit(tree_node_visitor* const v) const override;

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

CREATE_TREE_NODE_CLASS(round_div_expr, binary_expr);

CREATE_TREE_NODE_CLASS(round_mod_expr, binary_expr);

CREATE_TREE_NODE_CLASS(rrotate_expr, binary_expr);

CREATE_TREE_NODE_CLASS(rshift_expr, binary_expr);

CREATE_TREE_NODE_CLASS(save_expr, ternary_expr);

struct scope_ref : public expr_node
{
   explicit scope_ref(unsigned int i) : expr_node(i)
   {
   }

   tree_nodeRef op0;

   tree_nodeRef op1;

   GET_KIND_TEXT(scope_ref)

   
   GET_KIND(scope_ref)

   
   void visit(tree_node_visitor* const v) const override;

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

CREATE_TREE_NODE_CLASS(set_le_expr, binary_expr);

CREATE_TREE_NODE_CLASS(set_type, type_node);

CREATE_TREE_NODE_CLASS(sizeof_expr, unary_expr);

struct ssa_name : public tree_node
{
 private:
   TreeNodeMap<size_t> use_stmts;

   TreeNodeSet def_stmts;

 public:
   explicit ssa_name(unsigned int i);

   tree_nodeRef type;

   tree_nodeRef var;

   unsigned int vers;

   unsigned int orig_vers;

   bool volatile_flag;

   bool virtual_flag;

   bool default_flag;

   void AddUseStmt(const tree_nodeRef& use_stmt);

   const TreeNodeMap<size_t>& CGetUseStmts() const;

   size_t CGetNumberUses() const;

   void RemoveUse(const tree_nodeRef& use_stmt);

   tree_nodeRef min;

   tree_nodeRef max;

   std::string bit_values;

   RangeRef range;

   PointToSolutionRef use_set;

   void SetDefStmt(const tree_nodeRef& def);

   void AddDefStmt(const tree_nodeRef& def);

   GET_KIND_TEXT(ssa_name)

   
   GET_KIND(ssa_name)

   
   void visit(tree_node_visitor* const v) const override;

   const tree_nodeRef CGetDefStmt() const;

   const TreeNodeSet CGetDefStmts() const;

   enum
   {
      GETID(tree_node) = 0,
      GETID(type),
      GETID(var),
      GETID(use_stmts),
      GETID(def_stmts),
      GETID(min),
      GETID(max),
      GETID(use_set)
   };
};

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

   std::list<tree_nodeRef> list_of_stmt;

   std::map<unsigned int, blocRef> list_of_bloc;

   void add_bloc(const blocRef& a);

   void add_stmt(const tree_nodeRef& a)
   {
      list_of_stmt.push_back(a);
   }

   GET_KIND_TEXT(statement_list)

   
   GET_KIND(statement_list)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0,
      GETID(list_of_stmt),
      GETID(list_of_bloc)
   };
};

CREATE_TREE_NODE_CLASS(static_cast_expr, unary_expr);

struct string_cst : public cst_node
{
   explicit string_cst(unsigned int i) : cst_node(i), lngt(-1)
   {
   }

   std::string strg;

   int lngt;

   GET_KIND_TEXT(string_cst)

   
   GET_KIND(string_cst)

   
   void visit(tree_node_visitor* const v) const override;

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

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

   tree_nodeRef op0;

   tree_nodeRef op1;

   GET_KIND_TEXT(gimple_switch)

   
   GET_KIND(gimple_switch)

   
   void visit(tree_node_visitor* const v) const override;

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

struct target_expr : public expr_node
{
   explicit target_expr(unsigned int i) : expr_node(i)
   {
   }

   tree_nodeRef decl;

   tree_nodeRef init;

   tree_nodeRef clnp;

   GET_KIND_TEXT(target_expr)

   
   GET_KIND(target_expr)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(expr_node) = 0,
      GETID(decl),
      GETID(init),
      GETID(clnp)
   };
};
struct target_mem_ref : public WeightedNode
{
   explicit target_mem_ref(unsigned int i) : WeightedNode(i)
   {
   }

   tree_nodeRef type;

   tree_nodeRef symbol;

   tree_nodeRef base;

   tree_nodeRef idx;

   tree_nodeRef step;

   tree_nodeRef offset;

   tree_nodeRef orig;

   tree_nodeRef tag;

   GET_KIND_TEXT(target_mem_ref)

   
   GET_KIND(target_mem_ref)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(WeightedNode) = 0,
      GETID(type),
      GETID(symbol),
      GETID(base),
      GETID(idx),
      GETID(step),
      GETID(offset),
      GETID(orig),
      GETID(tag)
   };
};

struct target_mem_ref461 : public WeightedNode
{
   explicit target_mem_ref461(unsigned int i) : WeightedNode(i)
   {
   }

   tree_nodeRef type;

   tree_nodeRef base;

   tree_nodeRef offset;

   tree_nodeRef idx;

   tree_nodeRef step;

   tree_nodeRef idx2;

   GET_KIND_TEXT(target_mem_ref461)

   
   GET_KIND(target_mem_ref461)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(WeightedNode) = 0,
      GETID(type),
      GETID(base),
      GETID(idx),
      GETID(idx2),
      GETID(step),
      GETID(offset)
   };
};

struct template_decl : public decl_node
{
   explicit template_decl(unsigned int i) : decl_node(i)
   {
   }

   /*decl_node fields are in the parent class: decl_node*/

   tree_nodeRef rslt;

   tree_nodeRef inst;

   tree_nodeRef spcs;

   tree_nodeRef prms;

   GET_KIND_TEXT(template_decl)

   
   GET_KIND(template_decl)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(decl_node) = 0,
      GETID(rslt),
      GETID(inst),
      GETID(base),
      GETID(spcs),
      GETID(prms)
   };
};

CREATE_TREE_NODE_CLASS(template_id_expr, expr_node);

/* Index into a template parameter list.  The TEMPLATE_PARM_IDX gives
   the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL
   gives the level (from 1) of the parameter.

   Here's an example:

   template <class T> // Index 0, Level 1.
   struct S
   {
      template <class U, // Index 0, Level 2.
      class V> // Index 1, Level 2.
      void f();
   };

   The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended
   from this one.  The first descendant will have the same IDX, but
   its LEVEL will be one less.  The TREE_CHAIN field is used to chain
   together the descendants.  The TEMPLATE_PARM_DECL is the
   declaration of this parameter, either a TYPE_DECL or CONST_DECL.
   The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant
   parent, i.e., the LEVEL that the parameter originally had when it
   was declared.  For example, if we instantiate S<int>, we will have:

   struct S<int>
   {
     template <class U, // Index 0, Level 1, Orig Level 2
          class V> // Index 1, Level 1, Orig Level 2
     void f();
   };

   The LEVEL is the level of the parameter when we are worrying about
   the types of things; the ORIG_LEVEL is the level when we are
   worrying about instantiating things.  */
struct template_parm_index : public tree_node
{
   tree_nodeRef type;
   tree_nodeRef decl;
   bool constant_flag;
   bool readonly_flag;
   int idx;
   int level;
   int orig_level;

   explicit template_parm_index(unsigned int i)
       : tree_node(i), constant_flag(false), readonly_flag(false), idx(0), level(0), orig_level(0)
   {
   }

   GET_KIND_TEXT(template_parm_index)

   
   GET_KIND(template_parm_index)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0,
      GETID(type),
      GETID(decl)
   };
};

CREATE_TREE_NODE_CLASS(template_type_parm, type_node);

struct type_argument_pack : public type_node
{
   explicit type_argument_pack(unsigned int i) : type_node(i)
   {
   }

   tree_nodeRef arg;

   GET_KIND_TEXT(type_argument_pack)

   
   GET_KIND(type_argument_pack)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(type_node) = 0,
      GETID(arg)
   };
};

/* Represents an argument pack of values, which can be used either for
   non-type template arguments or function call arguments.

   NONTYPE_ARGUMENT_PACK plays precisely the same role as
   TYPE_ARGUMENT_PACK, but will be used for packing non-type template
   arguments (e.g., "int... Dimensions") or function arguments ("const
   Args&... args"). */

struct nontype_argument_pack : public expr_node
{
   explicit nontype_argument_pack(unsigned int i) : expr_node(i)
   {
   }

   tree_nodeRef arg;

   GET_KIND_TEXT(nontype_argument_pack)

   
   GET_KIND(nontype_argument_pack)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(expr_node) = 0,
      GETID(arg)
   };
};

CREATE_TREE_NODE_CLASS(ternary_plus_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(ternary_pm_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(ternary_mp_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(ternary_mm_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(throw_expr, unary_expr);

CREATE_TREE_NODE_CLASS(trait_expr, tree_node);

CREATE_TREE_NODE_CLASS(translation_unit_decl, decl_node);

struct tree_list : public WeightedNode
{
   explicit tree_list(unsigned int i) : WeightedNode(i)
   {
   }

   tree_nodeRef purp;

   tree_nodeRef valu;

   tree_nodeRef chan;

   GET_KIND_TEXT(tree_list)

   
   GET_KIND(tree_list)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(WeightedNode) = 0,
      GETID(purp),
      GETID(valu),
      GETID(chan)
   };
};

struct tree_vec : public tree_node
{
   explicit tree_vec(unsigned int i) : tree_node(i), lngt(0)
   {
   }

   size_t lngt;

   std::vector<tree_nodeRef> list_of_op;

   void add_op(const tree_nodeRef& a)
   {
      list_of_op.push_back(a);
   }

   size_t get_number_of_op() const
   {
      return list_of_op.size();
   }

   tree_nodeRef get_op(size_t n) const
   {
      return list_of_op[n];
   }

   GET_KIND_TEXT(tree_vec)

   
   GET_KIND(tree_vec)

   
   void visit(tree_node_visitor* const v) const override;

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

CREATE_TREE_NODE_CLASS(trunc_div_expr, binary_expr);

CREATE_TREE_NODE_CLASS(trunc_mod_expr, binary_expr);

CREATE_TREE_NODE_CLASS(truth_and_expr, binary_expr);

CREATE_TREE_NODE_CLASS(truth_andif_expr, binary_expr);

CREATE_TREE_NODE_CLASS(truth_not_expr, unary_expr);

CREATE_TREE_NODE_CLASS(truth_or_expr, binary_expr);

CREATE_TREE_NODE_CLASS(truth_orif_expr, binary_expr);

CREATE_TREE_NODE_CLASS(truth_xor_expr, binary_expr);

struct try_block : public tree_node
{
   explicit try_block(unsigned int i) : tree_node(i), line(-1)
   {
   }

   int line;

   tree_nodeRef body;

   tree_nodeRef hdlr;

   tree_nodeRef next;

   GET_KIND_TEXT(try_block)

   
   GET_KIND(try_block)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(tree_node) = 0,
      GETID(body),
      GETID(hdlr),
      GETID(next)
   };
};

CREATE_TREE_NODE_CLASS(try_catch_expr, binary_expr);

CREATE_TREE_NODE_CLASS(try_finally, binary_expr);

struct type_decl : public decl_node
{
   explicit type_decl(unsigned int i) : decl_node(i)
   {
   }

   tree_nodeRef tmpl_parms;

   tree_nodeRef tmpl_args;

   GET_KIND_TEXT(type_decl)

   
   GET_KIND(type_decl)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(decl_node) = 0,
      GETID(tmpl_parms),
      GETID(tmpl_args)
   };
};

CREATE_TREE_NODE_CLASS(typename_type, type_node);

CREATE_TREE_NODE_CLASS(uneq_expr, binary_expr);

CREATE_TREE_NODE_CLASS(unge_expr, binary_expr);

CREATE_TREE_NODE_CLASS(ungt_expr, binary_expr);

struct union_type : public type_node
{
   explicit union_type(unsigned int i) : type_node(i)
   {
   }

   /*type_node fields are in the parent class*/

   std::vector<tree_nodeRef> list_of_flds;

   std::vector<tree_nodeRef> list_of_fncs;

   tree_nodeRef binf;

   void add_flds(const tree_nodeRef& a)
   {
      list_of_flds.push_back(a);
   }

   void add_fncs(const tree_nodeRef& a)
   {
      list_of_fncs.push_back(a);
   }

   GET_KIND_TEXT(union_type)

   
   GET_KIND(union_type)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(type_node) = 0,
      GETID(list_of_flds),
      GETID(list_of_fncs),
      GETID(binf)
   };
};

CREATE_TREE_NODE_CLASS(unle_expr, binary_expr);

CREATE_TREE_NODE_CLASS(unlt_expr, binary_expr);

CREATE_TREE_NODE_CLASS(unordered_expr, binary_expr);

CREATE_TREE_NODE_CLASS(unsave_expr, unary_expr);

CREATE_TREE_NODE_CLASS(using_decl, decl_node);

CREATE_TREE_NODE_CLASS(va_arg_expr, unary_expr);

struct var_decl : public decl_node, public attr
{
   explicit var_decl(unsigned int i);

   /*decl_node fields are in the parent class: decl_node*/

   int use_tmpl;

   bool static_static_flag;

   bool static_flag;

   bool extern_flag;

   bool addr_taken;

   bool addr_not_taken;

   /*attr fields are in the parent class: attr*/

   tree_nodeRef init;

   tree_nodeRef size;

   unsigned int algn;

   int used;

   bool register_flag;

   bool readonly_flag;

   std::string bit_values;

   tree_nodeRef smt_ann;

   CustomUnorderedSet<tree_nodeRef> defs;

   CustomUnorderedSet<tree_nodeRef> uses;

   CustomUnorderedSet<tree_nodeRef> addressings;

   GET_KIND_TEXT(var_decl)

   
   GET_KIND(var_decl)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(decl_node) = 0,
      GETID(attr),
      GETID(init),
      GETID(size),
      GETID(smt_ann)
   };
};

CREATE_TREE_NODE_CLASS(dot_prod_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(vec_cond_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(vec_perm_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(vec_lshift_expr, binary_expr);
CREATE_TREE_NODE_CLASS(vec_rshift_expr, binary_expr);

CREATE_TREE_NODE_CLASS(widen_mult_hi_expr, binary_expr);
CREATE_TREE_NODE_CLASS(widen_mult_lo_expr, binary_expr);

CREATE_TREE_NODE_CLASS(vec_unpack_hi_expr, unary_expr);
CREATE_TREE_NODE_CLASS(vec_unpack_lo_expr, unary_expr);

CREATE_TREE_NODE_CLASS(vec_unpack_float_hi_expr, unary_expr);
CREATE_TREE_NODE_CLASS(vec_unpack_float_lo_expr, unary_expr);

CREATE_TREE_NODE_CLASS(vec_pack_trunc_expr, binary_expr);
CREATE_TREE_NODE_CLASS(vec_pack_sat_expr, binary_expr);

CREATE_TREE_NODE_CLASS(vec_pack_fix_trunc_expr, binary_expr);

CREATE_TREE_NODE_CLASS(vec_extracteven_expr, binary_expr);
CREATE_TREE_NODE_CLASS(vec_extractodd_expr, binary_expr);

CREATE_TREE_NODE_CLASS(vec_interleavehigh_expr, binary_expr);
CREATE_TREE_NODE_CLASS(vec_interleavelow_expr, binary_expr);

CREATE_TREE_NODE_CLASS(vec_new_expr, expr_node);

struct vector_cst : public cst_node
{
   explicit vector_cst(unsigned int i) : cst_node(i)
   {
   }

   std::vector<tree_nodeRef> list_of_valu;

   void add_valu(const tree_nodeRef& a)
   {
      list_of_valu.push_back(a);
   }

   GET_KIND_TEXT(vector_cst)

   
   GET_KIND(vector_cst)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(cst_node) = 0,
      GETID(list_of_valu)
   };
};

CREATE_TREE_NODE_CLASS(void_cst, cst_node);

struct vector_type : public type_node
{
   explicit vector_type(unsigned int i) : type_node(i)
   {
   }

   tree_nodeRef elts;

   GET_KIND_TEXT(vector_type)

   
   GET_KIND(vector_type)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(type_node) = 0,
      GETID(elts)
   };
};

CREATE_TREE_NODE_CLASS(view_convert_expr, unary_expr);

CREATE_TREE_NODE_CLASS(void_type, type_node);

CREATE_TREE_NODE_CLASS(vtable_ref, ternary_expr);

CREATE_TREE_NODE_CLASS(with_cleanup_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(with_size_expr, binary_expr);

CREATE_TREE_NODE_CLASS(widen_sum_expr, binary_expr);

CREATE_TREE_NODE_CLASS(widen_mult_expr, binary_expr);

struct lut_expr : public expr_node
{
   explicit lut_expr(unsigned int i) : expr_node(i)
   {
   }

   tree_nodeRef op0;

   tree_nodeRef op1;

   tree_nodeRef op2;

   tree_nodeRef op3;

   tree_nodeRef op4;

   tree_nodeRef op5;

   tree_nodeRef op6;

   tree_nodeRef op7;

   tree_nodeRef op8;

   GET_KIND_TEXT(lut_expr)

   
   GET_KIND(lut_expr)

   
   void visit(tree_node_visitor* const v) const override;

   enum
   {
      GETID(expr_node) = 0,
      GETID(op0),
      GETID(op1),
      GETID(op2),
      GETID(op3),
      GETID(op4),
      GETID(op5),
      GETID(op6),
      GETID(op7),
      GETID(op8)
   };
};

CREATE_TREE_NODE_CLASS(extract_bit_expr, binary_expr);

CREATE_TREE_NODE_CLASS(sat_plus_expr, binary_expr);

CREATE_TREE_NODE_CLASS(sat_minus_expr, binary_expr);

CREATE_TREE_NODE_CLASS(fshl_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(fshr_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(extractvalue_expr, binary_expr);

CREATE_TREE_NODE_CLASS(insertvalue_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(extractelement_expr, binary_expr);

CREATE_TREE_NODE_CLASS(insertelement_expr, ternary_expr);

CREATE_TREE_NODE_CLASS(frem_expr, binary_expr);

#endif