cs_procedure.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_HPP
#define CS_PROCEDURE_HPP

#include "cs_procedure_decl.hpp"
#include "cs_symbol_decl.hpp"

namespace cs{
    inline symbol procedure::get_symbol() const
    {
        cs_abs_loc rv;
        check(cs_pdg_abs_loc(inner, &rv));
        return symbol::;
    }

    inline point procedure::add_declaration(symbol al)
    {
        cs_pdg_vertex rv;
        check(cs_pdg_add_declaration(inner, cglue<symbol>::unwrap(al), &rv));
        return point::;
    }

    inline point_set procedure::used_points(symbol al) const
    {
        cs_pdg_vertex_set rv;
        check(cs_pdg_abs_loc_used_vertices(
                  inner, cglue<symbol>::unwrap(al), &rv));
        return cglue<point_set>::wrap(rv, false);
    }
    
    inline point_set procedure::killed_points(symbol al) const
    {
        cs_pdg_vertex_set rv;
        check(cs_pdg_abs_loc_killed_vertices(
                  inner, cglue<symbol>::unwrap(al), &rv));
        return cglue<point_set>::wrap(rv, false);
    }
    
    inline point_set procedure::cond_killed_points(symbol al) const
    {
        cs_pdg_vertex_set rv;
        check(cs_pdg_abs_loc_cond_killed_vertices(
                  inner, cglue<symbol>::unwrap(al), &rv));
        return cglue<point_set>::wrap(rv, false);
    }
    
    inline point_set procedure::may_killed_points(symbol al) const
    {
        cs_pdg_vertex_set rv;
        check(cs_pdg_abs_loc_may_killed_vertices(
                  inner, cglue<symbol>::unwrap(al), &rv));
        return cglue<point_set>::wrap(rv, false);
    }
    inline basic_block procedure::retrieve_basic_block(csint64 _id) const
    {
        cs_basic_block rv;
        check(cs_pdg_retrieve_basic_block(
                  inner, _id, &rv));
        return basic_block::;
    }
    
    inline basic_block procedure::entry_basic_block() const
    {
        cs_basic_block rv;
        check(cs_pdg_entry_basic_block(
                  inner, &rv));
        return basic_block::;
    }
    
    inline basic_block procedure::exit_basic_block() const
    {
        cs_basic_block rv;
        check(cs_pdg_exit_basic_block(
                  inner, &rv));
        return basic_block::;
    }
    inline procedure cglue<procedure>::wrap(const cs_pdg &c)
    { return procedure(c); }

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

#endif /* CS_PROCEDURE_HPP */