abg-ir.cc

Go to the documentation of this file.

// C++ -*-
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// -*- Mode: C++ -*-
 
// Copyright (C) 2013-2024 Red Hat, Inc.
//
//Author: Dodji Seketeli
 
/// @file
///
/// Definitions for the Internal Representation artifacts of libabigail.
 
#include <cxxabi.h>
#include <cstdint>
#include <functional>
#include <iterator>
#include <memory>
#include <sstream>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "abg-internal.h"
// <headers defining libabigail's API go under here>
ABG_BEGIN_EXPORT_DECLARATIONS
 
#include "abg-interned-str.h"
#include "abg-ir.h"
#include "abg-corpus.h"
#include "abg-regex.h"
 
ABG_END_EXPORT_DECLARATIONS
// </headers defining libabigail's API>
 
#include "abg-corpus-priv.h"
#include "abg-comp-filter.h"
#include "abg-ir-priv.h"
 
namespace
{
/// 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().
class qualified_name_setter : public abigail::ir::ir_node_visitor
{
 
public:
  bool
  do_update(abigail::ir::decl_base* d);
 
  bool
  visit_begin(abigail::ir::decl_base* d);
 
  bool
  visit_begin(abigail::ir::type_base* d);
}; // end class qualified_name_setter
 
}// end anon namespace
 
namespace abigail
{
 
// Inject.
using std::string;
using std::list;
using std::vector;
using std::unordered_map;
using std::dynamic_pointer_cast;
using std::static_pointer_cast;
 
/// Convenience typedef for a map of string -> string*.
typedef unordered_map<string, string*> pool_map_type;
 
/// The type of the private data structure of type @ref
/// intered_string_pool.
struct interned_string_pool::priv
{
  pool_map_type map;
}; //end struc struct interned_string_pool::priv
 
/// Default constructor.
interned_string_pool::interned_string_pool()
  : priv_(new priv)
{
  priv_->map[""] = 0;
}
 
/// Test if the interned string pool already contains a string with a
/// given value.
///
/// @param s the string to test for.
///
/// @return true if the pool contains a string with the value @p s.
bool
interned_string_pool::has_string(const char* s) const
{return priv_->map.find(s) != priv_->map.end();}
 
/// Get a pointer to the interned string which has a given value.
///
/// @param s the value of the interned string to look for.
///
/// @return a pointer to the raw string of characters which has the
/// value of @p s.  Or null if no string with value @p s was interned.
const char*
interned_string_pool::get_string(const char* s) const
{
  unordered_map<string, string*>::const_iterator i =
    priv_->map.find(s);
  if (i == priv_->map.end())
    return 0;
  if (i->second)
    return i->second->c_str();
  return "";
}
 
/// Create an interned string with a given value.
///
/// @param str_value the value of the interned string to create.
///
/// @return the new created instance of @ref interned_string created.
interned_string
interned_string_pool::create_string(const std::string& str_value)
{
  string*& result = priv_->map[str_value];
  if (!result && !str_value.empty())
    result = new string(str_value);
  return interned_string(result);
}
 
/// Destructor.
interned_string_pool::~interned_string_pool()
{
  for (pool_map_type::iterator i = priv_->map.begin();
       i != priv_->map.end();
       ++i)
    if (i->second)
      delete i->second;
}
 
/// Equality operator.
///
/// @param l the instance of std::string on the left-hand-side of the
/// equality operator.
///
/// @param r the instance of @ref interned_string on the
/// right-hand-side of the equality operator.
///
/// @return true iff the two string are equal.
bool
operator==(const std::string& l, const interned_string& r)
{return r.operator==(l);}
 
bool
operator!=(const std::string& l, const interned_string& r)
{return !(l == r);}
 
/// Streaming operator.
///
/// Streams an instance of @ref interned_string to an output stream.
///
/// @param o the destination output stream.
///
/// @param s the instance of @ref interned_string to stream out.
///
/// @return the output stream this function just streamed to.
std::ostream&
operator<<(std::ostream& o, const interned_string& s)
{
  o << static_cast<std::string>(s);
  return o;
}
 
/// Concatenation operator.
///
/// Concatenate two instances of @ref interned_string, builds an
/// instance of std::string with the resulting string and return it.
///
/// @param s1 the first string to consider.
///
/// @param s2 the second string to consider.
///
/// @return the resuting concatenated string.
std::string
operator+(const interned_string& s1,const std::string& s2)
{return static_cast<std::string>(s1) + s2;}
 
/// Concatenation operator.
///
/// Concatenate two instances of @ref interned_string, builds an
/// instance of std::string with the resulting string and return it.
///
/// @param s1 the first string to consider.
///
/// @param s2 the second string to consider.
///
/// @return the resuting concatenated string.
std::string
operator+(const std::string& s1, const interned_string& s2)
{return s1 + static_cast<std::string>(s2);}
 
namespace ir
{
 
static size_t
hash_as_canonical_type_or_constant(const type_base *t);
 
static bool
has_generic_anonymous_internal_type_name(const decl_base *d);
 
static interned_string
get_generic_anonymous_internal_type_name(const decl_base *d);
 
static string
get_internal_real_type_name(const type_base*);
 
static void
update_qualified_name(decl_base * d);
 
static void
update_qualified_name(decl_base_sptr d);
 
static interned_string
pointer_declaration_name(const type_base* ptr,
             const string& variable_name,
             bool qualified, bool internal);
 
static interned_string
pointer_declaration_name(const type_base_sptr& ptr,
             const string& variable_name,
             bool qualified, bool internal);
 
static interned_string
ptr_to_mbr_declaration_name(const ptr_to_mbr_type* ptr,
                const string& variable_name,
                bool qualified, bool internal);
 
static interned_string
ptr_to_mbr_declaration_name(const ptr_to_mbr_type_sptr& ptr,
                const string& variable_name,
                bool qualified, bool internal);
 
static interned_string
array_declaration_name(const array_type_def* array,
               const string& variable_name,
               bool qualified, bool internal);
 
static interned_string
array_declaration_name(const array_type_def_sptr& array,
               const string& variable_name,
               bool qualified, bool internal);
 
static void
stream_pretty_representation_of_fn_parms(const function_type& fn_type,
                     ostream& o, bool qualified,
                     bool internal);
static string
add_outer_pointer_to_fn_type_expr(const type_base* pointer_to_fn,
                  const string& input, bool qualified,
                  bool internal);
 
static string
add_outer_pointer_to_fn_type_expr(const type_base_sptr& pointer_to_fn,
                  const string& input, bool qualified,
                  bool internal);
 
static string
add_outer_pointer_to_array_type_expr(const type_base* pointer_to_ar,
                     const string& input, bool qualified,
                     bool internal);
 
static string
add_outer_pointer_to_array_type_expr(const type_base_sptr& pointer_to_ar,
                     const string& input, bool qualified,
                     bool internal);
 
static string
add_outer_ptr_to_mbr_type_expr(const ptr_to_mbr_type* p,
                   const  string& input, bool qualified,
                   bool internal);
 
static string
add_outer_ptr_to_mbr_type_expr(const ptr_to_mbr_type_sptr& p,
                   const  string& input, bool qualified,
                   bool internal);
 
static string
add_outer_pointer_to_ptr_to_mbr_type_expr(const type_base* p,
                      const  string& input,
                      bool qualified, bool internal);
 
void
push_composite_type_comparison_operands(const type_base& left,
                    const type_base& right);
 
void
pop_composite_type_comparison_operands(const type_base& left,
                       const type_base& right);
 
 
/// Push a pair of operands on the stack of operands of the current
/// type comparison, during type canonicalization.
///
/// For more information on this, please look at the description of
/// the environment::priv::right_type_comp_operands_ data member.
///
/// @param left the left-hand-side comparison operand to push.
///
/// @param right the right-hand-side comparison operand to push.
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);
}
 
/// Pop a pair of operands from the stack of operands to the current
/// type comparison.
///
/// For more information on this, please look at the description of
/// the environment::privright_type_comp_operands_ data member.
///
/// @param left the left-hand-side comparison operand we expect to
/// pop from the top of the stack.  If this doesn't match the
/// operand found on the top of the stack, the function aborts.
///
/// @param right the right-hand-side comparison operand we expect to
/// pop from the bottom of the stack. If this doesn't match the
/// operand found on the top of the stack, the function aborts.
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);
}
 
/// Getter of the canonical type index of a given type.
///
/// @param t the type to consider.
///
/// @return the CTI of the type.
size_t
get_canonical_type_index(const type_base& t)
{return t.priv_->canonical_type_index;}
 
/// Getter of the canonical type index of a given type.
///
/// @param t the type to consider.
///
/// @return the CTI of the type.
size_t
get_canonical_type_index(const type_base* t)
{return get_canonical_type_index(*t);}
 
/// Getter of the canonical type index of a given type.
///
/// @param t the type to consider.
///
/// @return the CTI of the type.
size_t
get_canonical_type_index(const type_base_sptr& t)
{return get_canonical_type_index(t.get());}
 
/// Test if a type originates from a corpus.
///
/// Note that this function supports testing if a type originates from
/// a corpus group.
///
/// @param t the type to consider.
///
/// @param c the corpus or corpus group to consider.
///
/// @return true iff the type @p t originates from the corpus (or
/// group) @p c.
bool
type_originates_from_corpus(type_base_sptr t, corpus_sptr& c)
{
  bool result = false;
  if (c && t->get_corpus())
    {
      corpus_group_sptr g = is_corpus_group(c);
      if (g)
    {
      if (t->get_corpus()->get_group() == g.get())
        result = true;
    }
      else
    {
      if (t->get_corpus() == c.get())
        result = true;
    }
    }
  return result;
}
/// @brief the location of a token represented in its simplest form.
/// Instances of this type are to be stored in a sorted vector, so the
/// type must have proper relational operators.
class expanded_location
{
  string    path_;
  unsigned  line_;
  unsigned  column_;
 
  expanded_location();
 
public:
 
  friend class location_manager;
 
  expanded_location(const string& path, unsigned line, unsigned column)
  : path_(path), line_(line), column_(column)
  {}
 
  bool
  operator==(const expanded_location& l) const
  {
    return (path_ == l.path_
        && line_ == l.line_
        && column_ && l.column_);
  }
 
  bool
  operator<(const expanded_location& l) const
  {
    if (path_ < l.path_)
      return true;
    else if (path_ > l.path_)
      return false;
 
    if (line_ < l.line_)
      return true;
    else if (line_ > l.line_)
      return false;
 
    return column_ < l.column_;
  }
};
 
/// Expand the location into a tripplet path, line and column number.
///
/// @param path the output parameter where this function sets the
/// expanded path.
///
/// @param line the output parameter where this function sets the
/// expanded line.
///
/// @param column the ouptut parameter where this function sets the
/// expanded column.
void
location::expand(std::string& path, unsigned& line, unsigned& column) const
{
  if (!get_location_manager())
    {
      // We don't have a location manager maybe because this location
      // was just freshly instanciated.  We still want to be able to
      // expand to default values.
      path = "";
      line = 0;
      column = 0;
      return;
    }
  get_location_manager()->expand_location(*this, path, line, column);
}
 
 
/// Expand the location into a string.
///
/// @return the string representing the location.
string
location::expand(void) const
{
  string path, result;
  unsigned line = 0, column = 0;
  expand(path, line, column);
 
  std::ostringstream o;
  o << path << ":" << line << ":" << column;
  return o.str();
}
 
struct location_manager::priv
{
  /// This sorted vector contains the expanded locations of the tokens
  /// coming from a given ABI Corpus.  The index of a given expanded
  /// location in the table gives us an integer that is used to build
  /// instance of location types.
  std::vector<expanded_location> locs;
};
 
location_manager::location_manager()
  : priv_(new location_manager::priv)
{}
 
location_manager::~location_manager() = default;
 
/// Insert the triplet representing a source locus into our internal
/// vector of location triplet.  Return an instance of location type,
/// built from an real type that represents the index of the
/// source locus triplet into our source locus table.
///
/// @param file_path the file path of the source locus
/// @param line the line number of the source location
/// @param col the column number of the source location
location
location_manager::create_new_location(const std::string&    file_path,
                      size_t            line,
                      size_t            col)
{
  expanded_location l(file_path, line, col);
 
  // Just append the new expanded location to the end of the vector
  // and return its index.  Note that indexes start at 1.
  priv_->locs.push_back(l);
  return location(priv_->locs.size(), this);
}
 
/// Given an instance of location type, return the triplet
/// {path,line,column} that represents the source locus.  Note that
/// the location must have been previously created from the function
/// location_manager::create_new_location, otherwise this function yields
/// unexpected results, including possibly a crash.
///
/// @param location the instance of location type to expand
/// @param path the resulting path of the source locus
/// @param line the resulting line of the source locus
/// @param column the resulting colum of the source locus
void
location_manager::expand_location(const location&   location,
                  std::string&      path,
                  unsigned&     line,
                  unsigned&     column) const
{
  if (location.value_ == 0)
    return;
  expanded_location &l = priv_->locs[location.value_ - 1];
  path = l.path_;
  line = l.line_;
  column = l.column_;
}
 
typedef unordered_map<function_type_sptr,
              bool,
              function_type::hash,
              type_shared_ptr_equal> fn_type_ptr_map;
 
// <type_maps stuff>
 
struct type_maps::priv
{
  mutable istring_type_base_wptrs_map_type  basic_types_;
  mutable istring_type_base_wptrs_map_type  class_types_;
  mutable istring_type_base_wptrs_map_type  union_types_;
  mutable istring_type_base_wptrs_map_type  enum_types_;
  mutable istring_type_base_wptrs_map_type  typedef_types_;
  mutable istring_type_base_wptrs_map_type  qualified_types_;
  mutable istring_type_base_wptrs_map_type  pointer_types_;
  mutable istring_type_base_wptrs_map_type  ptr_to_mbr_types_;
  mutable istring_type_base_wptrs_map_type  reference_types_;
  mutable istring_type_base_wptrs_map_type  array_types_;
  mutable istring_type_base_wptrs_map_type  subrange_types_;
  mutable istring_type_base_wptrs_map_type  function_types_;
  mutable vector<type_base_wptr>        sorted_types_;
}; // end struct type_maps::priv
 
type_maps::type_maps()
  : priv_(new priv)
{}
 
type_maps::~type_maps() = default;
 
/// Test if the type_maps is empty.
///
/// @return true iff the type_maps is empty.
bool
type_maps::empty() const
{
  return (basic_types().empty()
      && class_types().empty()
      && union_types().empty()
      && enum_types().empty()
      && typedef_types().empty()
      && qualified_types().empty()
      && pointer_types().empty()
      && reference_types().empty()
      && array_types().empty()
      && subrange_types().empty()
      && function_types().empty());
}
 
/// Getter for the map that associates the name of a basic type to the
/// vector instances of type_decl_sptr that represents that type.
const istring_type_base_wptrs_map_type&
type_maps::basic_types() const
{return priv_->basic_types_;}
 
/// Getter for the map that associates the name of a basic type to the
/// vector of instances of @ref type_decl_sptr that represents that
/// type.
istring_type_base_wptrs_map_type&
type_maps::basic_types()
{return priv_->basic_types_;}
 
/// Getter for the map that associates the name of a class type to the
/// vector of instances of @ref class_decl_sptr that represents that
/// type.
const istring_type_base_wptrs_map_type&
type_maps::class_types() const
{return priv_->class_types_;}
 
/// Getter for the map that associates the name of a class type to the
/// vector of instances of @ref class_decl_sptr that represents that
/// type.
istring_type_base_wptrs_map_type&
type_maps::class_types()
{return priv_->class_types_;}
 
/// Getter for the map that associates the name of a union type to the
/// vector of instances of @ref union_decl_sptr that represents that
/// type.
istring_type_base_wptrs_map_type&
type_maps::union_types()
{return priv_->union_types_;}
 
/// Getter for the map that associates the name of a union type to the
/// vector of instances of @ref union_decl_sptr that represents that
/// type.
const istring_type_base_wptrs_map_type&
type_maps::union_types() const
{return priv_->union_types_;}
 
/// Getter for the map that associates the name of an enum type to the
/// vector of instances of @ref enum_type_decl_sptr that represents
/// that type.
istring_type_base_wptrs_map_type&
type_maps::enum_types()
{return priv_->enum_types_;}
 
/// Getter for the map that associates the name of an enum type to the
/// vector of instances of @ref enum_type_decl_sptr that represents
/// that type.
const istring_type_base_wptrs_map_type&
type_maps::enum_types() const
{return priv_->enum_types_;}
 
/// Getter for the map that associates the name of a typedef to the
/// vector of instances of @ref typedef_decl_sptr that represents tha
/// type.
istring_type_base_wptrs_map_type&
type_maps::typedef_types()
{return priv_->typedef_types_;}
 
/// Getter for the map that associates the name of a typedef to the
/// vector of instances of @ref typedef_decl_sptr that represents tha
/// type.
const istring_type_base_wptrs_map_type&
type_maps::typedef_types() const
{return priv_->typedef_types_;}
 
/// Getter for the map that associates the name of a qualified type to
/// the vector of instances of @ref qualified_type_def_sptr.
istring_type_base_wptrs_map_type&
type_maps::qualified_types()
{return priv_->qualified_types_;}
 
/// Getter for the map that associates the name of a qualified type to
/// the vector of instances of @ref qualified_type_def_sptr.
const istring_type_base_wptrs_map_type&
type_maps::qualified_types() const
{return priv_->qualified_types_;}
 
/// Getter for the map that associates the name of a pointer type to
/// the vector of instances of @ref pointer_type_def_sptr that
/// represents that type.
istring_type_base_wptrs_map_type&
type_maps::pointer_types()
{return priv_->pointer_types_;}
 
/// Getter for the map that associates the name of a pointer-to-member
/// type to the vector of instances of @ref ptr_to_mbr_type_sptr that
/// represents that type.
istring_type_base_wptrs_map_type&
type_maps::ptr_to_mbr_types()
{return priv_->ptr_to_mbr_types_;}
 
/// Getter for the map that associates the name of a pointer-to-member
/// type to the vector of instances of @ref ptr_to_mbr_type_sptr that
/// represents that type.
const istring_type_base_wptrs_map_type&
type_maps::ptr_to_mbr_types() const
{return priv_->ptr_to_mbr_types_;}
 
/// Getter for the map that associates the name of a pointer type to
/// the vector of instances of @ref pointer_type_def_sptr that
/// represents that type.
const istring_type_base_wptrs_map_type&
type_maps::pointer_types() const
{return priv_->pointer_types_;}
 
/// Getter for the map that associates the name of a reference type to
/// the vector of instances of @ref reference_type_def_sptr that
/// represents that type.
istring_type_base_wptrs_map_type&
type_maps::reference_types()
{return priv_->reference_types_;}
 
/// Getter for the map that associates the name of a reference type to
/// the vector of instances of @ref reference_type_def_sptr that
/// represents that type.
const istring_type_base_wptrs_map_type&
type_maps::reference_types() const
{return priv_->reference_types_;}
 
/// Getter for the map that associates the name of an array type to
/// the vector of instances of @ref array_type_def_sptr that
/// represents that type.
istring_type_base_wptrs_map_type&
type_maps::array_types()
{return priv_->array_types_;}
 
/// Getter for the map that associates the name of an array type to
/// the vector of instances of @ref array_type_def_sptr that
/// represents that type.
const istring_type_base_wptrs_map_type&
type_maps::array_types() const
{return priv_->array_types_;}
 
/// Getter for the map that associates the name of a subrange type to
/// the vector of instances of @ref array_type_def::subrange_sptr that
/// represents that type.
istring_type_base_wptrs_map_type&
type_maps::subrange_types()
{return priv_->subrange_types_;}
 
/// Getter for the map that associates the name of a subrange type to
/// the vector of instances of @ref array_type_def::subrange_sptr that
/// represents that type.
const istring_type_base_wptrs_map_type&
type_maps::subrange_types() const
{return priv_->subrange_types_;}
 
/// Getter for the map that associates the name of a function type to
/// the vector of instances of @ref function_type_sptr that represents
/// that type.
const istring_type_base_wptrs_map_type&
type_maps::function_types() const
{return priv_->function_types_;}
 
/// Getter for the map that associates the name of a function type to
/// the vector of instances of @ref function_type_sptr that represents
/// that type.
istring_type_base_wptrs_map_type&
type_maps::function_types()
{return priv_->function_types_;}
 
