cs_procedure_decl.hpp

Go to the documentation of this file.

/*
 *      Copyright (c) 2023, 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_PROCEDURE_DECL_HPP
#define CS_PROCEDURE_DECL_HPP

#include "cs_procedure_fwd.hpp"
#include "cs_point_decl.hpp"
#include "cs_basic_block_set_decl.hpp"
#include "cs_ast_decl.hpp"
#include "cs_sfileinst_decl.hpp"
#include "cs_compunit_decl.hpp"

namespace cs{
    class procedure_locals_iterator_policy{
    public:
        typedef cs_pdg_locals_iter iterator_impl;
        typedef symbol key;
        typedef cs_pdg ctype;
        
        static cs_result iter_first(
            const ctype &container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        { return cs_pdg_locals_iter_first( container, val, it ); }
        static cs_result iter_next(
            const ctype &container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_pdg_locals_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_pdg_locals_iter_close( it ); }
        static const char *name()
        { return "procedure_locals_iterator"; }
    };
    
    class procedure_call_sites_flags{
        CS_FLAGS_BOILERPLATE(procedure_call_sites_flags, 
                             cs_pdg_call_sites_flags, 
                             cs_pcsf_all,
                             "direct",
                             "indirect");
        static const procedure_call_sites_flags NONE;

        static const procedure_call_sites_flags DIRECT;

        static const procedure_call_sites_flags INDIRECT;

    };
    CS_FLAGS_BOILERPLATE_FRIENDS(procedure_call_sites_flags,
                                 friend class procedure;,
                                 cs
        )
#ifdef CS_CPP_IMPL
    const procedure_call_sites_flags procedure_call_sites_flags::NONE = procedure_call_sites_flags(cs_pcsf_none);
    const procedure_call_sites_flags procedure_call_sites_flags::DIRECT = procedure_call_sites_flags(cs_pcsf_direct);
    const procedure_call_sites_flags procedure_call_sites_flags::INDIRECT = procedure_call_sites_flags(cs_pcsf_indirect);
#endif

    class procedure_call_sites_iterator_policy{
    public:
        typedef cs_pdg_call_sites_iter iterator_impl;
        typedef point key;
#ifndef SWIG
        struct ctype
        {
            cs_pdg pdg;
            cs_pdg_call_sites_flags flags;
            ctype(cs_pdg _pdg, cs_pdg_call_sites_flags _flags)
                : pdg(_pdg), flags(_flags){}
        };
#endif
        
        static cs_result iter_first(
            ctype container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        { return cs_pdg_call_sites_iter_first( container.pdg, container.flags, val, it ); }
        static cs_result iter_next(
            ctype container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_pdg_call_sites_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_pdg_call_sites_iter_close( it ); }
        static const char *name()
        { return "procedure_call_sites_iterator"; }
    };
    
    class procedure_callers_iterator_policy{
    public:
        typedef cs_pdg_callers_iter iterator_impl;
        typedef point key;
        typedef cs_pdg ctype;
        
        static cs_result iter_first(
            ctype container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        { return cs_pdg_callers_iter_first( container, val, it ); }
        static cs_result iter_next(
            ctype container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_pdg_callers_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_pdg_callers_iter_close( it ); }
        static const char *name()
        { return "procedure_callers_iterator"; }
    };
    
    class procedure_adjusted_callers_iterator_policy;
    

    class procedure{
        CS_IR_BOILERPLATE(procedure);
        
        csuint64 stable_hash() const
        {
            return cs_pdg_stable_hash(inner);
        }

        int stable_cmp(const procedure& other) const
        {
            return cs_pdg_stable_compare(inner, other.inner);
        }


        procedure_kind get_kind() const
        { return cglue<procedure_kind>::wrap(cs_pdg_get_kind(inner)); }
        
        
#if 0
        /* This is redundant; use get_compunit().normalized_name() */
        std::string normalized_compilation_unit() const
        {
            string_scratchpad::
                to_string_functor1_limit<procedure, cs_pdg_normalized_compilation_unit> 
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }
        
        /* This is redundant; use get_compunit().name() */
        std::string compilation_unit() const
        {
            string_scratchpad::
                to_string_functor1_limit<
                    procedure, cs_pdg_compilation_unit> 
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }

