cs_point_decl.hpp

Go to the documentation of this file.

/*
 *      Copyright (c) 2023-2025, an unpublished work by CodeSecure, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      Copyright (c) 2013-2023, an unpublished work by GrammaTech, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      This software is furnished under a license and may be used and
 *      copied only in accordance with the terms of such license and the
 *      inclusion of the above copyright notice.  This software or any
 *      other copies thereof may not be provided or otherwise made
 *      available to any other person.  Title to and ownership of the
 *      software is retained by CodeSecure, Inc.
 */

#ifndef CS_POINT_DECL_HPP
#define CS_POINT_DECL_HPP

#include "cs_binaries.h"
#include "cs_point_fwd.hpp"
#include "cs_result.hpp"
#include "cs_sfileinst_decl.hpp"
#include "cs_compunit_decl.hpp"
#include "cs_ast_decl.hpp"
#include "cs_int_pair_set.hpp"
#include "cs_ir_boilerplate.hpp"
#include "cs_symbol_decl.hpp"
#include "cs_point_set_decl.hpp"
#include "cs_symbol_set.hpp"
#include "cs_basic_block_fwd.hpp"
#include "cs_scratchpad.hpp"
#include "cs_point_kind.hpp"
#include "cs_point_syntax.hpp"

namespace cs{
    template<>
    class cglue<exceptional_return>
    {
        cglue();
        friend class scratchpad<exceptional_return>;
    public:
        typedef exceptional_return type;
        typedef cs_exceptional_return ctype;
    CS_CXX_API_CGLUE_ACCESS_MODIFIER:
        static exceptional_return wrap(const ctype &c);
        /* unwrap intentionally omitted due to memory ownership
         * confusion. 
         */
    };


    class point{

        CS_IR_BOILERPLATE(point);


        csuint64 stable_hash() const
        {
            return cs_pdg_vertex_stable_hash(inner);
        }


        int stable_cmp(const point& other) const
        {
            return cs_pdg_vertex_stable_compare(inner, other.inner);
        }


        csint64 id() const
        {
            return cs_pdg_vertex_id(inner);
        }
        

        point_kind get_kind() const
        {
            return cglue<point_kind>::wrap(cs_pdg_vertex_kind(inner));
        }


        point_syntax_kind get_syntax_kind() const
        {
            return cglue<point_syntax_kind>::wrap(cs_pdg_vertex_syntax_kind(inner));
        }
        

        point_syntax_element get_syntax_element() const
        {
            return cglue<point_syntax_element>::wrap(cs_pdg_vertex_syntax_element(inner));
        }

        
        procedure get_procedure() const;
        

        ast get_ast(ast_family fam = ast_family::DEFAULT) const
        {
            cs_ast rv;
            check(cs_pdg_vertex_ast(
                      inner, cglue<ast_family>::unwrap(fam), &rv));
            return ast::;
        }
        
        bool has_ast(ast_family fam = ast_family::DEFAULT) const
        {
            cs_ast rv;
            return cs_pdg_vertex_ast(
                inner, cglue<ast_family>::unwrap(fam), &rv) == CS_SUCCESS;
        }

        void set_ast(ast_family fam, ast val)
        {
            check(cs_pdg_vertex_set_ast(inner, cglue<ast_family>::unwrap(fam), 
                                        cglue<ast>::unwrap(val)));
        }
        sfileinst_int_pair_set_pair charpos() const
        {
            cs_sfid sfid;
            cs_const_int_pair_set rv;
            check(cs_pdg_vertex_charpos(inner, &sfid, &rv));
            return sfileinst_int_pair_set_pair(
                sfileinst::,
                cglue<int_pair_set>::wrap(rv, true));
        }


        sfileinst_line_pair file_line() const
        {
            cs_sfid s;
            cs_line ln;
            check(cs_pdg_vertex_file_line(
                      inner, &s, &ln));
            return sfileinst_line_pair(sfileinst::, ln);
        }


        std::string characters(size_t limit=SIZE_MAX) const
        {
            string_scratchpad::
                to_string_functor1_limit<point, cs_pdg_vertex_characters> 
                functor(inner, limit);
            return string_scratchpad::to_string(functor);
        }
        