/// A comparison functor to compare/sort types based on their pretty
/// representations.
struct type_name_comp
{
  /// Comparison operator for two instances of @ref type_base.
  ///
  /// This compares the two types by lexicographically comparing their
  /// pretty representation.
  ///
  /// @param l the left-most type to compare.
  ///
  /// @param r the right-most type to compare.
  ///
  /// @return true iff @p l < @p r.
  bool
  operator()(type_base *l, type_base *r) const
  {
    if (l == 0 && r == 0)
      return false;
 
    string l_repr = get_pretty_representation(l);
    string r_repr = get_pretty_representation(r);
    return l_repr < r_repr;
  }
 
  /// Comparison operator for two instances of @ref type_base.
  ///
  /// This compares the two types by lexicographically comparing their
  /// pretty representation.
  ///
  /// @param l the left-most type to compare.
  ///
  /// @param r the right-most type to compare.
  ///
  /// @return true iff @p l < @p r.
  bool
  operator()(const type_base_sptr &l, const type_base_sptr &r) const
  {return operator()(l.get(), r.get());}
 
  /// Comparison operator for two instances of @ref type_base.
  ///
  /// This compares the two types by lexicographically comparing their
  /// pretty representation.
  ///
  /// @param l the left-most type to compare.
  ///
  /// @param r the right-most type to compare.
  ///
  /// @return true iff @p l < @p r.
  bool
  operator()(const type_base_wptr &l, const type_base_wptr &r) const
  {return operator()(type_base_sptr(l), type_base_sptr(r));}
}; // end struct type_name_comp
 
#ifdef WITH_DEBUG_SELF_COMPARISON
 
/// This is a function called when the ABG_RETURN* macros defined
/// below return false.
///
/// The purpose of this function is to ease debugging.  To know where
/// the equality functions first compare non-equal, we can just set a
/// breakpoint on this notify_equality_failed function and run the
/// equality functions.  Because all the equality functions use the
/// ABG_RETURN* macros to return their values, this function is always
/// called when any of those equality function return false.
///
/// @param l the first operand of the equality.
///
/// @param r the second operand of the equality.
static void
notify_equality_failed(const type_or_decl_base &l __attribute__((unused)),
               const type_or_decl_base &r __attribute__((unused)))
{}
 
/// This is a function called when the ABG_RETURN* macros defined
/// below return false.
///
/// The purpose of this function is to ease debugging.  To know where
/// the equality functions first compare non-equal, we can just set a
/// breakpoint on this notify_equality_failed function and run the
/// equality functions.  Because all the equality functions use the
/// ABG_RETURN* macros to return their values, this function is always
/// called when any of those equality function return false.
///
/// @param l the first operand of the equality.
///
/// @param r the second operand of the equality.
static void
notify_equality_failed(const type_or_decl_base *l __attribute__((unused)),
               const type_or_decl_base *r __attribute__((unused)))
{}
 
#define ABG_RETURN_EQUAL(l, r)          \
  do                        \
    {                       \
      if (l != r)               \
        notify_equality_failed(l, r);       \
      return (l == r);              \
    }                       \
  while(false)
 
 
#define ABG_RETURN_FALSE        \
  do                    \
    {                   \
      notify_equality_failed(l, r); \
      return false;         \
    } while(false)
 
#define ABG_RETURN(value)           \
  do                        \
    {                       \
      if (value == false)           \
    notify_equality_failed(l, r);       \
      return value;             \
    } while (false)
 
#else // WITH_DEBUG_SELF_COMPARISON
 
#define ABG_RETURN_FALSE return false
#define ABG_RETURN(value) return (value)
#define ABG_RETURN_EQUAL(l, r) return ((l) == (r));
#endif
 
/// Get the canonical type of a given type T* as a T*.
///
/// Note that normally, canonical types are returned as @ref
/// type_base* (un-typed form, kind of).  This function returns the
/// canonical type as a T*, just like the T* it is looking at.
///
///
/// @param t the type to consider.
///
/// @return either the canonical type of @p t or @p t itself if it
/// doesn't have any canonical type.
template<typename T>
T*
maybe_get_canonical_type(T* t)
{
  if (!t)
    return nullptr;
  if (type_base* type = t->get_naked_canonical_type())
    return dynamic_cast<T*>(type);
  return t;
}
 
/// Compare two types by comparing their canonical types if present.
///
/// If the canonical types are not present (because the types have not
/// yet been canonicalized, for instance) then the types are compared
/// structurally.
///
/// @param l the first type to take into account in the comparison.
///
/// @param r the second type to take into account in the comparison.
template<typename T>
bool
try_canonical_compare(const T *l, const T *r)
{
#if WITH_DEBUG_TYPE_CANONICALIZATION
  // We are debugging the canonicalization of a type down the stack.
  // 'l' is a subtype of a canonical type and 'r' is a subtype of the
  // type being canonicalized.  We are at a point where we can compare
  // 'l' and 'r' either using canonical comparison (if 'l' and 'r'
  // have canonical types) or structural comparison.
  //
  // Because we are debugging the process of type canonicalization, we
  // want to compare 'l' and 'r' canonically *AND* structurally.  Both
  // kinds of comparison should yield the same result, otherwise type
  // canonicalization just failed for the subtype 'r' of the type
  // being canonicalized.
  //
  // In concrete terms, this function is going to be called twice with
  // the same pair {'l', 'r'} to compare: The first time with
  // environment::priv_->use_canonical_type_comparison_ set to true,
  // 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_)
    {
      if (const type_base *lc = l->get_naked_canonical_type())
    if (const type_base *rc = r->get_naked_canonical_type())
      ABG_RETURN_EQUAL(lc, rc);
    }
 
  // If the two types have a non-empty hash value, then consider those
  // hash values.  If the hashes are different then the two types are
  // different.  If the hashes are equal then we'll compare then
  // structurally.
  if (hash_t l_hash = peek_hash_value(*l))
    if (hash_t r_hash = peek_hash_value(*r))
      if (l_hash != r_hash)
    ABG_RETURN_FALSE;
 
  // If a type has a canonical type, use its canonical type, always.
  l = maybe_get_canonical_type(l);
  r = maybe_get_canonical_type(r);
 
  return equals(*l, *r, 0);
#else
  if (const type_base *lc = l->get_naked_canonical_type())
    if (const type_base *rc = r->get_naked_canonical_type())
      ABG_RETURN_EQUAL(lc, rc);
 
  // If the two types have a non-empty hash value, then consider those
  // hash values.  If the hashes are different then the two types are
  // different.  If the hashes are equal then we'll compare then
  // structurally.
  if (hash_t l_hash = peek_hash_value(*l))
    if (hash_t r_hash = peek_hash_value(*r))
      if (l_hash != r_hash)
    ABG_RETURN_FALSE;
 
  // If a type has a canonical type, use its canonical type, always.
  l = maybe_get_canonical_type(l);
  r = maybe_get_canonical_type(r);
 
  return equals(*l, *r, 0);
#endif
}
 
/// Detect if a recursive comparison cycle is detected while
/// structurally comparing two types (a.k.a member-wise comparison).
///
/// @param l the left-hand-side operand of the current comparison.
///
/// @param r the right-hand-side operand of the current comparison.
///
/// @return true iff a comparison cycle is detected.
template<typename T>
bool
is_comparison_cycle_detected(T& l, T& r)
{
  bool result = l.priv_->comparison_started(l, r);
  return result ;
}
 
/// Detect if a recursive comparison cycle is detected while
/// structurally comparing two @ref class_decl types.
///
/// @param l the left-hand-side operand of the current comparison.
///
/// @param r the right-hand-side operand of the current comparison.
///
/// @return true iff a comparison cycle is detected.
template<>
bool
is_comparison_cycle_detected(const class_decl& l, const class_decl& r)
{
  return is_comparison_cycle_detected(static_cast<const class_or_union&>(l),
                      static_cast<const class_or_union&>(r));
}
 
/// This macro is to be used while comparing composite types that
/// might recursively refer to themselves.  Comparing two such types
/// might get us into a cyle.
///
/// Practically, if we detect that we are already into comparing 'l'
/// and 'r'; then, this is a cycle.
//
/// To break the cycle, we assume the result of the comparison is true
/// for now.  Comparing the other sub-types of l & r will tell us later
/// if l & r are actually different or not.
///
/// In the mean time, returning true from this macro should not be
/// used to propagate the canonical type of 'l' onto 'r' as we don't
/// know yet if l equals r.  All the types that depend on l and r
/// can't (and that are in the comparison stack currently) can't have
/// their canonical type propagated either.  So this macro disallows
/// canonical type propagation for those types that depend on a
/// recursively defined sub-type for now.
///
/// @param l the left-hand-side operand of the comparison.
#define RETURN_TRUE_IF_COMPARISON_CYCLE_DETECTED(l, r)          \
  do                                    \
    {                                   \
      if (is_comparison_cycle_detected(l, r))               \
    return true;                            \
    }                                   \
  while(false)
 
 
/// Mark a pair of types as being compared.
///
/// This is helpful to later detect recursive cycles in the comparison
/// stack.
///
/// @param l the left-hand-side operand of the comparison.
///
/// @parm r the right-hand-side operand of the comparison.
template<typename T>
void
mark_types_as_being_compared(T& l, T&r)
{
  l.priv_->mark_as_being_compared(l, r);
  push_composite_type_comparison_operands(l, r);
}
 
/// Mark a pair of @ref class_decl types as being compared.
///
/// This is helpful to later detect recursive cycles in the comparison
/// stack.
///
/// @param l the left-hand-side operand of the comparison.
///
/// @parm r the right-hand-side operand of the comparison.
template<>
void
mark_types_as_being_compared(const class_decl& l, const class_decl &r)
{
  return mark_types_as_being_compared(static_cast<const class_or_union&>(l),
                      static_cast<const class_or_union&>(r));
}
 
/// Mark a pair of types as being not compared anymore.
///
/// This is helpful to later detect recursive cycles in the comparison
/// stack.
///
/// Note that the types must have been passed to
/// mark_types_as_being_compared prior to calling this function.
///
/// @param l the left-hand-side operand of the comparison.
///
/// @parm r the right-hand-side operand of the comparison.
template<typename T>
void
unmark_types_as_being_compared(T& l, T&r)
{
  l.priv_->unmark_as_being_compared(l, r);
  pop_composite_type_comparison_operands(l, r);
}
 
/// Mark a pair of @ref class_decl types as being not compared
/// anymore.
///
/// This is helpful to later detect recursive cycles in the comparison
/// stack.
///
/// Note that the types must have been passed to
/// mark_types_as_being_compared prior to calling this function.
///
/// @param l the left-hand-side operand of the comparison.
///
/// @parm r the right-hand-side operand of the comparison.
template<>
void
unmark_types_as_being_compared(const class_decl& l, const class_decl &r)
{
  return unmark_types_as_being_compared(static_cast<const class_or_union&>(l),
                    static_cast<const class_or_union&>(r));
}
 
/// Return the result of the comparison of two (sub) types.
///
/// The function does the necessary book keeping before returning the
/// result of the comparison of two (sub) types.
///
/// The book-keeping done is essentially about type comparison cycle detection.
///
///   @param l the left-hand-side operand of the type comparison
///
///   @param r the right-hand-side operand of the type comparison
///
///   @param value the result of the comparison of @p l and @p r.
///
///   @return the value @p value.
template<typename T>
bool
return_comparison_result(T& l, T& r, bool value)
{
  unmark_types_as_being_compared(l, r);
  ABG_RETURN(value);
}
 
#define CACHE_AND_RETURN_COMPARISON_RESULT(value)           \
  do                                    \
    {                                   \
      bool res = return_comparison_result(l, r, value);     \
      l.get_environment().priv_->cache_type_comparison_result(l, r, res); \
      return res;                           \
    } while (false)
 
/// Cache the result of a comparison between too artifacts (l & r) and
/// return immediately.
///
/// @param value the value to cache.
#define CACHE_COMPARISON_RESULT_AND_RETURN(value)           \
  do                                    \
    {                                   \
      l.get_environment().priv_->cache_type_comparison_result(l, r, value); \
      return value;                         \
    } while (false)
 
/// Getter of all types types sorted by their pretty representation.
///
/// @return a sorted vector of all types sorted by their pretty
/// representation.
const vector<type_base_wptr>&
type_maps::get_types_sorted_by_name() const
{
  if (priv_->sorted_types_.empty())
    {
      istring_type_base_wptrs_map_type::const_iterator i;
      vector<type_base_wptr>::const_iterator j;
 
      for (i = basic_types().begin(); i != basic_types().end(); ++i)
    for (j = i->second.begin(); j != i->second.end(); ++j)
      priv_->sorted_types_.push_back(*j);
 
      for (i = class_types().begin(); i != class_types().end(); ++i)
    for (j = i->second.begin(); j != i->second.end(); ++j)
      priv_->sorted_types_.push_back(*j);
 
      for (i = union_types().begin(); i != union_types().end(); ++i)
    for (j = i->second.begin(); j != i->second.end(); ++j)
      priv_->sorted_types_.push_back(*j);
 
      for (i = enum_types().begin(); i != enum_types().end(); ++i)
    for (j = i->second.begin(); j != i->second.end(); ++j)
      priv_->sorted_types_.push_back(*j);
 
      for (i = typedef_types().begin(); i != typedef_types().end(); ++i)
    for (j = i->second.begin(); j != i->second.end(); ++j)
      priv_->sorted_types_.push_back(*j);
 
      type_name_comp comp;
      sort(priv_->sorted_types_.begin(), priv_->sorted_types_.end(), comp);
    }
 
  return priv_->sorted_types_;
}
 
// </type_maps stuff>
 
// <translation_unit stuff>
 
/// Constructor of translation_unit.
///
/// @param env the environment of this translation unit.  Please note
/// that the life time of the environment must be greater than the
/// life time of the translation unit because the translation uses
/// resources that are allocated in the environment.
///
/// @param path the location of the translation unit.
///
/// @param address_size the size of addresses in the translation unit,
/// in bits.
translation_unit::translation_unit(const environment&   env,
                   const std::string&   path,
                   char     address_size)
  : priv_(new priv(env))
{
  priv_->path_ = path;
  priv_->address_size_ = address_size;
}
 
/// Getter of the the global scope of the translation unit.
///
/// @return the global scope of the current translation unit.  If
/// there is not global scope allocated yet, this function creates one
/// and returns it.
const scope_decl_sptr&
translation_unit::get_global_scope() const
{
  return const_cast<translation_unit*>(this)->get_global_scope();
}
 
/// Getter of the global scope of the translation unit.
///
/// @return the global scope of the current translation unit.  If
/// there is not allocated yet, this function creates one and returns
/// it.
scope_decl_sptr&
translation_unit::get_global_scope()
{
  if (!priv_->global_scope_)
    {
      priv_->global_scope_.reset
    (new global_scope(const_cast<translation_unit*>(this)));
      priv_->global_scope_->set_translation_unit
    (const_cast<translation_unit*>(this));
    }
  return priv_->global_scope_;
}
 
/// Getter of the types of the current @ref translation_unit.
///
/// @return the maps of the types of the translation unit.
const type_maps&
translation_unit::get_types() const
{return priv_->types_;}
 
/// Getter of the types of the current @ref translation_unit.
///
/// @return the maps of the types of the translation unit.
type_maps&
translation_unit::get_types()
{return priv_->types_;}
 
/// Get the vector of function types that are used in the current
/// translation unit.
///
/// @return the vector of function types that are used in the current
/// translation unit.
const vector<function_type_sptr>&
translation_unit::get_live_fn_types() const
{return priv_->live_fn_types_;}
 
/// Getter of the environment of the current @ref translation_unit.
///
/// @return the translation unit of the current translation unit.
const environment&
translation_unit::get_environment() const
{return priv_->env_;}
 
/// Getter of the language of the source code of the translation unit.
///
/// @return the language of the source code.
translation_unit::language
translation_unit::get_language() const
{return priv_->language_;}
 
/// Setter of the language of the source code of the translation unit.
///
/// @param l the new language.
void
translation_unit::set_language(language l)
{priv_->language_ = l;}
 
 
/// Get the path of the current translation unit.
///
/// This path is relative to the build directory of the translation
/// unit as returned by translation_unit::get_compilation_dir_path.
///
/// @return the relative path of the compilation unit associated to
/// the current instance of translation_unit.
//
const std::string&
translation_unit::get_path() const
{return priv_->path_;}
 
/// Set the path associated to the current instance of
/// translation_unit.
///
/// This path is relative to the build directory of the translation
/// unit as returned by translation_unit::get_compilation_dir_path.
///
/// @param a_path the new relative path to set.
void
translation_unit::set_path(const string& a_path)
{priv_->path_ = a_path;}
 
 
/// Get the path of the directory that was 'current' when the
/// translation unit was compiled.
///
/// Note that the path returned by translation_unit::get_path is
/// relative to the path returned by this function.
///
/// @return the compilation directory for the current translation
/// unit.
const std::string&
translation_unit::get_compilation_dir_path() const
{return priv_->comp_dir_path_;}
 
/// Set the path of the directory that was 'current' when the
/// translation unit was compiled.
///
/// Note that the path returned by translation_unit::get_path is
/// relative to the path returned by this function.
///
/// @param the compilation directory for the current translation unit.
void
translation_unit::set_compilation_dir_path(const std::string& d)
{priv_->comp_dir_path_ = d;}
 
/// Get the concatenation of the build directory and the relative path
/// of the translation unit.
///
/// @return the absolute path of the translation unit.
const std::string&
translation_unit::get_absolute_path() const
{
  if (priv_->abs_path_.empty())
    {
      string path;
      if (!priv_->path_.empty())
    {
      if (!priv_->comp_dir_path_.empty())
        {
          path = priv_->comp_dir_path_;
          path += "/";
        }
      path += priv_->path_;
    }
      priv_->abs_path_ = path;
    }
 
  return priv_->abs_path_;
}
 
/// Set the corpus this translation unit is a member of.
///
/// Note that adding a translation unit to a @ref corpus automatically
/// triggers a call to this member function.
///
/// @param corpus the corpus.
void
translation_unit::set_corpus(corpus* c)
{priv_->corp = c;}
 
/// Get the corpus this translation unit is a member of.
///
/// @return the parent corpus, or nil if this doesn't belong to any
/// corpus yet.
corpus*
translation_unit::get_corpus()
{return priv_->corp;}
 
/// Get the corpus this translation unit is a member of.
///
/// @return the parent corpus, or nil if this doesn't belong to any
/// corpus yet.
const corpus*
translation_unit::get_corpus() const
{return const_cast<translation_unit*>(this)->get_corpus();}
 
/// Getter of the location manager for the current translation unit.
///
/// @return a reference to the location manager for the current
/// translation unit.
location_manager&
translation_unit::get_loc_mgr()
{return priv_->loc_mgr_;}
 
/// const Getter of the location manager.
///
/// @return a const reference to the location manager for the current
/// translation unit.
const location_manager&
translation_unit::get_loc_mgr() const
{return priv_->loc_mgr_;}
 
/// Tests whether if the current translation unit contains ABI
/// artifacts or not.
///
/// @return true iff the current translation unit is empty.
bool
translation_unit::is_empty() const
{
  if (!priv_->global_scope_)
    return true;
  return get_global_scope()->is_empty();
}
 
/// Getter of the address size in this translation unit.
///
/// @return the address size, in bits.
char
translation_unit::get_address_size() const
{return priv_->address_size_;}
 
/// Setter of the address size in this translation unit.
///
/// @param a the new address size in bits.
void
translation_unit::set_address_size(char a)
{priv_->address_size_= a;}
 
/// Getter of the 'is_constructed" flag.  It says if the translation
/// unit is fully constructed or not.
///
/// This flag is important for cases when comparison might depend on
/// if the translation unit is fully built or not.  For instance, when
/// reading types from DWARF, the virtual methods of a class are not
/// necessarily fully constructed until we have reached the end of the
/// translation unit.  In that case, before we've reached the end of
/// the translation unit, we might not take virtual functions into
/// account when comparing classes.
///
/// @return true if the translation unit is constructed.
bool
translation_unit::is_constructed() const
{return priv_->is_constructed_;}
 
/// Setter of the 'is_constructed" flag.  It says if the translation
/// unit is fully constructed or not.
///
/// This flag is important for cases when comparison might depend on
/// if the translation unit is fully built or not.  For instance, when
/// reading types from DWARF, the virtual methods of a class are not
/// necessarily fully constructed until we have reached the end of the
/// translation unit.  In that case, before we've reached the end of
/// the translation unit, we might not take virtual functions into
/// account when comparing classes.
///
/// @param f true if the translation unit is constructed.
void
translation_unit::set_is_constructed(bool f)
{priv_->is_constructed_ = f;}
 
/// Compare the current translation unit against another one.
///
/// @param other the other tu to compare against.
///
/// @return true if the two translation units are equal, false
/// otherwise.
bool
translation_unit::operator==(const translation_unit& other)const
{
  if (get_address_size() != other.get_address_size())
    return false;
 
  return *get_global_scope() == *other.get_global_scope();
}
 
