cs_point.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_POINT_HPP
#define CS_POINT_HPP

//#include "csurf/src/api/cpp/cs_cfg_set.hpp"
//#include "csurf/src/api/cpp/cs_basic_block.hpp"
#include "cs_point_decl.hpp"
#include "cs_symbol_decl.hpp"
#include "cs_procedure_decl.hpp"
#include "cs_basic_block_decl.hpp"
#include "cs_cfg_edge_set.hpp"
#include "cs_pdg_edge_set.hpp"
#include "cs_labeled_pdg_edge_set.hpp"

namespace cs{
    inline basic_block point::get_basic_block() const
    {
        cs_basic_block rv;
        check(cs_pdg_vertex_basic_block(inner, &rv));
        return basic_block::;
    }
    inline procedure point::get_procedure() const
    {
        cs_pdg rv;
        check(cs_pdg_vertex_pdg(inner, &rv));
        return procedure::;
    }

    inline procedure point::callee() const
    {
        cs_pdg rv;
        check(cs_pdg_vertex_callee(inner, &rv));
        return procedure::;
    }

    inline symbol point::declared_symbol() const
    {
        cs_abs_loc rv;
        check(cs_pdg_vertex_symbol(inner, &rv));
        return symbol::;
    }

    inline cfg_edge_set point::cfg_successors() const
    {
        cs_cfg_edge_set rv;
        check(cs_pdg_vertex_cfg_successors(inner, &rv));
        return cglue<cfg_edge_set>::wrap(rv, false);
    }
        
    inline cfg_edge_set point::cfg_predecessors() const
    {
        cs_cfg_edge_set rv;
        check(cs_pdg_vertex_cfg_predecessors(inner, &rv));
        return cglue<cfg_edge_set>::wrap(rv, false);
    }
    inline cfg_edge_set point::cfg_inter_targets() const
    {
        cs_cfg_edge_set rv;
        check(cs_pdg_vertex_cfg_inter_targets(inner, &rv));
        return cglue<cfg_edge_set>::wrap(rv, false);
    }
        
    inline cfg_edge_set point::cfg_inter_sources() const
    {
        cs_cfg_edge_set rv;
        check(cs_pdg_vertex_cfg_inter_sources(inner, &rv));
        return cglue<cfg_edge_set>::wrap(rv, false);
    }
    inline cfg_edge_set point::cfg_targets() const
    {
        cs_const_cfg_edge_set rv;
        check(cs_pdg_vertex_cfg_targets(inner, &rv));
        return cglue<cfg_edge_set>::wrap(rv, true);
    }

    inline cfg_edge_set point::cfg_sources() const
    {
        cs_const_cfg_edge_set rv;
        check(cs_pdg_vertex_cfg_sources(inner, &rv));
        return cglue<cfg_edge_set>::wrap(rv, true);
    }
    inline pdg_edge_set point::inter_targets() const
    {
        cs_const_pdg_edge_set rv;
        check(cs_pdg_vertex_inter_targets(
                  inner, &rv));
        return cglue<pdg_edge_set>::wrap(rv, true);
    }

    inline pdg_edge_set point::inter_sources() const
    {
        cs_const_pdg_edge_set rv;
        check(cs_pdg_vertex_inter_sources(
                  inner, &rv));
        return cglue<pdg_edge_set>::wrap(rv, true);
    }

    inline pdg_edge_set point::intra_targets() const
    {
        cs_const_pdg_edge_set rv;
        check(cs_pdg_vertex_intra_targets(
                  inner, &rv));
        return cglue<pdg_edge_set>::wrap(rv, true);
    }

    inline pdg_edge_set point::intra_sources() const
    {
        cs_const_pdg_edge_set rv;
        check(cs_pdg_vertex_intra_sources(
                  inner, &rv));
        return cglue<pdg_edge_set>::wrap(rv, true);
    }
        
    inline labeled_pdg_edge_set point::labeled_intra_control_sources() const
    {
        cs_const_labeled_pdg_edge_set rv;
        check(cs_pdg_vertex_labeled_intra_control_sources(inner, &rv));
        return cglue<labeled_pdg_edge_set>::wrap(rv, true);
    }
        
    inline labeled_pdg_edge_set point::labeled_intra_control_targets() const
    {
        cs_const_labeled_pdg_edge_set rv;
        check(cs_pdg_vertex_labeled_intra_control_targets(inner, &rv));
        return cglue<labeled_pdg_edge_set>::wrap(rv, true);
    }
    inline std::vector<exceptional_return> point::exceptional_returns() const
    {
        typedef scratchpad<exceptional_return> sp;
        sp::to_vector_functor1_card<point, cs_pdg_vertex_exceptional_returns> 
            functor(inner);
        return sp::to_vector(functor);
    }
    inline compunit_points 
    cglue<compunit_points>::wrap(const cs_uid_pdgvslist &c)
    {
        std::vector<std::pair<procedure, point_set> > vec;
        size_t i;
        for( i = 0; i < c.npdgs; i++ )
        {
            vec.push_back(
                std::pair<procedure, point_set>(
                    cglue<procedure>::wrap(c.pdgs[i].pdg), 
                    cglue<point_set>::wrap(c.pdgs[i].pdg_vertex_set, 
                                   false)));
        }
        return compunit_points( 
            cglue<compunit>::wrap(c.uid), 
            vec );
    }

    inline compunit_points_pair 
    cglue<compunit_points_pair>::wrap(const cs_uid_pdgvs_pair &c)
    {
        return compunit_points_pair( 
            cglue<compunit>::wrap(c.uid), 
            cglue<point_set>::wrap(c.pdg_vertex_set, false) );
    }

    inline point cglue<point>::wrap(const cs_pdg_vertex &c)
    { return point(c); }

    inline cs_pdg_vertex cglue<point>::unwrap(const point &c)
    { return c.unwrap(); }

    inline exceptional_return 
    cglue<exceptional_return>::wrap(const cs_exceptional_return &c)
    { 
        return exceptional_return(
            cglue<point>::wrap(c.vertex), 
            c.label);
    }
}

#endif /* CS_POINT_HPP */