cs_symbol_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_SYMBOL_DECL_HPP
#define CS_SYMBOL_DECL_HPP

#include "cs_binaries.h"
#include "cs_symbol_fwd.hpp"
#include "cs_scratchpad.hpp"
#include "cs_compunit_decl.hpp"
#include "cs_symbol_set_decl.hpp"
#include "cs_point_set_decl.hpp"
#include "cs_sfileinst_decl.hpp"

namespace cs{

    class var_attrs{
        CS_FLAGS_BOILERPLATE(var_attrs, cs_var_attrs, 
                             cs_var_attr_all,
                             "weak", 
                             "threadlocal");
        static const var_attrs NONE;

        static const var_attrs WEAK;

       static const var_attrs THREADLOCAL;
    };
    CS_FLAGS_BOILERPLATE_FRIENDS(var_attrs,
                                 friend class symbol;,
                                 cs
        )
#ifdef CS_CPP_IMPL
    const var_attrs var_attrs::NONE = var_attrs(cs_var_attr_none);
    const var_attrs var_attrs::WEAK = var_attrs(cs_var_attr_weak);
    const var_attrs var_attrs::THREADLOCAL = var_attrs(cs_var_attr_threadlocal);
#endif

    class func_attrs{
        CS_FLAGS_BOILERPLATE(func_attrs, cs_func_attrs, 
                             cs_func_attr_all,
                             "weak",
                             "inline",
                             "initialization",
                             "finalization",
                             "library",
                             "compiler-generated",
                             "cs-generated",
                             "constructor",
                             "destructor",
                             "assignment-operator",
                             "template",
                             "csonar-library-refine",
                             "multi-define",
                             "main",
                             "method",
                             "declared-static");
        static const func_attrs NONE;

        static const func_attrs WEAK;

        static const func_attrs INLINE_FUNCTION; /* used to be named
                                                  * INLINE, but
                                                  * conflicts with a
                                                  * common GT-internal
                                                  * macro */
        static const func_attrs INITIALIZATION;

        static const func_attrs FINALIZATION;

        static const func_attrs LIBRARY;

        static const func_attrs COMPILER_GENERATED;

        static const func_attrs CS_GENERATED;

        static const func_attrs CONSTRUCTOR;

        static const func_attrs DESTRUCTOR;

        static const func_attrs ASSIGNMENT_OPERATOR;

        static const func_attrs TEMPLATE;

        static const func_attrs CSONAR_LIBRARY_REFINE;

        static const func_attrs MULTI_DEFINE;

        static const func_attrs MAIN;

        static const func_attrs METHOD;
        static const func_attrs DECLARED_STATIC;
    };
    CS_FLAGS_BOILERPLATE_FRIENDS(func_attrs,
                                 friend class symbol;,
                                 cs
        )
#ifdef CS_CPP_IMPL
    const func_attrs func_attrs::NONE = func_attrs(cs_func_attr_none);
    const func_attrs func_attrs::WEAK = func_attrs(cs_func_attr_weak);
    const func_attrs func_attrs::INLINE_FUNCTION = func_attrs(cs_func_attr_inline);
    const func_attrs func_attrs::INITIALIZATION = func_attrs(cs_func_attr_initialization);
    const func_attrs func_attrs::FINALIZATION = func_attrs(cs_func_attr_finalization);
    const func_attrs func_attrs::LIBRARY = func_attrs(cs_func_attr_library);
    const func_attrs func_attrs::COMPILER_GENERATED = func_attrs(cs_func_attr_compiler_generated);
    const func_attrs func_attrs::CS_GENERATED = func_attrs(cs_func_attr_cs_generated);
    const func_attrs func_attrs::CONSTRUCTOR = func_attrs(cs_func_attr_constructor);
    const func_attrs func_attrs::DESTRUCTOR = func_attrs(cs_func_attr_destructor);
    const func_attrs func_attrs::ASSIGNMENT_OPERATOR = func_attrs(cs_func_attr_assignment_operator);
    const func_attrs func_attrs::TEMPLATE = func_attrs(cs_func_attr_template);
    const func_attrs func_attrs::CSONAR_LIBRARY_REFINE = func_attrs(cs_func_attr_csonar_library_refine);
    const func_attrs func_attrs::MULTI_DEFINE = func_attrs(cs_func_attr_multi_define);
    const func_attrs func_attrs::MAIN = func_attrs(cs_func_attr_main);
    const func_attrs func_attrs::METHOD = func_attrs(cs_func_attr_method);
    const func_attrs func_attrs::DECLARED_STATIC = func_attrs(cs_func_attr_declared_static);
#endif