/// Inequality operator.
///
/// @param o the instance of @ref translation_unit to compare the
/// current instance against.
///
/// @return true iff the current instance is different from @p o.
bool
translation_unit::operator!=(const translation_unit& o) const
{return ! operator==(o);}
 
/// Ensure that the life time of a function type is bound to the life
/// time of the current translation unit.
///
/// @param ftype the function time which life time to bind to the life
/// time of the current instance of @ref translation_unit.  That is,
/// it's onlyh when the translation unit is destroyed that the
/// function type can be destroyed to.
void
translation_unit::bind_function_type_life_time(function_type_sptr ftype) const
{
  const environment& env = get_environment();
 
  const_cast<translation_unit*>(this)->priv_->live_fn_types_.push_back(ftype);
 
  interned_string repr = get_type_name(ftype);
  const_cast<translation_unit*>(this)->get_types().function_types()[repr].
    push_back(ftype);
 
  // The function type must be out of the same environment as its
  // translation unit.
  {
    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);
  else
    ftype->set_translation_unit(const_cast<translation_unit*>(this));
 
  maybe_update_types_lookup_map(ftype);
}
 
/// This implements the ir_traversable_base::traverse virtual
/// function.
///
/// @param v the visitor used on the member nodes of the translation
/// unit during the traversal.
///
/// @return true if the entire type IR tree got traversed, false
/// otherwise.
bool
translation_unit::traverse(ir_node_visitor& v)
{return get_global_scope()->traverse(v);}
 
translation_unit::~translation_unit()
{}
 
/// Converts a translation_unit::language enumerator into a string.
///
/// @param l the language enumerator to translate.
///
/// @return the resulting string.
string
translation_unit_language_to_string(translation_unit::language l)
{
  switch (l)
    {
    case translation_unit::LANG_UNKNOWN:
      return "LANG_UNKNOWN";
    case translation_unit::LANG_Cobol74:
      return "LANG_Cobol74";
    case translation_unit::LANG_Cobol85:
      return "LANG_Cobol85";
    case translation_unit::LANG_C89:
      return "LANG_C89";
    case translation_unit::LANG_C99:
      return "LANG_C99";
    case translation_unit::LANG_C11:
      return "LANG_C11";
    case translation_unit::LANG_C:
      return "LANG_C";
    case translation_unit::LANG_C_plus_plus_11:
      return "LANG_C_plus_plus_11";
    case translation_unit::LANG_C_plus_plus_14:
      return "LANG_C_plus_plus_14";
    case translation_unit::LANG_C_plus_plus:
      return "LANG_C_plus_plus";
    case translation_unit::LANG_ObjC:
      return "LANG_ObjC";
    case translation_unit::LANG_ObjC_plus_plus:
      return "LANG_ObjC_plus_plus";
    case translation_unit::LANG_Fortran77:
      return "LANG_Fortran77";
    case translation_unit::LANG_Fortran90:
      return "LANG_Fortran90";
    case translation_unit::LANG_Fortran95:
      return "LANG_Fortran95";
    case translation_unit::LANG_Ada83:
      return "LANG_Ada83";
    case translation_unit::LANG_Ada95:
      return "LANG_Ada95";
    case translation_unit::LANG_Pascal83:
      return "LANG_Pascal83";
    case translation_unit::LANG_Modula2:
      return "LANG_Modula2";
    case translation_unit::LANG_Java:
      return "LANG_Java";
    case translation_unit::LANG_PLI:
      return "LANG_PLI";
    case translation_unit::LANG_UPC:
      return "LANG_UPC";
    case translation_unit::LANG_D:
      return "LANG_D";
    case translation_unit::LANG_Python:
      return "LANG_Python";
    case translation_unit::LANG_Go:
      return "LANG_Go";
    case translation_unit::LANG_Mips_Assembler:
      return "LANG_Mips_Assembler";
    default:
      return "LANG_UNKNOWN";
    }
 
  return "LANG_UNKNOWN";
}
 
/// Parse a string representing a language into a
/// translation_unit::language enumerator into a string.
///
/// @param l the string representing the language.
///
/// @return the resulting translation_unit::language enumerator.
translation_unit::language
string_to_translation_unit_language(const string& l)
{
  if (l == "LANG_Cobol74")
    return translation_unit::LANG_Cobol74;
  else if (l == "LANG_Cobol85")
    return translation_unit::LANG_Cobol85;
  else if (l == "LANG_C89")
    return translation_unit::LANG_C89;
  else if (l == "LANG_C99")
    return translation_unit::LANG_C99;
  else if (l == "LANG_C11")
    return translation_unit::LANG_C11;
  else if (l == "LANG_C")
    return translation_unit::LANG_C;
  else if (l == "LANG_C_plus_plus_11")
    return translation_unit::LANG_C_plus_plus_11;
  else if (l == "LANG_C_plus_plus_14")
    return translation_unit::LANG_C_plus_plus_14;
  else if (l == "LANG_C_plus_plus")
    return translation_unit::LANG_C_plus_plus;
  else if (l == "LANG_ObjC")
    return translation_unit::LANG_ObjC;
  else if (l == "LANG_ObjC_plus_plus")
    return translation_unit::LANG_ObjC_plus_plus;
  else if (l == "LANG_Fortran77")
    return translation_unit::LANG_Fortran77;
  else if (l == "LANG_Fortran90")
    return translation_unit::LANG_Fortran90;
    else if (l == "LANG_Fortran95")
    return translation_unit::LANG_Fortran95;
  else if (l == "LANG_Ada83")
    return translation_unit::LANG_Ada83;
  else if (l == "LANG_Ada95")
    return translation_unit::LANG_Ada95;
  else if (l == "LANG_Pascal83")
    return translation_unit::LANG_Pascal83;
  else if (l == "LANG_Modula2")
    return translation_unit::LANG_Modula2;
  else if (l == "LANG_Java")
    return translation_unit::LANG_Java;
  else if (l == "LANG_PLI")
    return translation_unit::LANG_PLI;
  else if (l == "LANG_UPC")
    return translation_unit::LANG_UPC;
  else if (l == "LANG_D")
    return translation_unit::LANG_D;
  else if (l == "LANG_Python")
    return translation_unit::LANG_Python;
  else if (l == "LANG_Go")
    return translation_unit::LANG_Go;
  else if (l == "LANG_Mips_Assembler")
    return translation_unit::LANG_Mips_Assembler;
 
  return translation_unit::LANG_UNKNOWN;
}
 
/// Test if a language enumerator designates the C language.
///
/// @param l the language enumerator to consider.
///
/// @return true iff @p l designates the C language.
bool
is_c_language(translation_unit::language l)
{
  return (l == translation_unit::LANG_C89
      || l == translation_unit::LANG_C99
      || l == translation_unit::LANG_C11
      || l == translation_unit::LANG_C);
}
 
/// Test if a language enumerator designates the C++ language.
///
/// @param l the language enumerator to consider.
///
/// @return true iff @p l designates the C++ language.
bool
is_cplus_plus_language(translation_unit::language l)
{
  return (l == translation_unit::LANG_C_plus_plus_03
      || l == translation_unit::LANG_C_plus_plus_11
      || l == translation_unit::LANG_C_plus_plus_14
      || l == translation_unit::LANG_C_plus_plus);
}
 
/// Test if a language enumerator designates the Java language.
///
/// @param l the language enumerator to consider.
///
/// @return true iff @p l designates the Java language.
bool
is_java_language(translation_unit::language l)
{return l == translation_unit::LANG_Java;}
 
/// Test if a language enumerator designates the Ada language.
///
/// @param l the language enumerator to consider.
///
/// @return true iff @p l designates the Ada language.
bool
is_ada_language(translation_unit::language l)
{
  return (l == translation_unit::LANG_Ada83
     || l == translation_unit::LANG_Ada95);
}
 
/// A deep comparison operator for pointers to translation units.
///
/// @param l the first translation unit to consider for the comparison.
///
/// @param r the second translation unit to consider for the comparison.
///
/// @return true if the two translation units are equal, false otherwise.
bool
operator==(const translation_unit_sptr& l, const translation_unit_sptr& r)
{
  if (l.get() == r.get())
    return true;
 
  if (!!l != !!r)
    return false;
 
  return *l == *r;
}
 
/// A deep inequality operator for pointers to translation units.
///
/// @param l the first translation unit to consider for the comparison.
///
/// @param r the second translation unit to consider for the comparison.
///
/// @return true iff the two translation units are different.
bool
operator!=(const translation_unit_sptr& l, const translation_unit_sptr& r)
{return !operator==(l, r);}
 
// </translation_unit stuff>
 
// <elf_symbol stuff>
struct elf_symbol::priv
{
  const environment&    env_;
  size_t        index_;
  size_t        size_;
  string        name_;
  elf_symbol::type  type_;
  elf_symbol::binding   binding_;
  elf_symbol::version   version_;
  elf_symbol::visibility visibility_;
  bool          is_defined_;
  // This flag below says if the symbol is a common elf symbol.  In
  // relocatable files, a common symbol is a symbol defined in a
  // section of kind SHN_COMMON.
  //
  // Note that a symbol of kind STT_COMMON is also considered a common
  // symbol.  Here is what the gABI says about STT_COMMON and
  // SHN_COMMON:
  //
  //     Symbols with type STT_COMMON label uninitialized common
  //     blocks. In relocatable objects, these symbols are not
  //     allocated and must have the special section index SHN_COMMON
  //     (see below). In shared objects and executables these symbols
  //     must be allocated to some section in the defining object.
  //
  //     In relocatable objects, symbols with type STT_COMMON are
  //     treated just as other symbols with index SHN_COMMON. If the
  //     link-editor allocates space for the SHN_COMMON symbol in an
  //     output section of the object it is producing, it must
  //     preserve the type of the output symbol as STT_COMMON.
  //
  //     When the dynamic linker encounters a reference to a symbol
  //     that resolves to a definition of type STT_COMMON, it may (but
  //     is not required to) change its symbol resolution rules as
  //     follows: instead of binding the reference to the first symbol
  //     found with the given name, the dynamic linker searches for
  //     the first symbol with that name with type other than
  //     STT_COMMON. If no such symbol is found, it looks for the
  //     STT_COMMON definition of that name that has the largest size.
  bool          is_common_;
  bool          is_in_ksymtab_;
  abg_compat::optional<uint32_t>    crc_;
  abg_compat::optional<std::string> namespace_;
  bool          is_suppressed_;
  elf_symbol_wptr   main_symbol_;
  elf_symbol_wptr   next_alias_;
  elf_symbol_wptr   next_common_instance_;
  string        id_string_;
 
  priv(const environment& e)
    : env_(e),
      index_(),
      size_(),
      type_(elf_symbol::NOTYPE_TYPE),
      binding_(elf_symbol::GLOBAL_BINDING),
      visibility_(elf_symbol::DEFAULT_VISIBILITY),
      is_defined_(false),
      is_common_(false),
      is_in_ksymtab_(false),
      crc_(),
      namespace_(),
      is_suppressed_(false)
  {}
 
  priv(const environment&     e,
       size_t             i,
       size_t             s,
       const string&          n,
       elf_symbol::type       t,
       elf_symbol::binding    b,
       bool           d,
       bool           c,
       const elf_symbol::version& ve,
       elf_symbol::visibility     vi,
       bool           is_in_ksymtab,
       const abg_compat::optional<uint32_t>&    crc,
       const abg_compat::optional<std::string>& ns,
       bool           is_suppressed)
    : env_(e),
      index_(i),
      size_(s),
      name_(n),
      type_(t),
      binding_(b),
      version_(ve),
      visibility_(vi),
      is_defined_(d),
      is_common_(c),
      is_in_ksymtab_(is_in_ksymtab),
      crc_(crc),
      namespace_(ns),
      is_suppressed_(is_suppressed)
  {
    if (!is_common_)
      is_common_ = type_ == COMMON_TYPE;
  }
}; // end struct elf_symbol::priv
 
/// 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.
///
/// @param e the environment we are operating from.
///
/// @param i the index of the symbol in the (ELF) symbol table.
///
/// @param s the size of the symbol.
///
/// @param n the name of the symbol.
///
/// @param t the type of the symbol.
///
/// @param b the binding of the symbol.
///
/// @param d true if the symbol is defined, false otherwise.
///
/// @param c true if the symbol is a common symbol, false otherwise.
///
/// @param ve the version of the symbol.
///
/// @param vi the visibility of the 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,
               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,
               const abg_compat::optional<uint32_t>&    crc,
               const abg_compat::optional<std::string>& ns,
               bool       is_suppressed)
  : priv_(new priv(e,
           i,
           s,
           n,
           t,
           b,
           d,
           c,
           ve,
           vi,
           is_in_ksymtab,
           crc,
           ns,
           is_suppressed))
{}
 
/// Factory of instances of @ref elf_symbol.
///
/// This is the function to use to create instances of @ref elf_symbol.
///
/// @param e the environment we are operating from.
///
/// @param i the index of the symbol in the (ELF) symbol table.
///
/// @param s the size of the symbol.
///
/// @param n the name of the symbol.
///
/// @param t the type of the symbol.
///
/// @param b the binding of the symbol.
///
/// @param d true if the symbol is defined, false otherwise.
///
/// @param c true if the symbol is a common symbol.
///
/// @param ve the version of the symbol.
///
/// @param vi the visibility of the symbol.
///
/// @param crc the CRC (modversions) value of Linux Kernel symbols
///
/// @param ns the namespace of Linux Kernel symbols, if any
///
/// @return a (smart) pointer to a newly created instance of @ref
/// elf_symbol.
elf_symbol_sptr
elf_symbol::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,
           const abg_compat::optional<uint32_t>&    crc,
           const abg_compat::optional<std::string>& ns,
           bool           is_suppressed)
{
  elf_symbol_sptr sym(new elf_symbol(e, i, s, n, t, b, d, c, ve, vi,
                     is_in_ksymtab, crc, ns, is_suppressed));
  sym->priv_->main_symbol_ = sym;
  return sym;
}
 
/// Test textual equality between two symbols.
///
/// Textual equality means that the aliases of the compared symbols
/// are not taken into account.  Only the name, type, and version of
/// the symbols are compared.
///
/// @return true iff the two symbols are textually equal.
static bool
textually_equals(const elf_symbol&l,
         const elf_symbol&r)
{
  bool equals = (l.get_name() == r.get_name()
         && l.get_type() == r.get_type()
         && l.is_public() == r.is_public()
         && l.is_defined() == r.is_defined()
         && l.is_common_symbol() == r.is_common_symbol()
         && l.get_version() == r.get_version()
         && l.get_crc() == r.get_crc()
         && l.get_namespace() == r.get_namespace());
 
  if (equals && l.is_variable())
    // These are variable symbols.  Let's compare their symbol size.
    // The symbol size in this case is the size taken by the storage
    // of the variable.  If that size changes, then it's an ABI
    // change.
    equals = l.get_size() == r.get_size();
 
  return equals;
}
 
/// Getter of the environment used by the current instance of @ref
/// elf_symbol.
///
/// @return the enviroment used by the current instance of @ref elf_symbol.
const environment&
elf_symbol::get_environment() const
{return priv_->env_;}
 
/// Getter for the index
///
/// @return the index of the symbol.
size_t
elf_symbol::get_index() const
{return priv_->index_;}
 
/// Setter for the index.
///
/// @param s the new index.
void
elf_symbol::set_index(size_t s)
{priv_->index_ = s;}
 
/// Getter for the name of the @ref elf_symbol.
///
/// @return a reference to the name of the @ref symbol.
const string&
elf_symbol::get_name() const
{return priv_->name_;}
 
/// Setter for the name of the current intance of @ref elf_symbol.
///
/// @param n the new name.
void
elf_symbol::set_name(const string& n)
{
  priv_->name_ = n;
  priv_->id_string_.clear();
}
 
/// Getter for the type of the current instance of @ref elf_symbol.
///
/// @return the type of the elf symbol.
elf_symbol::type
elf_symbol::get_type() const
{return priv_->type_;}
 
/// Setter for the type of the current instance of @ref elf_symbol.
///
/// @param t the new symbol type.
void
elf_symbol::set_type(type t)
{priv_->type_ = t;}
 
/// Getter of the size of the symbol.
///
/// @return the size of the symbol, in bytes.
size_t
elf_symbol::get_size() const
{return priv_->size_;}
 
/// Setter of the size of the symbol.
///
/// @param size the new size of the symbol, in bytes.
void
elf_symbol::set_size(size_t size)
{priv_->size_ = size;}
 
/// Getter for the binding of the current instance of @ref elf_symbol.
///
/// @return the binding of the symbol.
elf_symbol::binding
elf_symbol::get_binding() const
{return priv_->binding_;}
 
/// Setter for the binding of the current instance of @ref elf_symbol.
///
/// @param b the new binding.
void
elf_symbol::set_binding(binding b)
{priv_->binding_ = b;}
 
/// Getter for the version of the current instanc of @ref elf_symbol.
///
/// @return the version of the elf symbol.
elf_symbol::version&
elf_symbol::get_version() const
{return priv_->version_;}
 
/// Setter for the version of the current instance of @ref elf_symbol.
///
/// @param v the new version of the elf symbol.
void
elf_symbol::set_version(const version& v)
{
  priv_->version_ = v;
  priv_->id_string_.clear();
}
 
/// Setter of the visibility of the current instance of @ref
/// elf_symbol.
///
/// @param v the new visibility of the elf symbol.
void
elf_symbol::set_visibility(visibility v)
{priv_->visibility_ = v;}
 
/// Getter of the visibility of the current instance of @ref
/// elf_symbol.
///
/// @return the visibility of the elf symbol.
elf_symbol::visibility
elf_symbol::get_visibility() const
{return priv_->visibility_;}
 
/// Test if the current instance of @ref elf_symbol is defined or not.
///
/// @return true if the current instance of @ref elf_symbol is
/// defined, false otherwise.
bool
elf_symbol::is_defined() const
{return priv_->is_defined_;}
 
/// Sets a flag saying if the current instance of @ref elf_symbol is
/// defined
///
/// @param b the new value of the flag.
void
elf_symbol::is_defined(bool d)
{priv_->is_defined_ = d;}
 
/// Test if the current instance of @ref elf_symbol is public or not.
///
/// This tests if the symbol is defined, has default or protected
///visibility, and either:
///     - has global binding
///     - has weak binding
///     - or has a GNU_UNIQUE binding.
///
/// return true if the current instance of @ref elf_symbol is public,
/// false otherwise.
bool
elf_symbol::is_public() const
{
  return (is_defined()
      && (get_binding() == GLOBAL_BINDING
          || get_binding() == WEAK_BINDING
          || get_binding() == GNU_UNIQUE_BINDING)
      && (get_visibility() == DEFAULT_VISIBILITY
          || get_visibility() == PROTECTED_VISIBILITY));
}
 
/// Test if the current instance of @ref elf_symbol is a function
/// symbol or not.
///
/// @return true if the current instance of @ref elf_symbol is a
/// function symbol, false otherwise.
bool
elf_symbol::is_function() const
{return get_type() == FUNC_TYPE || get_type() == GNU_IFUNC_TYPE;}
 
/// Test if the current instance of @ref elf_symbol is a variable
/// symbol or not.
///
/// @return true if the current instance of @ref elf_symbol is a
/// variable symbol, false otherwise.
bool
elf_symbol::is_variable() const
{
    return (get_type() == OBJECT_TYPE
        || get_type() == TLS_TYPE
        // It appears that undefined variables have NOTYPE type.
        || (get_type() == NOTYPE_TYPE
        && !is_defined()));
}
 
/// Getter of the 'is-in-ksymtab' property.
///
/// @return true iff the current symbol is in the Linux Kernel
/// specific 'ksymtab' symbol table.
bool
elf_symbol::is_in_ksymtab() const
{return priv_->is_in_ksymtab_;}
 
/// Setter of the 'is-in-ksymtab' property.
///
/// @param is_in_ksymtab this is true iff the current symbol is in the
/// Linux Kernel specific 'ksymtab' symbol table.
void
elf_symbol::set_is_in_ksymtab(bool is_in_ksymtab)
{priv_->is_in_ksymtab_ = is_in_ksymtab;}
 
/// Getter of the 'crc' property.
///
/// @return the CRC (modversions) value for Linux Kernel symbols, if any
const abg_compat::optional<uint32_t>&
elf_symbol::get_crc() const
{return priv_->crc_;}
 
