From: Giuliano Procida <gprocida@google.com>
To: Dodji Seketeli <dodji@redhat.com>
Cc: woodard@redhat.com, guillermo.e.martinez@oracle.com,
jose.marchesi@oracle.com, libabigail@sourceware.org
Subject: Re: [PATCH 1/2] Use environment by reference
Date: Thu, 17 Nov 2022 14:17:42 +0000 [thread overview]
Message-ID: <CAGvU0HmNGrwjcMHzwCh8frfQRxGUWXKDBqz3dT_KpjvCoSs0MA@mail.gmail.com> (raw)
In-Reply-To: <87cz9molk8.fsf@redhat.com>
Hi.
On Wed, 16 Nov 2022 at 17:29, Dodji Seketeli <dodji@redhat.com> wrote:
>
> Hello,
>
> This patch simplifies how the environment is created and passed around
> the functions that create front ends. With this change, the
> environment can simply be allocated on the stack and passed by
> reference to the libabigail pipeline.
>
> At the core of this change, type_or_decl_base::priv now carries a
> const reference to an environment rather than a pointer. The side
> effect is that type_or_decl_base can no longer be copied. This is not
> a problem because throughout the years I could see that the use case
> to copy ABI artifacts is just not there. Similarly, elf_symbol::priv
> carries a const reference to environment now, no more a pointer.
> Getters, setters and code that use the environment from the ABI
> artifacts are updated accordingly.
>
> The DWARF front-end can now be created by code that looks like this,
> for instance:
>
> vector<char**> debug_info_paths;
> abigail::ir::environment env;
>
> abigail::ctf_reader::read_context_sptr reader =
> abigail::dwarf_reader::create_read_context("elf/file/to/analyze",
> debug_info_paths, env);
>
> elf_reader::status reading_status;
> corpus_sptr abi_corpus =
> abigail::dwarf_reader::read_corpus_from_elf(reader, reading_status);
>
> /* then do something with the resulting abi_corpus*/
>
> Note how, you don't need to use the "new" operator to instantiate the
> "env" object of type environment. It can sit on the stack and it's
> passed to the read_corpus_from_elf function by reference.
>
> In other words, the internal representation types have been changed to
> refer to the environment by reference, rather than requiring a pointer
> to it.
>
> * include/abg-corpus.h (corpus::corpus)
> (corpus_group::corpus_group): Take environment&, not environment*
> as parameter.
> (corpus::{get_environment, set_environment}): Take or return
> environment&, not environment*.
> * src/abg-corpus.cc (corpus::corpus): Likewise.
> (corpus::{get_environment, set_environment}): Likewise.
> (corpus::add): Don't update the environment of the translation
> unit.
> (corpus::{record_type_as_reachable_from_public_interfaces,
> type_is_reachable_from_public_interfaces, init_format_version,
> add_corpus}): Adjust for accessing a reference to environment,
> rather than a pointer.
> * include/abg-ctf-reader.h (create_read_context): Take or return
> environment&, not environment*.
> * src/abg-ctf-reader.cc (read_context::ir_env): Make this a
> reference to environment, not pointer anymore.
> (read_context::read_context): Initialize the reference to
> environment.
> (read_context::initialize): Do not re-set the environment.
> (process_ctf_base_type)
> (build_ir_node_for_variadic_parameter_type)
> (process_ctf_enum_type, read_corpus): Adjust for accessing a
> reference to environment, rather than a pointer.
> (create_read_context, reset_read_context): Take environment&, not
> environment*.
> * include/abg-dwarf-reader.h (create_read_context)
> (reset_read_context, read_corpus_from_elf)
> (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):
> Likewise.
> (read_context::options_type::env): Make this be a reference to
> environment, not a pointer.
> (read_context::options::options): Remove the default constructor.
> Add a new one to initialize the environment data member.
> (read_context::read_context): Take environment&, not environment*.
> Initialize the options_ data member.
> (read_context::initialize): Do not take or initialize an
> environment anymore.
> (read_context::env): Return or take environment&, not
> environment*.
> (read_context::{get_die_qualified_name,
> get_die_qualified_type_name, get_die_pretty_type_representation,
> get_die_pretty_representation, compare_before_canonicalisation})
> (build_translation_unit_and_add_to_ir, build_function_type)
> (build_typedef_type, read_debug_info_into_corpus)
> (read_debug_info_into_corpus, build_ir_node_from_die)
> (build_ir_node_for_variadic_parameter_type, has_alt_debug_info):
> Adjust to use an environment&, not a pointer.
> (create_default_fn_sym, create_read_context)
> (read_corpus_from_elf, lookup_symbol_from_elf)
> (lookup_public_function_symbol_from_elf): Take environment&, not
> environment*.
> (reset_read_context): Do not take or reset environment* anymore.
> * include/abg-fwd.h (type_or_void): Likewise.
> * include/abg-ir.h (translation_unit::translation_unit): Likewise.
> (translation_unit::{get_environment, set_environment}): Likewise.
> (elf_symbol::elf_symbol): Likewise.
> (elf_symbol::create): Remove the overload that takes no
> parameter. Then for overload that take parameters then take
> environment&, not environment*.
> (elf_symbol::get_environment): Take environment&, not
> environment*.
> (type_or_decl_base::type_or_decl_base): Make the copy constructor
> and assignment operator private.
> (type_or_decl_base::{s,g}et_environment): Take or return
> environment& not environment*.
> (type_or_decl_base::set_environment_for_artifact): Erase these
> methods.
> (decl_base::decl_base): Make copy constructor private. Take or
> return environment&, not environment* for the other constructors.
> (scope_decl::scope_decl): Take or return environment&, not
> environment*.
> (type_base::type_base): Likewise.
> (scope_type_decl::scope_type_decl): Likewise.
> (namespace_decl::namespace_decl): Likewise.
> (qualified_type_def::qualified_type_def): Likewise.
> (pointer_type_def::pointer_type_def): Likewise.
> (reference_type_def::reference_type_def): Likewise.
> (array_type_def::subrange_type::subrange_type): Likewise.
> (enum_type_def::enumerator::enumerator): Likewise.
> (enum_type_def::enumerator::{get_name, get_qualified_name}):
> Return a string&, no more interned_string&. As the enumerator
> don't have an enumerator anymore, there is no way to intern the
> string anymore. Hopefully this won't incur a performance loss.
> (typedef_decl::typedef_decl, function_type::function_type)
> (method_type::method_type, template_decl::template_decl)
> (function_tdecl::function_tdecl, class_tdecl::class_tdecl)
> (class_or_union::class_or_union, class_decl::class_decl)
> (union_decl::union_decl): Take or return environment&, not
> environment*.
> * include/abg-reader.h (read_translation_unit_from_file)
> (read_translation_unit_from_buffer)
> (read_translation_unit_from_istream)
> (create_native_xml_read_context, create_native_xml_read_context)
> (read_corpus_from_native_xml, read_corpus_from_native_xml_file)
> (read_corpus_group_from_native_xml)
> (read_corpus_group_from_native_xml_file): Likewise.
> * include/abg-tools-utils.h
> (build_corpus_group_from_kernel_dist_under): Likewise.
> * src/abg-tools-utils.cc (maybe_load_vmlinux_dwarf_corpus)
> (maybe_load_vmlinux_ctf_corpus)
> (build_corpus_group_from_kernel_dist_under): Likewise.
> * include/abg-writer.h (create_write_context): Likewise.
> * src/abg-writer.cc (id_manager::m_env, id_manager::id_manager)
> (id_manager::get_environment, id_manager::get_id)
> (id_manager::get_id_with_prefix): Adjust.
> (write_context::m_env, write_context::write_context)
> (write_context::get_environment, write_context::get_config)
> (write_context::get_id_for_type, write_context::decl_is_emitted)
> (write_context::record_decl_as_emitted, create_write_context)
> (write_class_decl): Likewise.
> * src/abg-comparison.cc (compute_diff): Stop ensuring that the two
> artifacts being compare are in the same environment. Now that the
> environment is passed by reference, the potential for
> accendentally comparing artifacts coming from different
> environments is very low, given how the API is used in practice.
> This is in the overloads for decl_base_sptr, type_base_sptr,
> var_decl_sptr, pointer_type_def_sptr, array_type_def_sptr,
> reference_type_def_sptr, qualified_type_def_sptr,
> enum_type_decl_sptr, class_decl_sptr, class_decl::base_spec_sptr,
> union_decl_sptr, scope_decl_sptr, function_decl::parameter_sptr,
> function_type_sptr, function_decl_sptr, type_decl_sptr,
> typedef_decl_sptr, translation_unit_sptr, corpus_sptr.
> * src/abg-corpus-priv.h (corpus::priv::env): Make this be a
> reference to environments, not a pointer.
> (corpus::priv::priv): Pass environment&, not environment*.
> * src/abg-ir-priv.h (translation_unit::priv::env_): Make this an
> environment&, not an environment* anymore.
> (translation_unit::priv::priv): Take an environment&, not an
> environment*.
> (environment::priv::{confirm_ct_propagation_for_types_dependant_on,
> confirm_ct_propagation,
> cancel_ct_propagation_for_types_dependant_on,
> mark_as_being_compared, unmark_as_being_compared,
> comparison_started, mark_as_being_compared, comparison_started}):
> Adjust to use an environment&, not a pointer.
> * src/abg-ir.cc (class environment_setter): Remove this class.
> (push_composite_type_comparison_operands)
> (pop_composite_type_comparison_operands, try_canonical_compare)
> (return_comparison_result, translation_unit::{get_global_scope,
> bind_function_type_life_time}): Adjust.
> (translation_unit::{translation_unit, get_environment}): Take or
> get an environment&, not an environment*. Remove the getter that
> returns an environment*.
> (elf_symbol::priv::env_): Make this an environment&, not an
> environment*.
> (elf_symbol::priv::priv): Adjust.
> (elf_symbol::elf_symbol): Remove the default constructor. Change
> the one that takes an environment.
> (elf_symbol::create): Remove the default one. Adjust the one that
> takes an environment.
> (elf_symbol::get_environment): Adjust.
> (elf_symbol::set_environment_for_artifact): Remove.
> (environment::{get_void_type, get_variadic_parameter_type}):
> Adjust.
> (type_or_decl_base::priv::env_): Make this be a const
> environment&, not a const environment*.
> (type_or_decl_base::priv::priv): Adjust.
> (type_or_decl_base::type_or_decl_base): Remove the default and
> copy constructor.
> (type_or_decl_base::{set_environment, operator=})
> (set_environment_for_artifact): Remove.
> (type_or_decl_base::get_environment): Adjust.
> (decl_base::{decl_base, set_name, set_naming_typedef,
> set_linkage_name}): Adjust.
> (get_decl_name_for_comparison, strip_typedef)
> (strip_useless_const_qualification): Adjust.
> (scope_decl::{scope_decl, add_member_decl, insert_member_decl}):
> Adjust.
> (get_generic_anonymous_internal_type_name, get_type_name)
> (get_name_of_pointer_to_type, get_name_of_reference_to_type)
> (get_name_of_qualified_type, get_function_type_name)
> (get_method_type_name, is_void_pointer_type, lookup_basic_type)
> (lookup_union_type, lookup_union_type_per_location)
> (lookup_enum_type, lookup_typedef_type, lookup_pointer_type)
> (lookup_type, lookup_basic_type_per_location)
> (lookup_basic_type_per_location, lookup_basic_type)
> (lookup_class_type, lookup_class_types)
> (lookup_class_type_per_location, lookup_union_type)
> (lookup_enum_type, lookup_enum_types)
> (lookup_enum_type_per_location, lookup_typedef_type)
> (lookup_typedef_type_per_location, maybe_update_types_lookup_map)
> (maybe_update_types_lookup_map)
> (synthesize_type_from_translation_unit)
> (synthesize_function_type_from_translation_unit)
> (demangle_cplus_mangled_name, type_or_void)
> (types_defined_same_linux_kernel_corpus_public)
> (compare_types_during_canonicalization)
> (type_base::get_canonical_type_for, type_base::type_base)
> (type_base::get_cached_pretty_representation)
> (type_decl::type_decl, type_decl::get_qualified_name): Adjust.
> (scope_type_decl::scope_type_decl)
> (namespace_decl::namespace_decl, qualified_type_def::build_name)
> (qualified_type_def::qualified_type_def)
> (qualified_type_def::get_qualified_name)
> (qualified_type_def::set_underlying_type)
> (pointer_type_def::pointer_type_def)
> (pointer_type_def::set_pointed_to_type)
> (reference_type_def::reference_type_def)
> (reference_type_def::set_pointed_to_type)
> (array_type_def::subrange_type::subrange_type)
> (array_type_def::array_type_def, array_type_def::update_size)
> (array_type_def::set_element_type)
> (array_type_def::append_subranges)
> (array_type_def::get_qualified_name, enum_has_non_name_change):
> Adjust.
> (enum_type_decl::enumerator::priv::env_): Remove this pointer to
> env. This is because the enumerator must be copy-able. As the
> enumerator doesn't have an env anymore, it can't intern strings.
> So the enumerator name and qualified name is not going to be
> interned. If that incurs a performance hit, we'll reconsider this
> decision. For now, it seems to work OK. As it simplifies things,
> I am keeping this for now.
> (enum_type_decl::enumerator::priv::{name, qualified_name}): Make
> this be string, not interned_string.
> (enum_type_decl::enumerator::get_environment): Remove.
> (enum_type_decl::enumerator::priv::priv): Adjust.
> (enum_type_decl::enumerator::enumerator)
> (enum_type_decl::enumerator::operator=)
> (enum_type_decl::enumerator::get_name)
> (enum_type_decl::enumerator::get_qualified_name)
> (enum_type_decl::enumerator::set_name): Likewise.
> (typedef_decl::typedef_decl): Adjust.
> (var_decl::get_id, var_decl::get_qualified_name): Adjust.
> (function_type::function_type, method_type::method_type)
> (function_decl::get_pretty_representation_of_declarator)
> (function_decl::set_symbol): Likewise.
> (function_decl::get_id, function_decl::parameter::get_type)
> (function_decl::parameter::get_type_name)
> (function_decl::parameter::get_type_pretty_representation)
> (function_decl::parameter::get_name_id)
> (class_or_union::class_or_union, class_decl::class_decl)
> (class_decl::add_base_specifier, union_decl::union_decl)
> (union_decl::union_decl, template_decl::template_decl)
> (class_tdecl::class_tdecl)
> (maybe_cancel_propagated_canonical_type)
> (dump_classes_being_compared)
> (dump_fn_types_being_compared, copy_member_function)
> (maybe_propagate_canonical_type, keep_type_alive)
> (is_non_canonicalized_type, qualified_name_setter::do_update):
> Likewise.
> (equals): Adjust the overloads for var_decl, function_type,
> class_or_union, class_decl, union_decl.
> * src/abg-reader.cc (read_context::m_env): Make this be an
> environment&, not an environment*.
> (read_context::read_context): Adjust
> (read_context::set_environment): Remove.
> (read_context::{get_environment,
> maybe_check_abixml_canonical_type_stability}): Adjust.
> (read_corpus_from_input, read_corpus_group_from_native_xml)
> (read_corpus_group_from_native_xml_file)
> (read_translation_unit_from_file)
> (read_translation_unit_from_buffer, read_translation_unit)
> (maybe_map_type_with_type_id, build_namespace_decl)
> (build_elf_symbol, build_function_parameter, build_function_decl)
> (build_function_type, build_enum_type_decl, build_class_decl)
> (build_union_decl, build_function_tdecl, build_class_tdecl)
> (build_type_tparameter, read_translation_unit_from_istream)
> (create_native_xml_read_context, read_corpus_from_native_xml):
> Likewise.
> * src/abg-symtab-reader.h (symtab::load): Likewise.
> * src/abg-symtab-reader.cc (symtab::load): Likewise.
> * tests/print-diff-tree.cc (main): Likewise.
> * tests/test-abidiff.cc (main): Likewise.
> * tests/test-diff-dwarf.cc (main): Likewise.
> * tests/test-ir-walker.cc (main): Likewise.
> * tests/test-read-ctf.cc (test_task_ctf::perform): Likewise.
> * tests/test-symtab.cc (read_corpus): Likewise.
> * tools/abicompat.cc (read_corpus, main): Likewise.
> * tools/abidiff.cc (main): Likewise.
> * tools/abidw.cc (load_corpus_and_write_abixml)
> (load_kernel_corpus_group_and_write_abixml, main): Likewise.
> * tools/abilint.cc (main): Likewise.
> * tools/abipkgdiff.cc (compare, compare_to_self)
> (compare_prepared_linux_kernel_packages, compare_task::perform):
> Likewise.
> * tools/abisym.cc (main): Likewise.
> * tools/kmidiff.cc (main): Likewise.
>
> Signed-off-by: Dodji Seketeli <dodji@redhat.com>
> ---
> include/abg-corpus.h | 12 +-
> include/abg-ctf-reader.h | 5 +-
> include/abg-dwarf-reader.h | 9 +-
> include/abg-fwd.h | 2 +-
> include/abg-ir.h | 154 +++----
> include/abg-reader.h | 19 +-
> include/abg-tools-utils.h | 2 +-
> include/abg-writer.h | 2 +-
> src/abg-comparison.cc | 67 +--
> src/abg-corpus-priv.h | 6 +-
> src/abg-corpus.cc | 58 +--
> src/abg-ctf-reader.cc | 32 +-
> src/abg-dwarf-reader.cc | 115 +++---
> src/abg-ir-priv.h | 57 ++-
> src/abg-ir.cc | 815 +++++++++++++------------------------
> src/abg-reader.cc | 132 +++---
> src/abg-symtab-reader.cc | 5 +-
> src/abg-symtab-reader.h | 6 +-
> src/abg-tools-utils.cc | 27 +-
> src/abg-writer.cc | 39 +-
> tests/print-diff-tree.cc | 6 +-
> tests/test-abidiff.cc | 14 +-
> tests/test-diff-dwarf.cc | 6 +-
> tests/test-ir-walker.cc | 4 +-
> tests/test-read-ctf.cc | 5 +-
> tests/test-symtab.cc | 4 +-
> tools/abicompat.cc | 10 +-
> tools/abidiff.cc | 28 +-
> tools/abidw.cc | 28 +-
> tools/abilint.cc | 29 +-
> tools/abipkgdiff.cc | 32 +-
> tools/abisym.cc | 4 +-
> tools/kmidiff.cc | 8 +-
> 33 files changed, 642 insertions(+), 1100 deletions(-)
>
> diff --git a/include/abg-corpus.h b/include/abg-corpus.h
> index 27de8c2f..930f56de 100644
> --- a/include/abg-corpus.h
> +++ b/include/abg-corpus.h
> @@ -60,19 +60,13 @@ public:
> struct priv;
> std::unique_ptr<priv> priv_;
>
> - corpus(ir::environment*, const string& path= "");
> + corpus(const ir::environment&, const string& path= "");
>
> virtual ~corpus();
>
> - const environment*
> + const environment&
> get_environment() const;
>
> - environment*
> - get_environment();
> -
> - void
> - set_environment(environment*);
> -
> void
> add(const translation_unit_sptr);
>
> @@ -355,7 +349,7 @@ class corpus_group : public corpus
> public:
> typedef vector<corpus_sptr> corpora_type;
>
> - corpus_group(ir::environment*, const string&);
> + corpus_group(const ir::environment&, const string&);
>
> virtual ~corpus_group();
>
> diff --git a/include/abg-ctf-reader.h b/include/abg-ctf-reader.h
> index 0f49b5eb..93d20973 100644
> --- a/include/abg-ctf-reader.h
> +++ b/include/abg-ctf-reader.h
> @@ -32,7 +32,7 @@ typedef shared_ptr<read_context> read_context_sptr;
> read_context_sptr
> create_read_context(const std::string& elf_path,
> const vector<char**>& debug_info_root_paths,
> - ir::environment *env);
> + ir::environment& env);
> corpus_sptr
> read_corpus(read_context *ctxt, elf_reader::status& status);
>
> @@ -48,8 +48,7 @@ set_read_context_corpus_group(read_context& ctxt, corpus_group_sptr& group);
> void
> reset_read_context(read_context_sptr &ctxt,
> const std::string& elf_path,
> - const vector<char**>& debug_info_root_path,
> - ir::environment* environment);
> + const vector<char**>& debug_info_root_path);
> std::string
> dic_type_key(ctf_dict_t *dic, ctf_id_t ctf_type);
> } // end namespace ctf_reader
> diff --git a/include/abg-dwarf-reader.h b/include/abg-dwarf-reader.h
> index 5766f906..a127f7ce 100644
> --- a/include/abg-dwarf-reader.h
> +++ b/include/abg-dwarf-reader.h
> @@ -53,7 +53,7 @@ typedef shared_ptr<read_context> read_context_sptr;
> read_context_sptr
> create_read_context(const std::string& elf_path,
> const vector<char**>& debug_info_root_paths,
> - ir::environment* environment,
> + ir::environment& environment,
> bool read_all_types = false,
> bool linux_kernel_mode = false);
>
> @@ -64,7 +64,6 @@ void
> reset_read_context(read_context_sptr &ctxt,
> const std::string& elf_path,
> const vector<char**>& debug_info_root_paths,
> - ir::environment* environment,
> bool read_all_types = false,
> bool linux_kernel_mode = false);
>
> @@ -81,7 +80,7 @@ read_corpus_from_elf(read_context& ctxt, elf_reader::status& stat);
> corpus_sptr
> read_corpus_from_elf(const std::string& elf_path,
> const vector<char**>& debug_info_root_paths,
> - ir::environment* environment,
> + ir::environment& environment,
> bool load_all_types,
> elf_reader::status&);
>
> @@ -89,14 +88,14 @@ corpus_sptr
> read_and_add_corpus_to_group_from_elf(read_context&, corpus_group&, elf_reader::status&);
>
> bool
> -lookup_symbol_from_elf(const environment* env,
> +lookup_symbol_from_elf(environment& env,
> const string& elf_path,
> const string& symbol_name,
> bool demangle,
> vector<elf_symbol_sptr>& symbols);
>
> bool
> -lookup_public_function_symbol_from_elf(const environment* env,
> +lookup_public_function_symbol_from_elf(environment& env,
> const string& path,
> const string& symname,
> vector<elf_symbol_sptr>& func_syms);
> diff --git a/include/abg-fwd.h b/include/abg-fwd.h
> index 1dbe99bb..33087b90 100644
> --- a/include/abg-fwd.h
> +++ b/include/abg-fwd.h
> @@ -1384,7 +1384,7 @@ string
> demangle_cplus_mangled_name(const string&);
>
> type_base_sptr
> -type_or_void(const type_base_sptr, const environment*);
> +type_or_void(const type_base_sptr, const environment&);
>
> type_base_sptr
> canonicalize(type_base_sptr);
> diff --git a/include/abg-ir.h b/include/abg-ir.h
> index 4892f0e2..ee24891d 100644
> --- a/include/abg-ir.h
> +++ b/include/abg-ir.h
> @@ -689,21 +689,15 @@ public:
> };
>
> public:
> - translation_unit(const ir::environment* env,
> + translation_unit(const ir::environment& env,
> const std::string& path,
> char address_size = 0);
>
> virtual ~translation_unit();
>
> - const environment*
> + const environment&
> get_environment() const;
>
> - environment*
> - get_environment();
> -
> - void
> - set_environment(const environment*);
> -
> language
> get_language() const;
>
> @@ -929,7 +923,7 @@ private:
>
> elf_symbol();
>
> - elf_symbol(const environment* e,
> + elf_symbol(const environment& e,
> size_t i,
> size_t s,
> const string& n,
> @@ -952,30 +946,24 @@ private:
> public:
>
> static elf_symbol_sptr
> - create();
> -
> - static elf_symbol_sptr
> - create(const environment* e,
> - size_t i,
> - size_t s,
> - const string& n,
> - type t,
> - binding b,
> - bool d,
> - bool c,
> - const version& ve,
> - visibility vi,
> - bool is_in_ksymtab = false,
> + create(const environment& e,
> + size_t i,
> + size_t s,
> + const string& n,
> + type t,
> + binding b,
> + bool d,
> + bool c,
> + const version& ve,
> + visibility vi,
> + bool is_in_ksymtab = false,
> const abg_compat::optional<uint64_t>& crc = {},
> const abg_compat::optional<std::string>& ns = {},
> - bool is_suppressed = false);
> + bool is_suppressed = false);
>
> - const environment*
> + const environment&
> get_environment() const;
>
> - void
> - set_environment(const environment*) const;
> -
> size_t
> get_index() const;
>
> @@ -1340,6 +1328,7 @@ class type_or_decl_base : public ir_traversable_base
> mutable std::unique_ptr<priv> priv_;
>
> type_or_decl_base();
> + type_or_decl_base(const type_or_decl_base&);
>
> protected:
>
> @@ -1399,13 +1388,14 @@ protected:
>
> void hashing_started(bool) const;
>
> + type_or_decl_base&
> + operator=(const type_or_decl_base&);
> +
> public:
>
> - type_or_decl_base(const environment*,
> + type_or_decl_base(const environment&,
> enum type_or_decl_kind k = ABSTRACT_TYPE_OR_DECL);
>
> - type_or_decl_base(const type_or_decl_base&);
> -
> virtual ~type_or_decl_base();
>
> bool
> @@ -1414,15 +1404,9 @@ public:
> void
> set_is_artificial(bool);
>
> - const environment*
> + const environment&
> get_environment() const;
>
> - environment*
> - get_environment();
> -
> - void
> - set_environment(const environment*);
> -
> void
> set_artificial_location(const location &);
>
> @@ -1447,9 +1431,6 @@ public:
> translation_unit*
> get_translation_unit();
>
> - type_or_decl_base&
> - operator=(const type_or_decl_base&);
> -
> virtual bool
> traverse(ir_node_visitor&);
>
> @@ -1511,14 +1492,6 @@ operator==(const type_or_decl_base_sptr&, const type_or_decl_base_sptr&);
> bool
> operator!=(const type_or_decl_base_sptr&, const type_or_decl_base_sptr&);
>
> -void
> -set_environment_for_artifact(type_or_decl_base* artifact,
> - const environment* env);
> -
> -void
> -set_environment_for_artifact(type_or_decl_base_sptr artifact,
> - const environment* env);
> -
> /// The base type of all declarations.
> class decl_base : public virtual type_or_decl_base
> {
> @@ -1591,23 +1564,22 @@ protected:
>
> void
> set_context_rel(context_rel *c);
> + decl_base(const decl_base&);
>
> public:
> - decl_base(const environment* e,
> + decl_base(const environment& e,
> const string& name,
> const location& locus,
> const string& mangled_name = "",
> visibility vis = VISIBILITY_DEFAULT);
>
> - decl_base(const environment* e,
> + decl_base(const environment& e,
> const interned_string& name,
> const location& locus,
> const interned_string& mangled_name = interned_string(),
> visibility vis = VISIBILITY_DEFAULT);
>
> - decl_base(const environment*, const location&);
> -
> - decl_base(const decl_base&);
> + decl_base(const environment&, const location&);
>
> virtual bool
> operator==(const decl_base&) const;
> @@ -1821,11 +1793,11 @@ protected:
> public:
> struct hash;
>
> - scope_decl(const environment* env,
> + scope_decl(const environment& env,
> const string& name, const location& locus,
> visibility vis = VISIBILITY_DEFAULT);
>
> - scope_decl(const environment* env, location& l);
> + scope_decl(const environment& env, location& l);
>
> virtual size_t
> get_hash() const;
> @@ -2000,7 +1972,7 @@ public:
> /// runtime type of the type pointed to.
> struct shared_ptr_hash;
>
> - type_base(const environment* e, size_t s, size_t a);
> + type_base(const environment& e, size_t s, size_t a);
>
> friend type_base_sptr canonicalize(type_base_sptr);
>
> @@ -2104,7 +2076,7 @@ public:
> /// Facility to hash instance of type_decl
> struct hash;
>
> - type_decl(const environment* env,
> + type_decl(const environment& env,
> const string& name,
> size_t size_in_bits,
> size_t alignment_in_bits,
> @@ -2159,7 +2131,7 @@ public:
> /// Hasher for instances of scope_type_decl
> struct hash;
>
> - scope_type_decl(const environment* env, const string& name,
> + scope_type_decl(const environment& env, const string& name,
> size_t size_in_bits, size_t alignment_in_bits,
> const location& locus, visibility vis = VISIBILITY_DEFAULT);
>
> @@ -2180,7 +2152,7 @@ class namespace_decl : public scope_decl
> {
> public:
>
> - namespace_decl(const environment* env, const string& name,
> + namespace_decl(const environment& env, const string& name,
> const location& locus, visibility vis = VISIBILITY_DEFAULT);
>
> virtual string
> @@ -2234,7 +2206,7 @@ public:
>
> qualified_type_def(type_base_sptr type, CV quals, const location& locus);
>
> - qualified_type_def(environment* env, CV quals, const location& locus);
> + qualified_type_def(const environment& env, CV quals, const location& locus);
>
> virtual size_t
> get_size_in_bits() const;
> @@ -2335,10 +2307,9 @@ public:
> pointer_type_def(const type_base_sptr& pointed_to_type, size_t size_in_bits,
> size_t alignment_in_bits, const location& locus);
>
> - pointer_type_def(environment* env, size_t size_in_bits,
> + pointer_type_def(const environment& env, size_t size_in_bits,
> size_t alignment_in_bits, const location& locus);
>
> -
> void
> set_pointed_to_type(const type_base_sptr&);
>
> @@ -2400,7 +2371,7 @@ public:
> bool lvalue, size_t size_in_bits,
> size_t alignment_in_bits, const location& locus);
>
> - reference_type_def(const environment* env, bool lvalue, size_t size_in_bits,
> + reference_type_def(const environment& env, bool lvalue, size_t size_in_bits,
> size_t alignment_in_bits, const location& locus);
>
> void
> @@ -2522,7 +2493,7 @@ public:
> /// Hasher for an instance of array::subrange
> struct hash;
>
> - subrange_type(const environment* env,
> + subrange_type(const environment& env,
> const string& name,
> bound_value lower_bound,
> bound_value upper_bound,
> @@ -2530,14 +2501,14 @@ public:
> const location& loc,
> translation_unit::language l = translation_unit::LANG_C11);
>
> - subrange_type(const environment* env,
> + subrange_type(const environment& env,
> const string& name,
> bound_value lower_bound,
> bound_value upper_bound,
> const location& loc,
> translation_unit::language l = translation_unit::LANG_C11);
>
> - subrange_type(const environment* env,
> + subrange_type(const environment& env,
> const string& name,
> bound_value upper_bound,
> const location& loc,
> @@ -2603,7 +2574,7 @@ public:
> const std::vector<subrange_sptr>& subs,
> const location& locus);
>
> - array_type_def(environment* env,
> + array_type_def(const environment& env,
> const std::vector<subrange_sptr>& subs,
> const location& locus);
>
> @@ -2761,7 +2732,7 @@ public:
>
> ~enumerator();
>
> - enumerator(const environment* env, const string& name, int64_t value);
> + enumerator(const string& name, int64_t value);
>
> enumerator(const enumerator&);
>
> @@ -2774,13 +2745,10 @@ public:
> bool
> operator!=(const enumerator& other) const;
>
> - const environment*
> - get_environment() const;
> -
> - const interned_string&
> + const string&
> get_name() const;
>
> - const interned_string&
> + const string&
> get_qualified_name(bool internal = false) const;
>
> void
> @@ -2823,7 +2791,7 @@ public:
> visibility vis = VISIBILITY_DEFAULT);
>
> typedef_decl(const string& name,
> - environment* env,
> + const environment& env,
> const location& locus,
> const string& mangled_name = "",
> visibility vis = VISIBILITY_DEFAULT);
> @@ -3320,7 +3288,7 @@ public:
> size_t size_in_bits,
> size_t alignment_in_bits);
>
> - function_type(const environment* env,
> + function_type(const environment& env,
> size_t size_in_bits,
> size_t alignment_in_bits);
>
> @@ -3415,7 +3383,7 @@ public:
> size_t size_in_bits,
> size_t alignment_in_bits);
>
> - method_type(const environment* env,
> + method_type(const environment& env,
> size_t size_in_bits,
> size_t alignment_in_bits);
>
> @@ -3452,7 +3420,7 @@ public:
> /// Hasher.
> struct hash;
>
> - template_decl(const environment* env,
> + template_decl(const environment& env,
> const string& name,
> const location& locus,
> visibility vis = VISIBILITY_DEFAULT);
> @@ -3683,7 +3651,7 @@ public:
> struct hash;
> struct shared_ptr_hash;
>
> - function_tdecl(const environment* env,
> + function_tdecl(const environment& env,
> const location& locus,
> visibility vis = VISIBILITY_DEFAULT,
> binding bind = BINDING_NONE);
> @@ -3732,7 +3700,7 @@ public:
> struct hash;
> struct shared_ptr_hash;
>
> - class_tdecl(const environment* env, const location& locus,
> + class_tdecl(const environment& env, const location& locus,
> visibility vis = VISIBILITY_DEFAULT);
>
> class_tdecl(class_decl_sptr pattern,
> @@ -3953,17 +3921,17 @@ public:
> typedef unordered_map<string, method_decl_sptr> string_mem_fn_sptr_map_type;
> /// @}
>
> - class_or_union(const environment* env, const string& name,
> + class_or_union(const environment& env, const string& name,
> size_t size_in_bits, size_t align_in_bits,
> const location& locus, visibility vis,
> member_types& mbrs, data_members& data_mbrs,
> member_functions& member_fns);
>
> - class_or_union(const environment* env, const string& name,
> + class_or_union(const environment& env, const string& name,
> size_t size_in_bits, size_t align_in_bits,
> const location& locus, visibility vis);
>
> - class_or_union(const environment* env, const string& name,
> + class_or_union(const environment& env, const string& name,
> bool is_declaration_only = true);
>
> virtual void
> @@ -4159,30 +4127,30 @@ private:
>
> public:
>
> - class_decl(const environment* env, const string& name,
> + class_decl(const environment& env, const string& name,
> size_t size_in_bits, size_t align_in_bits,
> bool is_struct, const location& locus,
> visibility vis, base_specs& bases,
> member_types& mbrs, data_members& data_mbrs,
> member_functions& member_fns);
>
> - class_decl(const environment* env, const string& name,
> + class_decl(const environment& env, const string& name,
> size_t size_in_bits, size_t align_in_bits,
> bool is_struct, const location& locus,
> visibility vis, base_specs& bases,
> member_types& mbrs, data_members& data_mbrs,
> member_functions& member_fns, bool is_anonymous);
>
> - class_decl(const environment* env, const string& name,
> + class_decl(const environment& env, const string& name,
> size_t size_in_bits, size_t align_in_bits,
> bool is_struct, const location& locus, visibility vis);
>
> - class_decl(const environment* env, const string& name,
> + class_decl(const environment& env, const string& name,
> size_t size_in_bits, size_t align_in_bits,
> bool is_struct, const location& locus,
> visibility vis, bool is_anonymous);
>
> - class_decl(const environment* env, const string& name, bool is_struct,
> + class_decl(const environment& env, const string& name, bool is_struct,
> bool is_declaration_only = true);
>
> virtual string
> @@ -4376,26 +4344,26 @@ class union_decl : public class_or_union
>
> public:
>
> - union_decl(const environment* env, const string& name,
> + union_decl(const environment& env, const string& name,
> size_t size_in_bits, const location& locus,
> visibility vis, member_types& mbrs,
> data_members& data_mbrs, member_functions& member_fns);
>
> - union_decl(const environment* env, const string& name,
> + union_decl(const environment& env, const string& name,
> size_t size_in_bits, const location& locus,
> visibility vis, member_types& mbrs,
> data_members& data_mbrs, member_functions& member_fns,
> bool is_anonymous);
>
> - union_decl(const environment* env, const string& name,
> + union_decl(const environment& env, const string& name,
> size_t size_in_bits, const location& locus,
> visibility vis);
>
> - union_decl(const environment* env, const string& name,
> + union_decl(const environment& env, const string& name,
> size_t size_in_bits, const location& locus,
> visibility vis, bool is_anonymous);
>
> - union_decl(const environment* env, const string& name,
> + union_decl(const environment& env, const string& name,
> bool is_declaration_only = true);
>
> virtual string
> diff --git a/include/abg-reader.h b/include/abg-reader.h
> index 624311bc..eb50482c 100644
> --- a/include/abg-reader.h
> +++ b/include/abg-reader.h
> @@ -30,15 +30,15 @@ class read_context;
>
> translation_unit_sptr
> read_translation_unit_from_file(const std::string& file_path,
> - environment* env);
> + environment& env);
>
> translation_unit_sptr
> read_translation_unit_from_buffer(const std::string& file_path,
> - environment* env);
> + environment& env);
>
> translation_unit_sptr
> read_translation_unit_from_istream(std::istream* in,
> - environment* env);
> + environment& env);
>
> translation_unit_sptr
> read_translation_unit(read_context&);
> @@ -47,21 +47,20 @@ read_translation_unit(read_context&);
> typedef shared_ptr<read_context> read_context_sptr;
>
> read_context_sptr
> -create_native_xml_read_context(const string& path, environment *env);
> +create_native_xml_read_context(const string& path, environment& env);
>
> read_context_sptr
> -create_native_xml_read_context(std::istream* in, environment* env);
> -
> +create_native_xml_read_context(std::istream* in, environment& env);
> const string&
> read_context_get_path(const read_context&);
>
> corpus_sptr
> read_corpus_from_native_xml(std::istream* in,
> - environment* env);
> + environment& env);
>
> corpus_sptr
> read_corpus_from_native_xml_file(const string& path,
> - environment* env);
> + environment& env);
>
> corpus_sptr
> read_corpus_from_input(read_context& ctxt);
> @@ -71,11 +70,11 @@ read_corpus_group_from_input(read_context& ctxt);
>
> corpus_group_sptr
> read_corpus_group_from_native_xml(std::istream* in,
> - environment* env);
> + environment& env);
>
> corpus_group_sptr
> read_corpus_group_from_native_xml_file(const string& path,
> - environment* env);
> + environment& env);
>
> void
> add_read_context_suppressions(read_context& ctxt,
> diff --git a/include/abg-tools-utils.h b/include/abg-tools-utils.h
> index 27bbfefe..c442c7c4 100644
> --- a/include/abg-tools-utils.h
> +++ b/include/abg-tools-utils.h
> @@ -311,7 +311,7 @@ build_corpus_group_from_kernel_dist_under(const string& root,
> vector<string>& kabi_wl_paths,
> suppr::suppressions_type& supprs,
> bool verbose,
> - environment_sptr& env,
> + environment& env,
> corpus::origin origin = corpus::DWARF_ORIGIN);
> }// end namespace tools_utils
>
> diff --git a/include/abg-writer.h b/include/abg-writer.h
> index ab01b486..58f60b74 100644
> --- a/include/abg-writer.h
> +++ b/include/abg-writer.h
> @@ -36,7 +36,7 @@ class write_context;
> typedef shared_ptr<write_context> write_context_sptr;
>
> write_context_sptr
> -create_write_context(const environment *env,
> +create_write_context(const environment& env,
> ostream& output_stream);
>
> void
> diff --git a/src/abg-comparison.cc b/src/abg-comparison.cc
> index 6e3b2b55..0868d384 100644
> --- a/src/abg-comparison.cc
> +++ b/src/abg-comparison.cc
> @@ -3133,8 +3133,6 @@ compute_diff(const decl_base_sptr first,
> if (!first || !second)
> return diff_sptr();
>
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> diff_sptr d;
> if (is_type(first) && is_type(second))
> d = compute_diff_for_types(first, second, ctxt);
> @@ -3165,9 +3163,6 @@ compute_diff(const type_base_sptr first,
> decl_base_sptr f = get_type_declaration(first),
> s = get_type_declaration(second);
>
> - if (first && second)
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> diff_sptr d = compute_diff_for_types(f,s, ctxt);
> ABG_ASSERT(d);
> return d;
> @@ -3317,9 +3312,6 @@ compute_diff(const var_decl_sptr first,
> const var_decl_sptr second,
> diff_context_sptr ctxt)
> {
> - if (first && second)
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> var_diff_sptr d(new var_diff(first, second, diff_sptr(), ctxt));
> ctxt->initialize_canonical_diff(d);
>
> @@ -3451,9 +3443,6 @@ compute_diff(pointer_type_def_sptr first,
> pointer_type_def_sptr second,
> diff_context_sptr ctxt)
> {
> - if (first && second)
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> diff_sptr d = compute_diff_for_types(first->get_pointed_to_type(),
> second->get_pointed_to_type(),
> ctxt);
> @@ -3607,9 +3596,6 @@ compute_diff(array_type_def_sptr first,
> array_type_def_sptr second,
> diff_context_sptr ctxt)
> {
> - if (first && second)
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> diff_sptr d = compute_diff_for_types(first->get_element_type(),
> second->get_element_type(),
> ctxt);
> @@ -3742,9 +3728,6 @@ compute_diff(reference_type_def_sptr first,
> reference_type_def_sptr second,
> diff_context_sptr ctxt)
> {
> - if (first && second)
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> diff_sptr d = compute_diff_for_types(first->get_pointed_to_type(),
> second->get_pointed_to_type(),
> ctxt);
> @@ -3892,9 +3875,6 @@ compute_diff(const qualified_type_def_sptr first,
> const qualified_type_def_sptr second,
> diff_context_sptr ctxt)
> {
> - if (first && second)
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> diff_sptr d = compute_diff_for_types(first->get_underlying_type(),
> second->get_underlying_type(),
> ctxt);
> @@ -4110,9 +4090,6 @@ compute_diff(const enum_type_decl_sptr first,
> const enum_type_decl_sptr second,
> diff_context_sptr ctxt)
> {
> - if (first && second)
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> diff_sptr ud = compute_diff_for_types(first->get_underlying_type(),
> second->get_underlying_type(),
> ctxt);
> @@ -5596,9 +5573,6 @@ compute_diff(const class_decl_sptr first,
> const class_decl_sptr second,
> diff_context_sptr ctxt)
> {
> - if (first && second)
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> class_decl_sptr f = is_class_type(look_through_decl_only_class(first)),
> s = is_class_type(look_through_decl_only_class(second));
>
> @@ -5821,15 +5795,6 @@ compute_diff(const class_decl::base_spec_sptr first,
> const class_decl::base_spec_sptr second,
> diff_context_sptr ctxt)
> {
> - if (first && second)
> - {
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> - ABG_ASSERT(first->get_base_class()->get_environment()
> - == second->get_base_class()->get_environment());
> - ABG_ASSERT(first->get_environment()
> - == first->get_base_class()->get_environment());
> - }
> -
> class_diff_sptr cl = compute_diff(first->get_base_class(),
> second->get_base_class(),
> ctxt);
> @@ -5945,9 +5910,6 @@ compute_diff(const union_decl_sptr first,
> const union_decl_sptr second,
> diff_context_sptr ctxt)
> {
> - if (first && second)
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> union_diff_sptr changes(new union_diff(first, second, ctxt));
>
> ctxt->initialize_canonical_diff(changes);
> @@ -6449,9 +6411,6 @@ compute_diff(const scope_decl_sptr first,
> {
> ABG_ASSERT(d->first_scope() == first && d->second_scope() == second);
>
> - if (first && second)
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> compute_diff(first->get_member_decls().begin(),
> first->get_member_decls().end(),
> second->get_member_decls().begin(),
> @@ -6482,10 +6441,6 @@ compute_diff(const scope_decl_sptr first_scope,
> const scope_decl_sptr second_scope,
> diff_context_sptr ctxt)
> {
> - if (first_scope && second_scope)
> - ABG_ASSERT(first_scope->get_environment()
> - == second_scope->get_environment());
> -
> scope_diff_sptr d(new scope_diff(first_scope, second_scope, ctxt));
> d = compute_diff(first_scope, second_scope, d, ctxt);
> ctxt->initialize_canonical_diff(d);
> @@ -6632,8 +6587,6 @@ compute_diff(const function_decl::parameter_sptr first,
> if (!first || !second)
> return fn_parm_diff_sptr();
>
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> fn_parm_diff_sptr result(new fn_parm_diff(first, second, ctxt));
> ctxt->initialize_canonical_diff(result);
>
> @@ -6930,8 +6883,6 @@ compute_diff(const function_type_sptr first,
> return function_type_diff_sptr();
> }
>
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> function_type_diff_sptr result(new function_type_diff(first, second, ctxt));
>
> diff_utils::compute_diff(first->get_first_parm(),
> @@ -7072,8 +7023,6 @@ compute_diff(const function_decl_sptr first,
> return function_decl_diff_sptr();
> }
>
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> function_type_diff_sptr type_diff = compute_diff(first->get_type(),
> second->get_type(),
> ctxt);
> @@ -7196,9 +7145,6 @@ compute_diff(const type_decl_sptr first,
> const type_decl_sptr second,
> diff_context_sptr ctxt)
> {
> - if (first && second)
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> type_decl_diff_sptr result(new type_decl_diff(first, second, ctxt));
>
> // We don't need to actually compute a diff here as a type_decl
> @@ -7349,9 +7295,6 @@ compute_diff(const typedef_decl_sptr first,
> const typedef_decl_sptr second,
> diff_context_sptr ctxt)
> {
> - if (first && second)
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> diff_sptr d = compute_diff_for_types(first->get_underlying_type(),
> second->get_underlying_type(),
> ctxt);
> @@ -7470,8 +7413,6 @@ compute_diff(const translation_unit_sptr first,
> {
> ABG_ASSERT(first && second);
>
> - ABG_ASSERT(first->get_environment() == second->get_environment());
> -
> if (!ctxt)
> ctxt.reset(new diff_context);
>
> @@ -10929,10 +10870,6 @@ compute_diff(const corpus_sptr f,
>
> ABG_ASSERT(f && s);
>
> - // We can only compare two corpora that were built out of the same
> - // environment.
> - ABG_ASSERT(f->get_environment() == s->get_environment());
> -
> if (!ctxt)
> ctxt.reset(new diff_context);
>
> @@ -12272,11 +12209,11 @@ is_diff_of_variadic_parameter_type(const diff* d)
> return false;
>
> type_base_sptr t = is_type(d->first_subject());
> - if (t && t->get_environment()->is_variadic_parameter_type(t))
> + if (t && t->get_environment().is_variadic_parameter_type(t))
> return true;
>
> t = is_type(d->second_subject());
> - if (t && t->get_environment()->is_variadic_parameter_type(t))
> + if (t && t->get_environment().is_variadic_parameter_type(t))
> return true;
>
> return false;
> diff --git a/src/abg-corpus-priv.h b/src/abg-corpus-priv.h
> index 8719be56..74dc9448 100644
> --- a/src/abg-corpus-priv.h
> +++ b/src/abg-corpus-priv.h
> @@ -667,7 +667,7 @@ struct corpus::priv
> mutable unordered_map<string, type_base_sptr> canonical_types_;
> string format_major_version_number_;
> string format_minor_version_number_;
> - environment* env;
> + const environment& env;
> corpus_group* group;
> corpus::exported_decls_builder_sptr exported_decls_builder;
> corpus::origin origin_;
> @@ -717,8 +717,8 @@ private:
> mutable abg_compat::optional<elf_symbols> unrefed_fun_symbols;
>
> public:
> - priv(const string & p,
> - environment* e)
> + priv(const string & p,
> + const environment& e)
> : env(e),
> group(),
> origin_(ARTIFICIAL_ORIGIN),
> diff --git a/src/abg-corpus.cc b/src/abg-corpus.cc
> index 0b23667f..a42cbaa1 100644
> --- a/src/abg-corpus.cc
> +++ b/src/abg-corpus.cc
> @@ -596,7 +596,7 @@ corpus::priv::~priv()
> /// @param env the environment of the corpus.
> ///
> /// @param path the path to the file containing the ABI corpus.
> -corpus::corpus(ir::environment* env, const string& path)
> +corpus::corpus(const ir::environment& env, const string& path)
> {
> priv_.reset(new priv(path, env));
> init_format_version();
> @@ -607,27 +607,10 @@ corpus::~corpus() = default;
> /// Getter of the enviroment of the corpus.
> ///
> /// @return the environment of this corpus.
> -const environment*
> +const environment&
> corpus::get_environment() const
> {return priv_->env;}
>
> -/// Getter of the enviroment of the corpus.
> -///
> -/// @return the environment of this corpus.
> -environment*
> -corpus::get_environment()
> -{return priv_->env;}
> -
> -/// Setter of the environment of this corpus.
> -///
> -/// @param e the new environment.
> -void
> -corpus::set_environment(environment* e)
> -{
> - priv_->env = e;
> - init_format_version();
> -}
> -
> /// Add a translation unit to the current ABI Corpus. Next time
> /// corpus::save is called, all the translation unit that got added to
> /// the corpus are going to be serialized on disk in the file
> @@ -641,11 +624,6 @@ corpus::set_environment(environment* e)
> void
> corpus::add(const translation_unit_sptr tu)
> {
> - if (!tu->get_environment())
> - tu->set_environment(get_environment());
> -
> - ABG_ASSERT(tu->get_environment() == get_environment());
> -
> ABG_ASSERT(priv_->members.insert(tu).second);
>
> if (!tu->get_absolute_path().empty())
> @@ -741,7 +719,7 @@ void
> corpus::record_type_as_reachable_from_public_interfaces(const type_base& t)
> {
> string repr = get_pretty_representation(&t, /*internal=*/true);
> - interned_string s = t.get_environment()->intern(repr);
> + interned_string s = t.get_environment().intern(repr);
> priv_->get_public_types_pretty_representations()->insert(s);
> }
>
> @@ -759,7 +737,7 @@ bool
> corpus::type_is_reachable_from_public_interfaces(const type_base& t) const
> {
> string repr = get_pretty_representation(&t, /*internal=*/true);
> - interned_string s = t.get_environment()->intern(repr);
> + interned_string s = t.get_environment().intern(repr);
>
> return (priv_->get_public_types_pretty_representations()->find(s)
> != priv_->get_public_types_pretty_representations()->end());
> @@ -839,13 +817,10 @@ corpus::set_group(corpus_group* g)
> void
> corpus::init_format_version()
> {
> - if (priv_->env)
> - {
> - set_format_major_version_number
> - (priv_->env->get_config().get_format_major_version_number());
> - set_format_minor_version_number
> - (priv_->env->get_config().get_format_minor_version_number());
> - }
> + set_format_major_version_number
> + (priv_->env.get_config().get_format_major_version_number());
> + set_format_minor_version_number
> + (priv_->env.get_config().get_format_minor_version_number());
> }
>
> /// Getter for the origin of the corpus.
> @@ -1690,8 +1665,12 @@ struct corpus_group::priv
> }
> }; // end corpus_group::priv
>
> -/// Default constructor of the @ref corpus_group type.
> -corpus_group::corpus_group(environment* env, const string& path = "")
> +/// Constructor of the @ref corpus_group type.
> +///
> +/// @param env the environment of the @ref corpus_group.
> +///
> +/// @param path the path to the file represented by the corpus group.
> +corpus_group::corpus_group(const environment& env, const string& path = "")
> : corpus(env, path), priv_(new priv)
> {}
>
> @@ -1708,15 +1687,6 @@ corpus_group::add_corpus(const corpus_sptr& corp)
> if (!corp)
> return;
>
> - // Ensure the new environment patches the current one.
> - if (const environment* cur_env = get_environment())
> - {
> - if (environment* corp_env = corp->get_environment())
> - ABG_ASSERT(cur_env == corp_env);
> - }
> - else
> - set_environment(corp->get_environment());
> -
> // Ensure the new architecture name matches the current one.
> string cur_arch = get_architecture_name(),
> corp_arch = corp->get_architecture_name();
> diff --git a/src/abg-ctf-reader.cc b/src/abg-ctf-reader.cc
> index e307fcd7..49dd69df 100644
> --- a/src/abg-ctf-reader.cc
> +++ b/src/abg-ctf-reader.cc
> @@ -54,7 +54,7 @@ public:
> string filename;
>
> /// The IR environment.
> - ir::environment *ir_env;
> + ir::environment& ir_env;
>
> /// The CTF archive read from FILENAME. If an archive couldn't
> /// be read from the file then this is NULL.
> @@ -271,10 +271,10 @@ public:
> /// created within the same environment.
> read_context(const string& elf_path,
> const vector<char**>& debug_info_root_paths,
> - ir::environment *env) :
> - ctfa(NULL)
> + ir::environment& env) :
> + ir_env(env), ctfa(nullptr)
> {
> - initialize(elf_path, debug_info_root_paths, env);
> + initialize(elf_path, debug_info_root_paths);
> }
>
> /// Initializer of read_context.
> @@ -297,12 +297,10 @@ public:
> /// the environment.
> void
> initialize(const string& elf_path,
> - const vector<char**>& debug_info_root_paths,
> - ir::environment *env)
> + const vector<char**>& debug_info_root_paths)
> {
> types_map.clear();
> filename = elf_path;
> - ir_env = env;
> elf_handler = NULL;
> elf_handler_dbg = NULL;
> elf_fd = -1;
> @@ -425,7 +423,7 @@ process_ctf_base_type(read_context *ctxt,
> && type_encoding.cte_format == CTF_INT_SIGNED)
> {
> /* This is the `void' type. */
> - type_base_sptr void_type = ctxt->ir_env->get_void_type();
> + type_base_sptr void_type = ctxt->ir_env.get_void_type();
> decl_base_sptr type_declaration = get_type_declaration(void_type);
> result = is_type_decl(type_declaration);
> canonicalize(result);
> @@ -472,9 +470,8 @@ build_ir_node_for_variadic_parameter_type(read_context &ctxt,
> translation_unit_sptr tunit)
> {
>
> - ir::environment* env = ctxt.ir_env;
> - ABG_ASSERT(env);
> - type_base_sptr t = env->get_variadic_parameter_type();
> + ir::environment& env = ctxt.ir_env;
> + type_base_sptr t = env.get_variadic_parameter_type();
> decl_base_sptr type_declaration = get_type_declaration(t);
> if (!has_scope(type_declaration))
> add_decl_to_scope(type_declaration, tunit->get_global_scope());
> @@ -1041,7 +1038,7 @@ process_ctf_enum_type(read_context *ctxt,
> int evalue;
>
> while ((ename = ctf_enum_next(ctf_dictionary, ctf_type, &enum_next, &evalue)))
> - enms.push_back(enum_type_decl::enumerator(ctxt->ir_env, ename, evalue));
> + enms.push_back(enum_type_decl::enumerator(ename, evalue));
> if (ctf_errno(ctf_dictionary) != ECTF_NEXT_END)
> {
> fprintf(stderr, "ERROR from ctf_enum_next\n");
> @@ -1618,7 +1615,7 @@ find_ctfa_file(read_context *ctxt, std::string& ctfa_file)
> read_context_sptr
> create_read_context(const std::string& elf_path,
> const vector<char**>& debug_info_root_paths,
> - ir::environment *env)
> + ir::environment& env)
> {
> read_context_sptr result(new read_context(elf_path,
> debug_info_root_paths,
> @@ -1687,7 +1684,7 @@ read_corpus(read_context *ctxt, elf_reader::status &status)
> ctxt->ctfa = ctf_arc_bufopen(&ctxt->ctf_sect, &ctxt->symtab_sect,
> &ctxt->strtab_sect, &errp);
>
> - ctxt->ir_env->canonicalization_is_done(false);
> + ctxt->ir_env.canonicalization_is_done(false);
> if (ctxt->ctfa == NULL)
> status |= elf_reader::STATUS_DEBUG_INFO_NOT_FOUND;
> else
> @@ -1697,7 +1694,7 @@ read_corpus(read_context *ctxt, elf_reader::status &status)
> ctxt->cur_corpus_->sort_variables();
> }
>
> - ctxt->ir_env->canonicalization_is_done(true);
> + ctxt->ir_env.canonicalization_is_done(true);
>
> /* Cleanup and return. */
> close_elf_handler(ctxt);
> @@ -1776,11 +1773,10 @@ read_and_add_corpus_to_group_from_elf(read_context* ctxt,
> void
> reset_read_context(read_context_sptr &ctxt,
> const std::string& elf_path,
> - const vector<char**>& debug_info_root_path,
> - ir::environment* environment)
> + const vector<char**>& debug_info_root_path)
> {
> if (ctxt)
> - ctxt->initialize(elf_path, debug_info_root_path, environment);
> + ctxt->initialize(elf_path, debug_info_root_path);
> }
>
> /// Returns a key to be use in types_map dict conformed by
> diff --git a/src/abg-dwarf-reader.cc b/src/abg-dwarf-reader.cc
> index ddd040e1..f07cb80e 100644
> --- a/src/abg-dwarf-reader.cc
> +++ b/src/abg-dwarf-reader.cc
> @@ -892,7 +892,7 @@ compare_symbol_name(const string& symbol_name,
> /// @param syms_found a vector of symbols found with the name @p
> /// sym_name. table.
> static bool
> -lookup_symbol_from_sysv_hash_tab(const environment* env,
> +lookup_symbol_from_sysv_hash_tab(const environment& env,
> Elf* elf_handle,
> const string& sym_name,
> size_t ht_index,
> @@ -1169,7 +1169,7 @@ setup_gnu_ht(Elf* elf_handle,
> ///
> /// @return true if a symbol was actually found.
> static bool
> -lookup_symbol_from_gnu_hash_tab(const environment* env,
> +lookup_symbol_from_gnu_hash_tab(const environment& env,
> Elf* elf_handle,
> const string& sym_name,
> size_t ht_index,
> @@ -1301,7 +1301,7 @@ lookup_symbol_from_gnu_hash_tab(const environment* env,
> /// @return true iff the function found the symbol from the elf hash
> /// table.
> static bool
> -lookup_symbol_from_elf_hash_tab(const environment* env,
> +lookup_symbol_from_elf_hash_tab(const environment& env,
> Elf* elf_handle,
> hash_table_kind ht_kind,
> size_t ht_index,
> @@ -1358,7 +1358,7 @@ lookup_symbol_from_elf_hash_tab(const environment* env,
> ///
> /// @return true iff the symbol was found.
> static bool
You're losing the const in the next few functions. There may be some
other similar cases.
Otherwise, this looks like good to me.
> -lookup_symbol_from_symtab(const environment* env,
> +lookup_symbol_from_symtab(environment& env,
> Elf* elf_handle,
> const string& sym_name,
> size_t sym_tab_index,
> @@ -1449,7 +1449,7 @@ lookup_symbol_from_symtab(const environment* env,
> ///
> /// @return true iff a symbol with the name @p symbol_name was found.
> static bool
> -lookup_symbol_from_elf(const environment* env,
> +lookup_symbol_from_elf(environment& env,
> Elf* elf_handle,
> const string& symbol_name,
> bool demangle,
> @@ -1500,7 +1500,7 @@ lookup_symbol_from_elf(const environment* env,
> ///
> /// @return true iff the symbol was found.
> static bool
> -lookup_public_function_symbol_from_elf(const environment* env,
> +lookup_public_function_symbol_from_elf(environment& env,
> Elf* elf_handle,
> const string& symbol_name,
> vector<elf_symbol_sptr>& func_syms)
> @@ -2019,14 +2019,14 @@ class read_context
> public:
> struct options_type
> {
> - environment* env;
> + environment& env;
> bool load_in_linux_kernel_mode;
> bool load_all_types;
> bool show_stats;
> bool do_log;
>
> - options_type()
> - : env(),
> + options_type(environment& e)
> + : env(e),
> load_in_linux_kernel_mode(),
> load_all_types(),
> show_stats(),
> @@ -2280,11 +2280,12 @@ public:
> /// exported or not.
> read_context(const string& elf_path,
> const vector<char**>& debug_info_root_paths,
> - ir::environment* environment,
> + ir::environment& environment,
> bool load_all_types,
> bool linux_kernel_mode)
> + : options_(environment)
> {
> - initialize(elf_path, debug_info_root_paths, environment,
> + initialize(elf_path, debug_info_root_paths,
> load_all_types, linux_kernel_mode);
> }
>
> @@ -2320,7 +2321,6 @@ public:
> void
> initialize(const string& elf_path,
> const vector<char**>& debug_info_root_paths,
> - ir::environment* environment,
> bool load_all_types,
> bool linux_kernel_mode)
> {
> @@ -2378,7 +2378,6 @@ public:
>
> memset(&offline_callbacks_, 0, sizeof(offline_callbacks_));
> create_default_dwfl(debug_info_root_paths);
> - options_.env = environment;
> options_.load_in_linux_kernel_mode = linux_kernel_mode;
> options_.load_all_types = load_all_types;
> drop_undefined_syms_ = false;
> @@ -2442,23 +2441,16 @@ public:
> /// Getter for the current environment.
> ///
> /// @return the current environment.
> - const ir::environment*
> - env() const
> + environment&
> + env()
> {return options_.env;}
>
> /// Getter for the current environment.
> ///
> /// @return the current environment.
> - ir::environment*
> - env()
> - {return options_.env;}
> -
> - /// Setter for the current environment.
> - ///
> - /// @param env the new current environment.
> - void
> - env(ir::environment* env)
> - {options_.env = env;}
> + const environment&
> + env() const
> + {return const_cast<read_context*>(this)->env();}
>
> /// Getter for the flag that tells us if we are dropping functions
> /// and variables that have undefined symbols.
> @@ -3333,7 +3325,7 @@ public:
> {
> read_context& ctxt = *const_cast<read_context*>(this);
> string qualified_name = die_qualified_name(ctxt, die, where_offset);
> - interned_string istr = env()->intern(qualified_name);
> + interned_string istr = env().intern(qualified_name);
> map[die_offset] = istr;
> return istr;
> }
> @@ -3384,7 +3376,7 @@ public:
>
> // The name of the translation unit die is "".
> if (die == cur_tu_die())
> - return env()->intern("");
> + return env().intern("");
>
> die_istring_map_type& map =
> die_qualified_name_maps_.get_container(*const_cast<read_context*>(this),
> @@ -3412,7 +3404,7 @@ public:
> qualified_name =
> die_qualified_type_name(ctxt, die, where_offset);
>
> - interned_string istr = env()->intern(qualified_name);
> + interned_string istr = env().intern(qualified_name);
> map[die_offset] = istr;
> return istr;
> }
> @@ -3453,7 +3445,7 @@ public:
> read_context& ctxt = *const_cast<read_context*>(this);
> string pretty_representation =
> die_pretty_print_type(ctxt, die, where_offset);
> - interned_string istr = env()->intern(pretty_representation);
> + interned_string istr = env().intern(pretty_representation);
> map[die_offset] = istr;
> return istr;
> }
> @@ -3490,7 +3482,7 @@ public:
> read_context& ctxt = *const_cast<read_context*>(this);
> string pretty_representation =
> die_pretty_print(ctxt, die, where_offset);
> - interned_string istr = env()->intern(pretty_representation);
> + interned_string istr = env().intern(pretty_representation);
> map[die_offset] = istr;
> return istr;
> }
> @@ -4262,16 +4254,16 @@ public:
> if (!l || !r)
> return !!l == !!r;
>
> - const environment* e = l->get_environment();
> - ABG_ASSERT(!e->canonicalization_is_done());
> + const environment& e = l->get_environment();
> + ABG_ASSERT(!e.canonicalization_is_done());
>
> - e->priv_->allow_type_comparison_results_caching(true);
> - bool s0 = e->decl_only_class_equals_definition();
> - e->decl_only_class_equals_definition(true);
> + e.priv_->allow_type_comparison_results_caching(true);
> + bool s0 = e.decl_only_class_equals_definition();
> + e.decl_only_class_equals_definition(true);
> bool equal = l == r;
> - e->decl_only_class_equals_definition(s0);
> - e->priv_->clear_type_comparison_results_cache();
> - e->priv_->allow_type_comparison_results_caching(false);
> + e.decl_only_class_equals_definition(s0);
> + e.priv_->clear_type_comparison_results_cache();
> + e.priv_->allow_type_comparison_results_caching(false);
> return equal;
> }
>
> @@ -12764,7 +12756,7 @@ build_translation_unit_and_add_to_ir(read_context& ctxt,
> do
> // Analyze all the DIEs we encounter unless we are asked to only
> // analyze exported interfaces and the types reachables from them.
> - if (!ctxt.env()->analyze_exported_interfaces_only()
> + if (!ctxt.env().analyze_exported_interfaces_only()
> || ctxt.is_decl_die_with_exported_symbol(&child))
> build_ir_node_from_die(ctxt, &child,
> die_is_public_decl(&child),
> @@ -13098,7 +13090,7 @@ build_enum_type(read_context& ctxt,
> die_loc_and_name(ctxt, &child, l, n, m);
> uint64_t val = 0;
> die_unsigned_constant_attribute(&child, DW_AT_const_value, val);
> - enms.push_back(enum_type_decl::enumerator(ctxt.env(), n, val));
> + enms.push_back(enum_type_decl::enumerator(n, val));
> }
> while (dwarf_siblingof(&child, &child) == 0);
> }
> @@ -14698,8 +14690,7 @@ build_function_type(read_context& ctxt,
> {
> // This is a variadic function parameter.
> bool is_artificial = die_is_artificial(&child);
> - ir::environment* env = ctxt.env();
> - ABG_ASSERT(env);
> +
> type_base_sptr parm_type =
> is_type(build_ir_node_for_variadic_parameter_type(ctxt));
> function_decl::parameter_sptr p
> @@ -15044,7 +15035,7 @@ build_typedef_type(read_context& ctxt,
> if (!die_die_attribute(die, DW_AT_type, underlying_type_die))
> // A typedef DIE with no underlying type means a typedef to
> // void type.
> - utype = ctxt.env()->get_void_type();
> + utype = ctxt.env().get_void_type();
>
> if (!utype)
> utype =
> @@ -15639,7 +15630,7 @@ get_opaque_version_of_type(read_context &ctxt,
> ///
> /// @return the newly created symbol.
> elf_symbol_sptr
> -create_default_fn_sym(const string& sym_name, const environment *env)
> +create_default_fn_sym(const string& sym_name, const environment& env)
> {
> elf_symbol::version ver;
> elf_symbol_sptr result =
> @@ -15795,14 +15786,14 @@ read_debug_info_into_corpus(read_context& ctxt)
> ctxt.current_corpus()->set_origin(origin);
>
> if (origin & corpus::LINUX_KERNEL_BINARY_ORIGIN
> - && !ctxt.env()->user_set_analyze_exported_interfaces_only())
> + && !ctxt.env().user_set_analyze_exported_interfaces_only())
> // So we are looking at the Linux Kernel and the user has not set
> // any particular option regarding the amount of types to analyse.
> // In that case, we need to only analyze types that are reachable
> // from exported interfaces otherwise we get such a massive amount
> // of type DIEs to look at that things are just too slow down the
> // road.
> - ctxt.env()->analyze_exported_interfaces_only(true);
> + ctxt.env().analyze_exported_interfaces_only(true);
>
> ctxt.current_corpus()->set_soname(ctxt.dt_soname());
> ctxt.current_corpus()->set_needed(ctxt.dt_needed());
> @@ -15825,8 +15816,8 @@ read_debug_info_into_corpus(read_context& ctxt)
> (ctxt.current_corpus()->get_exported_decls_builder().get());
>
> #ifdef WITH_DEBUG_SELF_COMPARISON
> - if (ctxt.env()->self_comparison_debug_is_on())
> - ctxt.env()->set_self_comparison_debug_input(ctxt.current_corpus());
> + if (ctxt.env().self_comparison_debug_is_on())
> + ctxt.env().set_self_comparison_debug_input(ctxt.current_corpus());
> #endif
>
> // Walk all the DIEs of the debug info to build a DIE -> parent map
> @@ -15851,7 +15842,7 @@ read_debug_info_into_corpus(read_context& ctxt)
> }
> }
>
> - ctxt.env()->canonicalization_is_done(false);
> + ctxt.env().canonicalization_is_done(false);
>
> {
> tools_utils::timer t;
> @@ -15987,7 +15978,7 @@ read_debug_info_into_corpus(read_context& ctxt)
> }
> }
>
> - ctxt.env()->canonicalization_is_done(true);
> + ctxt.env().canonicalization_is_done(true);
>
> {
> tools_utils::timer t;
> @@ -16739,9 +16730,8 @@ build_ir_node_from_die(read_context& ctxt,
> static decl_base_sptr
> build_ir_node_for_void_type(read_context& ctxt)
> {
> - ir::environment* env = ctxt.env();
> - ABG_ASSERT(env);
> - type_base_sptr t = env->get_void_type();
> + ir::environment& env = ctxt.env();
> + type_base_sptr t = env.get_void_type();
> decl_base_sptr type_declaration = get_type_declaration(t);
> if (!has_scope(type_declaration))
> add_decl_to_scope(type_declaration,
> @@ -16759,9 +16749,8 @@ static decl_base_sptr
> build_ir_node_for_variadic_parameter_type(read_context &ctxt)
> {
>
> - ir::environment* env = ctxt.env();
> - ABG_ASSERT(env);
> - type_base_sptr t = env->get_variadic_parameter_type();
> + ir::environment& env = ctxt.env();
> + type_base_sptr t = env.get_variadic_parameter_type();
> decl_base_sptr type_declaration = get_type_declaration(t);
> if (!has_scope(type_declaration))
> add_decl_to_scope(type_declaration,
> @@ -16862,7 +16851,7 @@ build_ir_node_from_die(read_context& ctxt,
> read_context_sptr
> create_read_context(const std::string& elf_path,
> const vector<char**>& debug_info_root_paths,
> - ir::environment* environment,
> + ir::environment& environment,
> bool load_all_types,
> bool linux_kernel_mode)
> {
> @@ -16919,12 +16908,11 @@ void
> reset_read_context(read_context_sptr &ctxt,
> const std::string& elf_path,
> const vector<char**>& debug_info_root_path,
> - ir::environment* environment,
> bool read_all_types,
> bool linux_kernel_mode)
> {
> if (ctxt)
> - ctxt->initialize(elf_path, debug_info_root_path, environment,
> + ctxt->initialize(elf_path, debug_info_root_path,
> read_all_types, linux_kernel_mode);
> }
>
> @@ -17082,7 +17070,7 @@ read_and_add_corpus_to_group_from_elf(read_context& ctxt,
> corpus_sptr
> read_corpus_from_elf(const std::string& elf_path,
> const vector<char**>& debug_info_root_paths,
> - ir::environment* environment,
> + environment& environment,
> bool load_all_types,
> status& status)
> {
> @@ -17111,7 +17099,7 @@ read_corpus_from_elf(const std::string& elf_path,
> /// @return true iff the symbol was found among the publicly exported
> /// symbols of the ELF file.
> bool
> -lookup_symbol_from_elf(const environment* env,
> +lookup_symbol_from_elf(environment& env,
> const string& elf_path,
> const string& symbol_name,
> bool demangle,
> @@ -17156,7 +17144,7 @@ lookup_symbol_from_elf(const environment* env,
> /// @return true iff a function with symbol name @p symbol_name is
> /// found.
> bool
> -lookup_public_function_symbol_from_elf(const environment* env,
> +lookup_public_function_symbol_from_elf(environment& env,
> const string& path,
> const string& symname,
> vector<elf_symbol_sptr>& syms)
> @@ -17279,7 +17267,8 @@ has_alt_debug_info(const string& elf_path,
> {
> vector<char**> di_roots;
> di_roots.push_back(debug_info_root_path);
> - read_context_sptr c = create_read_context(elf_path, di_roots, 0);
> + environment env;
> + read_context_sptr c = create_read_context(elf_path, di_roots, env);
> read_context& ctxt = *c;
>
> // Load debug info from the elf path.
> diff --git a/src/abg-ir-priv.h b/src/abg-ir-priv.h
> index dd3c6276..32041d31 100644
> --- a/src/abg-ir-priv.h
> +++ b/src/abg-ir-priv.h
> @@ -141,7 +141,7 @@ parse_integral_type(const string& type_name,
> /// Private type to hold private members of @ref translation_unit
> struct translation_unit::priv
> {
> - const environment* env_;
> + const environment& env_;
> corpus* corp;
> bool is_constructed_;
> char address_size_;
> @@ -156,7 +156,7 @@ struct translation_unit::priv
> type_maps types_;
>
>
> - priv(const environment* env)
> + priv(const environment& env)
> : env_(env),
> corp(),
> is_constructed_(),
> @@ -845,7 +845,7 @@ struct environment::priv
> for (auto i : types_with_non_confirmed_propagated_ct_)
> {
> type_base *t = reinterpret_cast<type_base*>(i);
> - ABG_ASSERT(t->get_environment()->priv_->is_recursive_type(t)
> + ABG_ASSERT(t->get_environment().priv_->is_recursive_type(t)
> || t->priv_->depends_on_recursive_type());
> t->priv_->set_does_not_depend_on_recursive_type(dependant_type);
> if (!t->priv_->depends_on_recursive_type())
> @@ -876,13 +876,12 @@ struct environment::priv
> if (!t || t->priv_->propagated_canonical_type_confirmed())
> return;
>
> - const environment* env = t->get_environment();
> - ABG_ASSERT(env);
> + const environment& env = t->get_environment();
>
> - env->priv_->confirm_ct_propagation_for_types_dependant_on(t);
> + env.priv_->confirm_ct_propagation_for_types_dependant_on(t);
> t->priv_->set_does_not_depend_on_recursive_type();
> - env->priv_->remove_from_types_with_non_confirmed_propagated_ct(t);
> - env->priv_->set_is_not_recursive(t);
> + env.priv_->remove_from_types_with_non_confirmed_propagated_ct(t);
> + env.priv_->set_is_not_recursive(t);
> t->priv_->set_propagated_canonical_type_confirmed(true);
> }
>
> @@ -900,7 +899,7 @@ struct environment::priv
> for (auto i : types_with_non_confirmed_propagated_ct_)
> {
> type_base *t = reinterpret_cast<type_base*>(i);
> - ABG_ASSERT(t->get_environment()->priv_->is_recursive_type(t)
> + ABG_ASSERT(t->get_environment().priv_->is_recursive_type(t)
> || t->priv_->depends_on_recursive_type());
> t->priv_->set_does_not_depend_on_recursive_type();
> t->priv_->set_propagated_canonical_type_confirmed(true);
> @@ -970,7 +969,7 @@ struct environment::priv
> for (auto i : to_remove)
> {
> type_base *t = reinterpret_cast<type_base*>(i);
> - ABG_ASSERT(t->get_environment()->priv_->is_recursive_type(t)
> + ABG_ASSERT(t->get_environment().priv_->is_recursive_type(t)
> || t->priv_->depends_on_recursive_type());
> type_base_sptr canonical = t->priv_->canonical_type.lock();
> if (canonical)
> @@ -1007,10 +1006,10 @@ struct environment::priv
> if (!t)
> return;
>
> - const environment *env = t->get_environment();
> - env->priv_->cancel_ct_propagation_for_types_dependant_on(t);
> + const environment& env = t->get_environment();
> + env.priv_->cancel_ct_propagation_for_types_dependant_on(t);
> if (t->priv_->depends_on_recursive_type()
> - || env->priv_->is_recursive_type(t))
> + || env.priv_->is_recursive_type(t))
> {
> // This cannot carry any tentative canonical type at this
> // point.
> @@ -1020,7 +1019,7 @@ struct environment::priv
> // Reset the marking of the type as it no longer carries a
> // tentative canonical type that might be later cancelled.
> t->priv_->set_does_not_depend_on_recursive_type();
> - env->priv_->remove_from_types_with_non_confirmed_propagated_ct(t);
> + env.priv_->remove_from_types_with_non_confirmed_propagated_ct(t);
> }
> }
>
> @@ -1174,9 +1173,8 @@ struct class_or_union::priv
> mark_as_being_compared(const class_or_union& first,
> const class_or_union& second) const
> {
> - const environment* env = first.get_environment();
> - ABG_ASSERT(env);
> - env->priv_->classes_being_compared_.insert
> + const environment& env = first.get_environment();
> + env.priv_->classes_being_compared_.insert
> (std::make_pair(reinterpret_cast<uint64_t>(&first),
> reinterpret_cast<uint64_t>(&second)));
> }
> @@ -1237,9 +1235,8 @@ struct class_or_union::priv
> unmark_as_being_compared(const class_or_union& first,
> const class_or_union& second) const
> {
> - const environment* env = first.get_environment();
> - ABG_ASSERT(env);
> - env->priv_->classes_being_compared_.erase
> + const environment& env = first.get_environment();
> + env.priv_->classes_being_compared_.erase
> (std::make_pair(reinterpret_cast<uint64_t>(&first),
> reinterpret_cast<uint64_t>(&second)));
> }
> @@ -1279,9 +1276,8 @@ struct class_or_union::priv
> comparison_started(const class_or_union& first,
> const class_or_union& second) const
> {
> - const environment* env = first.get_environment();
> - ABG_ASSERT(env);
> - return env->priv_->
> + const environment& env = first.get_environment();
> + return env.priv_->
> classes_being_compared_.count
> (std::make_pair(reinterpret_cast<uint64_t>(&first),
> reinterpret_cast<uint64_t>((&second))));
> @@ -1340,9 +1336,8 @@ struct function_type::priv
> mark_as_being_compared(const function_type& first,
> const function_type& second) const
> {
> - const environment* env = first.get_environment();
> - ABG_ASSERT(env);
> - env->priv_->fn_types_being_compared_.insert
> + const environment& env = first.get_environment();
> + env.priv_->fn_types_being_compared_.insert
> (std::make_pair(reinterpret_cast<uint64_t>(&first),
> reinterpret_cast<uint64_t>(&second)));
> }
> @@ -1358,9 +1353,8 @@ struct function_type::priv
> unmark_as_being_compared(const function_type& first,
> const function_type& second) const
> {
> - const environment* env = first.get_environment();
> - ABG_ASSERT(env);
> - env->priv_->fn_types_being_compared_.erase
> + const environment& env = first.get_environment();
> + env.priv_->fn_types_being_compared_.erase
> (std::make_pair(reinterpret_cast<uint64_t>(&first),
> reinterpret_cast<uint64_t>(&second)));
> }
> @@ -1374,9 +1368,8 @@ struct function_type::priv
> comparison_started(const function_type& first,
> const function_type& second) const
> {
> - const environment* env = first.get_environment();
> - ABG_ASSERT(env);
> - return env->priv_->fn_types_being_compared_.count
> + const environment& env = first.get_environment();
> + return env.priv_->fn_types_being_compared_.count
> (std::make_pair(reinterpret_cast<uint64_t>(&first),
> reinterpret_cast<uint64_t>(&second)));
> }
> diff --git a/src/abg-ir.cc b/src/abg-ir.cc
> index 5193934a..f4b50cae 100644
> --- a/src/abg-ir.cc
> +++ b/src/abg-ir.cc
> @@ -39,59 +39,6 @@ ABG_END_EXPORT_DECLARATIONS
>
> namespace
> {
> -/// This internal type is a tree walker that walks the sub-tree of a
> -/// type and sets the environment of the type (including its sub-type)
> -/// to a new environment.
> -class environment_setter : public abigail::ir::ir_node_visitor
> -{
> - const abigail::ir::environment* env_;
> -
> -public:
> - environment_setter(const abigail::ir::environment* env)
> - : env_(env)
> - {}
> -
> - /// This function is called on each sub-tree node that is a
> - /// declaration. Note that it's also called on some types because
> - /// most types that have a declarations also inherit the type @ref
> - /// decl_base.
> - ///
> - /// @param d the declaration being visited.
> - bool
> - visit_begin(abigail::ir::decl_base* d)
> - {
> - if (const abigail::ir::environment* env = d->get_environment())
> - {
> - ABG_ASSERT(env == env_);
> - return false;
> - }
> - else
> - d->set_environment(env_);
> -
> - return true;
> -
> - }
> -
> - /// This function is called on each sub-tree node that is a type.
> - ///
> - /// @param t the type being visited.
> - bool
> - visit_begin(abigail::ir::type_base* t)
> - {
> - if (abigail::ir::environment* env = t->get_environment())
> - {
> - ABG_ASSERT(env == env_);
> - return false;
> - }
> - else
> - {
> - ABG_ASSERT(!t->get_environment());
> - t->set_environment(env_);
> - }
> - return true;
> - }
> -};
> -
> /// This internal type is a tree walking that is used to set the
> /// qualified name of a tree of decls and types. It used by the
> /// function update_qualified_name().
> @@ -297,8 +244,8 @@ void
> push_composite_type_comparison_operands(const type_base& left,
> const type_base& right)
> {
> - const environment * env = left.get_environment();
> - env->priv_->push_composite_type_comparison_operands(&left, &right);
> + const environment& env = left.get_environment();
> + env.priv_->push_composite_type_comparison_operands(&left, &right);
> }
>
> /// Pop a pair of operands from the stack of operands to the current
> @@ -318,8 +265,8 @@ void
> pop_composite_type_comparison_operands(const type_base& left,
> const type_base& right)
> {
> - const environment * env = left.get_environment();
> - env->priv_->pop_composite_type_comparison_operands(&left, &right);
> + const environment& env = left.get_environment();
> + env.priv_->pop_composite_type_comparison_operands(&left, &right);
> }
>
> /// In the stack of the current types being compared (as part of type
> @@ -381,9 +328,9 @@ pop_composite_type_comparison_operands(const type_base& left,
> bool
> mark_dependant_types_compared_until(const type_base &r)
> {
> - const environment * env = r.get_environment();
> - if (env->do_on_the_fly_canonicalization())
> - return env->priv_->mark_dependant_types_compared_until(&r);
> + const environment& env = r.get_environment();
> + if (env.do_on_the_fly_canonicalization())
> + return env.priv_->mark_dependant_types_compared_until(&r);
> return false;
> }
>
> @@ -888,8 +835,8 @@ try_canonical_compare(const T *l, const T *r)
> // instructing us to compare them canonically, and the second time
> // with that boolean set to false, instructing us to compare them
> // structurally.
> - const environment *env = l->get_environment();
> - if (env->priv_->use_canonical_type_comparison_)
> + const environment&env = l->get_environment();
> + if (env.priv_->use_canonical_type_comparison_)
> {
> if (const type_base *lc = l->get_naked_canonical_type())
> if (const type_base *rc = r->get_naked_canonical_type())
> @@ -1073,8 +1020,8 @@ return_comparison_result(T& l, T& r, bool value,
>
> unmark_types_as_being_compared(l, r);
>
> - const environment* env = l.get_environment();
> - if (env->do_on_the_fly_canonicalization())
> + const environment& env = l.get_environment();
> + if (env.do_on_the_fly_canonicalization())
> // We are instructed to perform the "canonical type propagation"
> // optimization, making 'r' to possibly get the canonical type of
> // 'l' if it has one. This mostly means that we are currently
> @@ -1083,17 +1030,17 @@ return_comparison_result(T& l, T& r, bool value,
> {
> if (value == true
> && (is_type(&r)->priv_->depends_on_recursive_type()
> - || env->priv_->is_recursive_type(&r))
> + || env.priv_->is_recursive_type(&r))
> && is_type(&r)->priv_->canonical_type_propagated()
> && !is_type(&r)->priv_->propagated_canonical_type_confirmed()
> - && !env->priv_->right_type_comp_operands_.empty())
> + && !env.priv_->right_type_comp_operands_.empty())
> {
> // Track the object 'r' for which the propagated canonical
> // type might be re-initialized if the current comparison
> // eventually fails.
> - env->priv_->add_to_types_with_non_confirmed_propagated_ct(is_type(&r));
> + env.priv_->add_to_types_with_non_confirmed_propagated_ct(is_type(&r));
> }
> - else if (value == true && env->priv_->right_type_comp_operands_.empty())
> + else if (value == true && env.priv_->right_type_comp_operands_.empty())
> {
> // The type provided in the 'r' argument is the type that is
> // being canonicalized; 'r' is not a mere subtype being
> @@ -1102,16 +1049,16 @@ return_comparison_result(T& l, T& r, bool value,
> // confirm the "canonical type propagation" of all the
> // sub-types that were compared during the comparison of
> // 'r'.
> - env->priv_->confirm_ct_propagation(&r);
> + env.priv_->confirm_ct_propagation(&r);
> }
> else if (value == false)
> {
> // The comparison of the current sub-type failed. So all
> // the types in
> - // env->prix_->types_with_non_confirmed_propagated_ct_
> + // env.prix_->types_with_non_confirmed_propagated_ct_
> // should see their tentatively propagated canonical type
> // cancelled.
> - env->priv_->cancel_ct_propagation(&r);
> + env.priv_->cancel_ct_propagation(&r);
> }
> }
>
> @@ -1123,13 +1070,13 @@ return_comparison_result(T& l, T& r, bool value,
> // propagation can now see their tentative canonical type be
> // confirmed for real.
> if (value == true
> - && env->priv_->right_type_comp_operands_.empty()
> - && !env->priv_->types_with_non_confirmed_propagated_ct_.empty())
> + && env.priv_->right_type_comp_operands_.empty()
> + && !env.priv_->types_with_non_confirmed_propagated_ct_.empty())
> // So the comparison is completely done and there are some
> // types for which their propagated canonical type is sitll
> // considered not confirmed. As the comparison did yield true, we
> // shall now confirm the propagation for all those types.
> - env->priv_->confirm_ct_propagation();
> + env.priv_->confirm_ct_propagation();
>
> ABG_RETURN(value);
> }
> @@ -1188,7 +1135,7 @@ type_maps::get_types_sorted_by_name() const
> ///
> /// @param address_size the size of addresses in the translation unit,
> /// in bits.
> -translation_unit::translation_unit(const environment* env,
> +translation_unit::translation_unit(const environment& env,
> const std::string& path,
> char address_size)
> : priv_(new priv(env))
> @@ -1220,10 +1167,6 @@ translation_unit::get_global_scope()
> {
> priv_->global_scope_.reset
> (new global_scope(const_cast<translation_unit*>(this)));
> - // The global scope must be out of the same environment as its
> - // translation unit.
> - priv_->global_scope_->
> - set_environment(const_cast<environment*>(get_environment()));
> priv_->global_scope_->set_translation_unit
> (const_cast<translation_unit*>(this));
> }
> @@ -1256,24 +1199,10 @@ translation_unit::get_live_fn_types() const
> /// Getter of the environment of the current @ref translation_unit.
> ///
> /// @return the translation unit of the current translation unit.
> -const environment*
> +const environment&
> translation_unit::get_environment() const
> {return priv_->env_;}
>
> -/// Getter of the environment of the current @ref translation_unit.
> -///
> -/// @return the translation unit of the current translation unit.
> -environment*
> -translation_unit::get_environment()
> -{return const_cast<environment*>(priv_->env_);}
> -
> -/// Setter of the environment of the current @ref translation_unit.
> -///
> -/// @param env the environment.
> -void
> -translation_unit::set_environment(const environment* env)
> -{priv_->env_ = env;}
> -
> /// Getter of the language of the source code of the translation unit.
> ///
> /// @return the language of the source code.
> @@ -1496,8 +1425,7 @@ translation_unit::operator!=(const translation_unit& o) const
> void
> translation_unit::bind_function_type_life_time(function_type_sptr ftype) const
> {
> - const environment* env = get_environment();
> - ABG_ASSERT(env);
> + const environment& env = get_environment();
>
> const_cast<translation_unit*>(this)->priv_->live_fn_types_.push_back(ftype);
>
> @@ -1507,10 +1435,10 @@ translation_unit::bind_function_type_life_time(function_type_sptr ftype) const
>
> // The function type must be out of the same environment as its
> // translation unit.
> - if (const environment* e = ftype->get_environment())
> - ABG_ASSERT(env == e);
> - else
> - ftype->set_environment(const_cast<environment*>(env));
> + {
> + const environment& e = ftype->get_environment();
> + ABG_ASSERT(&env == &e);
> + }
>
> if (const translation_unit* existing_tu = ftype->get_translation_unit())
> ABG_ASSERT(existing_tu == this);
> @@ -1749,7 +1677,7 @@ operator!=(const translation_unit_sptr& l, const translation_unit_sptr& r)
> // <elf_symbol stuff>
> struct elf_symbol::priv
> {
> - const environment* env_;
> + const environment& env_;
> size_t index_;
> size_t size_;
> string name_;
> @@ -1796,8 +1724,8 @@ struct elf_symbol::priv
> elf_symbol_wptr next_common_instance_;
> string id_string_;
>
> - priv()
> - : env_(),
> + priv(const environment& e)
> + : env_(e),
> index_(),
> size_(),
> type_(elf_symbol::NOTYPE_TYPE),
> @@ -1811,7 +1739,7 @@ struct elf_symbol::priv
> is_suppressed_(false)
> {}
>
> - priv(const environment* e,
> + priv(const environment& e,
> size_t i,
> size_t s,
> const string& n,
> @@ -1845,16 +1773,6 @@ struct elf_symbol::priv
> }
> }; // end struct elf_symbol::priv
>
> -/// Default constructor of the @ref elf_symbol type.
> -///
> -/// Note that this constructor is private, so client code cannot use
> -/// it to create instances of @ref elf_symbol. Rather, client code
> -/// should use the @ref elf_symbol::create() function to create
> -/// instances of @ref elf_symbol instead.
> -elf_symbol::elf_symbol()
> - : priv_(new priv)
> -{}
> -
> /// Constructor of the @ref elf_symbol type.
> ///
> /// Note that this constructor is private, so client code cannot use
> @@ -1885,7 +1803,7 @@ elf_symbol::elf_symbol()
> /// @param crc the CRC (modversions) value of Linux Kernel symbols
> ///
> /// @param ns the namespace of Linux Kernel symbols, if any
> -elf_symbol::elf_symbol(const environment* e,
> +elf_symbol::elf_symbol(const environment& e,
> size_t i,
> size_t s,
> const string& n,
> @@ -1915,20 +1833,6 @@ elf_symbol::elf_symbol(const environment* e,
> is_suppressed))
> {}
>
> -/// Factory of instances of @ref elf_symbol.
> -///
> -/// This is the function to use to create instances of @ref elf_symbol.
> -///
> -/// @return a (smart) pointer to a newly created instance of @ref
> -/// elf_symbol.
> -elf_symbol_sptr
> -elf_symbol::create()
> -{
> - elf_symbol_sptr e(new elf_symbol());
> - e->priv_->main_symbol_ = e;
> - return e;
> -}
> -
> /// Factory of instances of @ref elf_symbol.
> ///
> /// This is the function to use to create instances of @ref elf_symbol.
> @@ -1960,7 +1864,7 @@ elf_symbol::create()
> /// @return a (smart) pointer to a newly created instance of @ref
> /// elf_symbol.
> elf_symbol_sptr
> -elf_symbol::create(const environment* e,
> +elf_symbol::create(const environment& e,
> size_t i,
> size_t s,
> const string& n,
> @@ -2015,19 +1919,10 @@ textually_equals(const elf_symbol&l,
> /// elf_symbol.
> ///
> /// @return the enviroment used by the current instance of @ref elf_symbol.
> -const environment*
> +const environment&
> elf_symbol::get_environment() const
> {return priv_->env_;}
>
> -/// Setter of the environment used by the current instance of @ref
> -/// elf_symbol.
> -///
> -/// @param The new enviroment used by the current instance of @ref
> -/// elf_symbol.
> -void
> -elf_symbol::set_environment(const environment* e) const
> -{priv_->env_ = e;}
> -
> /// Getter for the index
> ///
> /// @return the index of the symbol.
> @@ -3593,7 +3488,7 @@ const type_base_sptr&
> environment::get_void_type() const
> {
> if (!priv_->void_type_)
> - priv_->void_type_.reset(new type_decl(const_cast<environment*>(this),
> + priv_->void_type_.reset(new type_decl(*this,
> intern("void"),
> 0, 0, location()));
> return priv_->void_type_;
> @@ -3609,7 +3504,7 @@ environment::get_variadic_parameter_type() const
> {
> if (!priv_->variadic_marker_type_)
> priv_->variadic_marker_type_.
> - reset(new type_decl(const_cast<environment*>(this),
> + reset(new type_decl(*this,
> intern("variadic parameter type"),
> 0, 0, location()));
> return priv_->variadic_marker_type_;
> @@ -4064,7 +3959,7 @@ struct type_or_decl_base::priv
> // hotspots, due to their use of dynamic_cast.
> void* type_or_decl_ptr_;
> bool hashing_started_;
> - const environment* env_;
> + const environment& env_;
> translation_unit* translation_unit_;
> // The location of an artifact as seen from its input by the
> // artifact reader. This might be different from the source
> @@ -4082,7 +3977,7 @@ struct type_or_decl_base::priv
> ///
> /// @param k the identifier of the runtime type of the current
> /// instance of ABI artifact.
> - priv(const environment* e = 0,
> + priv(const environment& e,
> enum type_or_decl_kind k = ABSTRACT_TYPE_OR_DECL)
> : kind_(k),
> rtti_(),
> @@ -4142,26 +4037,17 @@ operator&=(type_or_decl_base::type_or_decl_kind& l,
> return l;
> }
>
> -/// Default constructor of @ref type_or_decl_base.
> -type_or_decl_base::type_or_decl_base()
> - :priv_(new priv)
> -{}
> -
> /// Constructor of @ref type_or_decl_base.
> ///
> /// @param the environment the current ABI artifact is constructed
> /// from.
> ///
> /// @param k the runtime identifier bitmap of the type being built.
> -type_or_decl_base::type_or_decl_base(const environment* e,
> +type_or_decl_base::type_or_decl_base(const environment& e,
> enum type_or_decl_kind k)
> :priv_(new priv(e, k))
> {}
>
> -/// Copy constructor of @ref type_or_decl_base.
> -type_or_decl_base::type_or_decl_base(const type_or_decl_base& o)
> -{*priv_ = *o.priv_;}
> -
> /// The destructor of the @ref type_or_decl_base type.
> type_or_decl_base::~type_or_decl_base()
> {}
> @@ -4280,22 +4166,10 @@ void
> type_or_decl_base::hashing_started(bool b) const
> {priv_->hashing_started_ = b;}
>
> -/// Setter of the environment of the current ABI artifact.
> -///
> -/// This just sets the environment artifact of the current ABI
> -/// artifact, not on its sub-trees. If you want to set the
> -/// environment of an ABI artifact including its sub-tree, use the
> -/// abigail::ir::set_environment_for_artifact() function.
> -///
> -/// @param env the new environment.
> -void
> -type_or_decl_base::set_environment(const environment* env)
> -{priv_->env_ = env;}
> -
> /// Getter of the environment of the current ABI artifact.
> ///
> /// @return the environment of the artifact.
> -const environment*
> +const environment&
> type_or_decl_base::get_environment() const
> {return priv_->env_;}
>
> @@ -4345,13 +4219,6 @@ type_or_decl_base::has_artificial_location() const
> && priv_->artificial_location_.get_is_artificial());
> }
>
> -/// Getter of the environment of the current ABI artifact.
> -///
> -/// @return the environment of the artifact.
> -environment*
> -type_or_decl_base::get_environment()
> -{return const_cast<environment*>(priv_->env_);}
> -
> /// Get the @ref corpus this ABI artifact belongs to.
> ///
> /// @return the corpus this ABI artifact belongs to, or nil if it
> @@ -4399,19 +4266,6 @@ const translation_unit*
> type_or_decl_base::get_translation_unit() const
> {return const_cast<type_or_decl_base*>(this)->get_translation_unit();}
>
> -/// Assignment operator for @ref type_or_decl_base.
> -///
> -/// @param o the other instance to assign the current instance to.
> -///
> -/// return a reference to the assigned instance of @ref
> -/// type_or_decl_base.
> -type_or_decl_base&
> -type_or_decl_base::operator=(const type_or_decl_base& o)
> -{
> - *priv_ = *o.priv_;
> - return *this;
> -}
> -
> /// Traverse the the ABI artifact.
> ///
> /// @param v the visitor used to traverse the sub-tree nodes of the
> @@ -4420,33 +4274,6 @@ bool
> type_or_decl_base::traverse(ir_node_visitor&)
> {return true;}
>
> -/// Set the environment of a given ABI artifact, including recursively
> -/// setting the environment on the sub-trees of the artifact.
> -///
> -/// @param artifact the artifact to set the environment for.
> -///
> -/// @param env the new environment.
> -void
> -set_environment_for_artifact(type_or_decl_base* artifact,
> - const environment* env)
> -{
> - ABG_ASSERT(artifact && env);
> -
> - ::environment_setter s(env);
> - artifact->traverse(s);
> -}
> -
> -/// Set the environment of a given ABI artifact, including recursively
> -/// setting the environment on the sub-trees of the artifact.
> -///
> -/// @param artifact the artifact to set the environment for.
> -///
> -/// @param env the new environment.
> -void
> -set_environment_for_artifact(type_or_decl_base_sptr artifact,
> - const environment* env)
> -{set_environment_for_artifact(artifact.get(), env);}
> -
> /// Non-member equality operator for the @type_or_decl_base type.
> ///
> /// @param lr the left-hand operand of the equality.
> @@ -4590,13 +4417,13 @@ struct decl_base::priv
> /// @param linkage_name the linkage name of the declaration.
> ///
> /// @param vis the visibility of the declaration.
> -decl_base::decl_base(const environment* e,
> +decl_base::decl_base(const environment& e,
> const string& name,
> const location& locus,
> const string& linkage_name,
> visibility vis)
> : type_or_decl_base(e, ABSTRACT_DECL_BASE),
> - priv_(new priv(e->intern(name), e->intern(linkage_name), vis))
> + priv_(new priv(e.intern(name), e.intern(linkage_name), vis))
> {
> set_location(locus);
> }
> @@ -4614,7 +4441,7 @@ decl_base::decl_base(const environment* e,
> /// constructed.
> ///
> /// @param vis the visibility of the declaration being constructed.
> -decl_base::decl_base(const environment* e,
> +decl_base::decl_base(const environment& e,
> const interned_string& name,
> const location& locus,
> const interned_string& linkage_name,
> @@ -4632,26 +4459,13 @@ decl_base::decl_base(const environment* e,
> ///
> /// @param l the location where to find the declaration in the source
> /// code.
> -decl_base::decl_base(const environment* e, const location& l)
> +decl_base::decl_base(const environment& e, const location& l)
> : type_or_decl_base(e, ABSTRACT_DECL_BASE),
> priv_(new priv())
> {
> set_location(l);
> }
>
> -decl_base::decl_base(const decl_base& d)
> - : type_or_decl_base(d)
> -{
> - priv_->in_pub_sym_tab_ = d.priv_->in_pub_sym_tab_;
> - priv_->location_ = d.priv_->location_;
> - priv_->name_ = d.priv_->name_;
> - priv_->qualified_parent_name_ = d.priv_->qualified_parent_name_;
> - priv_->qualified_name_ = d.priv_->qualified_name_;
> - priv_->linkage_name_ = d.priv_->linkage_name_;
> - priv_->context_ = d.priv_->context_;
> - priv_->visibility_ = d.priv_->visibility_;
> -}
> -
> /// Getter for the qualified name.
> ///
> /// Unlike decl_base::get_qualified_name() this doesn't try to update
> @@ -4831,7 +4645,7 @@ decl_base::set_location(const location& l)
> void
> decl_base::set_name(const string& n)
> {
> - priv_->name_ = get_environment()->intern(n);
> + priv_->name_ = get_environment().intern(n);
> priv_->is_anonymous_ = n.empty();
> }
>
> @@ -4923,7 +4737,7 @@ decl_base::set_naming_typedef(const typedef_decl_sptr& t)
> priv_->naming_typedef_ = t;
> set_name(t->get_name());
> string qualified_name = build_qualified_name(get_scope(), t->get_name());
> - set_qualified_name(get_environment()->intern(qualified_name));
> + set_qualified_name(get_environment().intern(qualified_name));
> set_is_anonymous(false);
> // Now that the qualified type of the decl has changed, let's update
> // the qualified names of the member types of this decls.
> @@ -4943,9 +4757,8 @@ decl_base::get_linkage_name() const
> void
> decl_base::set_linkage_name(const string& m)
> {
> - const environment* env = get_environment();
> - ABG_ASSERT(env);
> - priv_->linkage_name_ = env->intern(m);
> + const environment& env = get_environment();
> + priv_->linkage_name_ = env.intern(m);
> }
>
> /// Getter for the visibility of the decl.
> @@ -5271,7 +5084,7 @@ get_decl_name_for_comparison(const decl_base &d)
> // other anymous types of the same kind.
> string r;
> r += get_generic_anonymous_internal_type_name(&d);
> - return d.get_environment()->intern(r);
> + return d.get_environment().intern(r);
> }
>
> interned_string n = (is_anonymous_or_typedef_named(d)
> @@ -6722,8 +6535,7 @@ strip_typedef(const type_base_sptr type)
> return type;
> }
>
> - environment* env = type->get_environment();
> - ABG_ASSERT(env);
> + const environment& env = type->get_environment();
> type_base_sptr t = type;
>
> if (const typedef_decl_sptr ty = is_typedef(t))
> @@ -6818,9 +6630,6 @@ strip_typedef(const type_base_sptr type)
> ty->get_alignment_in_bits()));
> }
>
> - if (!t->get_environment())
> - set_environment_for_artifact(t, env);
> -
> if (!t->get_translation_unit())
> t->set_translation_unit(type->get_translation_unit());
>
> @@ -6852,12 +6661,12 @@ strip_useless_const_qualification(const qualified_type_def_sptr t)
>
> decl_base_sptr result = t;
> type_base_sptr u = t->get_underlying_type();
> - environment* env = t->get_environment();
> + const environment& env = t->get_environment();
>
> if ((t->get_cv_quals() & qualified_type_def::CV_CONST
> && (is_reference_type(u)))
> || (t->get_cv_quals() & qualified_type_def::CV_CONST
> - && env->is_void_type(u))
> + && env.is_void_type(u))
> || t->get_cv_quals() == qualified_type_def::CV_NONE)
> // Let's strip the const qualifier because a reference is always
> // 'const' and a const void doesn't make sense. They will just
> @@ -7696,7 +7505,7 @@ struct scope_decl::priv
> /// @param locus the source location where the scope_decl is defined.
> ///
> /// @param vis the visibility of the declaration.
> -scope_decl::scope_decl(const environment* env,
> +scope_decl::scope_decl(const environment& env,
> const string& name,
> const location& locus,
> visibility vis)
> @@ -7712,7 +7521,7 @@ scope_decl::scope_decl(const environment* env,
> /// @param l the source location where the scope_decl is defined.
> ///
> /// @param vis the visibility of the declaration.
> -scope_decl::scope_decl(const environment* env, location& l)
> +scope_decl::scope_decl(const environment& env, location& l)
> : type_or_decl_base(env, ABSTRACT_SCOPE_DECL|ABSTRACT_DECL_BASE),
> decl_base(env, "", l),
> priv_(new priv)
> @@ -7898,9 +7707,6 @@ scope_decl::add_member_decl(const decl_base_sptr& member)
>
> update_qualified_name(member);
>
> - if (const environment* env = get_environment())
> - set_environment_for_artifact(member, env);
> -
> if (translation_unit* tu = get_translation_unit())
> {
> if (translation_unit* existing_tu = member->get_translation_unit())
> @@ -8043,9 +7849,6 @@ scope_decl::insert_member_decl(decl_base_sptr member,
>
> update_qualified_name(member);
>
> - if (const environment* env = get_environment())
> - set_environment_for_artifact(member, env);
> -
> if (translation_unit* tu = get_translation_unit())
> {
> if (translation_unit* existing_tu = member->get_translation_unit())
> @@ -8714,18 +8517,18 @@ get_generic_anonymous_internal_type_name(const decl_base *d)
> {
> ABG_ASSERT(has_generic_anonymous_internal_type_name(d));
>
> - const environment *env = d->get_environment();
> + const environment&env = d->get_environment();
>
> interned_string result;
> if (is_class_type(d))
> result =
> - env->intern(tools_utils::get_anonymous_struct_internal_name_prefix());
> + env.intern(tools_utils::get_anonymous_struct_internal_name_prefix());
> else if (is_union_type(d))
> result =
> - env->intern(tools_utils::get_anonymous_union_internal_name_prefix());
> + env.intern(tools_utils::get_anonymous_union_internal_name_prefix());
> else if (is_enum_type(d))
> result =
> - env->intern(tools_utils::get_anonymous_enum_internal_name_prefix());
> + env.intern(tools_utils::get_anonymous_enum_internal_name_prefix());
> else
> ABG_ASSERT_NOT_REACHED;
>
> @@ -8795,15 +8598,14 @@ get_type_name(const type_base* t, bool qualified, bool internal)
> {
> string r;
> r += get_generic_anonymous_internal_type_name(d);
> - return t->get_environment()->intern(r);
> + return t->get_environment().intern(r);
> }
>
> if (qualified)
> return d->get_qualified_name(internal);
>
> - const environment *env = d->get_environment();
> - ABG_ASSERT(env);
> - return env->intern(get_internal_integral_type_name(t));
> + const environment&env = d->get_environment();
> + return env.intern(get_internal_integral_type_name(t));
> }
>
> if (qualified)
> @@ -8844,13 +8646,11 @@ interned_string
> get_name_of_pointer_to_type(const type_base& pointed_to_type,
> bool qualified, bool internal)
> {
> - const environment* env = pointed_to_type.get_environment();
> - ABG_ASSERT(env);
> -
> + const environment& env = pointed_to_type.get_environment();
> string tn = get_type_name(pointed_to_type, qualified, internal);
> tn = tn + "*";
>
> - return env->intern(tn);
> + return env.intern(tn);
> }
>
> /// Get the name of the reference to a given type.
> @@ -8869,8 +8669,7 @@ get_name_of_reference_to_type(const type_base& pointed_to_type,
> bool lvalue_reference,
> bool qualified, bool internal)
> {
> - const environment* env = pointed_to_type.get_environment();
> - ABG_ASSERT(env);
> + const environment& env = pointed_to_type.get_environment();
>
> string name = get_type_name(pointed_to_type, qualified, internal);
> if (lvalue_reference)
> @@ -8878,7 +8677,7 @@ get_name_of_reference_to_type(const type_base& pointed_to_type,
> else
> name = name + "&&";
>
> - return env->intern(name);
> + return env.intern(name);
> }
>
> /// Get the name of a qualified type, given the underlying type and
> @@ -8900,8 +8699,7 @@ get_name_of_qualified_type(const type_base_sptr& underlying_type,
> qualified_type_def::CV quals,
> bool qualified, bool internal)
> {
> - const environment* env = underlying_type->get_environment();
> - ABG_ASSERT(env);
> + const environment& env = underlying_type->get_environment();
>
> string quals_repr = get_string_representation_of_cv_quals(quals);
> string name = get_type_name(underlying_type, qualified, internal);
> @@ -8931,7 +8729,7 @@ get_name_of_qualified_type(const type_base_sptr& underlying_type,
> name = quals_repr + " " + name;
> }
>
> - return env->intern(name);
> + return env.intern(name);
> }
>
> /// Get the name of a given function type and return a copy of it.
> @@ -8994,8 +8792,7 @@ get_function_type_name(const function_type& fn_type,
> internal
> ? peel_typedef_type(fn_type.get_return_type())
> : fn_type.get_return_type();
> - const environment* env = fn_type.get_environment();
> - ABG_ASSERT(env);
> + const environment& env = fn_type.get_environment();
>
> o << get_pretty_representation(return_type, internal);
>
> @@ -9015,7 +8812,7 @@ get_function_type_name(const function_type& fn_type,
> }
> o <<")";
>
> - return env->intern(o.str());
> + return env.intern(o.str());
> }
>
> /// Get the name of a given method type and return a copy of it.
> @@ -9076,8 +8873,7 @@ get_method_type_name(const method_type& fn_type,
> internal
> ? peel_typedef_type(fn_type.get_return_type())
> : fn_type.get_return_type();
> - const environment* env = fn_type.get_environment();
> - ABG_ASSERT(env);
> + const environment& env = fn_type.get_environment();
>
> if (return_type)
> o << return_type->get_cached_pretty_representation(internal);
> @@ -9112,7 +8908,7 @@ get_method_type_name(const method_type& fn_type,
> }
> o <<")";
>
> - return env->intern(o.str());
> + return env.intern(o.str());
> }
>
> /// Build and return a copy of the pretty representation of an ABI
> @@ -10572,7 +10368,7 @@ is_void_pointer_type(const type_base* type)
> // Look through typedefs in the pointed-to type as well.
> type_base * ty = t->get_pointed_to_type().get();
> ty = peel_qualified_or_typedef_type(ty);
> - if (ty->get_environment()->is_void_type(ty))
> + if (ty->get_environment().is_void_type(ty))
> return ty;
>
> return 0;
> @@ -11198,10 +10994,9 @@ lookup_basic_type(const interned_string& type_name, const translation_unit& tu)
> type_decl_sptr
> lookup_basic_type(const string& type_name, const translation_unit& tu)
> {
> - const environment* env = tu.get_environment();
> - ABG_ASSERT(env);
> + const environment& env = tu.get_environment();
>
> - interned_string s = env->intern(type_name);
> + interned_string s = env.intern(type_name);
> return lookup_basic_type(s, tu);
> }
>
> @@ -11221,10 +11016,8 @@ lookup_basic_type(const string& type_name, const translation_unit& tu)
> class_decl_sptr
> lookup_class_type(const string& fqn, const translation_unit& tu)
> {
> - const environment* env = tu.get_environment();
> - ABG_ASSERT(env);
> -
> - interned_string s = env->intern(fqn);
> + const environment& env = tu.get_environment();
> + interned_string s = env.intern(fqn);
> return lookup_class_type(s, tu);
> }
>
> @@ -11278,10 +11071,8 @@ lookup_union_type(const interned_string& type_name, const translation_unit& tu)
> union_decl_sptr
> lookup_union_type(const string& fqn, const translation_unit& tu)
> {
> - const environment* env = tu.get_environment();
> - ABG_ASSERT(env);
> -
> - interned_string s = env->intern(fqn);
> + const environment& env = tu.get_environment();
> + interned_string s = env.intern(fqn);
> return lookup_union_type(s, tu);
> }
>
> @@ -11312,10 +11103,8 @@ lookup_union_type_per_location(const interned_string &loc, const corpus& corp)
> union_decl_sptr
> lookup_union_type_per_location(const string& loc, const corpus& corp)
> {
> - const environment* env = corp.get_environment();
> - ABG_ASSERT(env);
> -
> - return lookup_union_type_per_location(env->intern(loc), corp);
> + const environment& env = corp.get_environment();
> + return lookup_union_type_per_location(env.intern(loc), corp);
> }
>
> /// Lookup an enum type from a translation unit.
> @@ -11350,10 +11139,8 @@ lookup_enum_type(const interned_string& type_name, const translation_unit& tu)
> enum_type_decl_sptr
> lookup_enum_type(const string& type_name, const translation_unit& tu)
> {
> - const environment* env = tu.get_environment();
> - ABG_ASSERT(env);
> -
> - interned_string s = env->intern(type_name);
> + const environment& env = tu.get_environment();
> + interned_string s = env.intern(type_name);
> return lookup_enum_type(s, tu);
> }
>
> @@ -11392,10 +11179,8 @@ lookup_typedef_type(const interned_string& type_name,
> typedef_decl_sptr
> lookup_typedef_type(const string& type_name, const translation_unit& tu)
> {
> - const environment* env = tu.get_environment();
> - ABG_ASSERT(env);
> -
> - interned_string s = env->intern(type_name);
> + const environment& env = tu.get_environment();
> + interned_string s = env.intern(type_name);
> return lookup_typedef_type(s, tu);
> }
>
> @@ -11481,10 +11266,8 @@ lookup_pointer_type(const interned_string& type_name,
> pointer_type_def_sptr
> lookup_pointer_type(const string& type_name, const translation_unit& tu)
> {
> - const environment* env = tu.get_environment();
> - ABG_ASSERT(env);
> -
> - interned_string s = env->intern(type_name);
> + const environment& env = tu.get_environment();
> + interned_string s = env.intern(type_name);
> return lookup_pointer_type(s, tu);
> }
>
> @@ -11666,9 +11449,8 @@ lookup_type(const interned_string& fqn,
> type_base_sptr
> lookup_type(const string& fqn, const translation_unit& tu)
> {
> - const environment *env = tu.get_environment();
> - ABG_ASSERT(env);
> - interned_string ifqn = env->intern(fqn);
> + const environment&env = tu.get_environment();
> + interned_string ifqn = env.intern(fqn);
> return lookup_type(ifqn, tu);
> }
>
> @@ -12450,10 +12232,8 @@ lookup_basic_type_per_location(const interned_string &loc,
> type_decl_sptr
> lookup_basic_type_per_location(const string &loc, const corpus &corp)
> {
> - const environment* env = corp.get_environment();
> - ABG_ASSERT(env);
> -
> - return lookup_basic_type_per_location(env->intern(loc), corp);
> + const environment& env = corp.get_environment();
> + return lookup_basic_type_per_location(env.intern(loc), corp);
> }
>
> /// Look into a given corpus to find a basic type which has a given
> @@ -12471,7 +12251,7 @@ lookup_basic_type_per_location(const string &loc, const corpus &corp)
> type_decl_sptr
> lookup_basic_type(const string& qualified_name, const corpus& corp)
> {
> - return lookup_basic_type(corp.get_environment()->intern(qualified_name),
> + return lookup_basic_type(corp.get_environment().intern(qualified_name),
> corp);
> }
>
> @@ -12508,7 +12288,7 @@ lookup_class_type(const class_decl& t, const corpus& corp)
> class_decl_sptr
> lookup_class_type(const string& qualified_name, const corpus& corp)
> {
> - interned_string s = corp.get_environment()->intern(qualified_name);
> + interned_string s = corp.get_environment().intern(qualified_name);
> return lookup_class_type(s, corp);
> }
>
> @@ -12595,7 +12375,7 @@ lookup_decl_only_class_types(const interned_string& qualified_name,
> const type_base_wptrs_type*
> lookup_class_types(const string& qualified_name, const corpus& corp)
> {
> - interned_string s = corp.get_environment()->intern(qualified_name);
> + interned_string s = corp.get_environment().intern(qualified_name);
> return lookup_class_types(s, corp);
> }
>
> @@ -12627,10 +12407,8 @@ lookup_class_type_per_location(const interned_string& loc,
> class_decl_sptr
> lookup_class_type_per_location(const string &loc, const corpus &corp)
> {
> - const environment* env = corp.get_environment();
> - ABG_ASSERT(env);
> -
> - return lookup_class_type_per_location(env->intern(loc), corp);
> + const environment& env = corp.get_environment();
> + return lookup_class_type_per_location(env.intern(loc), corp);
> }
>
> /// Look into a given corpus to find a union type which has a given
> @@ -12670,7 +12448,7 @@ lookup_union_type(const interned_string& type_name, const corpus& corp)
> union_decl_sptr
> lookup_union_type(const string& type_name, const corpus& corp)
> {
> - interned_string s = corp.get_environment()->intern(type_name);
> + interned_string s = corp.get_environment().intern(type_name);
> return lookup_union_type(s, corp);
> }
>
> @@ -12708,7 +12486,7 @@ lookup_enum_type(const enum_type_decl& t, const corpus& corp)
> enum_type_decl_sptr
> lookup_enum_type(const string& qualified_name, const corpus& corp)
> {
> - interned_string s = corp.get_environment()->intern(qualified_name);
> + interned_string s = corp.get_environment().intern(qualified_name);
> return lookup_enum_type(s, corp);
> }
>
> @@ -12764,7 +12542,7 @@ lookup_enum_types(const interned_string& qualified_name, const corpus& corp)
> const type_base_wptrs_type*
> lookup_enum_types(const string& qualified_name, const corpus& corp)
> {
> - interned_string s = corp.get_environment()->intern(qualified_name);
> + interned_string s = corp.get_environment().intern(qualified_name);
> return lookup_enum_types(s, corp);
> }
>
> @@ -12795,10 +12573,8 @@ lookup_enum_type_per_location(const interned_string &loc, const corpus& corp)
> enum_type_decl_sptr
> lookup_enum_type_per_location(const string &loc, const corpus &corp)
> {
> - const environment* env = corp.get_environment();
> - ABG_ASSERT(env);
> -
> - return lookup_enum_type_per_location(env->intern(loc), corp);
> + const environment& env = corp.get_environment();
> + return lookup_enum_type_per_location(env.intern(loc), corp);
> }
>
> /// Look into a given corpus to find a typedef type which has the
> @@ -12835,7 +12611,7 @@ lookup_typedef_type(const typedef_decl& t, const corpus& corp)
> typedef_decl_sptr
> lookup_typedef_type(const string& qualified_name, const corpus& corp)
> {
> - interned_string s = corp.get_environment()->intern(qualified_name);
> + interned_string s = corp.get_environment().intern(qualified_name);
> return lookup_typedef_type(s, corp);
> }
>
> @@ -12892,10 +12668,8 @@ lookup_typedef_type_per_location(const interned_string &loc, const corpus &corp)
> typedef_decl_sptr
> lookup_typedef_type_per_location(const string &loc, const corpus &corp)
> {
> - const environment* env = corp.get_environment();
> - ABG_ASSERT(env);
> -
> - return lookup_typedef_type_per_location(env->intern(loc), corp);
> + const environment& env = corp.get_environment();
> + return lookup_typedef_type_per_location(env.intern(loc), corp);
> }
>
> /// Look into a corpus to find a class, union or typedef type which
> @@ -13329,7 +13103,7 @@ maybe_update_types_lookup_map(const shared_ptr<TypeKind>& type,
> else if (location l = type->get_location())
> {
> string str = l.expand();
> - s = type->get_environment()->intern(str);
> + s = type->get_environment().intern(str);
> }
>
> istring_type_base_wptrs_map_type::iterator i = types_map.find(s);
> @@ -13384,12 +13158,12 @@ maybe_update_types_lookup_map<class_decl>(const class_decl_sptr& class_type,
> if (use_type_name_as_key)
> {
> string qname = type->get_qualified_name();
> - s = type->get_environment()->intern(qname);
> + s = type->get_environment().intern(qname);
> }
> else if (location l = type->get_location())
> {
> string str = l.expand();
> - s = type->get_environment()->intern(str);
> + s = type->get_environment().intern(str);
> }
>
> bool result = false;
> @@ -13988,7 +13762,6 @@ synthesize_type_from_translation_unit(const type_base_sptr& type,
> p->get_size_in_bits(),
> p->get_alignment_in_bits(),
> p->get_location()));
> - result->set_environment(pointed_to_type->get_environment());
> }
> }
> else if (reference_type_def_sptr r = is_reference_type(type))
> @@ -14002,7 +13775,6 @@ synthesize_type_from_translation_unit(const type_base_sptr& type,
> r->get_size_in_bits(),
> r->get_alignment_in_bits(),
> r->get_location()));
> - result->set_environment(pointed_to_type->get_environment());
> }
> }
> else if (function_type_sptr f = is_function_type(type))
> @@ -14046,13 +13818,12 @@ synthesize_function_type_from_translation_unit(const function_type& fn_type,
> {
> function_type_sptr nil = function_type_sptr();
>
> - environment* env = tu.get_environment();
> - ABG_ASSERT(env);
> + const environment& env = tu.get_environment();
>
> type_base_sptr return_type = fn_type.get_return_type();
> type_base_sptr result_return_type;
> - if (!return_type || env->is_void_type(return_type))
> - result_return_type = env->get_void_type();
> + if (!return_type || env.is_void_type(return_type))
> + result_return_type = env.get_void_type();
> else
> result_return_type = synthesize_type_from_translation_unit(return_type, tu);
> if (!result_return_type)
> @@ -14104,9 +13875,6 @@ synthesize_function_type_from_translation_unit(const function_type& fn_type,
> fn_type.get_alignment_in_bits()));
>
> tu.priv_->synthesized_types_.push_back(result_fn_type);
> - // The new synthesized type must be in the same environment as its
> - // translation unit.
> - result_fn_type->set_environment(tu.get_environment());
> tu.bind_function_type_life_time(result_fn_type);
>
> canonicalize(result_fn_type);
> @@ -14149,17 +13917,14 @@ demangle_cplus_mangled_name(const string& mangled_name)
> ///
> /// @return either @p t if it is non-null, or the void type.
> type_base_sptr
> -type_or_void(const type_base_sptr t, const environment* env)
> +type_or_void(const type_base_sptr t, const environment& env)
> {
> type_base_sptr r;
>
> if (t)
> r = t;
> else
> - {
> - ABG_ASSERT(env);
> - r = type_base_sptr(env->get_void_type());
> - }
> + r = type_base_sptr(env.get_void_type());
>
> return r;
> }
> @@ -14239,7 +14004,7 @@ types_defined_same_linux_kernel_corpus_public(const type_base& t1,
> {
> if (c1->get_is_declaration_only() != c2->get_is_declaration_only())
> {
> - if (c1->get_environment()->decl_only_class_equals_definition())
> + if (c1->get_environment().decl_only_class_equals_definition())
> // At least one of classes/union is declaration-only.
> // Because we are in a context in which a declaration-only
> // class/union is equal to all definitions of that
> @@ -14316,13 +14081,13 @@ compare_types_during_canonicalization(const type_base_sptr& canonical_type,
> const type_base_sptr& candidate_type)
> {
> #ifdef WITH_DEBUG_TYPE_CANONICALIZATION
> - environment *env = canonical_type->get_environment();
> - if (env->debug_type_canonicalization_is_on())
> + const environment&env = canonical_type->get_environment();
> + if (env.debug_type_canonicalization_is_on())
> {
> bool canonical_equality = false, structural_equality = false;
> - env->priv_->use_canonical_type_comparison_ = false;
> + env.priv_->use_canonical_type_comparison_ = false;
> structural_equality = canonical_type == candidate_type;
> - env->priv_->use_canonical_type_comparison_ = true;
> + env.priv_->use_canonical_type_comparison_ = true;
> canonical_equality = canonical_type == candidate_type;
> if (canonical_equality != structural_equality)
> {
> @@ -14365,8 +14130,7 @@ type_base::get_canonical_type_for(type_base_sptr t)
> if (!t)
> return t;
>
> - environment* env = t->get_environment();
> - ABG_ASSERT(env);
> + environment& env = const_cast<environment&>(t->get_environment());
>
> if (is_non_canonicalized_type(t))
> // This type should not be canonicalized!
> @@ -14377,7 +14141,7 @@ type_base::get_canonical_type_for(type_base_sptr t)
>
> // Look through decl-only types (classes, unions and enums)
> bool decl_only_class_equals_definition =
> - (odr_is_relevant(*t) || env->decl_only_class_equals_definition());
> + (odr_is_relevant(*t) || env.decl_only_class_equals_definition());
>
> class_or_union_sptr class_or_union = is_class_or_union_type(t);
>
> @@ -14424,7 +14188,7 @@ type_base::get_canonical_type_for(type_base_sptr t)
> // type.
> type_base_sptr canonical_type_present_in_corpus;
> environment::canonical_types_map_type& types =
> - env->get_canonical_types_map();
> + env.get_canonical_types_map();
>
> type_base_sptr result;
> environment::canonical_types_map_type::iterator i = types.find(repr);
> @@ -14465,20 +14229,20 @@ type_base::get_canonical_type_for(type_base_sptr t)
> // declaration-only struct S should be left alone and not
> // resolved to any of the two definitions of struct S.
> bool saved_decl_only_class_equals_definition =
> - env->decl_only_class_equals_definition();
> - env->do_on_the_fly_canonicalization(true);
> + env.decl_only_class_equals_definition();
> + env.do_on_the_fly_canonicalization(true);
> // Compare types by considering that decl-only classes don't
> // equal their definition.
> - env->decl_only_class_equals_definition(false);
> - env->priv_->allow_type_comparison_results_caching(true);
> + env.decl_only_class_equals_definition(false);
> + env.priv_->allow_type_comparison_results_caching(true);
> bool equal = (types_defined_same_linux_kernel_corpus_public(**it, *t)
> || compare_types_during_canonicalization(*it, t));
> // Restore the state of the on-the-fly-canonicalization and
> // the decl-only-class-being-equal-to-a-matching-definition
> // flags.
> - env->priv_->allow_type_comparison_results_caching(false);
> - env->do_on_the_fly_canonicalization(false);
> - env->decl_only_class_equals_definition
> + env.priv_->allow_type_comparison_results_caching(false);
> + env.do_on_the_fly_canonicalization(false);
> + env.decl_only_class_equals_definition
> (saved_decl_only_class_equals_definition);
> if (equal)
> {
> @@ -14487,12 +14251,12 @@ type_base::get_canonical_type_for(type_base_sptr t)
> }
> }
> #ifdef WITH_DEBUG_SELF_COMPARISON
> - if (env->self_comparison_debug_is_on())
> + if (env.self_comparison_debug_is_on())
> {
> // So we are debugging the canonicalization process,
> // possibly via the use of 'abidw --debug-abidiff <binary>'.
> corpus_sptr corp1, corp2;
> - env->get_self_comparison_debug_inputs(corp1, corp2);
> + env.get_self_comparison_debug_inputs(corp1, corp2);
> if (corp1 && corp2 && t->get_corpus() == corp2.get())
> {
> // If 't' comes from the second corpus, then it *must*
> @@ -14503,7 +14267,7 @@ type_base::get_canonical_type_for(type_base_sptr t)
> // have canonical types coming from the first corpus.
> if (result)
> {
> - if (!env->priv_->
> + if (!env.priv_->
> check_canonical_type_from_abixml_during_self_comp(t,
> result))
> // The canonical type of the type re-read from abixml
> @@ -14521,7 +14285,7 @@ type_base::get_canonical_type_for(type_base_sptr t)
> else //!result
> {
> uintptr_t ptr_val = reinterpret_cast<uintptr_t>(t.get());
> - string type_id = env->get_type_id_from_pointer(ptr_val);
> + string type_id = env.get_type_id_from_pointer(ptr_val);
> if (type_id.empty())
> type_id = "type-id-<not-found>";
> // We are in the case where 't' is different from all
> @@ -14743,7 +14507,7 @@ decl_base::set_definition_of_declaration(const decl_base_sptr& d)
> /// @param s the size of the type, in bits.
> ///
> /// @param a the alignment of the type, in bits.
> -type_base::type_base(const environment* e, size_t s, size_t a)
> +type_base::type_base(const environment& e, size_t s, size_t a)
> : type_or_decl_base(e, ABSTRACT_TYPE_BASE|ABSTRACT_TYPE_BASE),
> priv_(new priv(s, a))
> {}
> @@ -14796,7 +14560,7 @@ type_base::get_cached_pretty_representation(bool internal) const
> if (!get_naked_canonical_type() || priv_->internal_cached_repr_.empty())
> {
> string r = ir::get_pretty_representation(this, internal);
> - priv_->internal_cached_repr_ = get_environment()->intern(r);
> + priv_->internal_cached_repr_ = get_environment().intern(r);
> }
> return priv_->internal_cached_repr_;
> }
> @@ -14804,7 +14568,7 @@ type_base::get_cached_pretty_representation(bool internal) const
> if (!get_naked_canonical_type() || priv_->cached_repr_.empty())
> {
> string r = ir::get_pretty_representation(this, internal);
> - priv_->cached_repr_ = get_environment()->intern(r);
> + priv_->cached_repr_ = get_environment().intern(r);
> }
>
> return priv_->cached_repr_;
> @@ -15291,7 +15055,7 @@ integral_type::operator string() const
> /// @param linkage_name the linkage_name of the current type declaration.
> ///
> /// @param vis the visibility of the type declaration.
> -type_decl::type_decl(const environment* env,
> +type_decl::type_decl(const environment& env,
> const string& name,
> size_t size_in_bits,
> size_t alignment_in_bits,
> @@ -15476,8 +15240,8 @@ type_decl::get_qualified_name(interned_string& qualified_name,
> const interned_string&
> type_decl::get_qualified_name(bool internal) const
> {
> - const environment* env = get_environment();
> - ABG_ASSERT(env);
> + const environment& env = get_environment();
> +
>
> if (internal)
> if (is_integral_type(this))
> @@ -15486,13 +15250,13 @@ type_decl::get_qualified_name(bool internal) const
> {
> if (decl_base::priv_->internal_qualified_name_.empty())
> decl_base::priv_->internal_qualified_name_ =
> - env->intern(get_internal_integral_type_name(this));
> + env.intern(get_internal_integral_type_name(this));
> return decl_base::priv_->internal_qualified_name_;
> }
> else
> {
> decl_base::priv_->temporary_internal_qualified_name_ =
> - env->intern(get_internal_integral_type_name(this));
> + env.intern(get_internal_integral_type_name(this));
> return decl_base::priv_->temporary_internal_qualified_name_;
> }
> }
> @@ -15569,7 +15333,7 @@ type_decl::~type_decl()
> /// @param locus the source location where the type is defined.
> ///
> /// @param vis the visibility of the type.
> -scope_type_decl::scope_type_decl(const environment* env,
> +scope_type_decl::scope_type_decl(const environment& env,
> const string& name,
> size_t size_in_bits,
> size_t alignment_in_bits,
> @@ -15706,7 +15470,7 @@ scope_type_decl::~scope_type_decl()
> /// @param locus the source location where the namespace is defined.
> ///
> /// @param vis the visibility of the namespace.
> -namespace_decl::namespace_decl(const environment* env,
> +namespace_decl::namespace_decl(const environment& env,
> const string& name,
> const location& locus,
> visibility vis)
> @@ -15883,7 +15647,7 @@ qualified_type_def::build_name(bool fully_qualified, bool internal) const
> // especially during the construction of the type, while the
> // underlying type is not yet constructed. In that case, let's do
> // like if the underlying type is the 'void' type.
> - t = get_environment()->get_void_type();
> + t = get_environment().get_void_type();
>
> return get_name_of_qualified_type(t, get_cv_quals(),
> fully_qualified,
> @@ -15922,7 +15686,7 @@ qualified_type_def::qualified_type_def(type_base_sptr type,
> priv_(new priv(quals, type))
> {
> runtime_type_instance(this);
> - interned_string name = type->get_environment()->intern(build_name(false));
> + interned_string name = type->get_environment().intern(build_name(false));
> set_name(name);
> }
>
> @@ -15933,7 +15697,7 @@ qualified_type_def::qualified_type_def(type_base_sptr type,
> /// @param quals a bitfield representing the const/volatile qualifiers
> ///
> /// @param locus the location of the qualified type definition
> -qualified_type_def::qualified_type_def(environment* env,
> +qualified_type_def::qualified_type_def(const environment& env,
> CV quals,
> const location& locus)
> : type_or_decl_base(env,
> @@ -15948,7 +15712,7 @@ qualified_type_def::qualified_type_def(environment* env,
> runtime_type_instance(this);
> // We don't yet have an underlying type. So for naming purpose,
> // let's temporarily pretend the underlying type is 'void'.
> - interned_string name = env->intern("void");
> + interned_string name = env.intern("void");
> set_name(name);
> }
>
> @@ -16109,8 +15873,8 @@ qualified_type_def::get_qualified_name(interned_string& qualified_name,
> const interned_string&
> qualified_type_def::get_qualified_name(bool internal) const
> {
> - const environment* env = get_environment();
> - ABG_ASSERT(env);
> + const environment& env = get_environment();
> +
>
> if (!get_canonical_type())
> {
> @@ -16124,14 +15888,14 @@ qualified_type_def::get_qualified_name(bool internal) const
> // Lets compute it and return a reference to where it's
> // stored.
> priv_->temporary_internal_name_ =
> - env->intern(build_name(true, /*internal=*/true));
> + env.intern(build_name(true, /*internal=*/true));
> return priv_->temporary_internal_name_;
> }
> else
> {
> // We are asked to return a temporary non-internal name.
> set_temporary_qualified_name
> - (env->intern(build_name(true, /*internal=*/false)));
> + (env.intern(build_name(true, /*internal=*/false)));
> return peek_temporary_qualified_name();
> }
> }
> @@ -16143,7 +15907,7 @@ qualified_type_def::get_qualified_name(bool internal) const
> {
> if (priv_->internal_name_.empty())
> priv_->internal_name_ =
> - env->intern(build_name(/*qualified=*/true,
> + env.intern(build_name(/*qualified=*/true,
> /*internal=*/true));
> return priv_->internal_name_;
> }
> @@ -16151,7 +15915,7 @@ qualified_type_def::get_qualified_name(bool internal) const
> {
> if (peek_qualified_name().empty())
> set_qualified_name
> - (env->intern(build_name(/*qualified=*/true,
> + (env.intern(build_name(/*qualified=*/true,
> /*internal=*/false)));
> return peek_qualified_name();
> }
> @@ -16225,7 +15989,7 @@ qualified_type_def::set_underlying_type(const type_base_sptr& t)
> // Now we need to update other properties that depend on the new underlying type.
> set_size_in_bits(t->get_size_in_bits());
> set_alignment_in_bits(t->get_alignment_in_bits());
> - interned_string name = get_environment()->intern(build_name(false));
> + interned_string name = get_environment().intern(build_name(false));
> set_name(name);
> if (scope_decl* s = get_scope())
> {
> @@ -16350,7 +16114,7 @@ struct pointer_type_def::priv
> interned_string temp_internal_qualified_name_;
>
> priv(const type_base_sptr& t)
> - : pointed_to_type_(type_or_void(t, 0)),
> + : pointed_to_type_(type_or_void(t, t->get_environment())),
> naked_pointed_to_type_(t.get())
> {}
>
> @@ -16396,10 +16160,10 @@ pointer_type_def::pointer_type_def(const type_base_sptr& pointed_to,
> try
> {
> ABG_ASSERT(pointed_to);
> - const environment* env = pointed_to->get_environment();
> + const environment& env = pointed_to->get_environment();
> decl_base_sptr pto = dynamic_pointer_cast<decl_base>(pointed_to);
> string name = (pto ? pto->get_name() : string("void")) + "*";
> - set_name(env->intern(name));
> + set_name(env.intern(name));
> if (pto)
> set_visibility(pto->get_visibility());
> }
> @@ -16416,7 +16180,7 @@ pointer_type_def::pointer_type_def(const type_base_sptr& pointed_to,
> /// @param align_in_bits the alignment of the type, in bits.
> ///
> /// @param locus the source location where the type was defined.
> -pointer_type_def::pointer_type_def(environment* env, size_t size_in_bits,
> +pointer_type_def::pointer_type_def(const environment& env, size_t size_in_bits,
> size_t alignment_in_bits,
> const location& locus)
> : type_or_decl_base(env,
> @@ -16429,7 +16193,7 @@ pointer_type_def::pointer_type_def(environment* env, size_t size_in_bits,
> {
> runtime_type_instance(this);
> string name = string("void") + "*";
> - set_name(env->intern(name));
> + set_name(env.intern(name));
> }
>
> /// Set the pointed-to type of the pointer.
> @@ -16444,11 +16208,10 @@ pointer_type_def::set_pointed_to_type(const type_base_sptr& t)
>
> try
> {
> - const environment* env = t->get_environment();
> - ABG_ASSERT(get_environment() == env);
> + const environment& env = t->get_environment();
> decl_base_sptr pto = dynamic_pointer_cast<decl_base>(t);
> string name = (pto ? pto->get_name() : string("void")) + "*";
> - set_name(env->intern(name));
> + set_name(env.intern(name));
> if (pto)
> set_visibility(pto->get_visibility());
> }
> @@ -16763,11 +16526,12 @@ reference_type_def::reference_type_def(const type_base_sptr pointed_to,
>
> if (!is_lvalue())
> name += "&";
> - environment* env = pointed_to->get_environment();
> - ABG_ASSERT(env);
> - set_name(env->intern(name));
> + const environment& env = pointed_to->get_environment();
> + set_name(env.intern(name));
>
> - pointed_to_type_ = type_base_wptr(type_or_void(pointed_to, 0));
> + pointed_to_type_ =
> + type_base_wptr(type_or_void(pointed_to,
> + pointed_to->get_environment()));
> }
> catch (...)
> {}
> @@ -16790,7 +16554,7 @@ reference_type_def::reference_type_def(const type_base_sptr pointed_to,
> /// @param align_in_bits the alignment of the type, in bits.
> ///
> /// @param locus the source location of the type.
> -reference_type_def::reference_type_def(const environment* env, bool lvalue,
> +reference_type_def::reference_type_def(const environment& env, bool lvalue,
> size_t size_in_bits,
> size_t alignment_in_bits,
> const location& locus)
> @@ -16806,9 +16570,9 @@ reference_type_def::reference_type_def(const environment* env, bool lvalue,
> string name = "void&";
> if (!is_lvalue())
> name += "&";
> - ABG_ASSERT(env);
> - set_name(env->intern(name));
> - pointed_to_type_ = type_base_wptr(env->get_void_type());
> +
> + set_name(env.intern(name));
> + pointed_to_type_ = type_base_wptr(env.get_void_type());
> }
>
> /// Setter of the pointed_to type of the current reference type.
> @@ -16832,9 +16596,8 @@ reference_type_def::set_pointed_to_type(type_base_sptr& pointed_to_type)
> string name = string(pto->get_name()) + "&";
> if (!is_lvalue())
> name += "&";
> - environment* env = pto->get_environment();
> - ABG_ASSERT(env && env == get_environment());
> - set_name(env->intern(name));
> + const environment& env = pto->get_environment();
> + set_name(env.intern(name));
> }
> }
>
> @@ -17210,7 +16973,7 @@ struct array_type_def::subrange_type::priv
> /// @param underlying_type the underlying type of the subrange type.
> ///
> /// @param loc the source location where the type is defined.
> -array_type_def::subrange_type::subrange_type(const environment* env,
> +array_type_def::subrange_type::subrange_type(const environment& env,
> const string& name,
> bound_value lower_bound,
> bound_value upper_bound,
> @@ -17242,7 +17005,7 @@ array_type_def::subrange_type::subrange_type(const environment* env,
> /// @param loc the source location where the type is defined.
> ///
> /// @param l the language that generated this subrange.
> -array_type_def::subrange_type::subrange_type(const environment* env,
> +array_type_def::subrange_type::subrange_type(const environment& env,
> const string& name,
> bound_value lower_bound,
> bound_value upper_bound,
> @@ -17270,7 +17033,7 @@ array_type_def::subrange_type::subrange_type(const environment* env,
> /// @param loc the source location of the type.
> ///
> /// @param the language that generated this type.
> -array_type_def::subrange_type::subrange_type(const environment* env,
> +array_type_def::subrange_type::subrange_type(const environment& env,
> const string& name,
> bound_value upper_bound,
> const location& loc,
> @@ -17625,7 +17388,7 @@ array_type_def::array_type_def(const type_base_sptr e_type,
> /// @param subs a vector of the array's subranges(dimensions)
> ///
> /// @param locus the source location of the array type definition.
> -array_type_def::array_type_def(environment* env,
> +array_type_def::array_type_def(const environment& env,
> const std::vector<subrange_sptr>& subs,
> const location& locus)
> : type_or_decl_base(env,
> @@ -17655,9 +17418,6 @@ array_type_def::update_size()
> {
> for (const auto &sub : get_subranges())
> s *= sub->get_length();
> -
> - const environment* env = e->get_environment();
> - ABG_ASSERT(env);
> set_size_in_bits(s);
> }
> set_alignment_in_bits(e->get_alignment_in_bits());
> @@ -17900,7 +17660,7 @@ array_type_def::set_element_type(const type_base_sptr& element_type)
> {
> priv_->element_type_ = element_type;
> update_size();
> - set_name(get_environment()->intern(get_pretty_representation()));
> + set_name(get_environment().intern(get_pretty_representation()));
> }
>
> /// Append subranges from the vector @param subs to the current
> @@ -17913,7 +17673,7 @@ array_type_def::append_subranges(const std::vector<subrange_sptr>& subs)
> priv_->subranges_.push_back(sub);
>
> update_size();
> - set_name(get_environment()->intern(get_pretty_representation()));
> + set_name(get_environment().intern(get_pretty_representation()));
> }
>
> /// @return true if one of the sub-ranges of the array is infinite, or
> @@ -17964,8 +17724,8 @@ array_type_def::get_qualified_name(interned_string& qn, bool internal) const
> const interned_string&
> array_type_def::get_qualified_name(bool internal) const
> {
> - const environment* env = get_environment();
> - ABG_ASSERT(env);
> + const environment& env = get_environment();
> +
>
> if (internal)
> {
> @@ -17973,13 +17733,13 @@ array_type_def::get_qualified_name(bool internal) const
> {
> if (priv_->internal_qualified_name_.empty())
> priv_->internal_qualified_name_ =
> - env->intern(get_type_representation(*this, /*internal=*/true));
> + env.intern(get_type_representation(*this, /*internal=*/true));
> return priv_->internal_qualified_name_;
> }
> else
> {
> priv_->temp_internal_qualified_name_ =
> - env->intern(get_type_representation(*this, /*internal=*/true));
> + env.intern(get_type_representation(*this, /*internal=*/true));
> return priv_->temp_internal_qualified_name_;
> }
> }
> @@ -17988,13 +17748,13 @@ array_type_def::get_qualified_name(bool internal) const
> if (get_canonical_type())
> {
> if (decl_base::peek_qualified_name().empty())
> - set_qualified_name(env->intern(get_type_representation
> + set_qualified_name(env.intern(get_type_representation
> (*this, /*internal=*/false)));
> return decl_base::peek_qualified_name();
> }
> else
> {
> - set_temporary_qualified_name(env->intern(get_type_representation
> + set_temporary_qualified_name(env.intern(get_type_representation
> (*this,
> /*internal=*/false)));
> return decl_base::peek_temporary_qualified_name();
> @@ -18229,8 +17989,8 @@ enum_has_non_name_change(const enum_type_decl& l,
> }
>
> enum_type_decl &local_r = const_cast<enum_type_decl&>(r);
> - interned_string qn_r = l.get_environment()->intern(r.get_qualified_name());
> - interned_string qn_l = l.get_environment()->intern(l.get_qualified_name());
> + interned_string qn_r = l.get_environment().intern(r.get_qualified_name());
> + interned_string qn_l = l.get_environment().intern(l.get_qualified_name());
> string n_l = l.get_name();
> string n_r = r.get_name();
> local_r.set_qualified_name(qn_l);
> @@ -18576,10 +18336,9 @@ operator!=(const enum_type_decl_sptr& l, const enum_type_decl_sptr& r)
> /// enum_type_decl::enumerator.
> class enum_type_decl::enumerator::priv
> {
> - const environment* env_;
> - interned_string name_;
> + string name_;
> int64_t value_;
> - interned_string qualified_name_;
> + string qualified_name_;
> enum_type_decl* enum_type_;
>
> friend class enum_type_decl::enumerator;
> @@ -18587,16 +18346,13 @@ class enum_type_decl::enumerator::priv
> public:
>
> priv()
> - : env_(),
> - enum_type_()
> + : enum_type_()
> {}
>
> - priv(const environment* env,
> - const string& name,
> + priv(const string& name,
> int64_t value,
> enum_type_decl* e = 0)
> - : env_(env),
> - name_(env ? env->intern(name) : interned_string()),
> + : name_(name),
> value_(value),
> enum_type_(e)
> {}
> @@ -18609,7 +18365,6 @@ enum_type_decl::enumerator::enumerator()
>
> enum_type_decl::enumerator::~enumerator() = default;
>
> -
> /// Constructor of the @ref enum_type_decl::enumerator type.
> ///
> /// @param env the environment we are operating from.
> @@ -18617,18 +18372,16 @@ enum_type_decl::enumerator::~enumerator() = default;
> /// @param name the name of the enumerator.
> ///
> /// @param value the value of the enumerator.
> -enum_type_decl::enumerator::enumerator(const environment* env,
> - const string& name,
> +enum_type_decl::enumerator::enumerator(const string& name,
> int64_t value)
> - : priv_(new priv(env, name, value))
> + : priv_(new priv(name, value))
> {}
>
> /// Copy constructor of the @ref enum_type_decl::enumerator type.
> ///
> /// @param other enumerator to copy.
> enum_type_decl::enumerator::enumerator(const enumerator& other)
> - : priv_(new priv(other.get_environment(),
> - other.get_name(),
> + : priv_(new priv(other.get_name(),
> other.get_value(),
> other.get_enum_type()))
> {}
> @@ -18639,12 +18392,12 @@ enum_type_decl::enumerator::enumerator(const enumerator& other)
> enum_type_decl::enumerator&
> enum_type_decl::enumerator::operator=(const enumerator& o)
> {
> - priv_->env_ = o.get_environment();
> priv_->name_ = o.get_name();
> priv_->value_ = o.get_value();
> priv_->enum_type_ = o.get_enum_type();
> return *this;
> }
> +
> /// Equality operator
> ///
> /// @param other the enumerator to compare to the current
> @@ -18669,19 +18422,12 @@ bool
> enum_type_decl::enumerator::operator!=(const enumerator& other) const
> {return !operator==(other);}
>
> -/// Getter of the environment of this enumerator.
> -///
> -/// @return the environment of this enumerator.
> -const environment*
> -enum_type_decl::enumerator::get_environment() const
> -{return priv_->env_;}
> -
> /// Getter for the name of the current instance of
> /// enum_type_decl::enumerator.
> ///
> /// @return a reference to the name of the current instance of
> /// enum_type_decl::enumerator.
> -const interned_string&
> +const string&
> enum_type_decl::enumerator::get_name() const
> {return priv_->name_;}
>
> @@ -18698,17 +18444,15 @@ enum_type_decl::enumerator::get_name() const
> ///
> /// @return the qualified name of the current instance of
> /// enum_type_decl::enumerator.
> -const interned_string&
> +const string&
> enum_type_decl::enumerator::get_qualified_name(bool internal) const
> {
> if (priv_->qualified_name_.empty())
> {
> - const environment* env = priv_->enum_type_->get_environment();
> - ABG_ASSERT(env);
> priv_->qualified_name_ =
> - env->intern(get_enum_type()->get_qualified_name(internal)
> - + "::"
> - + get_name());
> + get_enum_type()->get_qualified_name(internal)
> + + "::"
> + + get_name();
> }
> return priv_->qualified_name_;
> }
> @@ -18718,11 +18462,7 @@ enum_type_decl::enumerator::get_qualified_name(bool internal) const
> /// @param n the new name.
> void
> enum_type_decl::enumerator::set_name(const string& n)
> -{
> - const environment* env = get_environment();
> - ABG_ASSERT(env);
> - priv_->name_ = env->intern(n);
> -}
> +{priv_->name_ = n;}
>
> /// Getter for the value of @ref enum_type_decl::enumerator.
> ///
> @@ -18810,7 +18550,7 @@ typedef_decl::typedef_decl(const string& name,
> ///
> /// @param vis the visibility of the typedef type.
> typedef_decl::typedef_decl(const string& name,
> - environment* env,
> + const environment& env,
> const location& locus,
> const string& mangled_name,
> visibility vis)
> @@ -19117,7 +18857,7 @@ var_decl::set_symbol(const elf_symbol_sptr& sym)
> priv_->symbol_ = sym;
> // The variable id cache that depends on the symbol must be
> // invalidated because the symbol changed.
> - priv_->id_ = get_environment()->intern("");
> + priv_->id_ = get_environment().intern("");
> }
>
> /// Gets the the underlying ELF symbol for the current variable,
> @@ -19241,10 +18981,10 @@ equals(const var_decl& l, const var_decl& r, change_kind* k)
> // The variables have underlying elf symbols that are equal, so
> // now, let's compare the decl_base part of the variables w/o
> // considering their decl names.
> - const environment* env = l.get_environment();
> + const environment& env = l.get_environment();
> const interned_string n1 = l.get_qualified_name(), n2 = r.get_qualified_name();
> - const_cast<var_decl&>(l).set_qualified_name(env->intern(""));
> - const_cast<var_decl&>(r).set_qualified_name(env->intern(""));
> + const_cast<var_decl&>(l).set_qualified_name(env.intern(""));
> + const_cast<var_decl&>(r).set_qualified_name(env.intern(""));
> bool decl_bases_different = !l.decl_base::operator==(r);
> const_cast<var_decl&>(l).set_qualified_name(n1);
> const_cast<var_decl&>(r).set_qualified_name(n2);
> @@ -19321,11 +19061,11 @@ var_decl::get_id() const
> sym_str = s->get_id_string();
> else if (!get_linkage_name().empty())
> sym_str = get_linkage_name();
> - const environment* env = get_type()->get_environment();
> - ABG_ASSERT(env);
> - priv_->id_ = env->intern(repr);
> +
> + const environment& env = get_type()->get_environment();
> + priv_->id_ = env.intern(repr);
> if (!sym_str.empty())
> - priv_->id_ = env->intern(priv_->id_ + "{" + sym_str + "}");
> + priv_->id_ = env.intern(priv_->id_ + "{" + sym_str + "}");
> }
> return priv_->id_;
> }
> @@ -19374,7 +19114,7 @@ var_decl::get_qualified_name(bool internal) const
> {
> // Display the anonymous data member in a way that makes sense.
> string r = get_pretty_representation(internal);
> - set_qualified_name(get_environment()->intern(r));
> + set_qualified_name(get_environment().intern(r));
> }
>
> return decl_base::get_qualified_name(internal);
> @@ -19614,7 +19354,7 @@ function_type::function_type(type_base_sptr return_type,
> /// @param size_in_bits the size of this type, in bits.
> ///
> /// @param alignment_in_bits the alignment of this type, in bits.
> -function_type::function_type(const environment* env,
> +function_type::function_type(const environment& env,
> size_t size_in_bits,
> size_t alignment_in_bits)
> : type_or_decl_base(env, FUNCTION_TYPE | ABSTRACT_TYPE_BASE),
> @@ -19772,7 +19512,7 @@ equals(const function_type& l,
> // comparison has been cached, let's just re-use it, rather than
> // comparing them all over again.
> bool cached_result = false;
> - if (l.get_environment()->priv_->is_type_comparison_cached(l, r,
> + if (l.get_environment().priv_->is_type_comparison_cached(l, r,
> cached_result))
> return cached_result;
> }
> @@ -19914,7 +19654,7 @@ equals(const function_type& l,
> // perform this caching also on the earlier return points of this
> // function. That would basically mean to redefine the RETURN macro
> // to make it perform this caching for us.
> - l.get_environment()->priv_->cache_type_comparison_result(l, r, result);
> + l.get_environment().priv_->cache_type_comparison_result(l, r, result);
>
> RETURN(result);
> #undef RETURN
> @@ -20186,7 +19926,7 @@ method_type::method_type(type_base_sptr return_type,
> /// @param size_in_bits the size of the type, expressed in bits.
> ///
> /// @param alignment_in_bits the alignment of the type, expressed in bits
> -method_type::method_type(const environment* env,
> +method_type::method_type(const environment& env,
> size_t size_in_bits,
> size_t alignment_in_bits)
> : type_or_decl_base(env, METHOD_TYPE | ABSTRACT_TYPE_BASE | FUNCTION_TYPE),
> @@ -20493,7 +20233,7 @@ function_decl::get_pretty_representation_of_declarator (bool internal) const
> if (parm.get() != first_parm.get())
> result += ", ";
> if (parm->get_variadic_marker()
> - || get_environment()->is_variadic_parameter_type(parm->get_type()))
> + || get_environment().is_variadic_parameter_type(parm->get_type()))
> result += "...";
> else
> {
> @@ -20581,7 +20321,7 @@ function_decl::set_symbol(const elf_symbol_sptr& sym)
> priv_->symbol_ = sym;
> // The function id cache that depends on the symbol must be
> // invalidated because the symbol changed.
> - priv_->id_ = get_environment()->intern("");
> + priv_->id_ = get_environment().intern("");
> }
>
> /// Gets the the underlying ELF symbol for the current variable,
> @@ -20880,22 +20620,22 @@ function_decl::get_id() const
> {
> if (priv_->id_.empty())
> {
> - const environment* env = get_type()->get_environment();
> + const environment& env = get_type()->get_environment();
> if (elf_symbol_sptr s = get_symbol())
> {
> if (s->has_aliases())
> // The symbol has several aliases, so let's use a scheme
> // that allows all aliased functions to have different
> // IDs.
> - priv_->id_ = env->intern(get_name() + "/" + s->get_id_string());
> + priv_->id_ = env.intern(get_name() + "/" + s->get_id_string());
> else
> // Let's use the full symbol name with its version as ID.
> - priv_->id_ = env->intern(s->get_id_string());
> + priv_->id_ = env.intern(s->get_id_string());
> }
> else if (!get_linkage_name().empty())
> - priv_->id_= env->intern(get_linkage_name());
> + priv_->id_= env.intern(get_linkage_name());
> else
> - priv_->id_ = env->intern(get_pretty_representation());
> + priv_->id_ = env.intern(get_pretty_representation());
> }
> return priv_->id_;
> }
> @@ -21069,19 +20809,18 @@ function_decl::parameter::get_type()const
> interned_string
> function_decl::parameter::get_type_name() const
> {
> - const environment* env = get_environment();
> - ABG_ASSERT(env);
> + const environment& env = get_environment();
>
> type_base_sptr t = get_type();
> string str;
> - if (get_variadic_marker() || env->is_variadic_parameter_type(t))
> + if (get_variadic_marker() || env.is_variadic_parameter_type(t))
> str = "...";
> else
> {
> ABG_ASSERT(t);
> str = abigail::ir::get_type_name(t);
> }
> - return env->intern(str);
> + return env.intern(str);
> }
>
> /// @return a copy of the pretty representation of the type of the
> @@ -21092,7 +20831,7 @@ function_decl::parameter::get_type_pretty_representation() const
> type_base_sptr t = get_type();
> string str;
> if (get_variadic_marker()
> - || get_environment()->is_variadic_parameter_type(t))
> + || get_environment().is_variadic_parameter_type(t))
> str = "...";
> else
> {
> @@ -21108,13 +20847,13 @@ function_decl::parameter::get_type_pretty_representation() const
> interned_string
> function_decl::parameter::get_name_id() const
> {
> - const environment* env = get_environment();
> - ABG_ASSERT(env);
> + const environment& env = get_environment();
> +
>
> std::ostringstream o;
> o << "parameter-" << get_index();
>
> - return env->intern(o.str());
> + return env.intern(o.str());
> }
>
> unsigned
> @@ -21302,14 +21041,13 @@ string
> function_decl::parameter::get_pretty_representation(bool internal,
> bool /*qualified_name*/) const
> {
> - const environment* env = get_environment();
> - ABG_ASSERT(env);
> + const environment& env = get_environment();
>
> string type_repr;
> type_base_sptr t = get_type();
> if (!t)
> type_repr = "void";
> - else if (env->is_variadic_parameter_type(t))
> + else if (env.is_variadic_parameter_type(t))
> type_repr = "...";
> else
> type_repr = ir::get_pretty_representation(t, internal);
> @@ -21351,7 +21089,7 @@ function_decl::parameter::get_pretty_representation(bool internal,
> ///
> /// @param member_fns the vector of member functions of this instance
> /// of @ref class_or_union.
> -class_or_union::class_or_union(const environment* env, const string& name,
> +class_or_union::class_or_union(const environment& env, const string& name,
> size_t size_in_bits, size_t align_in_bits,
> const location& locus, visibility vis,
> member_types& mem_types,
> @@ -21401,7 +21139,7 @@ class_or_union::class_or_union(const environment* env, const string& name,
> /// @param locus the source location of declaration point this class.
> ///
> /// @param vis the visibility of instances of @ref class_or_union.
> -class_or_union::class_or_union(const environment* env, const string& name,
> +class_or_union::class_or_union(const environment& env, const string& name,
> size_t size_in_bits, size_t align_in_bits,
> const location& locus, visibility vis)
> : type_or_decl_base(env,
> @@ -21423,7 +21161,7 @@ class_or_union::class_or_union(const environment* env, const string& name,
> ///
> /// @param is_declaration_only a boolean saying whether the instance
> /// represents a declaration only, or not.
> -class_or_union::class_or_union(const environment* env, const string& name,
> +class_or_union::class_or_union(const environment& env, const string& name,
> bool is_declaration_only)
> : type_or_decl_base(env,
> ABSTRACT_TYPE_BASE
> @@ -22127,7 +21865,7 @@ class_or_union::operator==(const class_or_union& other) const
> /// classes of interest are being compared.
> void
> dump_classes_being_compared(const type_or_decl_base& c)
> -{c.get_environment()->priv_->dump_classes_being_compared();}
> +{c.get_environment().priv_->dump_classes_being_compared();}
>
> /// Dumps a textual representation (to the standard error output) of
> /// the content of the set of function types being currently compared
> @@ -22139,7 +21877,7 @@ dump_classes_being_compared(const type_or_decl_base& c)
> /// function types of interest are being compared.
> void
> dump_fn_types_being_compared(const type_or_decl_base& t)
> -{t.get_environment()->priv_->dump_fn_types_being_compared();}
> +{t.get_environment().priv_->dump_fn_types_being_compared();}
>
> /// Compares two instances of @ref class_or_union.
> ///
> @@ -22193,7 +21931,7 @@ equals(const class_or_union& l, const class_or_union& r, change_kind* k)
> // change.
> return true;
>
> - if ((l.get_environment()->decl_only_class_equals_definition()
> + if ((l.get_environment().decl_only_class_equals_definition()
> || ((odr_is_relevant(l) && !def1)
> || (odr_is_relevant(r) && !def2)))
> && !is_anonymous_or_typedef_named(l)
> @@ -22414,7 +22152,6 @@ copy_member_function(const class_or_union_sptr& t, const method_decl* method)
> old_type->get_is_const(),
> old_type->get_size_in_bits(),
> old_type->get_alignment_in_bits()));
> - new_type->set_environment(t->get_environment());
> keep_type_alive(new_type);
>
> method_decl_sptr
> @@ -22553,18 +22290,17 @@ static bool
> maybe_propagate_canonical_type(const type_base& lhs_type,
> const type_base& rhs_type)
> {
> + const environment& env = lhs_type.get_environment();
> #if WITH_DEBUG_TYPE_CANONICALIZATION
> - if (const environment *env = lhs_type.get_environment())
> - if (!env->priv_->use_canonical_type_comparison_)
> - return false;
> + if (!env.priv_->use_canonical_type_comparison_)
> + return false;
> #endif
>
> - if (const environment *env = lhs_type.get_environment())
> - if (env->do_on_the_fly_canonicalization())
> - if (type_base_sptr canonical_type = lhs_type.get_canonical_type())
> - if (!rhs_type.get_canonical_type())
> - if (env->priv_->propagate_ct(lhs_type, rhs_type))
> - return true;
> + if (env.do_on_the_fly_canonicalization())
> + if (type_base_sptr canonical_type = lhs_type.get_canonical_type())
> + if (!rhs_type.get_canonical_type())
> + if (env.priv_->propagate_ct(lhs_type, rhs_type))
> + return true;
> return false;
> }
>
> @@ -22623,7 +22359,7 @@ struct class_decl::priv
> ///
> /// @param mbr_fns the vector of member functions of this instance of
> /// class_decl.
> -class_decl::class_decl(const environment* env, const string& name,
> +class_decl::class_decl(const environment& env, const string& name,
> size_t size_in_bits, size_t align_in_bits,
> bool is_struct, const location& locus,
> visibility vis, base_specs& bases,
> @@ -22674,7 +22410,7 @@ class_decl::class_decl(const environment* env, const string& name,
> ///
> /// @param is_anonymous whether the newly created instance is
> /// anonymous.
> -class_decl::class_decl(const environment* env, const string& name,
> +class_decl::class_decl(const environment& env, const string& name,
> size_t size_in_bits, size_t align_in_bits,
> bool is_struct, const location& locus,
> visibility vis, base_specs& bases,
> @@ -22720,7 +22456,7 @@ class_decl::class_decl(const environment* env, const string& name,
> /// @param locus the source location of declaration point this class.
> ///
> /// @param vis the visibility of instances of class_decl.
> -class_decl::class_decl(const environment* env, const string& name,
> +class_decl::class_decl(const environment& env, const string& name,
> size_t size_in_bits, size_t align_in_bits,
> bool is_struct, const location& locus,
> visibility vis)
> @@ -22757,7 +22493,7 @@ class_decl::class_decl(const environment* env, const string& name,
> ///
> /// @param is_anonymous whether the newly created instance is
> /// anonymous.
> -class_decl:: class_decl(const environment* env, const string& name,
> +class_decl:: class_decl(const environment& env, const string& name,
> size_t size_in_bits, size_t align_in_bits,
> bool is_struct, const location& locus,
> visibility vis, bool is_anonymous)
> @@ -22795,7 +22531,7 @@ class_decl:: class_decl(const environment* env, const string& name,
> ///
> /// @param is_declaration_only a boolean saying whether the instance
> /// represents a declaration only, or not.
> -class_decl::class_decl(const environment* env, const string& name,
> +class_decl::class_decl(const environment& env, const string& name,
> bool is_struct, bool is_declaration_only)
> : type_or_decl_base(env,
> CLASS_TYPE
> @@ -22848,12 +22584,8 @@ class_decl::is_struct() const
> void
> class_decl::add_base_specifier(base_spec_sptr b)
> {
> - ABG_ASSERT(get_environment());
> - ABG_ASSERT(b->get_environment() == get_environment());
> priv_->bases_.push_back(b);
> priv_->bases_map_[b->get_base_class()->get_qualified_name()] = b;
> - if (const environment* env = get_environment())
> - b->set_environment(env);
> }
>
> /// Get the base specifiers for this class.
> @@ -23755,12 +23487,12 @@ method_matches_at_least_one_in_vector(const method_decl_sptr& method,
> static bool
> maybe_cancel_propagated_canonical_type(const class_or_union& t)
> {
> - const environment* env = t.get_environment();
> - if (env && env->do_on_the_fly_canonicalization())
> + const environment& env = t.get_environment();
> + if (env.do_on_the_fly_canonicalization())
> if (is_type(&t)->priv_->canonical_type_propagated())
> {
> is_type(&t)->priv_->clear_propagated_canonical_type();
> - env->priv_->remove_from_types_with_non_confirmed_propagated_ct(&t);
> + env.priv_->remove_from_types_with_non_confirmed_propagated_ct(&t);
> return true;
> }
> return false;
> @@ -23794,7 +23526,7 @@ equals(const class_decl& l, const class_decl& r, change_kind* k)
> // cached, let's just re-use it, rather than comparing them all
> // over again.
> bool result = false;
> - if (l.get_environment()->priv_->is_type_comparison_cached(l, r, result))
> + if (l.get_environment().priv_->is_type_comparison_cached(l, r, result))
> return result;
> }
>
> @@ -23950,7 +23682,7 @@ equals(const class_decl& l, const class_decl& r, change_kind* k)
> // perform this caching also on the earlier return points of this
> // function. That would basically mean to redefine the RETURN macro
> // to make it perform this caching for us.
> - l.get_environment()->priv_->cache_type_comparison_result(l, r, result);
> + l.get_environment().priv_->cache_type_comparison_result(l, r, result);
>
> RETURN(result);
> #undef RETURN
> @@ -24591,7 +24323,7 @@ set_member_is_static(const decl_base_sptr& d, bool s)
> /// @param data_mbrs the data members of the union.
> ///
> /// @param member_fns the member functions of the union.
> -union_decl::union_decl(const environment* env, const string& name,
> +union_decl::union_decl(const environment& env, const string& name,
> size_t size_in_bits, const location& locus,
> visibility vis, member_types& mbr_types,
> data_members& data_mbrs, member_functions& member_fns)
> @@ -24627,7 +24359,7 @@ union_decl::union_decl(const environment* env, const string& name,
> ///
> /// @param is_anonymous whether the newly created instance is
> /// anonymous.
> -union_decl::union_decl(const environment* env, const string& name,
> +union_decl::union_decl(const environment& env, const string& name,
> size_t size_in_bits, const location& locus,
> visibility vis, member_types& mbr_types,
> data_members& data_mbrs, member_functions& member_fns,
> @@ -24665,7 +24397,7 @@ union_decl::union_decl(const environment* env, const string& name,
> /// @param locus the location of the type.
> ///
> /// @param vis the visibility of instances of @ref union_decl.
> -union_decl::union_decl(const environment* env, const string& name,
> +union_decl::union_decl(const environment& env, const string& name,
> size_t size_in_bits, const location& locus,
> visibility vis)
> : type_or_decl_base(env,
> @@ -24696,7 +24428,7 @@ union_decl::union_decl(const environment* env, const string& name,
> ///
> /// @param is_anonymous whether the newly created instance is
> /// anonymous.
> -union_decl::union_decl(const environment* env, const string& name,
> +union_decl::union_decl(const environment& env, const string& name,
> size_t size_in_bits, const location& locus,
> visibility vis, bool is_anonymous)
> : type_or_decl_base(env,
> @@ -24731,7 +24463,7 @@ union_decl::union_decl(const environment* env, const string& name,
> ///
> /// @param is_declaration_only a boolean saying whether the instance
> /// represents a declaration only, or not.
> -union_decl::union_decl(const environment* env,
> +union_decl::union_decl(const environment& env,
> const string& name,
> bool is_declaration_only)
> : type_or_decl_base(env,
> @@ -24948,7 +24680,7 @@ equals(const union_decl& l, const union_decl& r, change_kind* k)
> // cached, let's just re-use it, rather than comparing them all
> // over again.
> bool result = false;
> - if (l.get_environment()->priv_->is_type_comparison_cached(l, r, result))
> + if (l.get_environment().priv_->is_type_comparison_cached(l, r, result))
> return result;
> }
>
> @@ -24970,7 +24702,7 @@ equals(const union_decl& l, const union_decl& r, change_kind* k)
> // perform this caching also on the earlier return points of this
> // function. That would basically mean to redefine the RETURN macro
> // to make it perform this caching for us.
> - l.get_environment()->priv_->cache_type_comparison_result(l, r, result);
> + l.get_environment().priv_->cache_type_comparison_result(l, r, result);
>
> RETURN(result);
> }
> @@ -25076,7 +24808,7 @@ template_decl::get_template_parameters() const
> /// defined.
> ///
> /// @param vis the visibility of the template declaration.
> -template_decl::template_decl(const environment* env,
> +template_decl::template_decl(const environment& env,
> const string& name,
> const location& locus,
> visibility vis)
> @@ -25556,7 +25288,7 @@ public:
> ///
> /// @param bind the binding of the declaration. This is the binding
> /// the functions instantiated from this template are going to have.
> -function_tdecl::function_tdecl(const environment* env,
> +function_tdecl::function_tdecl(const environment& env,
> const location& locus,
> visibility vis,
> binding bind)
> @@ -25730,7 +25462,7 @@ public:
> ///
> /// @param vis the visibility of the instance of class instantiated
> /// from this template.
> -class_tdecl::class_tdecl(const environment* env,
> +class_tdecl::class_tdecl(const environment& env,
> const location& locus,
> visibility vis)
> : type_or_decl_base(env,
> @@ -25976,9 +25708,8 @@ type_has_sub_type_changes(const type_base_sptr t_v1,
> void
> keep_type_alive(type_base_sptr t)
> {
> - environment* env = t->get_environment();
> - ABG_ASSERT(env);
> - env->priv_->extra_live_types_.push_back(t);
> + const environment& env = t->get_environment();
> + env.priv_->extra_live_types_.push_back(t);
> }
>
> /// Hash an ABI artifact that is either a type or a decl.
> @@ -26107,10 +25838,10 @@ is_non_canonicalized_type(const type_base *t)
> if (!t)
> return true;
>
> - const environment* env = t->get_environment();
> + const environment& env = t->get_environment();
> return (is_declaration_only_class_or_union_type(t)
> - || env->is_void_type(t)
> - || env->is_variadic_parameter_type(t));
> + || env.is_void_type(t)
> + || env.is_variadic_parameter_type(t));
> }
>
> /// For a given type, return its exemplar type.
> @@ -26984,15 +26715,15 @@ qualified_name_setter::do_update(abigail::ir::decl_base* d)
> else
> d->priv_->qualified_parent_name_ = abigail::interned_string();
>
> - abigail::environment* env = d->get_environment();
> - ABG_ASSERT(env);
> + const abigail::ir::environment& env = d->get_environment();
> +
> if (!d->priv_->qualified_parent_name_.empty())
> {
> if (d->get_name().empty())
> d->priv_->qualified_name_ = abigail::interned_string();
> else
> d->priv_->qualified_name_ =
> - env->intern(d->priv_->qualified_parent_name_ + "::" + d->get_name());
> + env.intern(d->priv_->qualified_parent_name_ + "::" + d->get_name());
> }
>
> if (d->priv_->scoped_name_.empty())
> @@ -27001,10 +26732,10 @@ qualified_name_setter::do_update(abigail::ir::decl_base* d)
> && !parent->get_is_anonymous()
> && !parent->get_name().empty())
> d->priv_->scoped_name_ =
> - env->intern(parent->get_name() + "::" + d->get_name());
> + env.intern(parent->get_name() + "::" + d->get_name());
> else
> d->priv_->scoped_name_ =
> - env->intern(d->get_name());
> + env.intern(d->get_name());
> }
>
> if (!is_scope_decl(d))
> diff --git a/src/abg-reader.cc b/src/abg-reader.cc
> index 4afa427a..24b2ea30 100644
> --- a/src/abg-reader.cc
> +++ b/src/abg-reader.cc
> @@ -110,7 +110,7 @@ public:
>
> private:
> string m_path;
> - environment* m_env;
> + environment& m_env;
> unordered_map<string, vector<type_base_sptr> > m_types_map;
> unordered_map<string, shared_ptr<function_tdecl> > m_fn_tmpl_map;
> unordered_map<string, shared_ptr<class_tdecl> > m_class_tmpl_map;
> @@ -135,7 +135,7 @@ private:
>
> public:
> read_context(xml::reader_sptr reader,
> - environment* env)
> + environment& env)
> : m_env(env),
> m_reader(reader),
> m_corp_node(),
> @@ -196,23 +196,16 @@ public:
> /// Getter for the environment of this reader.
> ///
> /// @return the environment of this reader.
> - const environment*
> - get_environment() const
> + environment&
> + get_environment()
> {return m_env;}
>
> /// Getter for the environment of this reader.
> ///
> /// @return the environment of this reader.
> - environment*
> - get_environment()
> - {return m_env;}
> -
> - /// Setter for the environment of this reader.
> - ///
> - /// @param env the environment of this reader.
> - void
> - set_environment(environment* env)
> - {m_env = env;}
> + const environment&
> + get_environment() const
> + {return const_cast<read_context*>(this)->get_environment();}
>
> xml::reader_sptr
> get_reader() const
> @@ -923,8 +916,8 @@ public:
> void
> maybe_check_abixml_canonical_type_stability(type_base_sptr& t)
> {
> - if (!m_env->self_comparison_debug_is_on()
> - || m_env->get_type_id_canonical_type_map().empty())
> + if (!get_environment().self_comparison_debug_is_on()
> + || get_environment().get_type_id_canonical_type_map().empty())
> return ;
>
> if (class_decl_sptr c = is_class_type(t))
> @@ -936,15 +929,15 @@ public:
> // Let's get the type-id of this type as recorded in the
> // originating abixml file.
> string type_id =
> - m_env->get_type_id_from_pointer(reinterpret_cast<uintptr_t>(t.get()));
> + get_environment().get_type_id_from_pointer(reinterpret_cast<uintptr_t>(t.get()));
>
> if (!type_id.empty())
> {
> // Now let's get the canonical type that initially led to the
> // serialization of a type with this type-id, when the abixml
> // was being serialized.
> - auto j = m_env->get_type_id_canonical_type_map().find(type_id);
> - if (j == m_env->get_type_id_canonical_type_map().end())
> + auto j = get_environment().get_type_id_canonical_type_map().find(type_id);
> + if (j == get_environment().get_type_id_canonical_type_map().end())
> {
> if (t->get_naked_canonical_type())
> std::cerr << "error: no type with type-id: '"
> @@ -2111,8 +2104,8 @@ read_corpus_from_input(read_context& ctxt)
> {
> ctxt.set_corpus(std::make_shared<corpus>(ctxt.get_environment(), ""));
> #ifdef WITH_DEBUG_SELF_COMPARISON
> - if (ctxt.get_environment()->self_comparison_debug_is_on())
> - ctxt.get_environment()->
> + if (ctxt.get_environment().self_comparison_debug_is_on())
> + ctxt.get_environment().
> set_self_comparison_debug_input(ctxt.get_corpus());
> #endif
>
> @@ -2167,7 +2160,7 @@ read_corpus_from_input(read_context& ctxt)
> // due to potential suppression specifications. That's fine.
> corp.set_symtab(symtab_reader::symtab::load(fn_sym_db, var_sym_db));
>
> - ctxt.get_environment()->canonicalization_is_done(false);
> + ctxt.get_environment().canonicalization_is_done(false);
>
> // Read the translation units.
> while (read_translation_unit_from_input(ctxt))
> @@ -2186,7 +2179,7 @@ read_corpus_from_input(read_context& ctxt)
>
> ctxt.perform_late_type_canonicalizing();
>
> - ctxt.get_environment()->canonicalization_is_done(true);
> + ctxt.get_environment().canonicalization_is_done(true);
>
> if (call_reader_next)
> {
> @@ -2286,7 +2279,7 @@ read_corpus_group_from_input(read_context& ctxt)
> /// This is non-null iff the parsing resulted in a valid corpus group.
> corpus_group_sptr
> read_corpus_group_from_native_xml(std::istream* in,
> - environment* env)
> + environment& env)
> {
> read_context_sptr read_ctxt = create_native_xml_read_context(in, env);
> return read_corpus_group_from_input(*read_ctxt);
> @@ -2308,7 +2301,7 @@ read_corpus_group_from_native_xml(std::istream* in,
> /// group.
> corpus_group_sptr
> read_corpus_group_from_native_xml_file(const string& path,
> - environment* env)
> + environment& env)
> {
> read_context_sptr read_ctxt = create_native_xml_read_context(path, env);
> corpus_group_sptr group = read_corpus_group_from_input(*read_ctxt);
> @@ -2326,13 +2319,13 @@ read_corpus_group_from_native_xml_file(const string& path,
> /// successful completion, or nil.
> translation_unit_sptr
> read_translation_unit_from_file(const string& input_file,
> - environment* env)
> + environment& env)
> {
> read_context ctxt(xml::new_reader_from_file(input_file), env);
> translation_unit_sptr tu = read_translation_unit_from_input(ctxt);
> - ctxt.get_environment()->canonicalization_is_done(false);
> + env.canonicalization_is_done(false);
> ctxt.perform_late_type_canonicalizing();
> - ctxt.get_environment()->canonicalization_is_done(true);
> + env.canonicalization_is_done(true);
> return tu;
> }
>
> @@ -2348,13 +2341,13 @@ read_translation_unit_from_file(const string& input_file,
> /// successful completion, or nil.
> translation_unit_sptr
> read_translation_unit_from_buffer(const string& buffer,
> - environment* env)
> + environment& env)
> {
> read_context ctxt(xml::new_reader_from_buffer(buffer), env);
> translation_unit_sptr tu = read_translation_unit_from_input(ctxt);
> - ctxt.get_environment()->canonicalization_is_done(false);
> + env.canonicalization_is_done(false);
> ctxt.perform_late_type_canonicalizing();
> - ctxt.get_environment()->canonicalization_is_done(true);
> + env.canonicalization_is_done(true);
> return tu;
> }
>
> @@ -2369,9 +2362,9 @@ translation_unit_sptr
> read_translation_unit(read_context& ctxt)
> {
> translation_unit_sptr tu = read_translation_unit_from_input(ctxt);
> - ctxt.get_environment()->canonicalization_is_done(false);
> + ctxt.get_environment().canonicalization_is_done(false);
> ctxt.perform_late_type_canonicalizing();
> - ctxt.get_environment()->canonicalization_is_done(true);
> + ctxt.get_environment().canonicalization_is_done(true);
> return tu;
> }
>
> @@ -3052,12 +3045,12 @@ maybe_map_type_with_type_id(const type_base_sptr& t,
> if (!t)
> return false;
>
> - environment *env = t->get_environment();
> - if (!env->self_comparison_debug_is_on()
> + const environment& env = t->get_environment();
> + if (!env.self_comparison_debug_is_on()
> || is_non_canonicalized_type(t.get()))
> return false;
>
> - env->get_pointer_type_id_map()[reinterpret_cast<uintptr_t>(t.get())] =
> + env.get_pointer_type_id_map()[reinterpret_cast<uintptr_t>(t.get())] =
> type_id;
>
> return true;
> @@ -3083,8 +3076,8 @@ maybe_map_type_with_type_id(const type_base_sptr& t,
> if (!t)
> return false;
>
> - environment *env = t->get_environment();
> - if (!env->self_comparison_debug_is_on()
> + const environment& env = t->get_environment();
> + if (!env.self_comparison_debug_is_on()
> || is_non_canonicalized_type(t.get()))
> return false;
>
> @@ -3159,7 +3152,7 @@ build_namespace_decl(read_context& ctxt,
> location loc;
> read_location(ctxt, node, loc);
>
> - const environment* env = ctxt.get_environment();
> + const environment& env = ctxt.get_environment();
> namespace_decl_sptr decl(new namespace_decl(env, name, loc));
> maybe_set_artificial_location(ctxt, node, decl);
> ctxt.push_decl_to_current_scope(decl, add_to_current_scope);
> @@ -3255,7 +3248,7 @@ build_elf_symbol(read_context& ctxt, const xmlNodePtr node,
> if (drop_if_suppressed && is_suppressed)
> return elf_symbol_sptr();
>
> - const environment* env = ctxt.get_environment();
> + const environment& env = ctxt.get_environment();
> elf_symbol_sptr e = elf_symbol::create(env, /*index=*/0,
> size, name, type, binding,
> is_defined, is_common,
> @@ -3410,7 +3403,7 @@ build_elf_symbol_db(read_context& ctxt,
>
> /// Build a function parameter from a 'parameter' xml element node.
> ///
> -/// @param ctxt the contexte of the xml parsing.
> +/// @param rdr the contexte of the xml parsing.
> ///
> /// @param node the xml 'parameter' element node to de-serialize from.
> static shared_ptr<function_decl::parameter>
> @@ -3421,8 +3414,6 @@ build_function_parameter(read_context& ctxt, const xmlNodePtr node)
> if (!node || !xmlStrEqual(node->name, BAD_CAST("parameter")))
> return nil;
>
> - ABG_ASSERT(ctxt.get_environment());
> -
> bool is_variadic = false;
> string is_variadic_str;
> if (xml_char_sptr s =
> @@ -3441,14 +3432,13 @@ build_function_parameter(read_context& ctxt, const xmlNodePtr node)
>
> type_base_sptr type;
> if (is_variadic)
> - type = ctxt.get_environment()->get_variadic_parameter_type();
> + type = ctxt.get_environment().get_variadic_parameter_type();
> else
> {
> ABG_ASSERT(!type_id.empty());
> type = ctxt.build_or_get_type_decl(type_id, true);
> }
> ABG_ASSERT(type);
> - ABG_ASSERT(type->get_environment() == ctxt.get_environment());
>
> string name;
> if (xml_char_sptr a = xml::build_sptr(xmlGetProp(node, BAD_CAST("name"))))
> @@ -3518,10 +3508,9 @@ build_function_decl(read_context& ctxt,
> location loc;
> read_location(ctxt, node, loc);
>
> - environment* env = ctxt.get_environment();
> - ABG_ASSERT(env);
> + environment& env = ctxt.get_environment();
> std::vector<function_decl::parameter_sptr> parms;
> - type_base_sptr return_type = env->get_void_type();
> + type_base_sptr return_type = env.get_void_type();
>
> for (xmlNodePtr n = xmlFirstElementChild(node);
> n ;
> @@ -3885,7 +3874,7 @@ build_type_decl(read_context& ctxt,
> return ty;
> }
>
> - const environment* env = ctxt.get_environment();
> + const environment& env = ctxt.get_environment();
> type_decl_sptr decl(new type_decl(env, name, size_in_bits,
> alignment_in_bits, loc));
> maybe_set_artificial_location(ctxt, node, decl);
> @@ -4179,10 +4168,9 @@ build_function_type(read_context& ctxt,
> size_t size = ctxt.get_translation_unit()->get_address_size(), align = 0;
> read_size_and_alignment(node, size, align);
>
> - environment* env = ctxt.get_environment();
> - ABG_ASSERT(env);
> + const environment& env = ctxt.get_environment();
> std::vector<shared_ptr<function_decl::parameter> > parms;
> - type_base_sptr return_type = env->get_void_type();
> + type_base_sptr return_type = env.get_void_type();
>
> class_or_union_sptr method_class_type;
> if (is_method_t)
> @@ -4196,7 +4184,7 @@ build_function_type(read_context& ctxt,
>
> function_type_sptr fn_type(is_method_t
> ? new method_type(method_class_type,
> - ctxt.get_environment(),
> + /*is_const=*/false,
> size, align)
> : new function_type(return_type,
> parms, size, align));
> @@ -4586,9 +4574,6 @@ build_enum_type_decl(read_context& ctxt,
>
> ABG_ASSERT(!id.empty());
>
> - const environment* env = ctxt.get_environment();
> - ABG_ASSERT(env);
> -
> string base_type_id;
> enum_type_decl::enumerators enums;
> for (xmlNodePtr n = xmlFirstElementChild(node);
> @@ -4623,7 +4608,7 @@ build_enum_type_decl(read_context& ctxt,
> return nil;
> }
>
> - enums.push_back(enum_type_decl::enumerator(env, name, value));
> + enums.push_back(enum_type_decl::enumerator(name, value));
> }
> }
>
> @@ -4864,8 +4849,7 @@ build_class_decl(read_context& ctxt,
> return previous_declaration;
> }
>
> - const environment* env = ctxt.get_environment();
> - ABG_ASSERT(env);
> + const environment& env = ctxt.get_environment();
>
> if (!is_decl_only && previous_definition)
> // We are in the case where we've read this class definition
> @@ -5281,8 +5265,7 @@ build_union_decl(read_context& ctxt,
> return previous_declaration;
> }
>
> - const environment* env = ctxt.get_environment();
> - ABG_ASSERT(env);
> + const environment& env = ctxt.get_environment();
>
> if (!is_decl_only && previous_definition)
> // We are in the case where we've read this class definition
> @@ -5569,8 +5552,7 @@ build_function_tdecl(read_context& ctxt,
> decl_base::binding bind = decl_base::BINDING_NONE;
> read_binding(node, bind);
>
> - const environment* env = ctxt.get_environment();
> - ABG_ASSERT(env);
> + const environment& env = ctxt.get_environment();
>
> function_tdecl_sptr fn_tmpl_decl(new function_tdecl(env, loc, vis, bind));
> maybe_set_artificial_location(ctxt, node, fn_tmpl_decl);
> @@ -5633,8 +5615,7 @@ build_class_tdecl(read_context& ctxt,
> decl_base::visibility vis = decl_base::VISIBILITY_NONE;
> read_visibility(node, vis);
>
> - const environment* env = ctxt.get_environment();
> - ABG_ASSERT(env);
> + const environment& env = ctxt.get_environment();
>
> class_tdecl_sptr class_tmpl (new class_tdecl(env, loc, vis));
> maybe_set_artificial_location(ctxt, node, class_tmpl);
> @@ -5723,7 +5704,6 @@ build_type_tparameter(read_context& ctxt,
> else
> ctxt.push_and_key_type_decl(result, id, /*add_to_current_scope=*/true);
>
> - ABG_ASSERT(result->get_environment());
>
> ctxt.maybe_canonicalize_type(result, /*force_delay=*/false);
>
> @@ -6252,7 +6232,7 @@ handle_class_tdecl(read_context& ctxt,
> /// @return the translation unit resulting from the parsing upon
> /// successful completion, or nil.
> translation_unit_sptr
> -read_translation_unit_from_istream(istream* in, environment* env)
> +read_translation_unit_from_istream(istream* in, environment& env)
> {
> read_context read_ctxt(xml::new_reader_from_istream(in), env);
> return read_translation_unit_from_input(read_ctxt);
> @@ -6276,7 +6256,7 @@ struct array_deleter
> ///
> /// @return the created context.
> read_context_sptr
> -create_native_xml_read_context(const string& path, environment *env)
> +create_native_xml_read_context(const string& path, environment& env)
> {
> read_context_sptr result(new read_context(xml::new_reader_from_file(path),
> env));
> @@ -6284,8 +6264,8 @@ create_native_xml_read_context(const string& path, environment *env)
> corp->set_origin(corpus::NATIVE_XML_ORIGIN);
> result->set_corpus(corp);
> #ifdef WITH_DEBUG_SELF_COMPARISON
> - if (env->self_comparison_debug_is_on())
> - env->set_self_comparison_debug_input(result->get_corpus());
> + if (env.self_comparison_debug_is_on())
> + env.set_self_comparison_debug_input(result->corpus());
> #endif
> result->set_path(path);
> return result;
> @@ -6300,7 +6280,7 @@ create_native_xml_read_context(const string& path, environment *env)
> ///
> /// @return the created context.
> read_context_sptr
> -create_native_xml_read_context(std::istream* in, environment* env)
> +create_native_xml_read_context(std::istream* in, environment& env)
> {
> read_context_sptr result(new read_context(xml::new_reader_from_istream(in),
> env));
> @@ -6308,8 +6288,8 @@ create_native_xml_read_context(std::istream* in, environment* env)
> corp->set_origin(corpus::NATIVE_XML_ORIGIN);
> result->set_corpus(corp);
> #ifdef WITH_DEBUG_SELF_COMPARISON
> - if (env->self_comparison_debug_is_on())
> - env->set_self_comparison_debug_input(result->get_corpus());
> + if (env.self_comparison_debug_is_on())
> + env.set_self_comparison_debug_input(result->corpus());
> #endif
> return result;
> }
> @@ -6335,7 +6315,7 @@ read_context_get_path(const read_context& ctxt)
> /// is non-null iff the parsing resulted in a valid corpus.
> corpus_sptr
> read_corpus_from_native_xml(std::istream* in,
> - environment* env)
> + environment& env)
> {
> read_context_sptr read_ctxt = create_native_xml_read_context(in, env);
> return read_corpus_from_input(*read_ctxt);
> @@ -6356,7 +6336,7 @@ read_corpus_from_native_xml(std::istream* in,
> /// is non-null if the parsing successfully resulted in a corpus.
> corpus_sptr
> read_corpus_from_native_xml_file(const string& path,
> - environment* env)
> + environment& env)
> {
> read_context_sptr read_ctxt = create_native_xml_read_context(path, env);
> corpus_sptr corp = read_corpus_from_input(*read_ctxt);
> @@ -6443,7 +6423,7 @@ load_canonical_type_ids(xml_reader::read_context& ctxt, const string &file_path)
> // that are not canonicalized. Look into function
> // hash_as_canonical_type_or_constant for the details.
> && v != 0xdeadbabe)
> - ctxt.get_environment()->get_type_id_canonical_type_map()[id] = v;
> + ctxt.get_environment().get_type_id_canonical_type_map()[id] = v;
> }
> }
> return true;
> diff --git a/src/abg-symtab-reader.cc b/src/abg-symtab-reader.cc
> index 606c96a2..219ab6c6 100644
> --- a/src/abg-symtab-reader.cc
> +++ b/src/abg-symtab-reader.cc
> @@ -139,11 +139,10 @@ static struct
> /// not completed
> symtab_ptr
> symtab::load(Elf* elf_handle,
> - ir::environment* env,
> + const ir::environment& env,
> symbol_predicate is_suppressed)
> {
> ABG_ASSERT(elf_handle);
> - ABG_ASSERT(env);
>
> symtab_ptr result(new symtab);
> if (!result->load_(elf_handle, env, is_suppressed))
> @@ -201,7 +200,7 @@ symtab::symtab()
> /// @return true if the load succeeded
> bool
> symtab::load_(Elf* elf_handle,
> - ir::environment* env,
> + const ir::environment& env,
> symbol_predicate is_suppressed)
> {
> GElf_Ehdr ehdr_mem;
> diff --git a/src/abg-symtab-reader.h b/src/abg-symtab-reader.h
> index 384d757f..4d90c302 100644
> --- a/src/abg-symtab-reader.h
> +++ b/src/abg-symtab-reader.h
> @@ -243,7 +243,7 @@ public:
>
> static symtab_ptr
> load(Elf* elf_handle,
> - ir::environment* env,
> + const ir::environment& env,
> symbol_predicate is_suppressed = NULL);
>
> static symtab_ptr
> @@ -283,7 +283,9 @@ private:
> addr_symbol_map_type entry_addr_symbol_map_;
>
> bool
> - load_(Elf* elf_handle, ir::environment* env, symbol_predicate is_suppressed);
> + load_(Elf* elf_handle,
> + const ir::environment& env,
> + symbol_predicate is_suppressed);
>
> bool
> load_(string_elf_symbols_map_sptr function_symbol_map,
> diff --git a/src/abg-tools-utils.cc b/src/abg-tools-utils.cc
> index fe9ebc72..29700416 100644
> --- a/src/abg-tools-utils.cc
> +++ b/src/abg-tools-utils.cc
> @@ -2537,19 +2537,18 @@ maybe_load_vmlinux_dwarf_corpus(corpus::origin origin,
> suppressions_type& supprs,
> bool verbose,
> timer& t,
> - environment_sptr& env)
> + environment& env)
> {
> if (!(origin & corpus::DWARF_ORIGIN))
> return;
>
> - abigail::elf_reader::status status = abigail::elf_reader::STATUS_OK;
> + abigail::elf_reader::status status = abigail::elf_reader::STATUS_OK;
> dwarf_reader::read_context_sptr ctxt;
> ctxt =
> - dwarf_reader::create_read_context(vmlinux, di_roots, env.get(),
> - /*read_all_types=*/false,
> - /*linux_kernel_mode=*/true);
> - dwarf_reader::set_do_log(*ctxt, verbose);
> -
> + dwarf_reader::create_read_context(vmlinux, di_roots, env,
> + /*read_all_types=*/false,
> + /*linux_kernel_mode=*/true);
> + dwarf_reader::set_do_log(*ctxt, verbose);
> t.start();
> load_generate_apply_suppressions(*ctxt, suppr_paths,
> kabi_wl_paths, supprs);
> @@ -2560,7 +2559,7 @@ maybe_load_vmlinux_dwarf_corpus(corpus::origin origin,
> << t
> << "\n";
>
> - group.reset(new corpus_group(env.get(), root));
> + group.reset(new corpus_group(env, root));
>
> set_read_context_corpus_group(*ctxt, group);
>
> @@ -2595,7 +2594,7 @@ maybe_load_vmlinux_dwarf_corpus(corpus::origin origin,
> << "/" << total_nb_modules
> << ") ... " << std::flush;
>
> - reset_read_context(ctxt, *m, di_roots, env.get(),
> + reset_read_context(ctxt, *m, di_roots,
> /*read_all_types=*/false,
> /*linux_kernel_mode=*/true);
>
> @@ -2652,15 +2651,15 @@ maybe_load_vmlinux_ctf_corpus(corpus::origin origin,
> vector<char**>& di_roots,
> bool verbose,
> timer& t,
> - environment_sptr& env)
> + environment& env)
> {
> if (!(origin & corpus::CTF_ORIGIN))
> return;
>
> abigail::elf_reader::status status = abigail::elf_reader::STATUS_OK;
> ctf_reader::read_context_sptr ctxt;
> - ctxt = ctf_reader::create_read_context(vmlinux, di_roots, env.get());
> - group.reset(new corpus_group(env.get(), root));
> + ctxt = ctf_reader::create_read_context(vmlinux, di_roots, env);
> + group.reset(new corpus_group(env, root));
> set_read_context_corpus_group(*ctxt, group);
>
> if (verbose)
> @@ -2694,7 +2693,7 @@ maybe_load_vmlinux_ctf_corpus(corpus::origin origin,
> << "/" << total_nb_modules
> << ") ... " << std::flush;
>
> - reset_read_context(ctxt, *m, di_roots, env.get());
> + reset_read_context(ctxt, *m, di_roots);
> set_read_context_corpus_group(*ctxt, group);
>
> t.start();
> @@ -2757,7 +2756,7 @@ build_corpus_group_from_kernel_dist_under(const string& root,
> vector<string>& kabi_wl_paths,
> suppressions_type& supprs,
> bool verbose,
> - environment_sptr& env,
> + environment& env,
> corpus::origin origin)
> {
> string vmlinux = vmlinux_path;
> diff --git a/src/abg-writer.cc b/src/abg-writer.cc
> index dff8813a..1cffd77b 100644
> --- a/src/abg-writer.cc
> +++ b/src/abg-writer.cc
> @@ -65,7 +65,7 @@ namespace xml_writer
>
> class id_manager
> {
> - const environment* m_env;
> + const environment& m_env;
> mutable unsigned long long m_cur_id;
>
> unsigned long long
> @@ -73,11 +73,11 @@ class id_manager
> { return ++m_cur_id; }
>
> public:
> - id_manager(const environment* env)
> + id_manager(const environment& env)
> : m_env(env),
> m_cur_id(0) {}
>
> - const environment*
> + const environment&
> get_environment() const
> {return m_env;}
>
> @@ -87,9 +87,8 @@ public:
> {
> ostringstream o;
> o << get_new_id();
> - const environment* env = get_environment();
> - ABG_ASSERT(env);
> - return env->intern(o.str());
> + const environment& env = get_environment();
> + return env.intern(o.str());
> }
>
> /// Return a unique string representing a numerical ID, prefixed by
> @@ -101,9 +100,8 @@ public:
> {
> ostringstream o;
> o << prefix << get_new_id();
> - const environment* env = get_environment();
> - ABG_ASSERT(env);
> - return env->intern(o.str());
> + const environment& env = get_environment();
> + return env.intern(o.str());
> }
> };
>
> @@ -207,7 +205,7 @@ typedef unordered_map<shared_ptr<class_tdecl>,
>
> class write_context
> {
> - const environment* m_env;
> + const environment& m_env;
> id_manager m_id_manager;
> ostream* m_ostream;
> bool m_annotate;
> @@ -243,7 +241,7 @@ public:
> /// @param env the enviroment we are operating from.
> ///
> /// @param os the output stream to write to.
> - write_context(const environment* env, ostream& os)
> + write_context(const environment& env, ostream& os)
> : m_env(env),
> m_id_manager(env),
> m_ostream(&os),
> @@ -262,16 +260,13 @@ public:
> /// Getter of the environment we are operating from.
> ///
> /// @return the environment we are operating from.
> - const environment*
> + const environment&
> get_environment() const
> {return m_env;}
>
> const config&
> get_config() const
> - {
> - ABG_ASSERT(get_environment());
> - return get_environment()->get_config();
> - }
> + {return get_environment().get_config();}
>
> /// Getter for the current ostream
> ///
> @@ -498,7 +493,7 @@ public:
> ++hash;
> std::ostringstream os;
> os << std::hex << std::setfill('0') << std::setw(8) << hash;
> - return m_type_id_map[c] = c->get_environment()->intern(os.str());
> + return m_type_id_map[c] = c->get_environment().intern(os.str());
> }
> }
> ABG_ASSERT_NOT_REACHED;
> @@ -808,7 +803,7 @@ public:
> {
> ABG_ASSERT(!is_type(decl));
> string repr = get_pretty_representation(decl, true);
> - interned_string irepr = decl->get_environment()->intern(repr);
> + interned_string irepr = decl->get_environment().intern(repr);
> return m_emitted_decls_set.find(irepr) != m_emitted_decls_set.end();
> }
>
> @@ -819,7 +814,7 @@ public:
> record_decl_as_emitted(const decl_base_sptr& decl)
> {
> string repr = get_pretty_representation(decl, true);
> - interned_string irepr = decl->get_environment()->intern(repr);
> + interned_string irepr = decl->get_environment().intern(repr);
> m_emitted_decls_set.insert(irepr);
> }
>
> @@ -2064,7 +2059,7 @@ write_decl_in_scope(const decl_base_sptr& decl,
> ///
> /// @return the new @ref write_context object.
> write_context_sptr
> -create_write_context(const environment *env,
> +create_write_context(const environment& env,
> ostream& default_output_stream)
> {
> write_context_sptr ctxt(new write_context(env, default_output_stream));
> @@ -3691,7 +3686,7 @@ write_class_decl(const class_decl_sptr& d,
> {
> type_base_wptrs_type result;
> canonical_type_sptr_set_type member_types;
> - const environment* env = ctxt.get_environment();
> + const environment& env = ctxt.get_environment();
>
> // We are looking at a decl-only class. All decl-only classes
> // of a given name are equal. But then the problem is that a
> @@ -3708,7 +3703,7 @@ write_class_decl(const class_decl_sptr& d,
> //
> // So let's gather all the member-types of all the decl-only
> // classes of the fully-qualified name and emit them here.
> - if (lookup_decl_only_class_types(env->intern(decl->get_qualified_name()),
> + if (lookup_decl_only_class_types(env.intern(decl->get_qualified_name()),
> *decl->get_corpus(),
> result))
> {
> diff --git a/tests/print-diff-tree.cc b/tests/print-diff-tree.cc
> index c0c7195a..dce1c124 100644
> --- a/tests/print-diff-tree.cc
> +++ b/tests/print-diff-tree.cc
> @@ -104,9 +104,9 @@ main(int argc, char* argv[])
> elf_reader::status c1_status, c2_status;
> corpus_sptr c1, c2;
>
> - environment_sptr env(new environment);
> + environment env;
> vector<char**> di_roots;
> - c1 = dwarf_reader::read_corpus_from_elf(opts.elf1, di_roots, env.get(),
> + c1 = dwarf_reader::read_corpus_from_elf(opts.elf1, di_roots, env,
> /*load_all_types=*/false,
> c1_status);
> if (c1_status != elf_reader::STATUS_OK)
> @@ -115,7 +115,7 @@ main(int argc, char* argv[])
> return 1;
> }
>
> - c2 = dwarf_reader::read_corpus_from_elf(opts.elf2, di_roots, env.get(),
> + c2 = dwarf_reader::read_corpus_from_elf(opts.elf2, di_roots, env,
> /*load_all_types=*/false,
> c2_status);
> if (c2_status != elf_reader::STATUS_OK)
> diff --git a/tests/test-abidiff.cc b/tests/test-abidiff.cc
> index 951b6d25..0e2b922b 100644
> --- a/tests/test-abidiff.cc
> +++ b/tests/test-abidiff.cc
> @@ -211,18 +211,18 @@ main(int, char*[])
> continue;
> }
>
> - environment_sptr env(new environment);
> + environment env;
> translation_unit_sptr tu1, tu2;
> corpus_sptr corpus1, corpus2;
> corpus_group_sptr corpus_group1, corpus_group2;
> file_type t = guess_file_type(first_in_path);
> if (t == abigail::tools_utils::FILE_TYPE_NATIVE_BI)
> - tu1 = read_translation_unit_from_file(first_in_path, env.get());
> + tu1 = read_translation_unit_from_file(first_in_path, env);
> else if (t == abigail::tools_utils::FILE_TYPE_XML_CORPUS)
> - corpus1 = read_corpus_from_native_xml_file(first_in_path, env.get());
> + corpus1 = read_corpus_from_native_xml_file(first_in_path, env);
> else if (t == abigail::tools_utils::FILE_TYPE_XML_CORPUS_GROUP)
> corpus_group1 = read_corpus_group_from_native_xml_file(first_in_path,
> - env.get());
> + env);
> else
> abort();
> if (!tu1 && !corpus1 && !corpus_group1)
> @@ -234,12 +234,12 @@ main(int, char*[])
>
> t = guess_file_type(second_in_path);
> if (t == abigail::tools_utils::FILE_TYPE_NATIVE_BI)
> - tu2 = read_translation_unit_from_file(second_in_path, env.get());
> + tu2 = read_translation_unit_from_file(second_in_path, env);
> else if (t == abigail::tools_utils::FILE_TYPE_XML_CORPUS)
> - corpus2 = read_corpus_from_native_xml_file(second_in_path, env.get());
> + corpus2 = read_corpus_from_native_xml_file(second_in_path, env);
> else if (t == abigail::tools_utils::FILE_TYPE_XML_CORPUS_GROUP)
> corpus_group2 = read_corpus_group_from_native_xml_file(first_in_path,
> - env.get());
> + env);
> else
> abort();
> if (!tu2 && !corpus2 && !corpus_group2)
> diff --git a/tests/test-diff-dwarf.cc b/tests/test-diff-dwarf.cc
> index 42e25dfa..3a31284f 100644
> --- a/tests/test-diff-dwarf.cc
> +++ b/tests/test-diff-dwarf.cc
> @@ -383,19 +383,19 @@ main()
> abigail::elf_reader::status status =
> abigail::elf_reader::STATUS_UNKNOWN;
>
> - environment_sptr env(new environment);
> + environment env;
> std::vector<char**> di_roots;
> abigail::corpus_sptr corp0 =
> read_corpus_from_elf(in_elfv0_path,
> /*debug_info_root_path=*/di_roots,
> - env.get(),
> + env,
> /*load_all_types=*/false,
> status);
>
> abigail::corpus_sptr corp1 =
> read_corpus_from_elf(in_elfv1_path,
> /*debug_info_root_path=*/di_roots,
> - env.get(),
> + env,
> /*load_all_types=*/false,
> status);
>
> diff --git a/tests/test-ir-walker.cc b/tests/test-ir-walker.cc
> index b6042d20..b8e0d5e2 100644
> --- a/tests/test-ir-walker.cc
> +++ b/tests/test-ir-walker.cc
> @@ -155,12 +155,12 @@ main(int argc, char **argv)
>
> string file_name = argv[1];
>
> - abigail::ir::environment_sptr env(new abigail::ir::environment);
> + abigail::ir::environment env;
> abigail::corpus_sptr c;
> abigail::elf_reader::status status = abigail::elf_reader::STATUS_OK;
> std::vector<char**> di_roots;
> if (!(c = abigail::dwarf_reader::read_corpus_from_elf(file_name, di_roots,
> - env.get(),
> + env,
> /*load_all_type=*/false,
> status)))
> {
> diff --git a/tests/test-read-ctf.cc b/tests/test-read-ctf.cc
> index b0ef7de6..1a689bfa 100644
> --- a/tests/test-read-ctf.cc
> +++ b/tests/test-read-ctf.cc
> @@ -348,12 +348,11 @@ test_task_ctf::test_task_ctf(const InOutSpec &s,
> void
> test_task_ctf::perform()
> {
> - abigail::ir::environment_sptr env;
> + abigail::ir::environment env;
>
> set_in_elf_path();
> set_in_suppr_spec_path();
>
> - env.reset(new abigail::ir::environment);
> abigail::elf_reader::status status =
> abigail::elf_reader::STATUS_UNKNOWN;
> vector<char**> di_roots;
> @@ -361,7 +360,7 @@ test_task_ctf::perform()
>
> read_context_sptr ctxt = create_read_context(in_elf_path,
> di_roots,
> - env.get());
> + env);
> ABG_ASSERT(ctxt);
>
> corpus_sptr corp = read_corpus(ctxt.get(), status);
> diff --git a/tests/test-symtab.cc b/tests/test-symtab.cc
> index efef9a99..2ca51e22 100644
> --- a/tests/test-symtab.cc
> +++ b/tests/test-symtab.cc
> @@ -42,10 +42,10 @@ read_corpus(const std::string& path,
> {
> const std::string& absolute_path = test_data_dir + path;
>
> - environment_sptr env(new environment);
> + environment env;
> const std::vector<char**> debug_info_root_paths;
> read_context_sptr ctxt =
> - create_read_context(absolute_path, debug_info_root_paths, env.get(),
> + create_read_context(absolute_path, debug_info_root_paths, env,
> /* load_all_type = */ true,
> /* linux_kernel_mode = */ true);
>
> diff --git a/tools/abicompat.cc b/tools/abicompat.cc
> index 0be49a86..9bad54b8 100644
> --- a/tools/abicompat.cc
> +++ b/tools/abicompat.cc
> @@ -657,7 +657,7 @@ perform_compat_check_in_weak_mode(options& opts,
> static corpus_sptr
> read_corpus(options opts, status &status,
> const vector<char**> di_roots,
> - const environment_sptr &env,
> + environment& env,
> const string &path)
> {
> corpus_sptr retval = NULL;
> @@ -677,14 +677,14 @@ read_corpus(options opts, status &status,
> {
> abigail::ctf_reader::read_context_sptr r_ctxt
> = abigail::ctf_reader::create_read_context(path,
> - env.get());
> + env);
> ABG_ASSERT(r_ctxt);
>
> retval = abigail::ctf_reader::read_corpus(r_ctxt.get(), status);
> }
> else
> #endif
> - retval = read_corpus_from_elf(path, di_roots, env.get(),
> + retval = read_corpus_from_elf(path, di_roots, env,
> /*load_all_types=*/opts.weak_mode,
> status);
> }
> @@ -692,7 +692,7 @@ read_corpus(options opts, status &status,
> case abigail::tools_utils::FILE_TYPE_XML_CORPUS:
> {
> abigail::xml_reader::read_context_sptr r_ctxt =
> - abigail::xml_reader::create_native_xml_read_context(path, env.get());
> + abigail::xml_reader::create_native_xml_read_context(path, env);
> assert(r_ctxt);
> retval = abigail::xml_reader::read_corpus_from_input(*r_ctxt);
> }
> @@ -789,7 +789,7 @@ main(int argc, char* argv[])
> vector<char**> app_di_roots;
> app_di_roots.push_back(&app_di_root);
> status status = abigail::elf_reader::STATUS_UNKNOWN;
> - environment_sptr env(new environment);
> + environment env;
>
> corpus_sptr app_corpus = read_corpus(opts, status,
> app_di_roots, env,
> diff --git a/tools/abidiff.cc b/tools/abidiff.cc
> index 9b2ab784..44d30c43 100644
> --- a/tools/abidiff.cc
> +++ b/tools/abidiff.cc
> @@ -1153,17 +1153,17 @@ main(int argc, char* argv[])
> t1_type = guess_file_type(opts.file1);
> t2_type = guess_file_type(opts.file2);
>
> - environment_sptr env(new environment);
> + environment env;
> if (opts.exported_interfaces_only.has_value())
> - env->analyze_exported_interfaces_only(*opts.exported_interfaces_only);
> + env.analyze_exported_interfaces_only(*opts.exported_interfaces_only);
>
> #ifdef WITH_DEBUG_SELF_COMPARISON
> if (opts.do_debug_self_comparison)
> - env->self_comparison_debug_is_on(true);
> + env.self_comparison_debug_is_on(true);
> #endif
> #ifdef WITH_DEBUG_TYPE_CANONICALIZATION
> if (opts.do_debug_type_canonicalization)
> - env->debug_type_canonicalization_is_on(true);
> + env.debug_type_canonicalization_is_on(true);
> #endif
> translation_unit_sptr t1, t2;
> abigail::elf_reader::status c1_status =
> @@ -1194,7 +1194,7 @@ main(int argc, char* argv[])
> break;
> case abigail::tools_utils::FILE_TYPE_NATIVE_BI:
> t1 = abigail::xml_reader::read_translation_unit_from_file(opts.file1,
> - env.get());
> + env);
> break;
> case abigail::tools_utils::FILE_TYPE_ELF: // fall through
> case abigail::tools_utils::FILE_TYPE_AR:
> @@ -1205,7 +1205,7 @@ main(int argc, char* argv[])
> abigail::ctf_reader::read_context_sptr ctxt
> = abigail::ctf_reader::create_read_context(opts.file1,
> opts.prepared_di_root_paths1,
> - env.get());
> + env);
> ABG_ASSERT(ctxt);
> c1 = abigail::ctf_reader::read_corpus(ctxt.get(),
> c1_status);
> @@ -1216,7 +1216,7 @@ main(int argc, char* argv[])
> abigail::dwarf_reader::read_context_sptr ctxt =
> abigail::dwarf_reader::create_read_context
> (opts.file1, opts.prepared_di_root_paths1,
> - env.get(), /*read_all_types=*/opts.show_all_types,
> + env, /*read_all_types=*/opts.show_all_types,
> opts.linux_kernel_mode);
> assert(ctxt);
>
> @@ -1237,7 +1237,7 @@ main(int argc, char* argv[])
> {
> abigail::xml_reader::read_context_sptr ctxt =
> abigail::xml_reader::create_native_xml_read_context(opts.file1,
> - env.get());
> + env);
> assert(ctxt);
> set_suppressions(*ctxt, opts);
> set_native_xml_reader_options(*ctxt, opts);
> @@ -1251,7 +1251,7 @@ main(int argc, char* argv[])
> {
> abigail::xml_reader::read_context_sptr ctxt =
> abigail::xml_reader::create_native_xml_read_context(opts.file1,
> - env.get());
> + env);
> assert(ctxt);
> set_suppressions(*ctxt, opts);
> set_native_xml_reader_options(*ctxt, opts);
> @@ -1278,7 +1278,7 @@ main(int argc, char* argv[])
> break;
> case abigail::tools_utils::FILE_TYPE_NATIVE_BI:
> t2 = abigail::xml_reader::read_translation_unit_from_file(opts.file2,
> - env.get());
> + env);
> break;
> case abigail::tools_utils::FILE_TYPE_ELF: // Fall through
> case abigail::tools_utils::FILE_TYPE_AR:
> @@ -1289,7 +1289,7 @@ main(int argc, char* argv[])
> abigail::ctf_reader::read_context_sptr ctxt
> = abigail::ctf_reader::create_read_context(opts.file2,
> opts.prepared_di_root_paths2,
> - env.get());
> + env);
> ABG_ASSERT(ctxt);
> c2 = abigail::ctf_reader::read_corpus(ctxt.get(),
> c2_status);
> @@ -1300,7 +1300,7 @@ main(int argc, char* argv[])
> abigail::dwarf_reader::read_context_sptr ctxt =
> abigail::dwarf_reader::create_read_context
> (opts.file2, opts.prepared_di_root_paths2,
> - env.get(), /*read_all_types=*/opts.show_all_types,
> + env, /*read_all_types=*/opts.show_all_types,
> opts.linux_kernel_mode);
> assert(ctxt);
> abigail::dwarf_reader::set_show_stats(*ctxt, opts.show_stats);
> @@ -1320,7 +1320,7 @@ main(int argc, char* argv[])
> {
> abigail::xml_reader::read_context_sptr ctxt =
> abigail::xml_reader::create_native_xml_read_context(opts.file2,
> - env.get());
> + env);
> assert(ctxt);
> set_suppressions(*ctxt, opts);
> set_native_xml_reader_options(*ctxt, opts);
> @@ -1334,7 +1334,7 @@ main(int argc, char* argv[])
> {
> abigail::xml_reader::read_context_sptr ctxt =
> abigail::xml_reader::create_native_xml_read_context(opts.file2,
> - env.get());
> + env);
> assert(ctxt);
> set_suppressions(*ctxt, opts);
> set_native_xml_reader_options(*ctxt, opts);
> diff --git a/tools/abidw.cc b/tools/abidw.cc
> index f38d6048..a536a707 100644
> --- a/tools/abidw.cc
> +++ b/tools/abidw.cc
> @@ -531,7 +531,7 @@ set_suppressions(dwarf_reader::read_context& read_ctxt, options& opts)
> /// otherwise.
> static int
> load_corpus_and_write_abixml(char* argv[],
> - environment_sptr& env,
> + environment& env,
> options& opts)
> {
> int exit_code = 0;
> @@ -539,14 +539,14 @@ load_corpus_and_write_abixml(char* argv[],
>
> #ifdef WITH_DEBUG_SELF_COMPARISON
> if (opts.debug_abidiff)
> - env->self_comparison_debug_is_on(true);
> + env.self_comparison_debug_is_on(true);
> #endif
>
> #ifdef WITH_DEBUG_TYPE_CANONICALIZATION
> if (opts.debug_type_canonicalization)
> - env->debug_type_canonicalization_is_on(true);
> + env.debug_type_canonicalization_is_on(true);
> if (opts.debug_die_canonicalization)
> - env->debug_die_canonicalization_is_on(true);
> + env.debug_die_canonicalization_is_on(true);
> #endif
>
> // First of all, read a libabigail IR corpus from the file specified
> @@ -559,7 +559,7 @@ load_corpus_and_write_abixml(char* argv[],
> abigail::ctf_reader::read_context_sptr ctxt
> = abigail::ctf_reader::create_read_context(opts.in_file_path,
> opts.prepared_di_root_paths,
> - env.get());
> + env);
> assert (ctxt);
> t.start();
> corp = abigail::ctf_reader::read_corpus (ctxt, s);
> @@ -574,7 +574,7 @@ load_corpus_and_write_abixml(char* argv[],
> dwarf_reader::read_context_sptr c
> = abigail::dwarf_reader::create_read_context(opts.in_file_path,
> opts.prepared_di_root_paths,
> - env.get(),
> + env,
> opts.load_all_types,
> opts.linux_kernel_mode);
> dwarf_reader::read_context& ctxt = *c;
> @@ -615,8 +615,10 @@ load_corpus_and_write_abixml(char* argv[],
> }
> }
>
> - if (opts.exported_interfaces_only.has_value())
> - env->analyze_exported_interfaces_only(*opts.exported_interfaces_only);
> + // ... if we are asked to only analyze exported interfaces (to stay
> + // concise), then take that into account ...
> + if (opts.exported_interfaces_only.has_value())
> + env.analyze_exported_interfaces_only(*opts.exported_interfaces_only);
>
> t.start();
> corp = dwarf_reader::read_corpus_from_elf(ctxt, s);
> @@ -707,7 +709,7 @@ load_corpus_and_write_abixml(char* argv[],
> }
> #endif
> xml_reader::read_context_sptr read_ctxt =
> - create_native_xml_read_context(tmp_file->get_path(), env.get());
> + create_native_xml_read_context(tmp_file->get_path(), env);
>
> #ifdef WITH_DEBUG_SELF_COMPARISON
> if (opts.debug_abidiff
> @@ -810,7 +812,7 @@ load_corpus_and_write_abixml(char* argv[],
> /// otherwise.
> static int
> load_kernel_corpus_group_and_write_abixml(char* argv[],
> - environment_sptr& env,
> + environment& env,
> options& opts)
> {
> if (!(tools_utils::is_dir(opts.in_file_path) && opts.corpus_group_for_linux))
> @@ -826,7 +828,7 @@ load_kernel_corpus_group_and_write_abixml(char* argv[],
> suppressions_type supprs;
>
> if (opts.exported_interfaces_only.has_value())
> - env->analyze_exported_interfaces_only(*opts.exported_interfaces_only);
> + env.analyze_exported_interfaces_only(*opts.exported_interfaces_only);
>
> if (opts.do_log)
> emit_prefix(argv[0], cerr)
> @@ -861,7 +863,7 @@ corpus::origin origin =
> if (!opts.noout)
> {
> const xml_writer::write_context_sptr& ctxt
> - = xml_writer::create_write_context(group->get_environment(), cout);
> + = xml_writer::create_write_context(env, cout);
> set_common_options(*ctxt, opts);
>
> if (!opts.out_file_path.empty())
> @@ -983,7 +985,7 @@ main(int argc, char* argv[])
> return 1;
> }
>
> - environment_sptr env(new environment);
> + environment env;
> int exit_code = 0;
>
> if (tools_utils::is_regular_file(opts.in_file_path))
> diff --git a/tools/abilint.cc b/tools/abilint.cc
> index 087fc45f..55941865 100644
> --- a/tools/abilint.cc
> +++ b/tools/abilint.cc
> @@ -702,7 +702,7 @@ main(int argc, char* argv[])
> if (!maybe_check_suppression_files(opts))
> return 1;
>
> - abigail::ir::environment_sptr env(new abigail::ir::environment);
> + abigail::ir::environment env;
> if (opts.read_from_stdin)
> {
> if (!cin.good())
> @@ -711,7 +711,7 @@ main(int argc, char* argv[])
> if (opts.read_tu)
> {
> abigail::translation_unit_sptr tu =
> - read_translation_unit_from_istream(&cin, env.get());
> + read_translation_unit_from_istream(&cin, env);
>
> if (!tu)
> {
> @@ -723,7 +723,7 @@ main(int argc, char* argv[])
> if (!opts.noout)
> {
> const write_context_sptr& ctxt
> - = create_write_context(tu->get_environment(), cout);
> + = create_write_context(env, cout);
> write_translation_unit(*ctxt, *tu, 0);
> }
> return 0;
> @@ -732,14 +732,14 @@ main(int argc, char* argv[])
> {
> abigail::xml_reader::read_context_sptr ctxt =
> abigail::xml_reader::create_native_xml_read_context(&cin,
> - env.get());
> + env);
> assert(ctxt);
> set_suppressions(*ctxt, opts);
> corpus_sptr corp = abigail::xml_reader::read_corpus_from_input(*ctxt);
> if (!opts.noout)
> {
> const write_context_sptr& ctxt
> - = create_write_context(corp->get_environment(), cout);
> + = create_write_context(env, cout);
> write_corpus(*ctxt, corp, /*indent=*/0);
> }
> return 0;
> @@ -768,7 +768,7 @@ main(int argc, char* argv[])
> {
> abixml_read_ctxt =
> abigail::xml_reader::create_native_xml_read_context(opts.file_path,
> - env.get());
> + env);
> tu = read_translation_unit(*abixml_read_ctxt);
> }
> break;
> @@ -785,7 +785,7 @@ main(int argc, char* argv[])
> abigail::ctf_reader::read_context_sptr ctxt =
> abigail::ctf_reader::create_read_context(opts.file_path,
> di_roots,
> - env.get());
> + env);
> ABG_ASSERT(ctxt);
> corp = abigail::ctf_reader::read_corpus(ctxt.get(), s);
> }
> @@ -794,7 +794,7 @@ main(int argc, char* argv[])
> {
> abigail::dwarf_reader::read_context_sptr ctxt =
> abigail::dwarf_reader::create_read_context(opts.file_path,
> - di_roots, env.get(),
> + di_roots, env,
> /*load_all_types=*/false);
> assert(ctxt);
> set_suppressions(*ctxt, opts);
> @@ -806,7 +806,7 @@ main(int argc, char* argv[])
> {
> abixml_read_ctxt =
> abigail::xml_reader::create_native_xml_read_context(opts.file_path,
> - env.get());
> + env);
> assert(abixml_read_ctxt);
> set_suppressions(*abixml_read_ctxt, opts);
> corp = read_corpus_from_input(*abixml_read_ctxt);
> @@ -816,7 +816,7 @@ main(int argc, char* argv[])
> {
> abixml_read_ctxt =
> abigail::xml_reader::create_native_xml_read_context(opts.file_path,
> - env.get());
> + env);
> assert(abixml_read_ctxt);
> set_suppressions(*abixml_read_ctxt, opts);
> group = read_corpus_group_from_input(*abixml_read_ctxt);
> @@ -874,15 +874,6 @@ main(int argc, char* argv[])
> }
>
> std::ostream& of = opts.diff ? tmp_file->get_stream() : cout;
> - const abigail::ir::environment* env = 0;
> - if (tu)
> - env = tu->get_environment();
> - else if (corp)
> - env = corp->get_environment();
> - else if (group)
> - env = group->get_environment();
> -
> - ABG_ASSERT(env);
> const write_context_sptr ctxt = create_write_context(env, of);
>
> bool is_ok = true;
> diff --git a/tools/abipkgdiff.cc b/tools/abipkgdiff.cc
> index 656d5882..a8f160da 100644
> --- a/tools/abipkgdiff.cc
> +++ b/tools/abipkgdiff.cc
> @@ -1260,7 +1260,7 @@ compare(const elf_file& elf1,
> const string& debug_dir2,
> const suppressions_type& priv_types_supprs2,
> const options& opts,
> - abigail::ir::environment_sptr &env,
> + abigail::ir::environment& env,
> corpus_diff_sptr &diff,
> diff_context_sptr &ctxt,
> abigail::elf_reader::status *detailed_error_status = 0)
> @@ -1331,7 +1331,7 @@ compare(const elf_file& elf1,
> {
> ctxt_ctf = abigail::ctf_reader::create_read_context(elf1.path,
> di_dirs1,
> - env.get());
> + env);
> ABG_ASSERT(ctxt_ctf);
> corpus1 = abigail::ctf_reader::read_corpus(ctxt_ctf.get(),
> c1_status);
> @@ -1339,7 +1339,7 @@ compare(const elf_file& elf1,
> else
> #endif
> {
> - ctxt_dwarf = create_read_context(elf1.path, di_dirs1, env.get(),
> + ctxt_dwarf = create_read_context(elf1.path, di_dirs1, env,
> /*load_all_types=*/opts.show_all_types);
> add_read_context_suppressions(*ctxt_dwarf, priv_types_supprs1);
> if (!opts.kabi_suppressions.empty())
> @@ -1436,14 +1436,14 @@ compare(const elf_file& elf1,
> {
> ctxt_ctf = abigail::ctf_reader::create_read_context(elf2.path,
> di_dirs2,
> - env.get());
> + env);
> corpus2 = abigail::ctf_reader::read_corpus(ctxt_ctf.get(),
> c2_status);
> }
> else
> #endif
> {
> - ctxt_dwarf = create_read_context(elf2.path, di_dirs2, env.get(),
> + ctxt_dwarf = create_read_context(elf2.path, di_dirs2, env,
> /*load_all_types=*/opts.show_all_types);
> add_read_context_suppressions(*ctxt_dwarf, priv_types_supprs2);
>
> @@ -1575,7 +1575,7 @@ static abidiff_status
> compare_to_self(const elf_file& elf,
> const string& debug_dir,
> const options& opts,
> - abigail::ir::environment_sptr &env,
> + abigail::ir::environment& env,
> corpus_diff_sptr &diff,
> diff_context_sptr &ctxt,
> abigail::elf_reader::status *detailed_error_status = 0)
> @@ -1610,7 +1610,7 @@ compare_to_self(const elf_file& elf,
> {
> ctxt_ctf = abigail::ctf_reader::create_read_context(elf.path,
> di_dirs,
> - env.get());
> + env);
> ABG_ASSERT(ctxt_ctf);
> corp = abigail::ctf_reader::read_corpus(ctxt_ctf.get(),
> c_status);
> @@ -1619,7 +1619,7 @@ compare_to_self(const elf_file& elf,
> #endif
> {
> ctxt_dwarf =
> - create_read_context(elf.path, di_dirs, env.get(),
> + create_read_context(elf.path, di_dirs, env,
> /*read_all_types=*/opts.show_all_types);
>
> corp = read_corpus_from_elf(*ctxt_dwarf, c_status);
> @@ -1666,7 +1666,7 @@ compare_to_self(const elf_file& elf,
>
> {
> const abigail::xml_writer::write_context_sptr c =
> - abigail::xml_writer::create_write_context(env.get(), of);
> + abigail::xml_writer::create_write_context(env, of);
>
> if (opts.verbose)
> emit_prefix("abipkgdiff", cerr)
> @@ -1697,7 +1697,7 @@ compare_to_self(const elf_file& elf,
> {
> abigail::xml_reader::read_context_sptr c =
> abigail::xml_reader::create_native_xml_read_context(abi_file_path,
> - env.get());
> + env);
> if (!c)
> {
> if (opts.verbose)
> @@ -2074,7 +2074,7 @@ public:
> virtual void
> perform()
> {
> - abigail::ir::environment_sptr env(new abigail::ir::environment);
> + abigail::ir::environment env;
> diff_context_sptr ctxt;
> corpus_diff_sptr diff;
>
> @@ -2082,7 +2082,7 @@ public:
> abigail::elf_reader::STATUS_UNKNOWN;
>
> if (args->opts.exported_interfaces_only.has_value())
> - env->analyze_exported_interfaces_only
> + env.analyze_exported_interfaces_only
> (*args->opts.exported_interfaces_only);
>
> status |= compare(args->elf1, args->debug_dir1, args->private_types_suppr1,
> @@ -2147,12 +2147,12 @@ public:
> virtual void
> perform()
> {
> - abigail::ir::environment_sptr env(new abigail::ir::environment);
> + abigail::ir::environment env;
> diff_context_sptr ctxt;
> corpus_diff_sptr diff;
>
> if (args->opts.exported_interfaces_only.has_value())
> - env->analyze_exported_interfaces_only
> + env.analyze_exported_interfaces_only
> (*args->opts.exported_interfaces_only);
>
> abigail::elf_reader::status detailed_status =
> @@ -3036,9 +3036,9 @@ compare_prepared_linux_kernel_packages(package& first_package,
> string dist_root1 = first_package.extracted_dir_path();
> string dist_root2 = second_package.extracted_dir_path();
>
> - abigail::ir::environment_sptr env(new abigail::ir::environment);
> + abigail::ir::environment env;
> if (opts.exported_interfaces_only.has_value())
> - env->analyze_exported_interfaces_only
> + env.analyze_exported_interfaces_only
> (*opts.exported_interfaces_only);
>
> suppressions_type supprs;
> diff --git a/tools/abisym.cc b/tools/abisym.cc
> index 1e2215a6..7b708e42 100644
> --- a/tools/abisym.cc
> +++ b/tools/abisym.cc
> @@ -131,9 +131,9 @@ main(int argc, char* argv[])
> && opts.symbol_name != 0);
>
> string p = opts.elf_path, n = opts.symbol_name;
> - environment_sptr env(new environment);
> + environment env;
> vector<elf_symbol_sptr> syms;
> - if (!lookup_symbol_from_elf(env.get(), p, n, opts.demangle, syms))
> + if (!lookup_symbol_from_elf(env, p, n, opts.demangle, syms))
> {
> cout << "could not find symbol '"
> << opts.symbol_name
> diff --git a/tools/kmidiff.cc b/tools/kmidiff.cc
> index f3332765..2a77db7e 100644
> --- a/tools/kmidiff.cc
> +++ b/tools/kmidiff.cc
> @@ -415,10 +415,10 @@ main(int argc, char* argv[])
> return 0;
> }
>
> - environment_sptr env(new environment);
> + environment env;
>
> if (opts.exported_interfaces_only.has_value())
> - env->analyze_exported_interfaces_only(*opts.exported_interfaces_only);
> + env.analyze_exported_interfaces_only(*opts.exported_interfaces_only);
>
> corpus_group_sptr group1, group2;
> string debug_info_root_dir;
> @@ -451,7 +451,7 @@ main(int argc, char* argv[])
> else if (ftype == FILE_TYPE_XML_CORPUS_GROUP)
> group1 =
> read_corpus_group_from_native_xml_file(opts.kernel_dist_root1,
> - env.get());
> + env);
>
> }
>
> @@ -477,7 +477,7 @@ main(int argc, char* argv[])
> else if (ftype == FILE_TYPE_XML_CORPUS_GROUP)
> group2 =
> read_corpus_group_from_native_xml_file(opts.kernel_dist_root2,
> - env.get());
> + env);
> }
>
> abidiff_status status = abigail::tools_utils::ABIDIFF_OK;
> --
> 2.38.0
>
>
>
> --
> Dodji
>
next prev parent reply other threads:[~2022-11-17 14:18 UTC|newest]
Thread overview: 6+ messages / expand[flat|nested] mbox.gz Atom feed top
2022-11-16 17:19 [PATCH 0/2, v2] Make front-ends be first class in the libabigail framework Dodji Seketeli
2022-11-16 17:28 ` [PATCH 1/2] Use environment by reference Dodji Seketeli
2022-11-17 14:17 ` Giuliano Procida [this message]
2022-11-17 15:35 ` Dodji Seketeli
2022-11-16 17:29 ` [PATCH 2/2] Make Front Ends first class citizens Dodji Seketeli
2022-11-18 17:19 ` [PATCH 0/2, v2] Make front-ends be first class in the libabigail framework Dodji Seketeli
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=CAGvU0HmNGrwjcMHzwCh8frfQRxGUWXKDBqz3dT_KpjvCoSs0MA@mail.gmail.com \
--to=gprocida@google.com \
--cc=dodji@redhat.com \
--cc=guillermo.e.martinez@oracle.com \
--cc=jose.marchesi@oracle.com \
--cc=libabigail@sourceware.org \
--cc=woodard@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).