#endif

        ast get_ast(ast_family family = ast_family::DEFAULT) const
        {
            cs_ast rv;
            check(cs_pdg_ast(inner, cglue<ast_family>::unwrap(family), &rv));
            return ast::;
        }
        
        void set_ast(ast_family family, ast val)
        {
            check(cs_pdg_set_ast(inner, cglue<ast_family>::unwrap(family), 
                                 cglue<ast>::unwrap(val)));
        }
        sfileinst_line_pair file_line() const
        {
            cs_sfid rvs;
            cs_line rvl;
            check(cs_pdg_file_line(inner, &rvs, &rvl));
            return sfileinst_line_pair(sfileinst::, rvl);
        }


        symbol get_symbol() const;
        

        compunit get_compunit() const
        {
            cs_uid rv;
            check(cs_pdg_compilation_uid(inner, &rv));
            return compunit::;
        }

        point entry_point() const
        {
            cs_pdg_vertex rv;
            check(cs_pdg_entry_vertex(inner, &rv));
            return point::;
        }

        point preexit_point() const
        {
            cs_pdg_vertex rv;
            check(cs_pdg_preexit_vertex(inner, &rv));
            return point::;
        }

        point exit_point() const
        {
            cs_pdg_vertex rv;
            check(cs_pdg_exit_vertex(inner, &rv));
            return point::;
        }
        

        csint64 id() const
        { return cs_pdg_procedure_id(inner); }
      
  
        std::string verbose_name() const
        { return cs_pdg_string(inner); }


        std::string name() const
        {
            string_scratchpad::
                to_string_functor1_limit<procedure, cs_pdg_friendly_name> 
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }
        
        std::string basename() const
        {
            string_scratchpad::
                to_string_functor1_limit<procedure, cs_pdg_basename> 
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }

        std::string demangled_name() const
        {
            string_scratchpad::
                to_string_functor1_limit<procedure, cs_pdg_demangled_name>
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }

        point_set points() const
        {
            cs_const_pdg_vertex_set rv;
            check(cs_pdg_vertices(inner, &rv));
            return cglue<point_set>::wrap(rv, true);
        }
        
        procedure_locals_iterator local_symbols() const
        { return procedure_locals_iterator(inner); }
        

        std::vector<symbol> declared_symbols() const
        {
            typedef scratchpad<symbol> sp;
            sp::to_vector_functor1<procedure, cs_pdg_declarations> 
                functor(inner);
            return sp::to_vector(functor);
        }
        symbol find_symbol_by_offset(csint32 off) const
        {
            cs_abs_loc rv;
            check(cs_pdg_off_to_abs_loc(inner, off, &rv));
            return symbol::;
        }


        symbol find_containing_symbol_by_offset(csint32 off) const
        {
            cs_abs_loc rv;
            check(cs_pdg_off_to_containing_abs_loc(inner, off, &rv));
            return symbol::;
        }
        
        point add_declaration(symbol al);
        std::vector<point> call_sites_vector(
            procedure_call_sites_flags flags = procedure_call_sites_flags::DIRECT) const
        {
            typedef scratchpad<point> sp;
            sp::to_vector_functor2<procedure, cs_pdg_call_sites_flags, cs_pdg_call_sites> 
                functor(inner, cglue<procedure_call_sites_flags>::unwrap(flags));
            return sp::to_vector(functor);
        }
        

        size_t call_sites_count(
            procedure_call_sites_flags flags = procedure_call_sites_flags::DIRECT) const
        { return cs_pdg_call_sites_count(inner, cglue<procedure_call_sites_flags>::unwrap(flags)); }
        

        procedure_call_sites_iterator call_sites(
            procedure_call_sites_flags flags = procedure_call_sites_flags::DIRECT) const
        {
            return procedure_call_sites_iterator(
                procedure_call_sites_iterator_policy::ctype(
                    inner, cglue<procedure_call_sites_flags>::unwrap(flags)));
        }
        

        size_t callers_count() const
        { return cs_pdg_callers_count(inner); }
        

        procedure_callers_iterator callers() const
        { return procedure_callers_iterator(inner); }
        

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

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

        point formal_in(size_t rank)
        {
            cs_pdg_vertex rv;
            check(cs_pdg_formal_in(inner, rank, &rv));
            return point::;
        }
        
        void set_formal_ins(const std::vector<symbol> &v)
        {
            size_t count = v.size();
            cs_abs_loc *locs = new cs_abs_loc[count];
            for( size_t i = 0; i < count; i++ )
                locs[i] = cglue<symbol>::unwrap(v[i]);
            cs_result r = cs_pdg_set_formals_in(
                inner, locs, count);
            delete[] locs;
            check(r);
        }
        point_set formal_outs() const
        {
            cs_pdg_vertex_set rv;
            check(cs_pdg_formals_out(inner, &rv));
            return cglue<point_set>::wrap(rv, false);
        }
        

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

        void set_formal_outs(const std::vector<symbol> &v)
        {
            size_t count = v.size();
            cs_abs_loc *locs = new cs_abs_loc[count];
            for( size_t i = 0; i < count; i++ )
                locs[i] = cglue<symbol>::unwrap(v[i]);
            cs_result r = cs_pdg_set_formals_out(
                inner, locs, count);
            delete[] locs;
            check(r);
        }
        point retrieve_point(csint64 _id) const
        {
            cs_pdg_vertex rv;
            check(cs_pdg_retrieve_vertex(inner, _id, &rv));
            return point::;
        }
        
        point_set used_points(symbol al) const;
       point_set used_points_from_set(const symbol_set &s) const
        {
            cs_pdg_vertex_set rv;
            check(cs_pdg_abs_loc_set_used_vertices(
                      inner, cglue<symbol_set>::unwrap(s), &rv));
            return cglue<point_set>::wrap(rv, false);
        }
        point_set killed_points(symbol al) const;
        point_set killed_points_from_set(const symbol_set &s) const
        {
            cs_pdg_vertex_set rv;
            check(cs_pdg_abs_loc_set_killed_vertices(
                      inner, cglue<symbol_set>::unwrap(s), &rv));
            return cglue<point_set>::wrap(rv, false);
        }
        point_set cond_killed_points(symbol al) const;
        point_set cond_killed_points_from_set(const symbol_set &s) const
        {
            cs_pdg_vertex_set rv;
            check(cs_pdg_abs_loc_set_cond_killed_vertices(
                      inner, cglue<symbol_set>::unwrap(s), &rv));
            return cglue<point_set>::wrap(rv, false);
        }
        point_set may_killed_points(symbol al) const;
        point_set may_killed_points_from_set(const symbol_set &s) const
        {
            cs_pdg_vertex_set rv;
            check(cs_pdg_abs_loc_set_may_killed_vertices(
                      inner, cglue<symbol_set>::unwrap(s), &rv));
            return cglue<point_set>::wrap(rv, false);
        }
        symbol_set gref() const
        {
            cs_const_abs_loc_set rv;
            check(cs_pdg_gref_abs_loc_set(inner, &rv));
            return cglue<symbol_set>::wrap(rv, true);
        }
        symbol_set gmod() const
        {
            cs_const_abs_loc_set rv;
            check(cs_pdg_gmod_abs_loc_set(inner, &rv));
            return cglue<symbol_set>::wrap(rv, true);
        }
        bool has_vararg() const
        { return !!cs_pdg_has_vararg(inner); }
        

        bool has_incomplete_summary() const
        { return !!cs_pdg_has_incomplete_summary(inner); }
        size_t scc_id() const
        {
            size_t rv;
            check(cs_pdg_scc_id(inner, &rv));
            return rv;
        }
        basic_block retrieve_basic_block(csint64 id) const;


        basic_block entry_basic_block() const;


        basic_block exit_basic_block() const;
        

        basic_block_set basic_blocks() const
        {
            cs_basic_block_set rv;
            check(cs_pdg_get_basic_blocks(inner, &rv));
            return cglue<basic_block_set>::wrap(rv, false);
        }
        point normal_exit() const
        {
            cs_pdg_vertex rv;
            check(cs_pdg_normal_exit(inner, &rv));
            return point::;
        }
        std::vector<exceptional_exit> exceptional_exits() const
        {
            typedef scratchpad<exceptional_exit> sp;
            sp::to_vector_functor1_card<procedure, cs_pdg_exceptional_exits> 
                functor(inner);
            return sp::to_vector(functor);
        }
        std::string as_string() const
        { return name(); }
        

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

#if defined(CSONAR_API_SWIG_HPP) || !defined(SWIG)

      /* documented in csonar_visitor.hpp */
        iterator_adapter<procedure_adjusted_callers_iterator_policy> 
        adjusted_callers() const;

        bool
        reachable() const;
#endif

        std::string decompilation()
        {
            string_scratchpad::
                to_string_functor1_limit<procedure, cs_decompilation_for_pdg> 
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }
        effective_address get_address() const
        {
            effective_address addr;
            check(cs_pdg_ea(inner, &addr));
            return addr;
        }

        std::string handle() const
        { 
            string_scratchpad::
                to_string_functor1_limit<procedure, cs_pdg_get_handle> 
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }

    };
    CS_IR_BOILERPLATE_FRIENDS_PLUS_OSTREAM(procedure, cs)
}

#endif /* CS_PROCEDURE_DECL_HPP */