/// Setter of the 'crc' property.
///
/// @param crc the new CRC (modversions) value for Linux Kernel symbols
void
elf_symbol::set_crc(const abg_compat::optional<uint32_t>& crc)
{priv_->crc_ = crc;}
 
/// Getter of the 'namespace' property.
///
/// @return the namespace for Linux Kernel symbols, if any
const abg_compat::optional<std::string>&
elf_symbol::get_namespace() const
{return priv_->namespace_;}
 
/// Setter of the 'namespace' property.
///
/// @param ns the new namespace for Linux Kernel symbols, if any
void
elf_symbol::set_namespace(const abg_compat::optional<std::string>& ns)
{priv_->namespace_ = ns;}
 
/// Getter for the 'is-suppressed' property.
///
/// @return true iff the current symbol has been suppressed by a
/// suppression specification that was provided in the context that
/// led to the creation of the corpus this ELF symbol belongs to.
bool
elf_symbol::is_suppressed() const
{return priv_->is_suppressed_;}
 
/// Setter for the 'is-suppressed' property.
///
/// @param true iff the current symbol has been suppressed by a
/// suppression specification that was provided in the context that
/// led to the creation of the corpus this ELF symbol belongs to.
void
elf_symbol::set_is_suppressed(bool is_suppressed)
{priv_->is_suppressed_ = is_suppressed;}
 
/// @name Elf symbol aliases
///
/// An alias A for an elf symbol S is a symbol that is defined at the
/// same address as S.  S is chained to A through the
/// elf_symbol::get_next_alias() method.
///
/// When there are several aliases to a symbol, the main symbol is the
/// the first symbol found in the symbol table for a given address.
///
/// The alias chain is circular.  That means if S is the main symbol
/// and A is the alias, S is chained to A and A
/// is chained back to the main symbol S.  The last alias in an alias
///chain is always chained to the main symbol.
///
/// Thus, when looping over the aliases of an elf_symbol A, detecting
/// an alias that is equal to the main symbol should logically be a
/// loop exit condition.
///
/// Accessing and adding aliases for instances of elf_symbol is done
/// through the member functions below.
 
/// @{
 
/// Get the main symbol of an alias chain.
///
///@return the main symbol.
const elf_symbol_sptr
elf_symbol::get_main_symbol() const
{return priv_->main_symbol_.lock();}
 
/// Get the main symbol of an alias chain.
///
///@return the main symbol.
elf_symbol_sptr
elf_symbol::get_main_symbol()
{return priv_->main_symbol_.lock();}
 
/// Tests whether this symbol is the main symbol.
///
/// @return true iff this symbol is the main symbol.
bool
elf_symbol::is_main_symbol() const
{return get_main_symbol().get() == this;}
 
/// Get the next alias of the current symbol.
///
///@return the alias, or NULL if there is no alias.
elf_symbol_sptr
elf_symbol::get_next_alias() const
{return priv_->next_alias_.lock();}
 
 
/// Check if the current elf_symbol has an alias.
///
///@return true iff the current elf_symbol has an alias.
bool
elf_symbol::has_aliases() const
{return bool(get_next_alias());}
 
/// Get the number of aliases to this elf symbol
///
/// @return the number of aliases to this elf symbol.
int
elf_symbol::get_number_of_aliases() const
{
  int result = 0;
 
  for (elf_symbol_sptr a = get_next_alias();
       a && a.get() != get_main_symbol().get();
       a = a->get_next_alias())
    ++result;
 
  return result;
}
 
/// Add an alias to the current elf symbol.
///
/// @param alias the new alias.  Note that this elf_symbol should *NOT*
/// have aliases prior to the invocation of this function.
void
elf_symbol::add_alias(const elf_symbol_sptr& alias)
{
  if (!alias)
    return;
 
  ABG_ASSERT(!alias->has_aliases());
  ABG_ASSERT(is_main_symbol());
 
  if (has_aliases())
    {
      elf_symbol_sptr last_alias;
      for (elf_symbol_sptr a = get_next_alias();
       a && !a->is_main_symbol();
       a = a->get_next_alias())
    {
      if (a->get_next_alias()->is_main_symbol())
        {
          ABG_ASSERT(last_alias == 0);
          last_alias = a;
        }
    }
      ABG_ASSERT(last_alias);
 
      last_alias->priv_->next_alias_ = alias;
    }
  else
    priv_->next_alias_ = alias;
 
  alias->priv_->next_alias_ = get_main_symbol();
  alias->priv_->main_symbol_ = get_main_symbol();
}
 
/// Update the main symbol for a group of aliased symbols
///
/// If after the construction of the symbols (in order of discovery), the
/// actual main symbol can be identified (e.g. as the symbol that actually is
/// defined in the code), this method offers a way of updating the main symbol
/// through one of the aliased symbols.
///
/// For that, locate the new main symbol by name and update all references to
/// the main symbol among the group of aliased symbols.
///
/// @param name the name of the main symbol
///
/// @return the new main elf_symbol
elf_symbol_sptr
elf_symbol::update_main_symbol(const std::string& name)
{
  ABG_ASSERT(is_main_symbol());
  if (!has_aliases() || get_name() == name)
    return get_main_symbol();
 
  // find the new main symbol
  elf_symbol_sptr new_main;
  // we've already checked this; check the rest of the aliases
  for (elf_symbol_sptr a = get_next_alias(); a.get() != this;
       a = a->get_next_alias())
    if (a->get_name() == name)
      {
    new_main = a;
    break;
      }
 
  if (!new_main)
    return get_main_symbol();
 
  // now update all main symbol references
  priv_->main_symbol_ = new_main;
  for (elf_symbol_sptr a = get_next_alias(); a.get() != this;
       a = a->get_next_alias())
    a->priv_->main_symbol_ = new_main;
 
  return new_main;
}
 
/// Return true if the symbol is a common one.
///
/// @return true iff the symbol is common.
bool
elf_symbol::is_common_symbol() const
{return priv_->is_common_;}
 
/// Return true if this common common symbol has other common instances.
///
/// A common instance of a given common symbol is another common
/// symbol with the same name.  Those exist in relocatable files.  The
/// linker normally allocates all the instances into a common block in
/// the final output file.
///
/// Note that the current object must be a common symbol, otherwise,
/// this function aborts.
///
/// @return true iff the current common symbol has other common
/// instances.
bool
elf_symbol::has_other_common_instances() const
{
  ABG_ASSERT(is_common_symbol());
  return bool(get_next_common_instance());
}
 
/// Get the next common instance of the current common symbol.
///
/// A common instance of a given common symbol is another common
/// symbol with the same name.  Those exist in relocatable files.  The
/// linker normally allocates all the instances into a common block in
/// the final output file.
///
/// @return the next common instance, or nil if there is not any.
elf_symbol_sptr
elf_symbol::get_next_common_instance() const
{return priv_->next_common_instance_.lock();}
 
/// Add a common instance to the current common elf symbol.
///
/// Note that this symbol must be the main symbol.  Being the main
/// symbol means being the first common symbol to appear in the symbol
/// table.
///
/// @param common the other common instance to add.
void
elf_symbol::add_common_instance(const elf_symbol_sptr& common)
{
  if (!common)
    return;
 
  ABG_ASSERT(!common->has_other_common_instances());
  ABG_ASSERT(is_common_symbol());
  ABG_ASSERT(is_main_symbol());
 
  if (has_other_common_instances())
    {
      elf_symbol_sptr last_common_instance;
      for (elf_symbol_sptr c = get_next_common_instance();
       c && (c.get() != get_main_symbol().get());
       c = c->get_next_common_instance())
    {
      if (c->get_next_common_instance().get() == get_main_symbol().get())
        {
          ABG_ASSERT(last_common_instance == 0);
          last_common_instance = c;
        }
    }
      ABG_ASSERT(last_common_instance);
 
      last_common_instance->priv_->next_common_instance_ = common;
    }
  else
    priv_->next_common_instance_ = common;
 
  common->priv_->next_common_instance_ = get_main_symbol();
  common->priv_->main_symbol_ = get_main_symbol();
}
 
/// Get a string that is representative of a given elf_symbol.
///
/// If the symbol has a version, then the ID string is the
/// concatenation of the name of the symbol, the '@' character, and
/// the version of the symbol.  If the version is the default version
/// of the symbol then the '@' character is replaced by a "@@" string.
///
/// Otherwise, if the symbol does not have any version, this function
/// returns the name of the symbol.
///
/// @return a the ID string.
const string&
elf_symbol::get_id_string() const
{
  if (priv_->id_string_.empty())
    {
      string s = get_name ();
 
      if (!get_version().is_empty())
    {
      if (get_version().is_default())
        s += "@@";
      else
        s += "@";
      s += get_version().str();
    }
      priv_->id_string_ = s;
    }
 
  return priv_->id_string_;
}
 
/// From the aliases of the current symbol, lookup one with a given name.
///
/// @param name the name of symbol alias we are looking for.
///
/// @return the symbol alias that has the name @p name, or nil if none
/// has been found.
elf_symbol_sptr
elf_symbol::get_alias_from_name(const string& name) const
{
  if (name == get_name())
    return elf_symbol_sptr(priv_->main_symbol_);
 
   for (elf_symbol_sptr a = get_next_alias();
    a && a.get() != get_main_symbol().get();
    a = a->get_next_alias())
     if (a->get_name() == name)
       return a;
 
   return elf_symbol_sptr();
}
 
/// In the list of aliases of a given elf symbol, get the alias that
/// equals this current symbol.
///
/// @param other the elf symbol to get the potential aliases from.
///
/// @return the alias of @p other that texually equals the current
/// symbol, or nil if no alias textually equals the current symbol.
elf_symbol_sptr
elf_symbol::get_alias_which_equals(const elf_symbol& other) const
{
  for (elf_symbol_sptr a = other.get_next_alias();
       a && a.get() != a->get_main_symbol().get();
       a = a->get_next_alias())
    if (textually_equals(*this, *a))
      return a;
  return elf_symbol_sptr();
}
 
/// Return a comma separated list of the id of the current symbol as
/// well as the id string of its aliases.
///
/// @param syms a map of all the symbols of the corpus the current
/// symbol belongs to.
///
/// @param include_symbol_itself if set to true, then the name of the
/// current symbol is included in the list of alias names that is emitted.
///
/// @return the string.
string
elf_symbol::get_aliases_id_string(const string_elf_symbols_map_type& syms,
                  bool include_symbol_itself) const
{
  string result;
 
  if (include_symbol_itself)
      result = get_id_string();
 
  vector<elf_symbol_sptr> aliases;
  compute_aliases_for_elf_symbol(*this, syms, aliases);
  if (!aliases.empty() && include_symbol_itself)
    result += ", ";
 
  for (vector<elf_symbol_sptr>::const_iterator i = aliases.begin();
       i != aliases.end();
       ++i)
    {
      if (i != aliases.begin())
    result += ", ";
      result += (*i)->get_id_string();
    }
  return result;
}
 
/// Return a comma separated list of the id of the current symbol as
/// well as the id string of its aliases.
///
/// @param include_symbol_itself if set to true, then the name of the
/// current symbol is included in the list of alias names that is emitted.
///
/// @return the string.
string
elf_symbol::get_aliases_id_string(bool include_symbol_itself) const
{
  vector<elf_symbol_sptr> aliases;
  if (include_symbol_itself)
    aliases.push_back(get_main_symbol());
 
  for (elf_symbol_sptr a = get_next_alias();
       a && a.get() != get_main_symbol().get();
       a = a->get_next_alias())
    aliases.push_back(a);
 
  string result;
  for (vector<elf_symbol_sptr>::const_iterator i = aliases.begin();
       i != aliases.end();
       ++i)
    {
      if (i != aliases.begin())
    result += ", ";
      result += (*i)->get_id_string();
    }
 
  return result;
}
 
/// Given the ID of a symbol, get the name and the version of said
/// symbol.
///
/// @param id the symbol ID to consider.
///
/// @param name the symbol name extracted from the ID.  This is set
/// only if the function returned true.
///
/// @param ver the symbol version extracted from the ID.
bool
elf_symbol::get_name_and_version_from_id(const string&  id,
                     string&    name,
                     string&    ver)
{
  name.clear(), ver.clear();
 
  string::size_type i = id.find('@');
  if (i == string::npos)
    {
      name = id;
      return true;
    }
 
  name = id.substr(0, i);
  ++i;
 
  if (i >= id.size())
    return true;
 
  string::size_type j = id.find('@', i);
  if (j == string::npos)
    j = i;
  else
    ++j;
 
  if (j >= id.size())
    {
      ver = "";
      return true;
    }
 
  ver = id.substr(j);
  return true;
}
 
///@}
 
/// Test if two main symbols are textually equal, or, if they have
/// aliases that are textually equal.
///
/// @param other the symbol to compare against.
///
/// @return true iff the current instance of elf symbol equals the @p
/// other.
bool
elf_symbol::operator==(const elf_symbol& other) const
{
  bool are_equal = textually_equals(*this, other);
  if (!are_equal)
    are_equal = bool(get_alias_which_equals(other));
  return are_equal;
}
 
/// Test if the current symbol aliases another one.
///
/// @param o the other symbol to test against.
///
/// @return true iff the current symbol aliases @p o.
bool
elf_symbol::does_alias(const elf_symbol& o) const
{
  if (*this == o)
    return true;
 
  if (get_main_symbol() == o.get_main_symbol())
    return true;
 
  for (elf_symbol_sptr a = get_next_alias();
       a && !a->is_main_symbol();
       a = a->get_next_alias())
    {
      if (o == *a)
    return true;
    }
  return false;
}
 
/// Equality operator for smart pointers to elf_symbol.
///
/// @param lhs the first elf symbol to consider.
///
/// @param rhs the second elf symbol to consider.
///
/// @return true iff @p lhs equals @p rhs.
bool
operator==(const elf_symbol_sptr& lhs, const elf_symbol_sptr& rhs)
{
  if (!!lhs != !!rhs)
    return false;
 
  if (!lhs)
    return true;
 
  return *lhs == *rhs;
}
 
/// Inequality operator for smart pointers to elf_symbol.
///
/// @param lhs the first elf symbol to consider.
///
/// @param rhs the second elf symbol to consider.
///
/// @return true iff @p lhs is different from @p rhs.
bool
operator!=(const elf_symbol_sptr& lhs, const elf_symbol_sptr& rhs)
{return !operator==(lhs, rhs);}
 
/// Test if two symbols alias.
///
/// @param s1 the first symbol to consider.
///
/// @param s2 the second symbol to consider.
///
/// @return true if @p s1 aliases @p s2.
bool
elf_symbols_alias(const elf_symbol& s1, const elf_symbol& s2)
{return s1.does_alias(s2) || s2.does_alias(s1);}
 
void
compute_aliases_for_elf_symbol(const elf_symbol& sym,
                   const string_elf_symbols_map_type& symtab,
                   vector<elf_symbol_sptr>& aliases)
{
 
  if (elf_symbol_sptr a = sym.get_next_alias())
    for (; a && !a->is_main_symbol(); a = a->get_next_alias())
      aliases.push_back(a);
  else
    for (string_elf_symbols_map_type::const_iterator i = symtab.begin();
     i != symtab.end();
     ++i)
      for (elf_symbols::const_iterator j = i->second.begin();
       j != i->second.end();
       ++j)
    {
      if (**j == sym)
        for (elf_symbol_sptr s = (*j)->get_next_alias();
         s && !s->is_main_symbol();
         s = s->get_next_alias())
          aliases.push_back(s);
      else
        for (elf_symbol_sptr s = (*j)->get_next_alias();
         s && !s->is_main_symbol();
         s = s->get_next_alias())
          if (*s == sym)
        aliases.push_back(*j);
    }
}
 
/// Test if two symbols alias.
///
/// @param s1 the first symbol to consider.
///
/// @param s2 the second symbol to consider.
///
/// @return true if @p s1 aliases @p s2.
bool
elf_symbols_alias(const elf_symbol* s1, const elf_symbol* s2)
{
  if (!!s1 != !!s2)
    return false;
  if (s1 == s2)
    return true;
  return elf_symbols_alias(*s1, *s2);
}
 
/// Test if two symbols alias.
///
/// @param s1 the first symbol to consider.
///
/// @param s2 the second symbol to consider.
///
/// @return true if @p s1 aliases @p s2.
bool
elf_symbols_alias(const elf_symbol_sptr s1, const elf_symbol_sptr s2)
{return elf_symbols_alias(s1.get(), s2.get());}
 
/// Serialize an instance of @ref symbol_type and stream it to a given
/// output stream.
///
/// @param o the output stream to serialize the symbole type to.
///
/// @param t the symbol type to serialize.
std::ostream&
operator<<(std::ostream& o, elf_symbol::type t)
{
  string repr;
 
  switch (t)
    {
    case elf_symbol::NOTYPE_TYPE:
      repr = "unspecified symbol type";
      break;
    case elf_symbol::OBJECT_TYPE:
      repr = "variable symbol type";
      break;
    case elf_symbol::FUNC_TYPE:
      repr = "function symbol type";
      break;
    case elf_symbol::SECTION_TYPE:
      repr = "section symbol type";
      break;
    case elf_symbol::FILE_TYPE:
      repr = "file symbol type";
      break;
    case elf_symbol::COMMON_TYPE:
      repr = "common data object symbol type";
      break;
    case elf_symbol::TLS_TYPE:
      repr = "thread local data object symbol type";
      break;
    case elf_symbol::GNU_IFUNC_TYPE:
      repr = "indirect function symbol type";
      break;
    default:
      {
    std::ostringstream s;
    s << "unknown symbol type (" << (char)t << ')';
    repr = s.str();
      }
      break;
    }
 
  o << repr;
  return o;
}
 
/// Serialize an instance of @ref symbol_binding and stream it to a
/// given output stream.
///
/// @param o the output stream to serialize the symbole type to.
///
/// @param b the symbol binding to serialize.
std::ostream&
operator<<(std::ostream& o, elf_symbol::binding b)
{
  string repr;
 
  switch (b)
    {
    case elf_symbol::LOCAL_BINDING:
      repr = "local binding";
      break;
    case elf_symbol::GLOBAL_BINDING:
      repr = "global binding";
      break;
    case elf_symbol::WEAK_BINDING:
      repr = "weak binding";
      break;
    case elf_symbol::GNU_UNIQUE_BINDING:
      repr = "GNU unique binding";
      break;
    default:
      {
    std::ostringstream s;
    s << "unknown binding (" << (unsigned char) b << ")";
    repr = s.str();
      }
      break;
    }
 
  o << repr;
  return o;
}
 
/// Serialize an instance of @ref elf_symbol::visibility and stream it
/// to a given output stream.
///
/// @param o the output stream to serialize the symbole type to.
///
/// @param v the symbol visibility to serialize.
std::ostream&
operator<<(std::ostream& o, elf_symbol::visibility v)
{
  string repr;
 
  switch (v)
    {
    case elf_symbol::DEFAULT_VISIBILITY:
      repr = "default visibility";
      break;
    case elf_symbol::PROTECTED_VISIBILITY:
      repr = "protected visibility";
      break;
    case elf_symbol::HIDDEN_VISIBILITY:
      repr = "hidden visibility";
      break;
    case elf_symbol::INTERNAL_VISIBILITY:
      repr = "internal visibility";
      break;
    default:
      {
    std::ostringstream s;
    s << "unknown visibility (" << (unsigned char) v << ")";
    repr = s.str();
      }
      break;
    }
 
  o << repr;
  return o;
}
 
/// Convert a string representing a symbol type into an
/// elf_symbol::type.
///
///@param s the string to convert.
///
///@param t the resulting elf_symbol::type.
///
/// @return true iff the conversion completed successfully.
bool
string_to_elf_symbol_type(const string& s, elf_symbol::type& t)
{
  if (s == "no-type")
    t = elf_symbol::NOTYPE_TYPE;
  else if (s == "object-type")
    t = elf_symbol::OBJECT_TYPE;
  else if (s == "func-type")
    t = elf_symbol::FUNC_TYPE;
  else if (s == "section-type")
    t = elf_symbol::SECTION_TYPE;
  else if (s == "file-type")
    t = elf_symbol::FILE_TYPE;
  else if (s == "common-type")
    t = elf_symbol::COMMON_TYPE;
  else if (s == "tls-type")
    t = elf_symbol::TLS_TYPE;
  else if (s == "gnu-ifunc-type")
    t = elf_symbol::GNU_IFUNC_TYPE;
  else
    return false;
 
  return true;
}
 