    class symbol_kind{
        CS_ENUM_BOILERPLATE_UB(symbol_kind, cs_abs_loc_kind,
                               check(cs_abs_loc_kind_name(
                                         inner, &rv)),
                               cs_abs_loc_kind_count);
#include "cs_symbol_kind_decls.hpp"
    };
    CS_ENUM_BOILERPLATE_FRIENDS(symbol_kind,
                                friend class ir_factory;
                                friend class symbol;,
                                cs
        )
#include "cs_symbol_kind_defs.hpp"

    class symbol{
        CS_IR_BOILERPLATE(symbol);

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


        int stable_cmp(const symbol& other) const
        {
            return cs_abs_loc_stable_compare(inner, other.inner);
        }

    
        symbol_kind get_kind() const
        {
            cs_abs_loc_kind rv;
            check(cs_abs_loc_get_kind(inner, &rv));
            return symbol_kind::;
        }


        var_attrs get_var_attrs() const
        {
            cs_var_attrs rv;
            check(cs_abs_loc_var_attrs(inner, &rv));
            return var_attrs::;
        }


        func_attrs get_func_attrs() const
        {
            cs_func_attrs rv;
            check(cs_abs_loc_func_attrs(inner, &rv));
            return func_attrs::;
        }


        bool is_global() const
        {
            return !!cs_abs_loc_is_global(inner);
        }


        bool is_heap() const
        {
            return !!cs_abs_loc_is_heap(inner);
        }


        bool is_function() const
        {
            return !!cs_abs_loc_is_function(inner);
        }


        bool is_static_function() const
        {
            return !!cs_abs_loc_is_static_function(inner);
        }


        bool is_string() const
        {
            return !!cs_abs_loc_is_string(inner);
        }


        bool is_file_static() const
        {
            return !!cs_abs_loc_is_file_static(inner);
        }


        bool is_local_static() const
        {
            return !!cs_abs_loc_is_local_static(inner);
        }


        bool is_local() const
        {
            return !!cs_abs_loc_is_local(inner);
        }


        bool is_formal() const
        {
            return !!cs_abs_loc_is_formal(inner);
        }


        bool extern_only() const
        {
            return !!cs_abs_loc_extern_only(inner);
        }

        std::string name() const
        {
            /* The non-friendly name contains an extra "-42" or "'42"
             * suffix that serves no useful purpose and has
             * historically been a common cause of bugs in API clients
             * that did not expect it (why would they? it's not part
             * of the name).
             */
            return cs_abs_loc_friendly_string(inner);
        }


        std::string verbose_name() const
        {
            return cs_abs_loc_string(inner);
        }

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

        procedure as_procedure() const;
        

        std::string represented_string() const
        {
            string_scratchpad::
                to_string_functor1_limit<symbol, cs_abs_loc_represented_string> 
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }

        point_set declarations() const;
        point primary_declaration() const;
        procedure get_procedure() const;


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

        ast get_ast(ast_family family = ast_family::DEFAULT) const
        {
            cs_ast rv;
            check(cs_abs_loc_ast(inner, cglue<ast_family>::unwrap(family), &rv));
            return ast::;
        }


        bool has_ast(ast_family family = ast_family::DEFAULT) const
        {
            cs_ast rv;
            return cs_abs_loc_ast(inner, cglue<ast_family>::unwrap(family), &rv) == CS_SUCCESS;
        }


