mirror of
git://sourceware.org/git/libabigail.git
synced 2025-02-10 10:37:01 +00:00
cf8eba68c3
This patch implements string interning optimization. One can read about the principles of this optimization at https://en.wikipedia.org/wiki/String_interning. The patch introduces an abigail::interned_string type, as well as an abigail::interned_string_pool type. Each environment type owns a string pool and strings are interned in that pool for all types and decls of that environments. The interned_string has methods to interact seemingly with std::string including a hashing function. Of course hashing and comparing interned_string is faster than for std::string. To enable ABI artifacts to intern strings, each constructor of ABI artifacts now takes the environment it's constructed in as parameter. From the environment, it can thus use the interned string pool. The patch then changes declaration names to be of type interned_string, and performs the necessary adjustments. The hash maps that hash strings coming from those declaration names are adjusted to hash interned_string. * include/Makefile.am: Add the new abg-interned-str.h file to source distribution. * include/abg-corpus.h (corpus::corpus): Re-arrange the order of * src/abg-corpus.cc (corpus::exported_decls_builder::priv::get_id): Return interned_string rather than std::string. (corpus::corpus): Re-arrange the order of parameters: take an environment as first parameter. parameters: take an environment as first parameter. * include/abg-dwarf-reader.h (lookup_symbol_from_elf) (lookup_public_function_symbol_from_elf): Likewise. * src/abg-dwarf-reader.cc (lookup_symbol_from_sysv_hash_tab) (lookup_symbol_from_gnu_hash_tab) (lookup_symbol_from_elf_hash_tab, lookup_symbol_from_symtab) (lookup_symbol_from_elf, lookup_public_function_symbol_from_elf) (lookup_public_variable_symbol_from_elf, lookup_symbol_from_elf) (lookup_public_function_symbol_from_elf): Take an environment as first parameter and adjust. (build_translation_unit_and_add_to_ir) (build_namespace_decl_and_add_to_ir, build_type_decl) (build_enum_type, finish_member_function_reading) (build_class_type_and_add_to_ir, build_function_type) (read_debug_info_into_corpus, read_corpus_from_elf): Adjust. * include/abg-fwd.h: Include abg-interned-str.h (get_type_name, get_function_type_name, get_method_type_name): Return a interned_string, rather than a std::string. * include/abg-interned-str.h: New declarations for interned strings and their pool. * include/abg-ir.h (environment::intern): Declare new method. (elf_symbol::{g,s}et_environment): Likewise. (type_or_decl_base::type_or_decl_base): Make the default constructor private. ({translation, type_or_decl_base}::set_environment) (set_environment_for_artifact): Take a const environment*. (elf_symbol::elf_symbol) (elf_symbol::create) (type_or_decl_base::type_or_decl_base) (translation::translation, decl_base::decl_base) (scope_decl::scope_decl, type_base::type_base) (type_decl::type_decl, scope_type_decl::scope_type_decl) (namespace_decl::namespace_decl) (enum_type_decl::enumerator::enumerator) (function_type::function_type, method_type::method_type) (template_decl::template_decl, function_tdecl::function_tdecl) (class_tdecl::class_tdecl, class_decl::class_decl): Take an environment. (type_or_decl_base::operator=) (enum_type_decl::enumerator::get_environment): Declare new method. (decl_base::{peek_qualified_name, peek_temporary_qualified_name, get_qualified_name, get_name, get_qualified_parent_name, get_linkage_name}, qualified_type_def::get_qualified_name) (reference_type_def::get_qualified_name) (array_type_def::get_qualified_name) (enum_type_decl::enumerator::{get_name, get_qualified_name}) ({var,function}_decl::get_id) (function_decl::parameter::{get_type_name, get_name_id}): Return an interned_string, rather than a std::string. (decl_base::{set_qualified_name, set_temporary_qualified_name, get_qualified_name, set_linkage_name}) (qualified_type_def::get_qualified_name) (reference_type_def::get_qualified_name) (array_type_def::get_qualified_name) (function_decl::parameter::get_qualified_name): Take an interned_string, rather than a std::string. (class_decl::member_{class,function}_template::member_{class,function}_template): Adjust. * src/abg-ir.cc (environment_setter::env_): Make this be a pointer to const environment. (environment_setter::visit_begin): Adjust. (interned_string_pool::priv): Define new type. (interned_string_pool::*): Define the method declared in abg-interned-str. h. (operator==, operator!=, operator+): Define operator for interned_string and std::string (operator<<): Define for interned_string. (translation_unit::priv::env_): Make this be a pointer to const environment. (translation_unit::priv::priv): Take a pointer to const environment. (elf_symbol::priv::env_): New data member. (elf_symbol::priv::priv): Adjust. Make an overoad take an environment. (translation_unit::{g,s}et_environment): Adjust. (interned_string_bool_map_type): New typedef. (environment::priv::classes_being_compared_): Make this hastable of string be a hashtable of interned_string. (environment::priv::string_pool_): New data member. (environment::{get_void_type_decl, get_variadic_parameter_type_decl}): Adjust. (type_or_decl_base::priv::env_): Make this be a pointer to const environment. (type_or_decl::base::priv::priv): Adjust. (type_or_decl_base::set_environment) (set_environment_for_artifact): Take a pointer to const environment. (elf_symbol::{g,s}et_environment, environment::intern) (type_or_decl_base::operator=): Define new methods. (decl_base::priv::{name_, qualified_parent_name_, temporary_qualified_name_, qualified_name_, linkage_name_}): Make these data member be of tpe interned_string. (decl_base::priv::priv): Make this take an environment. Adjust. (decl_base::{peek_qualified_name, peek_temporary_qualified_name, get_linkage_name, get_qualified_parent_name, get_name, get_qualified_name}, get_type_name, get_function_type_name) (get_method_type_name, get_node_name) (qualified_type_def::get_qualified_name) (pointer_type_def::get_qualified_name) (array_type_def::get_qualified_name) (enum_type_decl::enumerator::get_qualified_name) (var_decl::get_id, function_decl::get_id) (function_decl::parameter::get_{name_id, type_name}): Return an interned_string. (decl_base::{set_qualified_name, set_temporary_qualified_name}) (qualified_type_def::get_qualified_name) (pointer_type_def::get_qualified_name) (reference_type_def::get_qualified_name) (array_type_def::get_qualified_name) (function_decl::parameter::get_qualified_name): Take an interned_string. (decl_base::{set_name, set_linkage_name}): Intern the std::string passed in parameter. (equals): In the overload for decl_base, adjust for a little speed optimization that is justified by profiling. (pointer_type_def::priv::{internal_qualified_name_, temp_internal_qualified_name_}): Make these data member be interned_string. (enum_type_decl::enumerator::priv::env_): New data member. (enum_type_decl::enumerator::priv::{name_, qualified_name}): Make these data member be of type interned_string. (enum_type_decl::enumerator::get_environment): New method. (enum_type_decl::enumerator::priv::priv) Adjust. (typedef_decl::operator==): Implement a little speed optimization. (var_decl::priv::nake_type_): New data member. (var_decl::priv::id_): Make this data member be of type interned_string. (equals): In the overload for var_decl, function_type, function_decl, adjust for the use of interned_string. (function_decl::priv::id_): Make this be of type interned_string. (scope_decl::{add_member_decl, insert_member_decl}) (lookup_function_type_in_translation_unit) (synthesize_type_from_translation_unit, lookup_node_in_scope) (lookup_type_in_scope, scope_decl::scope_decl) (qualified_type_def::qualified_type_def) (qualified_type_def::get_qualified_name) (pointer_type_def::pointer_type_def) (reference_type_def::reference_type_def) (array_type_def::array_type_def, array_type_def::append_subrange) (array_type_def::get_qualified_name) (enum_type_decl::enum_type_decl) (enum_type_decl::enumerator::get_qualified_name) (enum_type_decl::enumerator::set_name) (typedef_decl::typedef_decl, var_decl::var_decl) (function_type::function_type, method_type::method_type) (function_decl::function_decl) (function_decl::parameter::parameter) (class_decl::priv::comparison_started) (class_decl::add_base_specifier) (class_decl::base_spec::base_spec) (class_decl::method_decl::method_decl) (type_tparameter::type_tparameter) (non_type_tparameter::non_type_tparameter) (template_tparameter::template_tparameter) (type_composition::type_composition) (function_tdecl::function_tdecl, class_tdecl::class_tdecl) (qualified_name_setter::do_update): Adjust. (translation_unit::translation_unit, elf_symbol::elf_symbol) (elf_symbol::create, type_or_decl_base::type_or_decl_base) (decl_base::decl_base, type_base::type_base) (type_decl::type_decl, scope_type_decl::scope_type_decl) (namespace_decl::namespace_decl) (enum_type_decl::enumerator::enumerator, class_decl::class_decl) (template_decl::template_decl, function_tdecl::function_tdecl) (class_tdecl::class_tdecl): Take an environment. * src/abg-comparison.cc (function_suppression::suppresses_function): Adjust. * src/abg-reader.cc (read_translation_unit) (read_corpus_from_input, build_namespace_decl, build_elf_symbol) (build_function_parameter, build_function_decl, build_type_decl) (build_function_type, build_enum_type_decl, build_enum_type_decl) (build_class_decl, build_function_tdecl, build_class_tdecl) (read_corpus_from_native_xml): Likewise. * src/abg-writer.cc (id_manager::m_cur_id): Make this mutable. (id_manager::m_env): New data member. (id_manager::id_manager): Adjust. (id_manager::get_environment): New method. (id_manager::{get_id, get_id_with_prefix}): Return an interned_string. (type_ptr_map): Make this be a hash map of type_base* -> interned_string, rather a type_base* -> string. (write_context::m_env): New data member. (write_context::m_type_id_map): Make this data member be mutable. (write_context::m_emitted_type_id_map): Make this be a hash map of interned_string -> bool, rather than string -> bool. (write_context::write_context): Take an environment and adjust. (write_context::get_environment): New method. (write_context::get_id_manager): New const overload. (write_context::get_id_for_type): Return an interned_string; adjust. (write_context::{record_type_id_as_emitted, record_type_as_referenced}): Adjust. (write_context::type_id_is_emitted): Take an interned_string. (write_context::{type_is_emitted, record_decl_only_type_as_emitted}): Adjust. (write_translation_unit, write_corpus_to_native_xml, dump): Adjust. * tools/abisym.cc (main): Adjust. * tests/data/test-read-write/test22.xml: Adjust. * tests/data/test-read-write/test23.xml: Adjust. * tests/data/test-read-write/test26.xml: Adjust. Signed-off-by: Dodji Seketeli <dodji@redhat.com>
783 lines
17 KiB
C++
783 lines
17 KiB
C++
// -*- Mode: C++ -*-
|
|
//
|
|
// Copyright (C) 2013-2015 Red Hat, Inc.
|
|
//
|
|
// This file is part of the GNU Application Binary Interface Generic
|
|
// Analysis and Instrumentation Library (libabigail). This library is
|
|
// free software; you can redistribute it and/or modify it under the
|
|
// terms of the GNU Lesser General Public License as published by the
|
|
// Free Software Foundation; either version 3, or (at your option) any
|
|
// later version.
|
|
|
|
// This library is distributed in the hope that it will be useful, but
|
|
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// General Lesser Public License for more details.
|
|
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this program; see the file COPYING-LGPLV3. If
|
|
// not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/// @file
|
|
|
|
#ifndef __ABG_IRFWD_H__
|
|
#define __ABG_IRFWD_H__
|
|
|
|
#include <cstddef>
|
|
#include <tr1/memory>
|
|
#include <list>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <tr1/functional>
|
|
#include <typeinfo>
|
|
#include <utility> // for std::rel_ops, at least.
|
|
#include <ostream>
|
|
#include "abg-interned-str.h"
|
|
#include "abg-hash.h"
|
|
|
|
/// Toplevel namespace for libabigail.
|
|
namespace abigail
|
|
{
|
|
/**
|
|
@mainpage libabigail
|
|
|
|
This is the API documentation of the Application Binary
|
|
Interface Generic Analysis and Instrumentation Library, aka,
|
|
<em>libabigail</em>.
|
|
|
|
Check out <a href="http://sourceware.org/libabigail"> the project
|
|
homepage</a>!
|
|
|
|
The current libabigail source code can be browsed at
|
|
http://sourceware.org/git/gitweb.cgi?p=libabigail.git
|
|
|
|
It can be checked out with:
|
|
<em>git clone git://sourceware.org/git/libabigail.git</em>
|
|
|
|
The mailing list to send messages and patches to is
|
|
libabigail@sourceware.org.
|
|
|
|
You can hang out with libabigail developers and users on irc at
|
|
irc://irc.oftc.net\#libabigail.
|
|
*/
|
|
|
|
// Inject some types.
|
|
using std::tr1::shared_ptr;
|
|
using std::tr1::weak_ptr;
|
|
using std::string;
|
|
using std::vector;
|
|
|
|
// Pull in relational operators.
|
|
using namespace std::rel_ops;
|
|
|
|
namespace ir
|
|
{
|
|
|
|
// Forward declarations for corpus.
|
|
|
|
class corpus;
|
|
|
|
// Forward declarations for ir.
|
|
class environment;
|
|
class location;
|
|
class location_manager;
|
|
class corpus;
|
|
class translation_unit;
|
|
class class_decl;
|
|
class class_tdecl;
|
|
class type_or_decl_base;
|
|
class decl_base;
|
|
class enum_type_decl;
|
|
class function_decl;
|
|
class function_tdecl;
|
|
class function_type;
|
|
class global_scope;
|
|
class node_visitor;
|
|
class location;
|
|
class location_manager;
|
|
class method_type;
|
|
class namespace_decl;
|
|
class pointer_type_def;
|
|
class qualified_type_def;
|
|
class reference_type_def;
|
|
class scope_decl;
|
|
class scope_type_decl;
|
|
class template_decl;
|
|
class template_parameter;
|
|
class non_type_tparameter;
|
|
class type_tparameter;
|
|
class template_tparameter;
|
|
|
|
class type_composition;
|
|
class type_base;
|
|
class type_decl;
|
|
class typedef_decl;
|
|
class var_decl;
|
|
class array_type_def;
|
|
class subrange_type;
|
|
|
|
struct type_shared_ptr_equal;
|
|
struct traversable_base;
|
|
|
|
shared_ptr<decl_base>
|
|
add_decl_to_scope(shared_ptr<decl_base>, scope_decl*);
|
|
|
|
shared_ptr<decl_base>
|
|
add_decl_to_scope (shared_ptr<decl_base>, shared_ptr<scope_decl>);
|
|
|
|
const global_scope*
|
|
get_global_scope(const decl_base&);
|
|
|
|
const global_scope*
|
|
get_global_scope(const decl_base*);
|
|
|
|
const global_scope*
|
|
get_global_scope(const shared_ptr<decl_base>);
|
|
|
|
translation_unit*
|
|
get_translation_unit(const decl_base&);
|
|
|
|
translation_unit*
|
|
get_translation_unit(const decl_base*);
|
|
|
|
translation_unit*
|
|
get_translation_unit(const shared_ptr<decl_base>);
|
|
|
|
bool
|
|
is_global_scope(const scope_decl&);
|
|
|
|
const global_scope*
|
|
is_global_scope(const scope_decl*);
|
|
|
|
bool
|
|
is_global_scope(const shared_ptr<scope_decl>);
|
|
|
|
bool
|
|
is_at_global_scope(const decl_base&);
|
|
|
|
bool
|
|
is_at_global_scope(const shared_ptr<decl_base>);
|
|
|
|
bool
|
|
is_at_class_scope(const shared_ptr<decl_base>);
|
|
|
|
bool
|
|
is_at_class_scope(const decl_base*);
|
|
|
|
bool
|
|
is_at_class_scope(const decl_base&);
|
|
|
|
bool
|
|
is_at_template_scope(const shared_ptr<decl_base>);
|
|
|
|
bool
|
|
is_template_parameter(const shared_ptr<decl_base>);
|
|
|
|
function_decl*
|
|
is_function_decl(const decl_base*);
|
|
|
|
shared_ptr<function_decl>
|
|
is_function_decl(shared_ptr<decl_base>);
|
|
|
|
bool
|
|
is_function_decl(const decl_base&);
|
|
|
|
decl_base*
|
|
is_decl(const type_or_decl_base*);
|
|
|
|
shared_ptr<decl_base>
|
|
is_decl(const shared_ptr<type_or_decl_base>&);
|
|
|
|
bool
|
|
is_type(const type_or_decl_base&);
|
|
|
|
type_base*
|
|
is_type(const type_or_decl_base*);
|
|
|
|
shared_ptr<type_base>
|
|
is_type(const shared_ptr<type_or_decl_base>& tod);
|
|
|
|
bool
|
|
is_type(const decl_base&);
|
|
|
|
shared_ptr<type_base>
|
|
is_type(const shared_ptr<decl_base>);
|
|
|
|
type_base*
|
|
is_type(decl_base*);
|
|
|
|
bool
|
|
is_anonymous_type(type_base*);
|
|
|
|
bool
|
|
is_anonymous_type(const shared_ptr<type_base>&);
|
|
|
|
shared_ptr<type_decl>
|
|
is_type_decl(const shared_ptr<type_base>);
|
|
|
|
shared_ptr<typedef_decl>
|
|
is_typedef(const shared_ptr<type_base>);
|
|
|
|
shared_ptr<typedef_decl>
|
|
is_typedef(const shared_ptr<decl_base>);
|
|
|
|
const typedef_decl*
|
|
is_typedef(const type_base*);
|
|
|
|
typedef_decl*
|
|
is_typedef(type_base*);
|
|
|
|
shared_ptr<enum_type_decl>
|
|
is_enum_type(const shared_ptr<type_base>&);
|
|
|
|
shared_ptr<enum_type_decl>
|
|
is_enum_type(const shared_ptr<decl_base>&);
|
|
|
|
class_decl*
|
|
is_class_type(const decl_base*);
|
|
|
|
class_decl*
|
|
is_class_type(const type_base*);
|
|
|
|
shared_ptr<class_decl>
|
|
is_class_type(const shared_ptr<type_base>);
|
|
|
|
shared_ptr<class_decl>
|
|
is_class_type(const shared_ptr<decl_base>);
|
|
|
|
shared_ptr<class_decl>
|
|
is_compatible_with_class_type(const shared_ptr<type_base>);
|
|
|
|
shared_ptr<class_decl>
|
|
is_compatible_with_class_type(const shared_ptr<decl_base>);
|
|
|
|
pointer_type_def*
|
|
is_pointer_type(type_base*);
|
|
|
|
const pointer_type_def*
|
|
is_pointer_type(const type_base*);
|
|
|
|
shared_ptr<pointer_type_def>
|
|
is_pointer_type(const shared_ptr<type_base>);
|
|
|
|
reference_type_def*
|
|
is_reference_type(type_base*);
|
|
|
|
const reference_type_def*
|
|
is_reference_type(const type_base*);
|
|
|
|
shared_ptr<reference_type_def>
|
|
is_reference_type(const shared_ptr<type_base>);
|
|
|
|
qualified_type_def*
|
|
is_qualified_type(const type_base*);
|
|
|
|
shared_ptr<qualified_type_def>
|
|
is_qualified_type(const shared_ptr<type_base>);
|
|
|
|
shared_ptr<function_type>
|
|
is_function_type(const shared_ptr<type_base>);
|
|
|
|
function_type*
|
|
is_function_type(type_base*);
|
|
|
|
const function_type*
|
|
is_function_type(const type_base*);
|
|
|
|
shared_ptr<method_type>
|
|
is_method_type(const shared_ptr<type_base>);
|
|
|
|
const method_type*
|
|
is_method_type(const type_base*);
|
|
|
|
method_type*
|
|
is_method_type(type_base*);
|
|
|
|
shared_ptr<class_decl>
|
|
look_through_decl_only_class(shared_ptr<class_decl>);
|
|
|
|
var_decl*
|
|
is_var_decl(const type_or_decl_base*);
|
|
|
|
shared_ptr<var_decl>
|
|
is_var_decl(const shared_ptr<decl_base>);
|
|
|
|
shared_ptr<namespace_decl>
|
|
is_namespace(const shared_ptr<decl_base>&);
|
|
|
|
namespace_decl*
|
|
is_namespace(const decl_base*);
|
|
|
|
bool
|
|
is_template_parm_composition_type(const shared_ptr<decl_base>);
|
|
|
|
bool
|
|
is_template_decl(const shared_ptr<decl_base>);
|
|
|
|
bool
|
|
is_function_template_pattern(const shared_ptr<decl_base>);
|
|
|
|
shared_ptr<decl_base>
|
|
add_decl_to_scope(shared_ptr<decl_base>, scope_decl*);
|
|
|
|
shared_ptr<decl_base>
|
|
add_decl_to_scope(shared_ptr<decl_base>, shared_ptr<scope_decl>);
|
|
|
|
shared_ptr<decl_base>
|
|
insert_decl_into_scope(shared_ptr<decl_base>,
|
|
vector<shared_ptr<decl_base> >::iterator,
|
|
scope_decl*);
|
|
|
|
shared_ptr<decl_base>
|
|
insert_decl_into_scope(shared_ptr<decl_base>,
|
|
vector<shared_ptr<decl_base> >::iterator,
|
|
shared_ptr<scope_decl>);
|
|
|
|
bool
|
|
has_scope(const decl_base&);
|
|
|
|
bool
|
|
has_scope(const shared_ptr<decl_base>);
|
|
|
|
bool
|
|
is_member_decl(const shared_ptr<decl_base>);
|
|
|
|
bool
|
|
is_member_decl(const decl_base*);
|
|
|
|
bool
|
|
is_member_decl(const decl_base&);
|
|
|
|
scope_decl*
|
|
is_scope_decl(decl_base*);
|
|
|
|
bool
|
|
is_member_type(const shared_ptr<type_base>);
|
|
|
|
void
|
|
remove_decl_from_scope(shared_ptr<decl_base>);
|
|
|
|
bool
|
|
get_member_is_static(const decl_base&);
|
|
|
|
bool
|
|
get_member_is_static(const decl_base*);
|
|
|
|
bool
|
|
get_member_is_static(const shared_ptr<decl_base>&);
|
|
|
|
void
|
|
set_member_is_static(decl_base&, bool);
|
|
|
|
void
|
|
set_member_is_static(const shared_ptr<decl_base>&, bool);
|
|
|
|
bool
|
|
is_data_member(const var_decl&);
|
|
|
|
bool
|
|
is_data_member(const var_decl*);
|
|
|
|
bool
|
|
is_data_member(const shared_ptr<var_decl>);
|
|
|
|
shared_ptr<var_decl>
|
|
is_data_member(const shared_ptr<decl_base>&);
|
|
|
|
array_type_def*
|
|
is_array_type(const type_base* decl);
|
|
|
|
shared_ptr<array_type_def>
|
|
is_array_type(const shared_ptr<type_base> decl);
|
|
|
|
void
|
|
set_data_member_offset(shared_ptr<var_decl>, size_t);
|
|
|
|
size_t
|
|
get_data_member_offset(const var_decl&);
|
|
|
|
size_t
|
|
get_data_member_offset(const shared_ptr<var_decl>);
|
|
|
|
size_t
|
|
get_data_member_offset(const shared_ptr<decl_base>);
|
|
|
|
void
|
|
set_data_member_is_laid_out(shared_ptr<var_decl>, bool);
|
|
|
|
bool
|
|
get_data_member_is_laid_out(const var_decl&);
|
|
|
|
bool
|
|
get_data_member_is_laid_out(const shared_ptr<var_decl>);
|
|
|
|
bool
|
|
is_member_function(const function_decl&);
|
|
|
|
bool
|
|
is_member_function(const function_decl*);
|
|
|
|
bool
|
|
is_member_function(const shared_ptr<function_decl>&);
|
|
|
|
bool
|
|
get_member_function_is_ctor(const function_decl&);
|
|
|
|
bool
|
|
get_member_function_is_ctor(const shared_ptr<function_decl>&);
|
|
|
|
void
|
|
set_member_function_is_ctor(const function_decl&, bool);
|
|
|
|
void
|
|
set_member_function_is_ctor(const shared_ptr<function_decl>&, bool);
|
|
|
|
bool
|
|
get_member_function_is_dtor(const function_decl&);
|
|
|
|
bool
|
|
get_member_function_is_dtor(const shared_ptr<function_decl>&);
|
|
|
|
void
|
|
set_member_function_is_dtor(function_decl&, bool);
|
|
|
|
void
|
|
set_member_function_is_dtor(const shared_ptr<function_decl>&, bool);
|
|
|
|
bool
|
|
get_member_function_is_const(const function_decl&);
|
|
|
|
bool
|
|
get_member_function_is_const(const shared_ptr<function_decl>&);
|
|
|
|
void
|
|
set_member_function_is_const(function_decl&, bool);
|
|
|
|
void
|
|
set_member_function_is_const(const shared_ptr<function_decl>&, bool);
|
|
|
|
size_t
|
|
get_member_function_vtable_offset(const function_decl&);
|
|
|
|
size_t
|
|
get_member_function_vtable_offset(const shared_ptr<function_decl>&);
|
|
|
|
void
|
|
set_member_function_vtable_offset(const function_decl& f,
|
|
size_t s);
|
|
|
|
void
|
|
set_member_function_vtable_offset(const shared_ptr<function_decl> &f,
|
|
size_t s);
|
|
|
|
bool
|
|
get_member_function_is_virtual(const function_decl&);
|
|
|
|
bool
|
|
get_member_function_is_virtual(const shared_ptr<function_decl>&);
|
|
|
|
bool
|
|
get_member_function_is_virtual(const function_decl*);
|
|
|
|
void
|
|
set_member_function_is_virtual(function_decl&, bool);
|
|
|
|
void
|
|
set_member_function_is_virtual(const shared_ptr<function_decl>&, bool);
|
|
|
|
shared_ptr<type_base>
|
|
strip_typedef(const shared_ptr<type_base>);
|
|
|
|
shared_ptr<type_base>
|
|
peel_typedef_type(const shared_ptr<type_base>&);
|
|
|
|
const type_base*
|
|
peel_typedef_type(const type_base*);
|
|
|
|
shared_ptr<type_base>
|
|
peel_pointer_type(const shared_ptr<type_base>&);
|
|
|
|
const type_base*
|
|
peel_pointer_type(const type_base*);
|
|
|
|
shared_ptr<type_base>
|
|
peel_reference_type(const shared_ptr<type_base>&);
|
|
|
|
const type_base*
|
|
peel_reference_type(const type_base*);
|
|
|
|
const shared_ptr<type_base>
|
|
peel_array_type(const shared_ptr<type_base>&);
|
|
|
|
const type_base*
|
|
peel_array_type(const type_base*);
|
|
|
|
const type_base*
|
|
peel_qualified_type(const type_base*);
|
|
|
|
const shared_ptr<type_base>
|
|
peel_qualified_type(const shared_ptr<type_base>&);
|
|
|
|
shared_ptr<type_base>
|
|
peel_typedef_pointer_or_reference_type(const shared_ptr<type_base>);
|
|
|
|
type_base*
|
|
peel_typedef_pointer_or_reference_type(const type_base*);
|
|
|
|
string
|
|
get_name(const shared_ptr<type_or_decl_base>&,
|
|
bool qualified = true);
|
|
|
|
scope_decl*
|
|
get_type_scope(type_base*);
|
|
|
|
scope_decl*
|
|
get_type_scope(const shared_ptr<type_base>&);
|
|
|
|
interned_string
|
|
get_type_name(const shared_ptr<type_base>,
|
|
bool qualified = true,
|
|
bool internal = false);
|
|
|
|
interned_string
|
|
get_type_name(const type_base*,
|
|
bool qualified = true,
|
|
bool internal = false);
|
|
|
|
interned_string
|
|
get_type_name(const type_base&,
|
|
bool qualified = true,
|
|
bool internal = false);
|
|
|
|
interned_string
|
|
get_function_type_name(const shared_ptr<function_type>&,
|
|
bool internal = false);
|
|
|
|
interned_string
|
|
get_function_type_name(const function_type*, bool internal = false);
|
|
|
|
interned_string
|
|
get_function_type_name(const function_type&, bool internal = false);
|
|
|
|
interned_string
|
|
get_method_type_name(const shared_ptr<method_type>&, bool internal = false);
|
|
|
|
interned_string
|
|
get_method_type_name(const method_type*, bool internal = false);
|
|
|
|
interned_string
|
|
get_method_type_name(const method_type&, bool internal = false);
|
|
|
|
string
|
|
get_pretty_representation(const decl_base*, bool internal = false);
|
|
|
|
string
|
|
get_pretty_representation(const type_base*, bool internal = false);
|
|
|
|
string
|
|
get_pretty_representation(const type_or_decl_base*,bool internal = false);
|
|
|
|
string
|
|
get_pretty_representation(const shared_ptr<type_or_decl_base>&,
|
|
bool internal = false);
|
|
|
|
string
|
|
get_pretty_representation(const shared_ptr<decl_base>&, bool internal = false);
|
|
|
|
string
|
|
get_pretty_representation(const shared_ptr<type_base>&, bool internal = false);
|
|
|
|
string
|
|
get_pretty_representation(const function_type&, bool internal = false);
|
|
|
|
string
|
|
get_pretty_representation(const function_type*, bool internal = false);
|
|
|
|
string
|
|
get_pretty_representation(const shared_ptr<function_type>&,
|
|
bool internal = false);
|
|
|
|
string
|
|
get_pretty_representation(const method_type&, bool internal = false);
|
|
|
|
string
|
|
get_pretty_representation(const method_type*, bool internal = false);
|
|
|
|
string
|
|
get_pretty_representation(const shared_ptr<method_type>&,
|
|
bool internal = false);
|
|
|
|
const decl_base*
|
|
get_type_declaration(const type_base*);
|
|
|
|
decl_base*
|
|
get_type_declaration(type_base*);
|
|
|
|
shared_ptr<decl_base>
|
|
get_type_declaration(const shared_ptr<type_base>);
|
|
|
|
bool
|
|
types_are_compatible(const shared_ptr<type_base>,
|
|
const shared_ptr<type_base>);
|
|
|
|
bool
|
|
types_are_compatible(const shared_ptr<decl_base>,
|
|
const shared_ptr<decl_base>);
|
|
|
|
const scope_decl*
|
|
get_top_most_scope_under(const decl_base*,
|
|
const scope_decl*);
|
|
|
|
const scope_decl*
|
|
get_top_most_scope_under(const shared_ptr<decl_base>,
|
|
const scope_decl*);
|
|
|
|
const scope_decl*
|
|
get_top_most_scope_under(const shared_ptr<decl_base>,
|
|
const shared_ptr<scope_decl>);
|
|
|
|
void
|
|
fqn_to_components(const std::string&,
|
|
std::list<string>&);
|
|
|
|
string
|
|
components_to_type_name(const std::list<string>&);
|
|
|
|
const shared_ptr<decl_base>
|
|
lookup_type_in_corpus(const string&, const corpus&);
|
|
|
|
const shared_ptr<class_decl>
|
|
lookup_class_type_in_corpus(const string&, const corpus&);
|
|
|
|
const shared_ptr<function_type>
|
|
lookup_function_type_in_corpus(const function_type&, const corpus&);
|
|
|
|
const shared_ptr<decl_base>
|
|
lookup_type_in_translation_unit(const string&,
|
|
const translation_unit&);
|
|
|
|
const shared_ptr<decl_base>
|
|
lookup_type_in_translation_unit(const std::list<string>&,
|
|
const translation_unit&);
|
|
|
|
const shared_ptr<class_decl>
|
|
lookup_class_type_in_translation_unit(const std::list<string>& fqn,
|
|
const translation_unit& tu);
|
|
|
|
const shared_ptr<class_decl>
|
|
lookup_class_type_in_translation_unit(const string& fqn,
|
|
const translation_unit& tu);
|
|
|
|
const shared_ptr<type_base>
|
|
lookup_type_in_translation_unit(const shared_ptr<type_base>,
|
|
const translation_unit&);
|
|
|
|
shared_ptr<function_type>
|
|
lookup_function_type_in_translation_unit(const function_type&,
|
|
const translation_unit&);
|
|
|
|
shared_ptr<type_base>
|
|
synthesize_type_from_translation_unit(const shared_ptr<type_base>& type,
|
|
translation_unit& tu);
|
|
|
|
shared_ptr<function_type>
|
|
synthesize_function_type_from_translation_unit(const function_type&,
|
|
translation_unit&);
|
|
|
|
shared_ptr<function_type>
|
|
lookup_function_type_in_translation_unit(const shared_ptr<function_type>&,
|
|
const translation_unit&);
|
|
|
|
shared_ptr<function_type>
|
|
lookup_function_type_in_corpus(const shared_ptr<function_type>&,
|
|
corpus&);
|
|
|
|
shared_ptr<type_base>
|
|
lookup_type_in_corpus(const shared_ptr<type_base>&, corpus&);
|
|
|
|
const shared_ptr<decl_base>
|
|
lookup_type_in_scope(const string&,
|
|
const shared_ptr<scope_decl>&);
|
|
|
|
const shared_ptr<decl_base>
|
|
lookup_type_in_scope(const std::list<string>&,
|
|
const shared_ptr<scope_decl>&);
|
|
|
|
const shared_ptr<decl_base>
|
|
lookup_var_decl_in_scope(const string&,
|
|
const shared_ptr<scope_decl>&);
|
|
|
|
const shared_ptr<decl_base>
|
|
lookup_var_decl_in_scope(const std::list<string>&,
|
|
const shared_ptr<scope_decl>&);
|
|
|
|
string
|
|
demangle_cplus_mangled_name(const string&);
|
|
|
|
shared_ptr<type_base>
|
|
type_or_void(const shared_ptr<type_base>, const environment*);
|
|
|
|
shared_ptr<type_base>
|
|
canonicalize(shared_ptr<type_base>);
|
|
|
|
type_base*
|
|
type_has_non_canonicalized_subtype(shared_ptr<type_base> t);
|
|
|
|
bool
|
|
type_has_sub_type_changes(shared_ptr<type_base> t_v1,
|
|
shared_ptr<type_base> t_v2);
|
|
|
|
void
|
|
keep_type_alive(shared_ptr<type_base> t);
|
|
|
|
size_t
|
|
hash_type_or_decl(const type_or_decl_base *);
|
|
|
|
size_t
|
|
hash_type_or_decl(const shared_ptr<type_or_decl_base>&);
|
|
} // end namespace ir
|
|
|
|
using namespace abigail::ir;
|
|
|
|
void
|
|
dump(const shared_ptr<decl_base>, std::ostream&);
|
|
|
|
void
|
|
dump(const shared_ptr<decl_base>);
|
|
|
|
void
|
|
dump(const shared_ptr<type_base>, std::ostream&);
|
|
|
|
void
|
|
dump(const shared_ptr<type_base>);
|
|
|
|
void
|
|
dump(const shared_ptr<var_decl>, std::ostream&);
|
|
|
|
void
|
|
dump(const shared_ptr<var_decl>);
|
|
|
|
void
|
|
dump(const translation_unit&, std::ostream&);
|
|
|
|
void
|
|
dump(const translation_unit&);
|
|
|
|
void
|
|
dump(const shared_ptr<translation_unit>, std::ostream&);
|
|
|
|
void
|
|
dump(const shared_ptr<translation_unit>);
|
|
|
|
void
|
|
dump_decl_location(const decl_base&);
|
|
|
|
void
|
|
dump_decl_location(const decl_base*);
|
|
|
|
void
|
|
dump_decl_location(const shared_ptr<decl_base>&);
|
|
|
|
} // end namespace abigail
|
|
#endif // __ABG_IRFWD_H__
|