/// Convert a string representing a an elf symbol binding into an
/// elf_symbol::binding.
///
/// @param s the string to convert.
///
/// @param b the resulting elf_symbol::binding.
///
/// @return true iff the conversion completed successfully.
bool
string_to_elf_symbol_binding(const string& s, elf_symbol::binding& b)
{
    if (s == "local-binding")
      b = elf_symbol::LOCAL_BINDING;
    else if (s == "global-binding")
      b = elf_symbol::GLOBAL_BINDING;
    else if (s == "weak-binding")
      b = elf_symbol::WEAK_BINDING;
    else if (s == "gnu-unique-binding")
      b = elf_symbol::GNU_UNIQUE_BINDING;
    else
      return false;
 
    return true;
}
 
/// Convert a string representing a an elf symbol visibility into an
/// elf_symbol::visibility.
///
/// @param s the string to convert.
///
/// @param b the resulting elf_symbol::visibility.
///
/// @return true iff the conversion completed successfully.
bool
string_to_elf_symbol_visibility(const string& s, elf_symbol::visibility& v)
{
  if (s == "default-visibility")
    v = elf_symbol::DEFAULT_VISIBILITY;
  else if (s == "protected-visibility")
    v = elf_symbol::PROTECTED_VISIBILITY;
  else if (s == "hidden-visibility")
    v = elf_symbol::HIDDEN_VISIBILITY;
  else if (s == "internal-visibility")
    v = elf_symbol::INTERNAL_VISIBILITY;
  else
    return false;
 
  return true;
}
 
/// Test if the type of an ELF symbol denotes a function symbol.
///
/// @param t the type of the ELF symbol.
///
/// @return true iff elf symbol type @p t denotes a function symbol
/// type.
bool
elf_symbol_is_function(elf_symbol::type t)
{return t == elf_symbol::FUNC_TYPE;}
 
/// Test if the type of an ELF symbol denotes a function symbol.
///
/// @param t the type of the ELF symbol.
///
/// @return true iff elf symbol type @p t denotes a function symbol
/// type.
bool
elf_symbol_is_variable(elf_symbol::type t)
{return t == elf_symbol::OBJECT_TYPE;}
 
// <elf_symbol::version stuff>
 
struct elf_symbol::version::priv
{
  string    version_;
  bool      is_default_;
 
  priv()
    : is_default_(false)
  {}
 
  priv(const string& v,
       bool d)
    : version_(v),
      is_default_(d)
  {}
}; // end struct elf_symbol::version::priv
 
elf_symbol::version::version()
  : priv_(new priv)
{}
 
/// @param v the name of the version.
///
/// @param is_default true if this is a default version.
elf_symbol::version::version(const string& v,
                 bool is_default)
  : priv_(new priv(v, is_default))
{}
 
elf_symbol::version::version(const elf_symbol::version& v)
  : priv_(new priv(v.str(), v.is_default()))
{
}
 
elf_symbol::version::~version() = default;
 
/// Cast the version_type into a string that is its name.
///
/// @return the name of the version.
elf_symbol::version::operator const string&() const
{return priv_->version_;}
 
/// Getter for the version name.
///
/// @return the version name.
const string&
elf_symbol::version::str() const
{return priv_->version_;}
 
/// Setter for the version name.
///
/// @param s the version name.
void
elf_symbol::version::str(const string& s)
{priv_->version_ = s;}
 
/// Getter for the 'is_default' property of the version.
///
/// @return true iff this is a default version.
bool
elf_symbol::version::is_default() const
{return priv_->is_default_;}
 
/// Setter for the 'is_default' property of the version.
///
/// @param f true if this is the default version.
void
elf_symbol::version::is_default(bool f)
{priv_->is_default_ = f;}
 
bool
elf_symbol::version::is_empty() const
{return str().empty();}
 
/// Compares the current version against another one.
///
/// @param o the other version to compare the current one to.
///
/// @return true iff the current version equals @p o.
bool
elf_symbol::version::operator==(const elf_symbol::version& o) const
{return str() == o.str();}
 
/// Inequality operator.
///
/// @param o the version to compare against the current one.
///
/// @return true iff both versions are different.
bool
elf_symbol::version::operator!=(const version& o) const
{return !operator==(o);}
 
/// Assign a version to the current one.
///
/// @param o the other version to assign to this one.
///
/// @return a reference to the assigned version.
elf_symbol::version&
elf_symbol::version::operator=(const elf_symbol::version& o)
{
  str(o.str());
  is_default(o.is_default());
  return *this;
}
 
// </elf_symbol::version stuff>
 
// </elf_symbol stuff>
 
// <class dm_context_rel stuff>
struct dm_context_rel::priv
{
  bool is_laid_out_;
  size_t offset_in_bits_;
  var_decl* anonymous_data_member_;
 
  priv(bool is_static = false)
    : is_laid_out_(!is_static),
      offset_in_bits_(0),
      anonymous_data_member_()
  {}
 
  priv(bool is_laid_out, size_t offset_in_bits)
    : is_laid_out_(is_laid_out),
      offset_in_bits_(offset_in_bits),
      anonymous_data_member_()
  {}
}; //end struct dm_context_rel::priv
 
dm_context_rel::dm_context_rel()
  : context_rel(),
    priv_(new priv)
{}
 
dm_context_rel::dm_context_rel(scope_decl* s,
                   bool is_laid_out,
                   size_t offset_in_bits,
                   access_specifier a,
                   bool is_static)
  : context_rel(s, a, is_static),
    priv_(new priv(is_laid_out, offset_in_bits))
{}
 
dm_context_rel::dm_context_rel(scope_decl* s)
  : context_rel(s),
    priv_(new priv())
{}
 
bool
dm_context_rel::get_is_laid_out() const
{return priv_->is_laid_out_;}
 
void
dm_context_rel::set_is_laid_out(bool f)
{priv_->is_laid_out_ = f;}
 
size_t
dm_context_rel::get_offset_in_bits() const
{return priv_->offset_in_bits_;}
 
void
dm_context_rel::set_offset_in_bits(size_t o)
{priv_->offset_in_bits_ = o;}
 
bool
dm_context_rel::operator==(const dm_context_rel& o) const
{
  if (!context_rel::operator==(o))
    return false;
 
  return (priv_->is_laid_out_ == o.priv_->is_laid_out_
        && priv_->offset_in_bits_ == o.priv_->offset_in_bits_);
}
 
bool
dm_context_rel::operator!=(const dm_context_rel& o) const
{return !operator==(o);}
 
/// Return a non-nil value if this data member context relationship
/// has an anonymous data member.  That means, if the data member this
/// relation belongs to is part of an anonymous data member.
///
/// @return the containing anonymous data member of this data member
/// relationship.  Nil if there is none.
const var_decl*
dm_context_rel::get_anonymous_data_member() const
{return priv_->anonymous_data_member_;}
 
/// Set the containing anonymous data member of this data member
/// context relationship. That means that the data member this
/// relation belongs to is part of an anonymous data member.
///
/// @param anon_dm the containing anonymous data member of this data
/// member relationship.  Nil if there is none.
void
dm_context_rel::set_anonymous_data_member(var_decl* anon_dm)
{priv_->anonymous_data_member_ = anon_dm;}
 
dm_context_rel::~dm_context_rel()
{}
// </class dm_context_rel stuff>
 
// <environment stuff>
 
/// Convenience typedef for a map of interned_string -> bool.
typedef unordered_map<interned_string,
              bool, hash_interned_string> interned_string_bool_map_type;
 
 
/// Default constructor of the @ref environment type.
environment::environment()
  :priv_(new priv)
{}
 
/// Destructor for the @ref environment type.
environment::~environment()
{}
 
/// Getter the map of canonical types.
///
/// @return the map of canonical types.  The key of the map is the
/// hash of the canonical type and its value if the canonical type.
environment::canonical_types_map_type&
environment::get_canonical_types_map()
{return priv_->canonical_types_;}
 
/// Getter the map of canonical types.
///
/// @return the map of canonical types.  The key of the map is the
/// hash of the canonical type and its value if the canonical type.
const environment::canonical_types_map_type&
environment::get_canonical_types_map() const
{return const_cast<environment*>(this)->get_canonical_types_map();}
 
/// Helper to detect if a type is either a reference, a pointer, or a
/// qualified type.
bool
is_ptr_ref_or_qual_type(const type_base *t)
{
  if (is_pointer_type(t)
      || is_reference_type(t)
      || is_qualified_type(t))
    return true;
  return false;
}
 
/// Compare decls using their locations.
///
/// @param f the first decl to compare.
///
/// @param s the second decl to compare.
///
/// @return true if @p f compares less than @p s.
bool
compare_using_locations(const decl_base *f,
            const decl_base *s)
{
  // If a decl has artificial location, then use that one over the
  // natural one.
  location fl = get_artificial_or_natural_location(f);
  location sl = get_artificial_or_natural_location(s);
 
  ABG_ASSERT(fl.get_value() && sl.get_value());
  if (fl.get_is_artificial() == sl.get_is_artificial())
    {
      // The locations of the two artfifacts have the same
      // artificial-ness so they can be compared.
      string p1, p2;
      unsigned l1 = 0, l2 = 0, c1 = 0, c2 = 0;
      fl.expand(p1, l1, c1);
      sl.expand(p2, l2, c2);
      if (p1 != p2)
    return p1 < p2;
      if (l1 != l2)
    return l1 < l2;
      if (c1 != c2)
    return c1 < c2;
    }
 
  return (get_pretty_representation(f, /*internal=*/false)
      < get_pretty_representation(s, /*internal=*/false));
}
 
/// Sort types in a hopefully stable manner.
///
/// @param types a set of types with canonical types to sort.
///
/// @param result the resulting sorted vector.
void
sort_types(const canonical_type_sptr_set_type& types,
       vector<type_base_sptr>& result)
{
  for (auto t: types)
    result.push_back(t);
 
  type_topo_comp comp;
  std::stable_sort(result.begin(), result.end(), comp);
}
 
/// Get the unique @ref type_decl that represents a "void" type for
/// the current environment.  This node must be the only one
/// representing a void type in the system.
///
/// Note that upon first use of this IR node (by the relevant
/// front-end, for instance) it must be added to a scope using e.g,
/// the @ref add_decl_to_scope() function.
///
/// @return the @ref type_decl that represents a "void" type.
const type_base_sptr&
environment::get_void_type() const
{
  if (!priv_->void_type_)
    priv_->void_type_.reset(new type_decl(*this,
                      intern("void"),
                      0, 0, location()));
  return priv_->void_type_;
}
 
/// Getter of the "pointer-to-void" IR node that is shared across the
/// ABI corpus.  This node must be the only one representing a void
/// pointer type in the system.
///
/// Note that upon first use of this IR node (by the relevant
/// front-end, for instance) it must be added to a scope using e.g,
/// the @ref add_decl_to_scope() function.
///
/// @return the "pointer-to-void" IR node.
const type_base_sptr&
environment::get_void_pointer_type() const
{
  if (!priv_->void_pointer_type_)
    priv_->void_pointer_type_.reset(new pointer_type_def(get_void_type(),
                             0, 0, location()));
  return priv_->void_pointer_type_;
}
 
/// Get a @ref type_decl instance that represents a the type of a
/// variadic function parameter. This node must be the only one
/// representing a variadic parameter type in the system.
///
/// Note that upon first use of this IR node (by the relevant
/// front-end, for instance) it must be added to a scope using e.g,
/// the @ref add_decl_to_scope() function.
///
/// @return the Get a @ref type_decl instance that represents a the
/// type of a variadic function parameter.
const type_base_sptr&
environment::get_variadic_parameter_type() const
{
  if (!priv_->variadic_marker_type_)
    priv_->variadic_marker_type_.
      reset(new type_decl(*this, intern(get_variadic_parameter_type_name()),
              0, 0, location()));
  return priv_->variadic_marker_type_;
}
 
/// Getter of the name of the variadic parameter type.
///
/// @return the name of the variadic parameter type.
string&
environment::get_variadic_parameter_type_name()
{
  static string variadic_parameter_type_name = "variadic parameter type";
  return variadic_parameter_type_name;
}
 
/// Test if the canonicalization of types created out of the current
/// environment is done.
///
/// @return true iff the canonicalization of types created out of the current
/// environment is done.
bool
environment::canonicalization_is_done() const
{return priv_->canonicalization_is_done_;}
 
/// Set a flag saying if the canonicalization of types created out of
/// the current environment is done or not.
///
/// Note that this function must only be called by internal code of
/// the library that creates ABI artifacts (e.g, read an abi corpus
/// from elf or from our own xml format and creates representations of
/// types out of it) and thus needs to canonicalize types to speed-up
/// further type comparison.
///
/// @param f the new value of the flag.
void
environment::canonicalization_is_done(bool f)
{
  priv_->canonicalization_is_done_ = f;
  if (priv_->canonicalization_is_done_)
    canonicalization_started(false);
}
 
/// Getter of a flag saying if the canonicalization process has
/// started or not.
///
/// @return the flag saying if the canonicalization process has
/// started or not.
bool
environment::canonicalization_started() const
{return priv_->canonicalization_started_;}
 
/// Setter of a flag saying if the canonicalization process has
/// started or not.
///
/// @param f the new value of the flag saying if the canonicalization
/// process has started or not.
void
environment::canonicalization_started(bool f)
{priv_->canonicalization_started_ = f;}
 
/// Getter of the "decl-only-class-equals-definition" flag.
///
/// Usually, a declaration-only class named 'struct foo' compares
/// equal to any class definition named "struct foo'.  This is at
/// least true for C++.
///
/// In C, though, because there can be multiple definitions of 'struct
/// foo' in the binary, a declaration-only "struct foo" might be
/// considered to *NOT* resolve to any of the struct foo defined.  In
/// that case, the declaration-only "struct foo" is considered
/// different from the definitions.
///
/// This flag controls the behaviour of the comparison of an
/// unresolved decl-only class against a definition of the same name.
///
/// If set to false, the the declaration equals the definition.  If
/// set to false, then the decalration is considered different from
/// the declaration.
///
/// @return the value of the "decl-only-class-equals-definition" flag.
bool
environment::decl_only_class_equals_definition() const
{return priv_->decl_only_class_equals_definition_;}
 
/// Setter of the "decl-only-class-equals-definition" flag.
///
/// Usually, a declaration-only class named 'struct foo' compares
/// equal to any class definition named "struct foo'.  This is at
/// least true for C++.
///
/// In C, though, because there can be multiple definitions of 'struct
/// foo' in the binary, a declaration-only "struct foo" might be
/// considered to *NOT* resolve to any of the struct foo defined.  In
/// that case, the declaration-only "struct foo" is considered
/// different from the definitions.
///
/// This flag controls the behaviour of the comparison of an
/// unresolved decl-only class against a definition of the same name.
///
/// If set to false, the the declaration equals the definition.  If
/// set to false, then the decalration is considered different from
/// the declaration.
///
/// @param the new value of the "decl-only-class-equals-definition"
/// flag.
void
environment::decl_only_class_equals_definition(bool f) const
{priv_->decl_only_class_equals_definition_ = f;}
 
/// Test if a given type is a void type as defined in the current
/// environment.
///
/// @param t the type to consider.
///
/// @return true iff @p t is a void type as defined in the current
/// environment.
bool
environment::is_void_type(const type_base_sptr& t) const
{
  if (!t)
    return false;
  return is_void_type(t.get());
}
 
/// Test if a given type is a void type as defined in the current
/// environment.
///
/// @param t the type to consider.
///
/// @return true iff @p t is a void type as defined in the current
/// environment.
bool
environment::is_void_type(const type_base* t) const
{
  if (!t)
    return false;
  return (t == get_void_type().get()
      || (is_type_decl(t) && is_type_decl(t)->get_name() == "void"));
}
 
/// Test if a given type is the same as the void pointer type of the
/// environment.
///
/// @param t the IR type to test.
///
/// @return true iff @p t is the void pointer returned by
/// environment::get_void_pointer_type().
bool
environment::is_void_pointer_type(const type_base_sptr& t) const
{
  if (!t)
    return false;
 
  return t.get() == get_void_pointer_type().get();
}
 
/// Test if a given type is the same as the void pointer type of the
/// environment.
///
/// @param t the IR type to test.
///
/// @return true iff @p t is the void pointer returned by
/// environment::get_void_pointer_type().
bool
environment::is_void_pointer_type(const type_base* t) const
{
  if (!t)
    return false;
 
  return t == get_void_pointer_type().get();
}
 
/// Test if a type is a variadic parameter type as defined in the
/// current environment.
///
/// @param t the type to consider.
///
/// @return true iff @p t is a variadic parameter type as defined in
/// the current environment.
bool
environment::is_variadic_parameter_type(const type_base* t) const
{
  if (!t)
    return false;
  return t == get_variadic_parameter_type().get();
}
 
/// Test if a type is a variadic parameter type as defined in the
/// current environment.
///
/// @param t the type to consider.
///
/// @return true iff @p t is a variadic parameter type as defined in
/// the current environment.
bool
environment::is_variadic_parameter_type(const type_base_sptr& t) const
{return is_variadic_parameter_type(t.get());}
 
/// Do intern a string.
///
/// If a value of this string already exists in the interned string
/// pool of the current environment, then this function returns a new
/// interned_string pointing to that already existing string.
/// Otherwise, a new string is created, stored in the interned string
/// pool and a new interned_string instance is created to point to
/// that new intrerned string, and it's return.
///
/// @param s the value of the string to intern.
///
/// @return the interned string.
interned_string
environment::intern(const string& s) const
{return const_cast<environment*>(this)->priv_->string_pool_.create_string(s);}
 
/// Getter of the general configuration object.
///
/// @return the configuration object.
const config&
environment::get_config() const
{return priv_->config_;}
 
/// Getter for a property that says if the user actually did set the
/// analyze_exported_interfaces_only() property.  If not, it means
/// the default behaviour prevails.
///
/// @return tru iff the user did set the
/// analyze_exported_interfaces_only() property.
bool
environment::user_set_analyze_exported_interfaces_only() const
{return priv_->analyze_exported_interfaces_only_.has_value();}
 
/// Setter for the property that controls if we are to restrict the
/// analysis to the types that are only reachable from the exported
/// interfaces only, or if the set of types should be more broad than
/// that.  Typically, we'd restrict the analysis to types reachable
/// from exported interfaces only (stricto sensu, that would really be
/// only the types that are part of the ABI of well designed
/// libraries) for performance reasons.
///
/// @param f the value of the flag.
void
environment::analyze_exported_interfaces_only(bool f)
{priv_->analyze_exported_interfaces_only_ = f;}
 
/// Getter for the property that controls if we are to restrict the
/// analysis to the types that are only reachable from the exported
/// interfaces only, or if the set of types should be more broad than
/// that.  Typically, we'd restrict the analysis to types reachable
/// from exported interfaces only (stricto sensu, that would really be
/// only the types that are part of the ABI of well designed
/// libraries) for performance reasons.
///
/// @param f the value of the flag.
bool
environment::analyze_exported_interfaces_only() const
{return priv_->analyze_exported_interfaces_only_.value_or(false);}
 
#ifdef WITH_DEBUG_SELF_COMPARISON
/// Setter of the corpus of the input corpus of the self comparison
/// that takes place when doing "abidw --debug-abidiff <binary>".
///
/// The first invocation of this function sets the first corpus of the
/// self comparison.  The second invocation of this very same function
/// sets the second corpus of the self comparison.  That second corpus
/// is supposed to come from the abixml serialization of the first
/// corpus.
///
/// @param c the corpus of the input binary or the corpus of the
/// abixml serialization of the initial binary input.
void
environment::set_self_comparison_debug_input(const corpus_sptr& c)
{
  self_comparison_debug_is_on(true);
  if (priv_->first_self_comparison_corpus_.expired())
    priv_->first_self_comparison_corpus_ = c;
  else if (priv_->second_self_comparison_corpus_.expired()
       && c.get() != corpus_sptr(priv_->first_self_comparison_corpus_).get())
    priv_->second_self_comparison_corpus_ = c;
}
 
/// Getter for the corpora of the input binary and the intermediate
/// abixml of the self comparison that takes place when doing
///   'abidw --debug-abidiff <binary>'.
///
/// @param first_corpus output parameter that is set to the corpus of
/// the input corpus.
///
/// @param second_corpus output parameter that is set to the corpus of
/// the second corpus.
void
environment::get_self_comparison_debug_inputs(corpus_sptr& first_corpus,
                          corpus_sptr& second_corpus)
{
    first_corpus = priv_->first_self_comparison_corpus_.lock();
    second_corpus = priv_->second_self_comparison_corpus_.lock();
}
 
/// Turn on/off the self comparison debug mode.
///
/// @param f true iff the self comparison debug mode is turned on.
void
environment::self_comparison_debug_is_on(bool f)
{priv_->self_comparison_debug_on_ = f;}
 