        void set_ast(ast_family family, ast val)
        {
            check(cs_abs_loc_set_ast(inner, cglue<ast_family>::unwrap(family), 
                                     cglue<ast>::unwrap(val)));
        }
        ast get_type(ast_family family = ast_family::DEFAULT) const
        {
            cs_ast rv;
            check(cs_abs_loc_type(inner, cglue<ast_family>::unwrap(family), &rv));
            return ast::;
        }
        

        bool has_type(ast_family family = ast_family::DEFAULT) const
        {
            cs_ast rv;
            return cs_abs_loc_type(inner, cglue<ast_family>::unwrap(family), &rv) == CS_SUCCESS;
        }
        

        void set_type(ast_family family, ast val)
        {
            check(cs_abs_loc_set_type(inner, cglue<ast_family>::unwrap(family), 
                                      cglue<ast>::unwrap(val)));
        }
        sfileinst_line_pair file_line() const
        {
            cs_sfid rvsfid;
            cs_line rvline;
            check(cs_abs_loc_file_line(inner, &rvsfid, &rvline));
            return sfileinst_line_pair(sfileinst::, rvline);
        }
        

        compunit source_compunit() const
        {
            cs_uid rvuid;
            check(cs_abs_loc_source_uid(inner, &rvuid));
            return compunit::;
        }
        

        symbol_set pointed_to_by() const
        {
            cs_const_abs_loc_set rv;
            check(cs_abs_loc_pointed_to_by(inner, &rv));
            return cglue<symbol_set>::wrap(rv, true);
        }
        symbol_set points_to() const
        {
            cs_const_abs_loc_set rv;
            check(cs_abs_loc_points_to(inner, &rv));
            return cglue<symbol_set>::wrap(rv, true);
        }
       point_set used_points() const
        {
            cs_const_pdg_vertex_set rv;
            check(cs_abs_loc_used_vertices( inner, &rv ) );
            return cglue<point_set>::wrap(rv, true);
        }
        point_set killed_points() const
        {
            cs_const_pdg_vertex_set rv;
            check(cs_abs_loc_killed_vertices( inner, &rv ) );
            return cglue<point_set>::wrap(rv, true);
        }
        point_set cond_killed_points() const
        {
            cs_const_pdg_vertex_set rv;
            check(cs_abs_loc_cond_killed_vertices( inner, &rv ) );
            return cglue<point_set>::wrap(rv, true);
        }
        point_set may_killed_points() const
        {
            cs_const_pdg_vertex_set rv;
            check(cs_abs_loc_may_killed_vertices( inner, &rv ) );
            return cglue<point_set>::wrap(rv, true);
        }
        std::vector<symbol> fields() const
        {
            typedef scratchpad<symbol> sp;
            sp::to_vector_functor1<symbol, cs_abs_loc_get_fields> 
                functor(inner);
            return sp::to_vector(functor);
        }
        symbol container() const
        {
            cs_abs_loc rv;
            check(cs_abs_loc_get_struct(inner, &rv));
            return symbol(rv);
        }
        std::vector<symbol> inline_targets() const
        {
            typedef scratchpad<symbol> sp;
            sp::to_vector_functor1<symbol, cs_abs_loc_get_inline_targets> 
                functor(inner);
            return sp::to_vector(functor);
        }
        symbol inline_source() const
        {
            cs_abs_loc rv;
            check(cs_abs_loc_get_inline_source(inner, &rv));
            return symbol(rv);
        }
        std::string temp_source() const
        {
            string_scratchpad::
                to_string_functor1_limit<symbol, cs_abs_loc_temp_source> 
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }


        std::string as_string() const
        { return name(); }
        
 
       std::string as_repr() const
        { return CS_AS_REPR_FROM_STRING(symbol); }


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

    };
    CS_IR_BOILERPLATE_FRIENDS_PLUS_OSTREAM(symbol, cs)
}

#endif /* CS_SYMBOL_DECL_HPP */