        symbol declared_symbol() const;
        symbol_set declared_symbols() const
        {
            cs_abs_loc_set rv;
            check(cs_pdg_vertex_symbols(inner, &rv));
            return cglue<symbol_set>::wrap(rv, false);
        }
        size_t rank() const
        {
            size_t rv;
            check(cs_pdg_vertex_rank(inner, &rv));
            return rv;
        }
        
        symbol_set ids_decl_uses() const
        {
            cs_const_abs_loc_set rv;
            check(cs_pdg_vertex_ids_decl_uses(inner, &rv));
            return cglue<symbol_set>::wrap(rv, true);
        }
        symbol_set ids_used() const
        {
            cs_const_abs_loc_set rv;
            check(cs_pdg_vertex_ids_used(inner, &rv));
            return cglue<symbol_set>::wrap(rv, true);
        }
        symbol_set ids_killed() const
        {
            cs_const_abs_loc_set rv;
            check(cs_pdg_vertex_ids_killed(inner, &rv));
            return cglue<symbol_set>::wrap(rv, true);
        }
        symbol_set ids_cond_killed() const
        {
            cs_const_abs_loc_set rv;
            check(cs_pdg_vertex_ids_cond_killed(inner, &rv));
            return cglue<symbol_set>::wrap(rv, true);
        }
        symbol_set actual_points_to() const
        {
            cs_const_abs_loc_set rv;
            check(cs_pdg_vertex_ids_cond_killed(inner, &rv));
            return cglue<symbol_set>::wrap(rv, true);
        }
        std::vector<symbol> parameter_symbols() const
        {
            typedef scratchpad<symbol> sp;
            sp::to_vector_functor1
                <point, cs_pdg_vertex_parameter_symbols> 
                functor(inner);
            return sp::to_vector(functor);
        }
        cfg_edge_set cfg_successors() const;
        cfg_edge_set cfg_predecessors() const;
        cfg_edge_set cfg_inter_targets() const;


        cfg_edge_set cfg_inter_sources() const;
        cfg_edge_set cfg_targets() const;


        cfg_edge_set cfg_sources() const;
        basic_block get_basic_block() const;
        point solitary_cfg_target() const
        {
            cs_pdg_vertex rv;
            check(cs_pdg_vertex_solitary_cfg_target(
                      inner, &rv));
            return point::;
        }

        point solitary_cfg_source() const
        {
            cs_pdg_vertex rv;
            check(cs_pdg_vertex_solitary_cfg_source(
                      inner, &rv));
            return point::;
        }
        pdg_edge_set inter_targets() const;
        pdg_edge_set inter_sources() const;
        bool summary_edge(point to_pt) const
        {
            cs_boolean rv;
            check(cs_pdg_vertex_summary_edge(
                      inner, to_pt.inner, &rv));
            return !!rv;
        }
        pdg_edge_set intra_targets() const;
        pdg_edge_set intra_sources() const;
        point_set actual_to_formals() const
        {
            cs_pdg_vertex_set rv;
            check(cs_pdg_vertex_actual_to_formals(inner, &rv));
            return cglue<point_set>::wrap(rv, false);
        }


        point_set actuals_in() const
        {
            cs_pdg_vertex_set rv;
            check(cs_pdg_vertex_actuals_in(inner, &rv));
            return cglue<point_set>::wrap(rv, false);
        }


        point_set actuals_out() const
        {
            cs_pdg_vertex_set rv;
            check(cs_pdg_vertex_actuals_out(inner, &rv));
            return cglue<point_set>::wrap(rv, false);
        }


        void set_actual_outs(const std::vector<point>& ao_vertices)
        {
            check(cs_pdg_vertex_set_actual_outs(
                      inner, ao_vertices.size(), 
                      reinterpret_cast<const cs_pdg_vertex*>(&ao_vertices[0])));
        }
        void set_actual_ins(const std::vector<point>& ai_vertices)
        {
            check(cs_pdg_vertex_set_actual_ins(
                      inner, ai_vertices.size(), 
                      reinterpret_cast<const cs_pdg_vertex*>(&ai_vertices[0])));
        }
        std::vector<point> actuals_in_as_list() const
        {
            typedef scratchpad<point> sp;
            sp::to_vector_functor1<point, cs_pdg_vertex_actuals_in_as_list> 
                functor(inner);
            return sp::to_vector(functor);
        }
        