/// Test if we are in the process of the 'self-comparison
/// debugging' as triggered by 'abidw --debug-abidiff' command.
///
/// @return true if self comparison debug is on.
bool
environment::self_comparison_debug_is_on() const
{return priv_->self_comparison_debug_on_;}
#endif
 
#ifdef WITH_DEBUG_TYPE_CANONICALIZATION
/// Set the "type canonicalization debugging" mode, triggered by using
/// the command: "abidw --debug-tc".
///
/// @param flag if true then the type canonicalization debugging mode
/// is enabled.
void
environment::debug_type_canonicalization_is_on(bool flag)
{priv_->debug_type_canonicalization_ = flag;}
 
/// Getter of the "type canonicalization debugging" mode, triggered by
/// using the command: "abidw --debug-tc".
///
/// @return true iff the type canonicalization debugging mode is
/// enabled.
bool
environment::debug_type_canonicalization_is_on() const
{return priv_->debug_type_canonicalization_;}
 
/// Setter of the "DIE canonicalization debugging" mode, triggered by
/// using the command: "abidw --debug-dc".
///
/// @param flag true iff the DIE canonicalization debugging mode is
/// enabled.
void
environment::debug_die_canonicalization_is_on(bool flag)
{priv_->debug_die_canonicalization_ = flag;}
 
/// Getter of the "DIE canonicalization debugging" mode, triggered by
/// using the command: "abidw --debug-dc".
///
/// @return true iff the DIE canonicalization debugging mode is
/// enabled.
bool
environment::debug_die_canonicalization_is_on() const
{return priv_->debug_die_canonicalization_;}
#endif // WITH_DEBUG_TYPE_CANONICALIZATION
 
/// Get the vector of canonical types which have a given "string
/// representation".
///
/// @param 'name', the textual representation of the type as returned
/// by type_or_decl_base::get_pretty_representation(/*internal=*/true,
///                                                 /*qualified=*/true)
///
/// This is useful to for debugging purposes as it's handy to use from
/// inside a debugger like GDB.
///
/// @return a pointer to the vector of canonical types having the
/// representation @p name, or nullptr if no type with that
/// representation exists.
const vector<type_base_sptr>*
environment::get_canonical_types(const char* name) const
{
  auto ti = get_canonical_types_map().find(name);
  if (ti == get_canonical_types_map().end())
    return nullptr;
  return &ti->second;
}
 
/// Get a given canonical type which has a given "string
/// representation".
///
/// @param 'name', the textual representation of the type as returned
/// by type_or_decl_base::get_pretty_representation(/*internal=*/true,
///                                                 /*qualified=*/true).
///
/// @param index, the index of the type in the vector of types that
/// all have the same textual representation @p 'name'.  That vector
/// is returned by the function environment::get_canonical_types().
///
/// @return the canonical type which has the representation @p name,
/// and which is at index @p index in the vector of canonical types
/// having that same textual representation.
type_base*
environment::get_canonical_type(const char* name, unsigned index)
{
  const vector<type_base_sptr> *types = get_canonical_types(name);
  if (!types ||index >= types->size())
    return nullptr;
  return (*types)[index].get();
}
 
#ifdef WITH_DEBUG_SELF_COMPARISON
/// Get the set of abixml type-id and the pointer value of the
/// (canonical) type it's associated to.
///
/// This is useful for debugging purposes, especially in the context
/// of the use of the command:
///   'abidw --debug-abidiff <binary>'.
///
/// @return the set of abixml type-id and the pointer value of the
/// (canonical) type it's associated to.
const unordered_map<string, uintptr_t>&
environment::get_type_id_canonical_type_map() const
{return priv_->get_type_id_canonical_type_map();}
 
/// Get the set of abixml type-id and the pointer value of the
/// (canonical) type it's associated to.
///
/// This is useful for debugging purposes, especially in the context
/// of the use of the command:
///   'abidw --debug-abidiff <binary>'.
///
/// @return the set of abixml type-id and the pointer value of the
/// (canonical) type it's associated to.
unordered_map<string, uintptr_t>&
environment::get_type_id_canonical_type_map()
{return priv_->get_type_id_canonical_type_map();}
 
/// Getter of the map that associates the values of type pointers to
/// their type-id strings.
///
/// Note that this map is populated at abixml reading time, (by
/// build_type()) when a given XML element representing a type is
/// read into a corresponding abigail::ir::type_base.
///
/// This is used only for the purpose of debugging the
/// self-comparison process.  That is, when invoking "abidw
/// --debug-abidiff".
///
/// @return the map that associates the values of type pointers to
/// their type-id strings.
const unordered_map<uintptr_t, string>&
environment::get_pointer_type_id_map() const
{return priv_->get_pointer_type_id_map();}
 
/// Getter of the map that associates the values of type pointers to
/// their type-id strings.
///
/// Note that this map is populated at abixml reading time, (by
/// build_type()) when a given XML element representing a type is
/// read into a corresponding abigail::ir::type_base.
///
/// This is used only for the purpose of debugging the
/// self-comparison process.  That is, when invoking "abidw
/// --debug-abidiff".
///
/// @return the map that associates the values of type pointers to
/// their type-id strings.
unordered_map<uintptr_t, string>&
environment::get_pointer_type_id_map()
{return priv_->get_pointer_type_id_map();}
 
/// Getter of the type-id that corresponds to the value of a pointer
/// to abigail::ir::type_base that was created from the abixml reader.
///
/// That value is retrieved from the map returned from
/// environment::get_pointer_type_id_map().
///
/// That map is populated at abixml reading time, (by build_type())
/// when a given XML element representing a type is read into a
/// corresponding abigail::ir::type_base.
///
/// This is used only for the purpose of debugging the
/// self-comparison process.  That is, when invoking "abidw
/// --debug-abidiff".
///
/// @return the type-id strings that corresponds
string
environment::get_type_id_from_pointer(uintptr_t ptr) const
{return priv_->get_type_id_from_pointer(ptr);}
 
/// Getter of the type-id that corresponds to the value of an
/// abigail::ir::type_base that was created from the abixml reader.
///
/// That value is retrieved from the map returned from
/// environment::get_pointer_type_id_map().
///
/// That map is populated at abixml reading time, (by build_type())
/// when a given XML element representing a type is read into a
/// corresponding abigail::ir::type_base.
///
/// This is used only for the purpose of debugging the
/// self-comparison process.  That is, when invoking "abidw
/// --debug-abidiff".
///
/// @return the type-id strings that corresponds
string
environment::get_type_id_from_type(const type_base *t) const
{return priv_->get_type_id_from_type(t);}
 
/// Getter of the canonical type of the artifact designated by a
/// type-id.
///
/// That type-id was generated by the abixml writer at the emitting
/// time of the abixml file.  The corresponding canonical type was
/// stored in the map returned by
/// environment::get_type_id_canonical_type_map().
///
/// This is useful for debugging purposes, especially in the context
/// of the use of the command:
///   'abidw --debug-abidiff <binary>'.
///
/// @return the set of abixml type-id and the pointer value of the
/// (canonical) type it's associated to.
uintptr_t
environment::get_canonical_type_from_type_id(const char* type_id) const
{return priv_->get_canonical_type_from_type_id(type_id);}
#endif
 
// </environment stuff>
 
// <type_or_decl_base stuff>
 
/// bitwise "OR" operator for the type_or_decl_base::type_or_decl_kind
/// bitmap type.
type_or_decl_base::type_or_decl_kind
operator|(type_or_decl_base::type_or_decl_kind l,
      type_or_decl_base::type_or_decl_kind r)
{
  return static_cast<type_or_decl_base::type_or_decl_kind>
    (static_cast<unsigned>(l) | static_cast<unsigned>(r));
}
 
/// bitwise "|=" operator for the type_or_decl_base::type_or_decl_kind
/// bitmap type.
type_or_decl_base::type_or_decl_kind&
operator|=(type_or_decl_base::type_or_decl_kind& l,
       type_or_decl_base::type_or_decl_kind r)
{
  l = l | r;
  return l;
}
 
/// bitwise "AND" operator for the
/// type_or_decl_base::type_or_decl_kind bitmap type.
type_or_decl_base::type_or_decl_kind
operator&(type_or_decl_base::type_or_decl_kind l,
      type_or_decl_base::type_or_decl_kind r)
{
  return static_cast<type_or_decl_base::type_or_decl_kind>
    (static_cast<unsigned>(l) & static_cast<unsigned>(r));
}
 
/// bitwise "A&=" operator for the
/// type_or_decl_base::type_or_decl_kind bitmap type.
type_or_decl_base::type_or_decl_kind&
operator&=(type_or_decl_base::type_or_decl_kind& l,
      type_or_decl_base::type_or_decl_kind r)
{
  l = l & r;
  return l;
}
 
/// 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,
                     enum type_or_decl_kind k)
  :priv_(new priv(e, k))
{}
 
/// The destructor of the @ref type_or_decl_base type.
type_or_decl_base::~type_or_decl_base()
{}
 
/// Getter of the flag that says if the artefact is artificial.
///
/// Being artificial means it was not explicitely mentionned in the
/// source code, but was rather artificially created by the compiler
/// or libabigail.
///
/// @return true iff the declaration is artificial.
bool
type_or_decl_base::get_is_artificial() const
{return priv_->is_artificial_;}
 
/// Setter of the flag that says if the artefact is artificial.
///
/// Being artificial means the artefact was not explicitely
/// mentionned in the source code, but was rather artificially created
/// by the compiler or by libabigail.
///
/// @param f the new value of the flag that says if the artefact is
/// artificial.
void
type_or_decl_base::set_is_artificial(bool f)
{priv_->is_artificial_ = f;}
 
/// Getter for the "kind" property of @ref type_or_decl_base type.
///
/// This property holds the identifier bitmap of the runtime type of
/// an ABI artifact.
///
/// @return the runtime type identifier bitmap of the current ABI
/// artifact.
enum type_or_decl_base::type_or_decl_kind
type_or_decl_base::kind() const
{return priv_->kind();}
 
/// Setter for the "kind" property of @ref type_or_decl_base type.
///
/// This property holds the identifier bitmap of the runtime type of
/// an ABI artifact.
///
/// @param the runtime type identifier bitmap of the current ABI
/// artifact.
void
type_or_decl_base::kind(enum type_or_decl_kind k)
{priv_->kind(k);}
 
/// Getter of the pointer to the runtime type sub-object of the
/// current instance.
///
/// @return the pointer to the runtime type sub-object of the current
/// instance.
const void*
type_or_decl_base::runtime_type_instance() const
{return priv_->rtti_;}
 
/// Getter of the pointer to the runtime type sub-object of the
/// current instance.
///
/// @return the pointer to the runtime type sub-object of the current
/// instance.
void*
type_or_decl_base::runtime_type_instance()
{return priv_->rtti_;}
 
/// Setter of the pointer to the runtime type sub-object of the
/// current instance.
///
/// @param i the new pointer to the runtime type sub-object of the
/// current instance.
void
type_or_decl_base::runtime_type_instance(void* i)
{
  priv_->rtti_ = i;
  if (type_base* t = dynamic_cast<type_base*>(this))
    priv_->type_or_decl_ptr_ = t;
  else if (decl_base *d = dynamic_cast<decl_base*>(this))
    priv_->type_or_decl_ptr_ = d;
}
 
/// Getter of the pointer to either the type_base sub-object of the
/// current instance if it's a type, or to the decl_base sub-object of
/// the current instance if it's a decl.
///
/// @return the pointer to either the type_base sub-object of the
/// current instance if it's a type, or to the decl_base sub-object of
/// the current instance if it's a decl.
const void*
type_or_decl_base::type_or_decl_base_pointer() const
{return const_cast<type_or_decl_base*>(this)->type_or_decl_base_pointer();}
 
/// Getter of the pointer to either the type_base sub-object of the
/// current instance if it's a type, or to the decl_base sub-object of
/// the current instance if it's a decl.
///
/// @return the pointer to either the type_base sub-object of the
/// current instance if it's a type, or to the decl_base sub-object of
/// the current instance if it's a decl.
void*
type_or_decl_base::type_or_decl_base_pointer()
{return priv_->type_or_decl_ptr_;}
 
/// Return the hash value of the current IR node.
///
/// Note that upon the first invocation, this member functions
/// computes the hash value and returns it.  Subsequent invocations
/// just return the hash value that was previously calculated.
///
/// @return the hash value of the current IR node.
hash_t
type_or_decl_base::hash_value() const
{return priv_->hash_value_;}
 
void
type_or_decl_base::set_hash_value(hash_t h) const
{priv_->set_hash_value(h);}
 
/// Getter of the environment of the current ABI artifact.
///
/// @return the environment of the artifact.
const environment&
type_or_decl_base::get_environment() const
{return priv_->env_;}
 
/// Setter of the artificial location of the artificat.
///
/// The artificial location is a location that was artificially
/// generated by libabigail, not generated by the original emitter of
/// the ABI meta-data.  For instance, when reading an XML element from
/// an abixml file, the artificial location is the source location of
/// the XML element within the file, not the value of the
/// 'location'property that might be carried by the element.
///
/// Artificial locations might be useful to ensure that abixml emitted
/// by the abixml writer are sorted the same way as the input abixml
/// read by the reader.
///
/// @param l the new artificial location.
void
type_or_decl_base::set_artificial_location(const location &l)
{priv_->artificial_location_ = l;}
 
/// Getter of the artificial location of the artifact.
///
/// The artificial location is a location that was artificially
/// generated by libabigail, not generated by the original emitter of
/// the ABI meta-data.  For instance, when reading an XML element from
/// an abixml file, the artificial location is the source location of
/// the XML element within the file, not the value of the
/// 'location'property that might be carried by the element.
///
/// Artificial locations might be useful to ensure that the abixml
/// emitted by the abixml writer is sorted the same way as the input
/// abixml read by the reader.
///
/// @return the new artificial location.
location&
type_or_decl_base::get_artificial_location() const
{return priv_->artificial_location_;}
 
/// Test if the current ABI artifact carries an artificial location.
///
/// @return true iff the current ABI artifact carries an artificial location.
bool
type_or_decl_base::has_artificial_location() const
{
  return (priv_->artificial_location_
      && priv_->artificial_location_.get_is_artificial());
}
 
/// Get the @ref corpus this ABI artifact belongs to.
///
/// @return the corpus this ABI artifact belongs to, or nil if it
/// belongs to none for now.
corpus*
type_or_decl_base::get_corpus()
{
  translation_unit* tu = abigail::ir::get_translation_unit(this);
  if (!tu)
    return 0;
  return tu->get_corpus();
}
 
 
/// Get the @ref corpus this ABI artifact belongs to.
///
/// @return the corpus this ABI artifact belongs to, or nil if it
/// belongs to none for now.
const corpus*
type_or_decl_base::get_corpus() const
{return const_cast<type_or_decl_base*>(this)->get_corpus();}
 
/// Set the @ref translation_unit this ABI artifact belongs to.
///
/// Note that adding an ABI artifact to a containining on should
/// invoke this member function.
void
type_or_decl_base::set_translation_unit(translation_unit* tu)
{priv_->translation_unit_ = tu;}
 
 
/// Get the @ref translation_unit this ABI artifact belongs to.
///
/// @return the translation unit this ABI artifact belongs to, or nil
/// if belongs to none for now.
translation_unit*
type_or_decl_base::get_translation_unit()
{return priv_->translation_unit_;}
 
/// Get the @ref translation_unit this ABI artifact belongs to.
///
/// @return the translation unit this ABI artifact belongs to, or nil
/// if belongs to none for now.
const translation_unit*
type_or_decl_base::get_translation_unit() const
{return const_cast<type_or_decl_base*>(this)->get_translation_unit();}
 
/// Traverse the the ABI artifact.
///
/// @param v the visitor used to traverse the sub-tree nodes of the
/// artifact.
bool
type_or_decl_base::traverse(ir_node_visitor&)
{return true;}
 
/// Non-member equality operator for the @type_or_decl_base type.
///
/// @param lr the left-hand operand of the equality.
///
/// @param rr the right-hand operatnr of the equality.
///
/// @return true iff @p lr equals @p rr.
bool
operator==(const type_or_decl_base& lr, const type_or_decl_base& rr)
{
  const type_or_decl_base* l = &lr;
  const type_or_decl_base* r = &rr;
 
  const decl_base* dl = dynamic_cast<const decl_base*>(l),
    *dr = dynamic_cast<const decl_base*>(r);
 
  if (!!dl != !!dr)
    return false;
 
  if (dl && dr)
    return *dl == *dr;
 
  const type_base* tl = dynamic_cast<const type_base*>(l),
    *tr = dynamic_cast<const type_base*>(r);
 
  if (!!tl != !!tr)
    return false;
 
  if (tl && tr)
    return *tl == *tr;
 
  return false;
}
 
/// Non-member equality operator for the @type_or_decl_base type.
///
/// @param l the left-hand operand of the equality.
///
/// @param r the right-hand operatnr of the equality.
///
/// @return true iff @p l equals @p r.
bool
operator==(const type_or_decl_base_sptr& l, const type_or_decl_base_sptr& r)
{
  if (!! l != !!r)
    return false;
 
  if (!l)
    return true;
 
  return *r == *l;
}
 
/// Non-member inequality operator for the @type_or_decl_base type.
///
/// @param l the left-hand operand of the equality.
///
/// @param r the right-hand operator of the equality.
///
/// @return true iff @p l is different from @p r.
bool
operator!=(const type_or_decl_base_sptr& l, const type_or_decl_base_sptr& r)
{return !operator==(l, r);}
 
// </type_or_decl_base stuff>
 
// <Decl definition>
 
struct decl_base::priv
{
  bool          in_pub_sym_tab_;
  bool          is_anonymous_;
  location      location_;
  context_rel       *context_;
  interned_string   name_;
  interned_string   qualified_parent_name_;
  // This temporary qualified name is the cache used for the qualified
  // name before the type associated to this decl (if applicable) is
  // canonicalized.  Once the type is canonicalized, the cached use is
  // the data member qualified_parent_name_ above.
  interned_string   temporary_qualified_name_;
  // This is the fully qualified name of the decl.  It contains the
  // name of the decl and the qualified name of its scope.  So if in
  // the parent scopes of the decl, there is one anonymous struct,
  // somewhere in the name, there is going to by an
  // __anonymous_struct__ string, even if the anonymous struct is not
  // the direct containing scope of this decl.
  interned_string   qualified_name_;
  interned_string   temporary_internal_qualified_name_;
  interned_string   internal_qualified_name_;
  interned_string   internal_cached_repr_;
  interned_string   cached_repr_;
  // Unline qualified_name_, scoped_name_ contains the name of the
  // decl and the name of its scope; not the qualified name of the
  // scope.
  interned_string   scoped_name_;
  interned_string   linkage_name_;
  visibility        visibility_;
  decl_base_sptr    declaration_;
  decl_base_wptr    definition_of_declaration_;
  decl_base*        naked_definition_of_declaration_;
  bool          is_declaration_only_;
  typedef_decl_sptr naming_typedef_;
 
  priv()
    : in_pub_sym_tab_(false),
      is_anonymous_(true),
      context_(),
      visibility_(VISIBILITY_DEFAULT),
      naked_definition_of_declaration_(),
      is_declaration_only_(false)
  {}
 
  priv(interned_string name, interned_string linkage_name, visibility vis)
    : in_pub_sym_tab_(false),
      context_(),
      name_(name),
      qualified_name_(name),
      linkage_name_(linkage_name),
      visibility_(vis),
      naked_definition_of_declaration_(),
      is_declaration_only_(false)
  {
    is_anonymous_ = name_.empty();
  }
 
  ~priv()
  {
    delete context_;
  }
};// end struct decl_base::priv
 
/// Constructor for the @ref decl_base type.
///
/// @param e the environment the current @ref decl_base is being
/// created in.
///
/// @param name the name of the declaration.
///
/// @param locus the location where to find the declaration in the
/// source code.
///
/// @param linkage_name the linkage name of the declaration.
///
/// @param vis the visibility of the declaration.
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))
{
  set_location(locus);
}
 
/// Constructor.
///
/// @param e the environment this instance of @ref decl_base is
/// created in.
///
/// @param name the name of the declaration being constructed.
///
/// @param locus the source location of the declaration being constructed.
///
/// @param linkage_name the linkage name of the declaration being
/// constructed.
///
/// @param vis the visibility of the declaration being constructed.
decl_base::decl_base(const environment& e,
             const interned_string& name,
             const location& locus,
             const interned_string& linkage_name,
             visibility vis)
  : type_or_decl_base(e, ABSTRACT_DECL_BASE),
    priv_(new priv(name, linkage_name, vis))
{
  set_location(locus);
}
 
/// Constructor for the @ref decl_base type.
///
///@param environment the environment this instance of @ref decl_base
/// is being constructed in.
///
/// @param l the location where to find the declaration in the source
/// code.
decl_base::decl_base(const environment& e, const location& l)
  : type_or_decl_base(e, ABSTRACT_DECL_BASE),
    priv_(new priv())
{
  set_location(l);
}
 
/// Getter for the qualified name.
///
/// Unlike decl_base::get_qualified_name() this doesn't try to update
/// the qualified name.
///
/// @return the qualified name.
const interned_string&
decl_base::peek_qualified_name() const
{return priv_->qualified_name_;}
 
/// Clear the qualified name of this decl.
///
/// This is useful to ensure that the cache for the qualified name of
/// the decl is refreshed right after type canonicalization, for
/// instance.
void
decl_base::clear_qualified_name()
{priv_->qualified_name_.clear();}
 
/// Setter for the qualified name.
///
/// @param n the new qualified name.
void
decl_base::set_qualified_name(const interned_string& n) const
{priv_->qualified_name_ = n;}
 
/// Getter of the temporary qualified name of the current declaration.
///
/// This temporary qualified name is used as a qualified name cache by
/// the type for which this is the declaration (when applicable)
/// before the type is canonicalized.  Once the type is canonicalized,
/// it's the result of decl_base::peek_qualified_name() that becomes
/// the qualified name cached.
///
/// @return the temporary qualified name.
const interned_string&
decl_base::peek_temporary_qualified_name() const
{return priv_->temporary_qualified_name_;}
 
/// Setter for the temporary qualified name of the current
/// declaration.
///
///@param n the new temporary qualified name.
///
/// This temporary qualified name is used as a qualified name cache by
/// the type for which this is the declaration (when applicable)
/// before the type is canonicalized.  Once the type is canonicalized,
/// it's the result of decl_base::peek_qualified_name() that becomes
/// the qualified name cached.
void
decl_base::set_temporary_qualified_name(const interned_string& n) const
{priv_->temporary_qualified_name_ = n;}
 
///Getter for the context relationship.
///
///@return the context relationship for the current decl_base.
const context_rel*
decl_base::get_context_rel() const
{return priv_->context_;}
 
///Getter for the context relationship.
///
///@return the context relationship for the current decl_base.
context_rel*
decl_base::get_context_rel()
{return priv_->context_;}
 
void
decl_base::set_context_rel(context_rel *c)
{priv_->context_ = c;}
 
/// Test if the decl is defined in a ELF symbol table as a public
/// symbol.
///
/// @return true iff the decl is defined in a ELF symbol table as a
/// public symbol.
bool
decl_base::get_is_in_public_symbol_table() const
{return priv_->in_pub_sym_tab_;}
 
/// Set the flag saying if this decl is from a symbol that is in
/// a public symbols table, defined as public (global or weak).
///
/// @param f the new flag value.
void
decl_base::set_is_in_public_symbol_table(bool f)
{priv_->in_pub_sym_tab_ = f;}
 
/// Get the location of a given declaration.
///
/// The location is an abstraction for the tripplet {file path,
/// line, column} that defines where the declaration appeared in the
/// source code.
///
/// To get the value of the tripplet {file path, line, column} from
/// the @ref location, you need to use the
/// location_manager::expand_location() method.
///
/// The instance of @ref location_manager that you want is
/// accessible from the instance of @ref translation_unit that the
/// current instance of @ref decl_base belongs to, via a call to
/// translation_unit::get_loc_mgr().
///
/// @return the location of the current instance of @ref decl_base.
const location&
decl_base::get_location() const
{return priv_->location_;}
 
/// Set the location for a given declaration.
///
/// The location is an abstraction for the tripplet {file path,
/// line, column} that defines where the declaration appeared in the
/// source code.
///
/// To create a location from a tripplet {file path, line, column},
/// you need to use the method @ref
/// location_manager::create_new_location().
///
/// Note that there can be two kinds of location.  An artificial
/// location and a non-artificial one.  The non-artificial location is
/// the one emitted by the original emitter of the ABI artifact, for
/// instance, if the ABI artifact comes from debug info, then the
/// source location that is present in the debug info represent a
/// non-artificial location.  When looking at an abixml file on the
/// other hand, the value of the 'location' attribute of an XML
/// element describing an artifact is the non-artificial location.
/// The artificial location is the location (line number from the
/// beginning of the file) of the XML element within the abixml file.
///
/// So, if the location that is being set is artificial, note that the
/// type_or_decl_base::has_artificial_location() method of this decl will
/// subsequently return true and that artificial location will have to
/// be retrieved using type_or_decl_base::get_artificial_location().
/// If the location is non-artificial however,
/// type_or_decl_base::has_artificial_location() will subsequently
/// return false and the non-artificial location will have to be
/// retrieved using decl_base::get_location().
///
/// The instance of @ref location_manager that you want is
/// accessible from the instance of @ref translation_unit that the
/// current instance of @ref decl_base belongs to, via a call to
/// translation_unit::get_loc_mgr().
void
decl_base::set_location(const location& l)
{
  if (l.get_is_artificial())
    set_artificial_location(l);
  else
    priv_->location_ = l;
}
 
/// Setter for the name of the decl.
///
/// @param n the new name to set.
void
decl_base::set_name(const string& n)
{
  priv_->name_ = get_environment().intern(n);
  priv_->is_anonymous_ = n.empty();
}
 
/// Test if the current declaration is anonymous.
///
/// Being anonymous means that the declaration was created without a
/// name.  This can usually happen for enum or struct types.
///
/// @return true iff the type is anonymous.
bool
decl_base::get_is_anonymous() const
{return priv_->is_anonymous_;}
 
/// Set the "is_anonymous" flag of the current declaration.
///
/// Being anonymous means that the declaration was created without a
/// name.  This can usually happen for enum or struct types.
///
/// @param f the new value of the flag.
void
decl_base::set_is_anonymous(bool f)
{priv_->is_anonymous_ = f;}
 
 
/// Get the "has_anonymous_parent" flag of the current declaration.
///
/// Having an anoymous parent means having a anonymous parent scope
/// (containing type or namespace) which is either direct or indirect.
///
/// @return true iff the current decl has a direct or indirect scope
/// which is anonymous.
bool
decl_base::get_has_anonymous_parent() const
{
  scope_decl *scope = get_scope();
  if (!scope)
    return false;
  return scope->get_is_anonymous();
}
 
/// @return the logical "OR" of decl_base::get_is_anonymous() and
/// decl_base::get_has_anonymous_parent().
bool
decl_base::get_is_anonymous_or_has_anonymous_parent() const
{return get_is_anonymous() || get_has_anonymous_parent();}
 
/// Getter for the naming typedef of the current decl.
///
/// Consider the C idiom:
///
///    typedef struct {int member;} foo_type;
///
/// In that idiom, foo_type is the naming typedef of the anonymous
/// struct that is declared.
///
/// @return the naming typedef, if any.  Otherwise, returns nil.
typedef_decl_sptr
decl_base::get_naming_typedef() const
{return priv_->naming_typedef_;}
 
/// Set the naming typedef of the current instance of @ref decl_base.
///
/// Consider the C idiom:
///
///    typedef struct {int member;} foo_type;
///
/// In that idiom, foo_type is the naming typedef of the anonymous
/// struct that is declared.
///
/// After completion of this function, the decl will not be considered
/// anonymous anymore.  It's name is going to be the name of the
/// naming typedef.
///
/// @param typedef_type the new naming typedef.
void
decl_base::set_naming_typedef(const typedef_decl_sptr& t)
{
  // A naming typedef is usually for an anonymous type.
  ABG_ASSERT(get_is_anonymous()
         // Whe the typedef-named decl is saved into abixml, it's
         // not anonymous anymore.  Its name is the typedef name.
         // So when we read it back, we must still be able to
         // apply the naming typedef to the decl.
         || t->get_name() == get_name());
  // Only non canonicalized types can be edited this way.
  ABG_ASSERT(is_type(this)
         && is_type(this)->get_naked_canonical_type() == nullptr);
 
  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_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.
  update_qualified_name(this);
}
 
/// Getter for the mangled name.
///
/// @return the new mangled name.
const interned_string&
decl_base::get_linkage_name() const
{return priv_->linkage_name_;}
 
/// Setter for the linkage name.
///
/// @param m the new linkage name.
void
decl_base::set_linkage_name(const string& m)
{
  const environment& env = get_environment();
  priv_->linkage_name_ = env.intern(m);
}
 
/// Getter for the visibility of the decl.
///
/// @return the new visibility.
decl_base::visibility
decl_base::get_visibility() const
{return priv_->visibility_;}
 
/// Setter for the visibility of the decl.
///
/// @param v the new visibility.
void
decl_base::set_visibility(visibility v)
{priv_->visibility_ = v;}
 
/// Return the type containing the current decl, if any.
///
/// @return the type that contains the current decl, or NULL if there
/// is none.
scope_decl*
decl_base::get_scope() const
{
  if (priv_->context_)
    return priv_->context_->get_scope();
  return 0;
}
 
/// Return a copy of the qualified name of the parent of the current
/// decl.
///
/// @return the newly-built qualified name of the of the current decl.
const interned_string&
decl_base::get_qualified_parent_name() const
{return priv_->qualified_parent_name_;}
 
/// Getter for the name of the current decl.
///
/// @return the name of the current decl.
const interned_string&
decl_base::get_name() const
{return priv_->name_;}
 
/// Compute the qualified name of the decl.
///
/// @param qn the resulting qualified name.
///
/// @param internal set to true if the call is intended for an
/// internal use (for technical use inside the library itself), false
/// otherwise.  If you don't know what this is for, then set it to
/// false.
void
decl_base::get_qualified_name(interned_string& qn, bool internal) const
{qn = get_qualified_name(internal);}
 
/// Get the pretty representatin of the current declaration.
///
///
/// @param internal set to true if the call is intended to get a
/// representation of the decl (or type) for the purpose of canonical
/// type comparison.  This is mainly used in the function
/// type_base::get_canonical_type_for().
///
/// In other words if the argument for this parameter is true then the
/// call is meant for internal use (for technical use inside the
/// library itself), false otherwise.  If you don't know what this is
/// for, then set it to false.
///
/// @param qualified_name if true, names emitted in the pretty
/// representation are fully qualified.
///
/// @return the default pretty representation for a decl.  This is
/// basically the fully qualified name of the decl optionally prefixed
/// with a meaningful string to add context for the user.
string
decl_base::get_pretty_representation(bool internal,
                     bool qualified_name) const
{
  if (internal
      && get_is_anonymous()
      && has_generic_anonymous_internal_type_name(this))
    {
      // We are looking at an anonymous enum, union or class and we
      // want an *internal* pretty representation for it.  All
      // anonymous types of this kind in the same namespace must have
      // the same internal representation for type canonicalization to
      // work properly.
      //
      // OK, in practise, we are certainly looking at an enum because
      // classes and unions should have their own overloaded virtual
      // member function for this.
      string name = get_generic_anonymous_internal_type_name(this);
      if (qualified_name && !get_qualified_parent_name().empty())
    name = get_qualified_parent_name() + "::" + name;
      return name;
    }
 
  if (qualified_name)
    return get_qualified_name(internal);
  return get_name();
}
 
/// Get the pretty representation of the current decl.
///
/// The pretty representation is retrieved from a cache.  If the cache
/// is empty, this function computes the pretty representation, put it
/// in the cache and returns it.
///
/// Please note that if this function is called too early in the life
/// cycle of the decl (before it is fully constructed), then the
/// pretty representation that is cached is going to represent a
/// non-complete (and thus wrong) representation of the decl.  Thus
/// this function must be called only once the decl is fully
/// constructed.
///
/// @param internal if true, then the pretty representation is to be
/// used for purpuses that are internal to the libabigail library
/// itself.  If you don't know what this means, then you probably
/// should set this parameter to "false".
///
/// @return a reference to a cached @ref interned_string holding the
/// pretty representation of the current decl.
const interned_string&
decl_base::get_cached_pretty_representation(bool internal) const
{
    if (internal)
    {
      if (priv_->internal_cached_repr_.empty())
    {
      string r = ir::get_pretty_representation(this, internal);
      priv_->internal_cached_repr_ = get_environment().intern(r);
    }
      return priv_->internal_cached_repr_;
    }
 
  if (priv_->cached_repr_.empty())
    {
      string r = ir::get_pretty_representation(this, internal);
      priv_->cached_repr_ = get_environment().intern(r);
    }
 
  return priv_->cached_repr_;
}
 
/// Return the qualified name of the decl.
///
/// This is the fully qualified name of the decl.  It's made of the
/// concatenation of the name of the decl with the qualified name of
/// its scope.
///
/// Note that the value returned by this function is computed by @ref
/// update_qualified_name when the decl is added to its scope.
///
/// @param internal set to true if the call is intended for an
/// internal use (for technical use inside the library itself), false
/// otherwise.  If you don't know what this is for, then set it to
/// false.
///
/// @return the resulting qualified name.
const interned_string&
decl_base::get_qualified_name(bool /*internal*/) const
{return priv_->qualified_name_;}
 
/// Return the scoped name of the decl.
///
/// This is made of the concatenation of the name of the decl with the
/// name of its scope.  It doesn't contain the qualified name of its
/// scope, unlike what is returned by decl_base::get_qualified_name.
///
/// Note that the value returned by this function is computed by @ref
/// update_qualified_name when the decl is added to its scope.
///
/// @return the scoped name of the decl.
const interned_string&
decl_base::get_scoped_name() const
{return priv_->scoped_name_;}
 
/// If this @ref decl_base is a definition, get its earlier
/// declaration.
///
/// @return the earlier declaration of the class, if any.
const decl_base_sptr
decl_base::get_earlier_declaration() const
{return priv_->declaration_;}
 
/// set the earlier declaration of this @ref decl_base definition.
///
/// @param d the earlier declaration to set.  Note that it's set only
/// if it's a pure declaration.
void
decl_base::set_earlier_declaration(const decl_base_sptr& d)
{
  if (d && d->get_is_declaration_only())
    priv_->declaration_ = d;
}
 
 
/// If this @ref decl_base is declaration-only, get its definition, if
/// any.
///
/// @return the definition of this decl-only @ref decl_base.
const decl_base_sptr
decl_base::get_definition_of_declaration() const
{return priv_->definition_of_declaration_.lock();}
 
///  If this @ref decl_base is declaration-only, get its definition,
///  if any.
///
/// Note that this function doesn't return a smart pointer, but rather
/// the underlying pointer managed by the smart pointer.  So it's as
/// fast as possible.  This getter is to be used in code paths that
/// are proven to be performance hot spots; especially, when comparing
/// sensitive types like enums, classes or unions.  Those are compared
/// extremely frequently and thus, their access to the definition of
/// declaration must be fast.
///
/// @return the definition of the declaration.
const decl_base*
decl_base::get_naked_definition_of_declaration() const
{return priv_->naked_definition_of_declaration_;}
 
/// Test if a @ref decl_base is a declaration-only decl.
///
/// @return true iff the current @ref decl_base is declaration-only.
bool
decl_base::get_is_declaration_only() const
{return priv_->is_declaration_only_;}
 
/// Set a flag saying if the @ref enum_type_decl is a declaration-only
/// @ref enum_type_decl.
///
/// @param f true if the @ref enum_type_decl is a declaration-only
/// @ref enum_type_decl.
void
decl_base::set_is_declaration_only(bool f)
{
  bool update_types_lookup_map = !f && priv_->is_declaration_only_;
 
  priv_->is_declaration_only_ = f;
 
  if (update_types_lookup_map)
    if (scope_decl* s = get_scope())
      {
    scope_decl::declarations::iterator i;
    if (s->find_iterator_for_member(this, i))
      maybe_update_types_lookup_map(*i);
    else
      ABG_ASSERT_NOT_REACHED;
      }
}
 
change_kind
operator|(change_kind l, change_kind r)
{
  return static_cast<change_kind>(static_cast<unsigned>(l)
                  | static_cast<unsigned>(r));
}
 
change_kind
operator&(change_kind l, change_kind r)
{
  return static_cast<change_kind>(static_cast<unsigned>(l)
                  & static_cast<unsigned>(r));
}
 
change_kind&
operator|=(change_kind& l, change_kind r)
{
  l = l | r;
  return l;
}
 
change_kind&
operator&=(change_kind& l, change_kind r)
{
  l = l & r;
  return l;
}
 
/// Compare the properties that belong to the "is-a-member-relation"
/// of a decl.
///
/// For instance, access specifiers are part of the
/// "is-a-member-relation" of a decl.
///
/// This comparison however doesn't take decl names into account.  So
/// typedefs for instance are decls that we want to compare with this
/// function.
///
/// This function is a sub-routine of the more general 'equals'
/// overload for instances of decl_base.
///
/// @param l the left-hand side operand of the comparison.
///
/// @param r the right-hand side operand of the comparison.
///
/// @return true iff @p l compare equals, as a member decl, to @p r.
bool
maybe_compare_as_member_decls(const decl_base& l,
                  const decl_base& r,
                  change_kind* k)
{
  bool result = true;
  if (is_member_decl(l) && is_member_decl(r))
    {
      context_rel* r1 = const_cast<context_rel*>(l.get_context_rel());
      context_rel *r2 = const_cast<context_rel*>(r.get_context_rel());
 
      access_specifier la = no_access, ra = no_access;
      bool member_types_or_functions =
    ((is_type(l) && is_type(r))
     || (is_function_decl(l) && is_function_decl(r)));
 
      if (member_types_or_functions)
    {
      // Access specifiers on member types in DWARF is not
      // reliable; in the same DSO, the same struct can be either
      // a class or a struct, and the access specifiers of its
      // member types are not necessarily given, so they
      // effectively can be considered differently, again, in the
      // same DSO.  So, here, let's avoid considering those!
      // during comparison.
      la = r1->get_access_specifier();
      ra = r2->get_access_specifier();
      r1->set_access_specifier(no_access);
      r2->set_access_specifier(no_access);
    }
 
      bool rels_are_different = *r1 != *r2;
 
      if (member_types_or_functions)
    {
      // restore the access specifiers.
      r1->set_access_specifier(la);
      r2->set_access_specifier(ra);
    }
 
      if (rels_are_different)
    {
      result = false;
      if (k)
        *k |= LOCAL_NON_TYPE_CHANGE_KIND;
    }
    }
  ABG_RETURN(result);
}
 
/// Compares two instances of @ref decl_base.
///
/// If the two intances are different, set a bitfield to give some
/// insight about the kind of differences there are.
///
/// @param l the first artifact of the comparison.
///
/// @param r the second artifact of the comparison.
///
/// @param k a pointer to a bitfield that gives information about the
/// kind of changes there are between @p l and @p r.  This one is set
/// iff it's non-null and if the function returns false.
///
/// Please note that setting k to a non-null value does have a
/// negative performance impact because even if @p l and @p r are not
/// equal, the function keeps up the comparison in order to determine
/// the different kinds of ways in which they are different.
///
/// @return true if @p l equals @p r, false otherwise.
bool
equals(const decl_base& l, const decl_base& r, change_kind* k)
{
  bool result = true;
  const interned_string &l_linkage_name = l.get_linkage_name();
  const interned_string &r_linkage_name = r.get_linkage_name();
  if (!l_linkage_name.empty() && !r_linkage_name.empty())
    {
      if (l_linkage_name != r_linkage_name)
    {
      // Linkage names are different.  That usually means the two
      // decls are different, unless we are looking at two
      // function declarations which have two different symbols
      // that are aliases of each other.
      const function_decl *f1 = is_function_decl(&l),
        *f2 = is_function_decl(&r);
      if (f1 && f2 && function_decls_alias(*f1, *f2))
        ;// The two functions are aliases, so they are not
         // different.
      else
        {
          result = false;
          if (k)
        *k |= LOCAL_NON_TYPE_CHANGE_KIND;
          else
        ABG_RETURN_FALSE;
        }
    }
    }
 
    if (r.get_is_anonymous() && l.get_is_anonymous())
      // We are looking at too anonymous types (or two members of
      // anonymous types) with one not yet been added to the IR.  That
      // means we want to compare just the object part of the
      // anonymous type and not their qualified names.  This is used
      // when looking up an anonymous type inside a class type.
      ABG_RETURN(result);
 
    // This is the name of the decls that we want to compare.
    interned_string ln = l.get_name(), rn = r.get_name();
 
    /// If both of the current decls have an anonymous scope then let's
    /// compare their name component by component by properly handling
    /// anonymous scopes. That's the slow path.
    ///
    /// Otherwise, let's just compare their name, the obvious way.
    /// That's the fast path because in that case the names are
    /// interned_string and comparing them is much faster.
    bool decls_are_same = (ln == rn);
 
  if (!decls_are_same)
    {
      result = false;
      if (k)
    *k |= LOCAL_NON_TYPE_CHANGE_KIND;
      else
    ABG_RETURN_FALSE;
    }
 
  result &= maybe_compare_as_member_decls(l, r, k);
 
  ABG_RETURN(result);
}
 