        std::vector<point> actuals_out_as_list() const
        {
            typedef scratchpad<point> sp;
            sp::to_vector_functor1
                <point, cs_pdg_vertex_actuals_out_as_list> 
                functor(inner);
            return sp::to_vector(functor);
        }

        point actual_in(size_t _rank) const
        {
            cs_pdg_vertex rv;
            check(cs_pdg_vertex_actual_in(inner, _rank, &rv));
            return point::;
        }
       
 
        point actual_out(size_t _rank) const
        {
            cs_pdg_vertex rv;
            check(cs_pdg_vertex_actual_out(inner, _rank, &rv));
            return point::;
        }
        

        point call_site() const
        {
            cs_pdg_vertex rv;
            check(cs_pdg_vertex_call_site(inner, &rv));
            return point::;
        }
        

        procedure callee() const;
    
    
        point normal_return() const
        {
            cs_pdg_vertex rv;
            check(cs_pdg_vertex_normal_return(inner, &rv));
            return point::;
        }
        std::vector<exceptional_return> exceptional_returns() const;
        labeled_pdg_edge_set labeled_intra_control_sources() const;
        labeled_pdg_edge_set labeled_intra_control_targets() const;
        bool is_inside_macro() const
        { return cs_pdg_vertex_is_inside_macro( inner )?true:false; }


        bool is_implicit_actual_in() const
        { return cs_pdg_vertex_is_implicit_actual_in( inner )?true:false; }


        std::string source_pp() const
        {
            string_scratchpad::
                to_string_functor1_limit<point, cs_pdg_vertex_source_pp> 
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }
        csuint64 condition_number() const
        { return cs_pdg_vertex_condition_number(inner); }
        std::string as_string() const
        { return cs_pdg_vertex_string(inner); }


        std::string as_repr() const
        { return CS_AS_REPR_FROM_STRING(point); }


        effective_address get_address() const
        {
            effective_address addr;
            check(cs_pdg_vertex_ea(inner, &addr));
            return addr;
        }


        effective_address get_affiliated_address() const
        {
            effective_address addr;
            check(cs_pdg_vertex_affiliated_ea(inner, &addr));
            return addr;
        }

        std::string as_smtlib() const
        {
            string_scratchpad::
                to_string_functor1_limit<point, cs_pdg_vertex_to_smt>
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }
        std::string semantics(bool noexc = false) const
        {
            if (noexc) {
                string_scratchpad::
                    to_string_functor1_limit<point, cs_pdg_vertex_to_semantics_noexc>
                    functor(inner, -1);
                return string_scratchpad::to_string(functor);
            }
            else {
                string_scratchpad::
                    to_string_functor1_limit<point, cs_pdg_vertex_to_semantics>
                    functor(inner, -1);
                return string_scratchpad::to_string(functor);
            }
        }
        std::string handle() const
        { 
            string_scratchpad::
                to_string_functor1_limit<point, cs_pdg_vertex_get_handle> 
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }

#if defined(CSONAR_API_SWIG_HPP) || !defined(SWIG)
        // The following are declared here so they can belong to
        // the point class, but are defined only in CodeSonar.

       /* documented in csonar_visitor.hpp */
        procedure adjusted_callee() const;

       /* documented in csonar_visitor.hpp */
        iterator_adapter<point_adjusted_callees_iterator_policy> adjusted_callees() const;
        
       /* documented in csonar_visitor.hpp */
        procedure adjusted_callee_no_reroute() const;

       /* documented in csonar_visitor.hpp */
        iterator_adapter<point_adjusted_callees_no_reroute_iterator_policy> adjusted_callees_no_reroute() const;

        // These are on-demand versions of ids_used() and ids_killed(),
        // which are not supported by CodeSonar, as well as an
        // on-demand enumerator of references.

       /* documented in csonar_visitor.hpp */
        symbol_vector csonar_enum_used() const;

       /* documented in csonar_visitor.hpp */
        symbol_vector csonar_enum_killed() const;

       /* documented in csonar_visitor.hpp */
        symbol_vector csonar_enum_referenced() const;
#endif
    };

    CS_IR_BOILERPLATE_FRIENDS_PLUS_OSTREAM(point, cs)
}

#endif /* CS_POINT_DECL_HPP */