/// Return true iff the two decls have the same name.
///
/// This function doesn't test if the scopes of the the two decls are
/// equal.
///
/// Note that this virtual function is to be implemented by classes
/// that extend the \p decl_base class.
bool
decl_base::operator==(const decl_base& other) const
{return equals(*this, other, 0);}
 
/// Inequality operator.
///
/// @param other to other instance of @ref decl_base to compare the
/// current instance to.
///
/// @return true iff the current instance of @ref decl_base is
/// different from @p other.
bool
decl_base::operator!=(const decl_base& other) const
{return !operator==(other);}
 
/// Destructor of the @ref decl_base type.
decl_base::~decl_base()
{delete priv_;}
 
/// This implements the ir_traversable_base::traverse pure virtual
/// function.
///
/// @param v the visitor used on the member nodes of the translation
/// unit during the traversal.
///
/// @return true if the entire IR node tree got traversed, false
/// otherwise.
bool
decl_base::traverse(ir_node_visitor&)
{
  // Do nothing in the base class.
  return true;
}
 
/// Setter of the scope of the current decl.
///
/// Note that the decl won't hold a reference on the scope.  It's
/// rather the scope that holds a reference on its members.
void
decl_base::set_scope(scope_decl* scope)
{
  if (!priv_->context_)
    priv_->context_ = new context_rel(scope);
  else
    priv_->context_->set_scope(scope);
}
 
// </decl_base definition>
 
/// Streaming operator for the decl_base::visibility.
///
/// @param o the output stream to serialize the visibility to.
///
/// @param v the visibility to serialize.
///
/// @return the output stream.
std::ostream&
operator<<(std::ostream& o, decl_base::visibility v)
{
  string r;
  switch (v)
    {
    case decl_base::VISIBILITY_NONE:
      r = "none";
      break;
    case decl_base::VISIBILITY_DEFAULT:
      r = "default";
      break;
    case decl_base::VISIBILITY_PROTECTED:
      r = "protected";
      break;
    case decl_base::VISIBILITY_HIDDEN:
      r = "hidden";
      break;
    case decl_base::VISIBILITY_INTERNAL:
      r = "internal";
      break;
    }
  return o;
}
 
/// Streaming operator for decl_base::binding.
///
/// @param o the output stream to serialize the visibility to.
///
/// @param b the binding to serialize.
///
/// @return the output stream.
std::ostream&
operator<<(std::ostream& o, decl_base::binding b)
{
  string r;
  switch (b)
    {
    case decl_base::BINDING_NONE:
      r = "none";
      break;
    case decl_base::BINDING_LOCAL:
      r = "local";
      break;
    case decl_base::BINDING_GLOBAL:
      r = "global";
      break;
    case decl_base::BINDING_WEAK:
      r = "weak";
      break;
    }
  o << r;
  return o;
}
 
/// Turn equality of shared_ptr of decl_base into a deep equality;
/// that is, make it compare the pointed to objects, not just the
/// pointers.
///
/// @param l the shared_ptr of decl_base on left-hand-side of the
/// equality.
///
/// @param r the shared_ptr of decl_base on right-hand-side of the
/// equality.
///
/// @return true if the decl_base pointed to by the shared_ptrs are
/// equal, false otherwise.
bool
operator==(const decl_base_sptr& l, const decl_base_sptr& r)
{
  if (l.get() == r.get())
    return true;
  if (!!l != !!r)
    return false;
 
  return *l == *r;
}
 
/// Inequality operator of shared_ptr of @ref decl_base.
///
/// This is a deep equality operator, that is, it compares the
/// pointed-to objects, rather than just the pointers.
///
/// @param l the left-hand-side operand.
///
/// @param r the right-hand-side operand.
///
/// @return true iff @p l is different from @p r.
bool
operator!=(const decl_base_sptr& l, const decl_base_sptr& r)
{return !operator==(l, r);}
 
/// Turn equality of shared_ptr of type_base into a deep equality;
/// that is, make it compare the pointed to objects too.
///
/// @param l the shared_ptr of type_base on left-hand-side of the
/// equality.
///
/// @param r the shared_ptr of type_base on right-hand-side of the
/// equality.
///
/// @return true if the type_base pointed to by the shared_ptrs are
/// equal, false otherwise.
bool
operator==(const type_base_sptr& l, const type_base_sptr& r)
{
    if (l.get() == r.get())
    return true;
  if (!!l != !!r)
    return false;
 
  return *l == *r;
}
 
/// Turn inequality of shared_ptr of type_base into a deep equality;
/// that is, make it compare the pointed to objects..
///
/// @param l the shared_ptr of type_base on left-hand-side of the
/// equality.
///
/// @param r the shared_ptr of type_base on right-hand-side of the
/// equality.
///
/// @return true iff the type_base pointed to by the shared_ptrs are
/// different.
bool
operator!=(const type_base_sptr& l, const type_base_sptr& r)
{return !operator==(l, r);}
 
/// Tests if a declaration has got a scope.
///
/// @param d the declaration to consider.
///
/// @return true if the declaration has got a scope, false otherwise.
bool
has_scope(const decl_base& d)
{return (d.get_scope());}
 
/// Tests if a declaration has got a scope.
///
/// @param d the declaration to consider.
///
/// @return true if the declaration has got a scope, false otherwise.
bool
has_scope(const decl_base_sptr d)
{return has_scope(*d.get());}
 
/// Tests if a declaration is a class member.
///
/// @param d the declaration to consider.
///
/// @return true if @p d is a class member, false otherwise.
bool
is_member_decl(const decl_base_sptr d)
{return is_at_class_scope(d) || is_method_decl(d);}
 
/// Tests if a declaration is a class member.
///
/// @param d the declaration to consider.
///
/// @return true if @p d is a class member, false otherwise.
bool
is_member_decl(const decl_base* d)
{return is_at_class_scope(d) || is_method_decl(d);}
 
/// Tests if a declaration is a class member.
///
/// @param d the declaration to consider.
///
/// @return true if @p d is a class member, false otherwise.
bool
is_member_decl(const decl_base& d)
{return is_at_class_scope(d) || is_method_decl(d);}
 
/// Test if a declaration is a @ref scope_decl.
///
/// @param d the declaration to take in account.
///
/// @return the a pointer to the @ref scope_decl sub-object of @p d,
/// if d is a @ref scope_decl.
const scope_decl*
is_scope_decl(const decl_base* d)
{return dynamic_cast<const scope_decl*>(d);}
 
/// Test if a declaration is a @ref scope_decl.
///
/// @param d the declaration to take in account.
///
/// @return the a pointer to the @ref scope_decl sub-object of @p d,
/// if d is a @ref scope_decl.
scope_decl_sptr
is_scope_decl(const decl_base_sptr& d)
{return dynamic_pointer_cast<scope_decl>(d);}
 
/// Tests if a type is a class member.
///
/// @param t the type to consider.
///
/// @return true if @p t is a class member type, false otherwise.
bool
is_member_type(const type_base_sptr& t)
{
  decl_base_sptr d = get_type_declaration(t);
  return is_member_decl(d);
}
 
/// Test if a type is user-defined.
///
/// A type is considered user-defined if it's a
/// struct/class/union/enum that is *NOT* artificial.
///
/// @param t the type to consider.
///
/// @return true iff the type @p t is user-defined.
bool
is_user_defined_type(const type_base* t)
{
  if (t == 0)
    return false;
 
  t = peel_qualified_or_typedef_type(t);
  decl_base *d = is_decl(t);
 
  if ((is_class_or_union_type(t) || is_enum_type(t))
      && d && !d->get_is_artificial())
    return true;
 
  return false;
}
 
/// Test if a type is user-defined.
///
/// A type is considered user-defined if it's a
/// struct/class/union/enum.
///
///
/// @param t the type to consider.
///
/// @return true iff the type @p t is user-defined.
bool
is_user_defined_type(const type_base_sptr& t)
{return is_user_defined_type(t.get());}
 
/// Gets the access specifier for a class member.
///
/// @param d the declaration of the class member to consider.  Note
/// that this must be a class member otherwise the function aborts the
/// current process.
///
/// @return the access specifier for the class member @p d.
access_specifier
get_member_access_specifier(const decl_base& d)
{
  ABG_ASSERT(is_member_decl(d));
 
  const context_rel* c = d.get_context_rel();
  ABG_ASSERT(c);
 
  return c->get_access_specifier();
}
 
/// Gets the access specifier for a class member.
///
/// @param d the declaration of the class member to consider.  Note
/// that this must be a class member otherwise the function aborts the
/// current process.
///
/// @return the access specifier for the class member @p d.
access_specifier
get_member_access_specifier(const decl_base_sptr& d)
{return get_member_access_specifier(*d);}
 
/// Sets the access specifier for a class member.
///
/// @param d the class member to set the access specifier for.  Note
/// that this must be a class member otherwise the function aborts the
/// current process.
///
/// @param a the new access specifier to set the class member to.
void
set_member_access_specifier(decl_base& d,
                access_specifier a)
{
  ABG_ASSERT(is_member_decl(d));
 
  context_rel* c = d.get_context_rel();
  ABG_ASSERT(c);
 
  c->set_access_specifier(a);
}
 
/// Sets the access specifier for a class member.
///
/// @param d the class member to set the access specifier for.  Note
/// that this must be a class member otherwise the function aborts the
/// current process.
///
/// @param a the new access specifier to set the class member to.
void
set_member_access_specifier(const decl_base_sptr& d,
                access_specifier a)
{set_member_access_specifier(*d, a);}
 
/// Gets a flag saying if a class member is static or not.
///
/// @param d the declaration for the class member to consider. Note
/// that this must be a class member otherwise the function aborts the
/// current process.
///
/// @return true if the class member @p d is static, false otherwise.
bool
get_member_is_static(const decl_base&d)
{
  ABG_ASSERT(is_member_decl(d));
 
  const context_rel* c = d.get_context_rel();
  ABG_ASSERT(c);
 
  return c->get_is_static();
}
 
/// Gets a flag saying if a class member is static or not.
///
/// @param d the declaration for the class member to consider. Note
/// that this must be a class member otherwise the function aborts the
/// current process.
///
/// @return true if the class member @p d is static, false otherwise.
bool
get_member_is_static(const decl_base* d)
{return get_member_is_static(*d);}
 
/// Gets a flag saying if a class member is static or not.
///
/// @param d the declaration for the class member to consider.  Note
/// that this must be a class member otherwise the function aborts the
/// current process.
///
/// @return true if the class member @p d is static, false otherwise.
bool
get_member_is_static(const decl_base_sptr& d)
{return get_member_is_static(*d);}
 
/// Test if a var_decl is a data member.
///
/// @param v the var_decl to consider.
///
/// @return true if @p v is data member, false otherwise.
bool
is_data_member(const var_decl& v)
{return is_at_class_scope(v);}
 
/// Test if a var_decl is a data member.
///
/// @param v the var_decl to consider.
///
/// @return true if @p v is data member, false otherwise.
bool
is_data_member(const var_decl* v)
{return is_data_member(*v);}
 
/// Test if a var_decl is a data member.
///
/// @param v the var_decl to consider.
///
/// @return true if @p v is data member, false otherwise.
bool
is_data_member(const var_decl_sptr d)
{return is_at_class_scope(d);}
 
/// Test if a decl is a data member.
///
/// @param d the decl to consider.
///
/// @return a pointer to the data member iff @p d is a data member, or
/// a null pointer.
var_decl_sptr
is_data_member(const decl_base_sptr& d)
{
  if (var_decl_sptr v = is_var_decl(d))
    {
      if (is_data_member(v))
    return v;
    }
  return var_decl_sptr();
}
 
/// Test if a decl is a data member.
///
/// @param d the decl to consider.
///
/// @return a pointer to the data member iff @p d is a data member, or
/// a null pointer.
var_decl_sptr
is_data_member(const type_or_decl_base_sptr& d)
{
  if (var_decl_sptr v = is_var_decl(d))
    {
      if (is_data_member(v))
    return v;
    }
  return var_decl_sptr();
}
 
/// Test if a decl is a data member.
///
/// @param d the decl to consider.
///
/// @return a pointer to the data member iff @p d is a data member, or
/// a null pointer.
var_decl*
is_data_member(const type_or_decl_base* d)
{
 if (var_decl *v = is_var_decl(d))
    if (is_data_member(v))
      return v;
  return 0;
}
 
/// Test if a decl is a data member.
///
/// @param d the decl to consider.
///
/// @return a pointer to the data member iff @p d is a data member, or
/// a null pointer.
var_decl*
is_data_member(const decl_base *d)
{
  if (var_decl *v = is_var_decl(d))
    if (is_data_member(v))
      return v;
  return 0;
}
 
/// Get the first non-anonymous data member of a given anonymous data
/// member.
///
/// E.g:
///
///   struct S
///   {
///     union // <-- for this anonymous data member, the function
///           // returns a.
///     {
///       int a;
///       charb;
///     };
///   };
///
/// @return anon_dm the anonymous data member to consider.
///
/// @return the first non-anonymous data member of @p anon_dm.  If no
/// data member was found then this function returns @p anon_dm.
const var_decl_sptr
get_first_non_anonymous_data_member(const var_decl_sptr anon_dm)
{
  if (!anon_dm || !is_anonymous_data_member(anon_dm))
    return anon_dm;
 
  class_or_union_sptr klass = anonymous_data_member_to_class_or_union(anon_dm);
 var_decl_sptr first = *klass->get_non_static_data_members().begin();
 
 if (is_anonymous_data_member(first))
   return get_first_non_anonymous_data_member(first);
 
 return first;
}
 
/// In the context of a given class or union, this function returns
/// the data member that is located after a given data member.
///
/// @param klass the class or union to consider.
///
/// @param the data member to consider.
///
/// @return the data member that is located right after @p
/// data_member.
const var_decl_sptr
get_next_data_member(const class_or_union *klass,
             const var_decl_sptr &data_member)
{
  if (!klass ||!data_member)
    return var_decl_sptr();
 
  for (class_or_union::data_members::const_iterator it =
     klass->get_non_static_data_members().begin();
       it != klass->get_non_static_data_members().end();
       ++it)
    if (**it == *data_member)
      {
    ++it;
    if (it != klass->get_non_static_data_members().end())
      return get_first_non_anonymous_data_member(*it);
    break;
      }
 
  return var_decl_sptr();
}
 
/// In the context of a given class or union, this function returns
/// the data member that is located after a given data member.
///
/// @param klass the class or union to consider.
///
/// @param the data member to consider.
///
/// @return the data member that is located right after @p
/// data_member.
const var_decl_sptr
get_next_data_member(const class_or_union_sptr& klass,
             const var_decl_sptr &data_member)
{return get_next_data_member(klass.get(), data_member);}
 
/// Get the last data member of a class type.
///
/// @param klass the class type to consider.
var_decl_sptr
get_last_data_member(const class_or_union& klass)
{return klass.get_non_static_data_members().back();}
 
/// Get the last data member of a class type.
///
/// @param klass the class type to consider.
var_decl_sptr
get_last_data_member(const class_or_union* klass)
{return get_last_data_member(*klass);}
 
/// Get the last data member of a class type.
///
/// @param klass the class type to consider.
var_decl_sptr
get_last_data_member(const class_or_union_sptr &klass)
{return get_last_data_member(klass.get());}
 
/// Collect all the non-anonymous data members of a class or union type.
///
/// If the class contains any anonymous data member, this function
/// looks through it to collect the non-anonymous data members that it
/// contains.  The function also also looks through the base classes
/// of the current type.
///
/// @param cou the class or union type to consider.
///
/// @param dms output parameter.  This is populated by the function
/// with a map containing the non-anonymous data members that were
/// collected.  The key of the map is the name of the data member.
/// This is set iff the function returns true.
///
/// @return true iff at least one non-anonymous data member was
/// collected.
bool
collect_non_anonymous_data_members(const class_or_union* cou,
                   string_decl_base_sptr_map& dms)
{
  if (!cou)
    return false;
 
  bool result = false;
  class_decl* klass = is_class_type(cou);
  if (klass)
    // First look into base classes for data members.
    for (class_decl::base_spec_sptr base : klass->get_base_specifiers())
      result |= collect_non_anonymous_data_members(base->get_base_class().get(), dms);
 
  // Then look into our data members
  for (var_decl_sptr member : cou->get_non_static_data_members())
    {
      if (is_anonymous_data_member(member))
    {
      class_or_union_sptr cl = anonymous_data_member_to_class_or_union(member);
      ABG_ASSERT(cl);
      result |= collect_non_anonymous_data_members(cl.get(), dms);
    }
      else
    {
      dms[member->get_name()] = member;
      result = true;
    }
    }
  return true;
}
 
/// Collect all the non-anonymous data members of a class or union type.
///
/// If the class contains any anonymous data member, this function
/// looks through it to collect the non-anonymous data members that it
/// contains.  The function also also looks through the base classes
/// of the current type.
///
/// @param cou the class or union type to consider.
///
/// @param dms output parameter.  This is populated by the function
/// with a map containing the non-anonymous data members that were
/// collected.  The key of the map is the name of the data member.
/// This is set iff the function returns true.
///
/// @return true iff at least one non-anonymous data member was
/// collected.
bool
collect_non_anonymous_data_members(const class_or_union_sptr &cou, string_decl_base_sptr_map& dms)
{return collect_non_anonymous_data_members(cou.get(), dms);}
 
/// Test if a decl is an anonymous data member.
///
/// @param d the decl to consider.
///
/// @return true iff @p d is an anonymous data member.
bool
is_anonymous_data_member(const decl_base& d)
{return is_anonymous_data_member(&d);}
 
/// Test if a decl is an anonymous data member.
///
/// @param d the decl to consider.
///
/// @return the var_decl representing the data member iff @p d is an
/// anonymous data member.
const var_decl*
is_anonymous_data_member(const type_or_decl_base* d)
{
  if (const var_decl* v = is_data_member(d))
    {
      if (is_anonymous_data_member(v))
    return v;
    }
  return 0;
}
 
/// Test if a decl is an anonymous data member.
///
/// @param d the decl to consider.
///
/// @return a non-nil pointer to the @ref var_decl denoted by @p d if
/// it's an anonymous data member.  Otherwise returns a nil pointer.
const var_decl*
is_anonymous_data_member(const decl_base* d)
{
  if (const var_decl* v = is_data_member(d))
    {
      if (is_anonymous_data_member(v))
    return v;
    }
  return 0;
}
 
/// Test if a decl is an anonymous data member.
///
/// @param d the decl to consider.
///
/// @return a non-nil pointer to the @ref var_decl denoted by @p d if
/// it's an anonymous data member.  Otherwise returns a nil pointer.
var_decl_sptr
is_anonymous_data_member(const type_or_decl_base_sptr& d)
{
  if (var_decl_sptr v = is_data_member(d))
    {
      if (is_anonymous_data_member(v))
    return v;
    }
  return var_decl_sptr();
}
 
/// Test if a decl is an anonymous data member.
///
/// @param d the decl to consider.
///
/// @return a non-nil pointer to the @ref var_decl denoted by @p d if
/// it's an anonymous data member.  Otherwise returns a nil pointer.
var_decl_sptr
is_anonymous_data_member(const decl_base_sptr& d)
{
  if (var_decl_sptr v = is_data_member(d))
    return is_anonymous_data_member(v);
  return var_decl_sptr();
}
 
/// Test if a @ref var_decl is an anonymous data member.
///
/// @param d the @ref var_decl to consider.
///
/// @return a non-nil pointer to the @ref var_decl denoted by @p d if
/// it's an anonymous data member.  Otherwise returns a nil pointer.
var_decl_sptr
is_anonymous_data_member(const var_decl_sptr& d)
{
  if (is_anonymous_data_member(d.get()))
    return d;
  return var_decl_sptr();
}
 
/// Test if a @ref var_decl is an anonymous data member.
///
/// @param d the @ref var_decl to consider.
///
/// @return a non-nil pointer to the @ref var_decl denoted by @p d if
/// it's an anonymous data member.  Otherwise returns a nil pointer.
const var_decl*
is_anonymous_data_member(const var_decl* d)
{
  if (d && is_anonymous_data_member(*d))
    return d;
  return 0;
}
 
/// Test if a @ref var_decl is an anonymous data member.
///
/// @param d the @ref var_decl to consider.
///
/// @return true iff @p d is an anonymous data member.
bool