// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// -*- Mode: C++ -*-
//
// Copyright (C) 2013-2022 Red Hat, Inc.

/// @file

#ifndef __ABG_IRFWD_H__
#define __ABG_IRFWD_H__

#include <stdint.h>
#include <cstddef>
#include <cstdlib>
#include <list>
#include <memory>
#include <ostream>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <utility> // for std::rel_ops, at least.
#include <vector>
#include "abg-interned-str.h"
#include "abg-hash.h"

/// Toplevel namespace for libabigail.
namespace abigail
{
/**
   @mainpage libabigail

   This is the API documentation of the Application Binary
   Interface Generic Analysis and Instrumentation Library, aka,
   <em>libabigail</em>.

   Check out <a href="http://sourceware.org/libabigail"> the project
   homepage</a>!

   The current libabigail source code can be browsed at
   http://sourceware.org/git/gitweb.cgi?p=libabigail.git

   It can be checked out with:
       <em>git clone git://sourceware.org/git/libabigail.git</em>

   The mailing list to send messages and patches to is
   libabigail@sourceware.org.

   You can hang out with libabigail developers and users on irc at
   irc://irc.oftc.net\#libabigail.
*/

// Inject some types.
using std::shared_ptr;
using std::weak_ptr;
using std::unordered_map;
using std::string;
using std::vector;

// Pull in relational operators.
using namespace std::rel_ops;

namespace ir
{

// Forward declarations for corpus.

class corpus;
typedef shared_ptr<corpus> corpus_sptr;

class corpus_group;
typedef shared_ptr<corpus_group> corpus_group_sptr;

// Forward declarations for ir.

class  ir_node_visitor;

struct ir_traversable_base;

/// Convenience typedef for a shared pointer to @ref
/// ir_traversable_base.
typedef shared_ptr<ir_traversable_base> ir_traversable_base_sptr;

class environment;
/// Convenience typedef for a shared pointer to an @ref environment
typedef shared_ptr<environment> environment_sptr;

class location;
class location_manager;

class type_or_decl_base;
/// A convenience typedef for a shared_ptr to @ref type_or_decl_base.
typedef shared_ptr<type_or_decl_base> type_or_decl_base_sptr;

class type_base;

// Convenience typedef for a shared pointer on a @ref type_base
typedef shared_ptr<type_base> type_base_sptr;

/// Convenience typedef for a weak pointer on a @ref type_base
typedef weak_ptr<type_base> type_base_wptr;

/// Convenience typedef for a weak pointer to a @ref corpus.
typedef weak_ptr<corpus> corpus_wptr;

class translation_unit;
/// Convenience typedef for a shared pointer on a @ref
/// translation_unit type.
typedef shared_ptr<translation_unit> translation_unit_sptr;
/// Convenience typedef for a map that associates a string to a
/// translation unit.
typedef unordered_map<string, translation_unit_sptr> string_tu_map_type;

/// A convenience typedef for a vector of type_base_wptr.
typedef vector<type_base_wptr> type_base_wptrs_type;

/// A convenience typedef for a map which key is an interned_string
/// and which value is a vector of type_base_wptr.
typedef unordered_map<interned_string,
		      type_base_wptrs_type,
		      hash_interned_string> istring_type_base_wptrs_map_type;

class decl_base;

// Convenience typedef for a smart pointer on @ref decl_base.
typedef shared_ptr<decl_base> decl_base_sptr;

class type_decl;
/// Convenience typedef for a shared pointer on a @ref type_decl.
typedef shared_ptr<type_decl> type_decl_sptr;


class typedef_decl;

/// Convenience typedef for a shared pointer on a @ref typedef_decl.
typedef shared_ptr<typedef_decl> typedef_decl_sptr;

/// Convenience typedef for a weak pointer on a @ref typedef_decl.
typedef weak_ptr<typedef_decl> typedef_decl_wptr;

class enum_type_decl;

/// Convenience typedef for shared pointer to a @ref enum_type_decl.
typedef shared_ptr<enum_type_decl> enum_type_decl_sptr;

/// Convenience typedef for a vector of @ref enum_type_decl_sptr
typedef vector<enum_type_decl_sptr> enums_type;

/// Convenience typedef for a weak pointer to a @ref decl_base.
typedef weak_ptr<decl_base> decl_base_wptr;

class class_or_union;

typedef shared_ptr<class_or_union> class_or_union_sptr;
typedef weak_ptr<class_or_union> class_or_union_wptr;

class scope_type_decl;

class class_decl;

/// Convenience typedef for a shared pointer on a @ref class_decl
typedef shared_ptr<class_decl> class_decl_sptr;

/// Convenience typedef for a vector of @ref class_decl_sptr
typedef vector<class_decl_sptr> classes_type;

/// Convenience typedef for a weak pointer on a @ref class_decl.
typedef weak_ptr<class_decl> class_decl_wptr;

class union_decl;

typedef shared_ptr<union_decl> union_decl_sptr;

class function_type;
/// Convenience typedef for a shared pointer on a @ref function_type
typedef shared_ptr<function_type> function_type_sptr;

/// Convenience typedef fo a vector of @ref function_type_sptr
typedef vector<function_type_sptr> function_types_type;

/// Convenience typedef for a weak pointer on a @ref function_type
typedef weak_ptr<function_type> function_type_wptr;

class method_type;

/// Convenience typedef for shared pointer to @ref method_type.
typedef shared_ptr<method_type> method_type_sptr;

class pointer_type_def;

/// Convenience typedef for a shared pointer on a @ref pointer_type_def
typedef shared_ptr<pointer_type_def> pointer_type_def_sptr;

class qualified_type_def;

typedef shared_ptr<qualified_type_def> qualified_type_def_sptr;

class reference_type_def;

/// Convenience typedef for a shared pointer on a @ref reference_type_def
typedef shared_ptr<reference_type_def> reference_type_def_sptr;

class array_type_def;

/// Convenience typedef for a shared pointer on a @ref array_type_def
typedef shared_ptr<array_type_def> array_type_def_sptr;

class subrange_type;

class dm_context_rel;

/// A convenience typedef for a shared pointer to dm_context_rel.
typedef shared_ptr<dm_context_rel> dm_context_rel_sptr;

class var_decl;

/// Convenience typedef for a shared pointer on a @ref var_decl
typedef shared_ptr<var_decl> var_decl_sptr;

/// Convenience typedef for a weak pointer on a @ref var_decl
typedef weak_ptr<var_decl> var_decl_wptr;

typedef unordered_map<interned_string,
		      var_decl*,
		      hash_interned_string> istring_var_decl_ptr_map_type;

class scope_decl;

/// Convenience typedef for a shared pointer on a @ref scope_decl.
typedef shared_ptr<scope_decl> scope_decl_sptr;

class function_decl;

/// Convenience typedef for a shared pointer on a @ref function_decl
typedef shared_ptr<function_decl> function_decl_sptr;

typedef unordered_map<interned_string,
		      function_decl*,
		      hash_interned_string> istring_function_decl_ptr_map_type;

class method_decl;

typedef shared_ptr<method_decl> method_decl_sptr;

class mem_fn_context_rel;

/// A convenience typedef for a shared pointer to @ref
/// mem_fn_context_rel.
typedef shared_ptr<mem_fn_context_rel> mem_fn_context_rel_sptr;

class namespace_decl;

/// Convenience typedef for a shared pointer on namespace_decl.
typedef shared_ptr<namespace_decl> namespace_decl_sptr;

class class_tdecl;

/// Convenience typedef for a shared pointer on a @ref class_tdecl
typedef shared_ptr<class_tdecl> class_tdecl_sptr;

class function_tdecl;

/// Convenience typedef for a shared pointer on a @ref function_tdecl
typedef shared_ptr<function_tdecl> function_tdecl_sptr;

class global_scope;

/// Convenience typedef for shared pointer on @ref global_scope.
typedef shared_ptr<global_scope> global_scope_sptr;

class node_visitor;

class template_decl;

/// Convenience typedef for a shared pointer to @ref template_decl
typedef shared_ptr<template_decl> template_decl_sptr;

/// Convenience typedef for a weak pointer to template_decl
typedef weak_ptr<template_decl> template_decl_wptr;

class template_parameter;

/// Convenience typedef for shared pointer to template parameter
typedef shared_ptr<template_parameter> template_parameter_sptr;

class non_type_tparameter;

/// Convenience typedef for shared pointer to @ref
/// non_type_template_parameter
typedef shared_ptr<non_type_tparameter> non_type_tparameter_sptr;

class type_tparameter;

class template_tparameter;

/// Convenience typedef for a shared_ptr to @ref template_tparameter.
typedef shared_ptr<template_tparameter> template_tparameter_sptr;

/// Convenience typedef for a shared pointer to @ref type_tparameter.
typedef shared_ptr<type_tparameter> type_tparameter_sptr;

class type_composition;

class member_function_template;
typedef shared_ptr<member_function_template> member_function_template_sptr;
typedef vector<member_function_template_sptr> member_function_templates;

class member_class_template;
typedef shared_ptr<member_class_template> member_class_template_sptr;
typedef vector<member_class_template_sptr> member_class_templates;

/// Convenience typedef for shared pointer to type_composition
typedef shared_ptr<type_composition> type_composition_sptr;

decl_base_sptr
add_decl_to_scope(decl_base_sptr, scope_decl*);

decl_base_sptr
add_decl_to_scope(decl_base_sptr, const scope_decl_sptr&);

const global_scope*
get_global_scope(const decl_base&);

const global_scope*
get_global_scope(const decl_base*);

const global_scope*
get_global_scope(const decl_base_sptr);

translation_unit*
get_translation_unit(const decl_base&);

translation_unit*
get_translation_unit(const decl_base*);

translation_unit*
get_translation_unit(const decl_base_sptr);

bool
is_global_scope(const scope_decl&);

const global_scope*
is_global_scope(const scope_decl*);

bool
is_global_scope(const scope_decl_sptr);

bool
is_at_global_scope(const decl_base&);

bool
is_at_global_scope(const decl_base_sptr);

bool
is_at_global_scope(const decl_base*);

class_or_union*
is_at_class_scope(const decl_base_sptr);

class_or_union*
is_at_class_scope(const decl_base*);

class_or_union*
is_at_class_scope(const decl_base&);

bool
is_at_template_scope(const decl_base_sptr);

bool
is_template_parameter(const decl_base_sptr);

function_decl*
is_function_decl(const type_or_decl_base*);

function_decl_sptr
is_function_decl(const type_or_decl_base_sptr&);

bool
is_function_decl(const type_or_decl_base&);

decl_base*
is_decl(const type_or_decl_base*);

decl_base_sptr
is_decl(const type_or_decl_base_sptr&);

decl_base*
is_decl_slow(const type_or_decl_base*);

decl_base_sptr
is_decl_slow(const type_or_decl_base_sptr&);

bool
is_type(const type_or_decl_base&);

type_base*
is_type(const type_or_decl_base*);

type_base_sptr
is_type(const type_or_decl_base_sptr& tod);

bool
is_anonymous_type(const type_base*);

bool
is_anonymous_type(const type_base_sptr&);

const type_decl*
is_type_decl(const type_or_decl_base*);

type_decl_sptr
is_type_decl(const type_or_decl_base_sptr&);

type_decl*
is_integral_type(const type_or_decl_base*);

type_decl_sptr
is_integral_type(const type_or_decl_base_sptr&);

typedef_decl_sptr
is_typedef(const type_or_decl_base_sptr);

const typedef_decl*
is_typedef(const type_base*);

typedef_decl*
is_typedef(type_base*);

enum_type_decl_sptr
is_compatible_with_enum_type(const type_base_sptr&);

enum_type_decl_sptr
is_compatible_with_enum_type(const decl_base_sptr&);

enum_type_decl_sptr
is_enum_type(const type_or_decl_base_sptr&);

const enum_type_decl*
is_enum_type(const type_or_decl_base*);

bool
is_class_type(const type_or_decl_base&);

class_decl*
is_class_type(const type_or_decl_base*);

class_decl_sptr
is_class_type(const type_or_decl_base_sptr&);

bool
is_declaration_only_class_or_union_type(const type_base *t);

bool
is_declaration_only_class_or_union_type(const type_base_sptr&);

class_or_union*
is_class_or_union_type(const type_or_decl_base*);

class_or_union_sptr
is_class_or_union_type(const type_or_decl_base_sptr&);

bool
is_union_type(const type_or_decl_base&);

union_decl*
is_union_type(const type_or_decl_base*);

union_decl_sptr
is_union_type(const type_or_decl_base_sptr&);

class_decl_sptr
is_compatible_with_class_type(const type_base_sptr&);

class_decl_sptr
is_compatible_with_class_type(const decl_base_sptr&);

pointer_type_def*
is_pointer_type(type_or_decl_base*);

const pointer_type_def*
is_pointer_type(const type_or_decl_base*);

pointer_type_def_sptr
is_pointer_type(const type_or_decl_base_sptr&);

reference_type_def*
is_reference_type(type_or_decl_base*);

const reference_type_def*
is_reference_type(const type_or_decl_base*);

reference_type_def_sptr
is_reference_type(const type_or_decl_base_sptr&);

const type_base*
is_void_pointer_type(const type_base*);

qualified_type_def*
is_qualified_type(const type_or_decl_base*);

qualified_type_def_sptr
is_qualified_type(const type_or_decl_base_sptr&);

function_type_sptr
is_function_type(const type_or_decl_base_sptr&);

function_type*
is_function_type(type_or_decl_base*);

const function_type*
is_function_type(const type_or_decl_base*);

method_type_sptr
is_method_type(const type_or_decl_base_sptr&);

const method_type*
is_method_type(const type_or_decl_base*);

method_type*
is_method_type(type_or_decl_base*);

class_or_union_sptr
look_through_decl_only_class(const class_or_union&);

class_or_union_sptr
look_through_decl_only_class(class_or_union_sptr);

class_or_union*
look_through_decl_only_class(class_or_union*);

enum_type_decl_sptr
look_through_decl_only_enum(const enum_type_decl&);

enum_type_decl_sptr
look_through_decl_only_enum(enum_type_decl_sptr);

decl_base_sptr
look_through_decl_only(const decl_base&);

decl_base*
look_through_decl_only(decl_base*);

decl_base_sptr
look_through_decl_only(const decl_base_sptr&);

var_decl*
is_var_decl(const type_or_decl_base*);

var_decl_sptr
is_var_decl(const type_or_decl_base_sptr&);

namespace_decl_sptr
is_namespace(const decl_base_sptr&);

namespace_decl*
is_namespace(const decl_base*);

bool
is_template_parm_composition_type(const decl_base_sptr);

bool
is_template_decl(const decl_base_sptr);

bool
is_function_template_pattern(const decl_base_sptr);


decl_base_sptr
insert_decl_into_scope(decl_base_sptr,
		       vector<decl_base_sptr >::iterator,
		       scope_decl*);

decl_base_sptr
insert_decl_into_scope(decl_base_sptr,
		       vector<decl_base_sptr >::iterator,
		       scope_decl_sptr);

bool
has_scope(const decl_base&);

bool
has_scope(const decl_base_sptr);

bool
is_member_decl(const decl_base_sptr);

bool
is_member_decl(const decl_base*);

bool
is_member_decl(const decl_base&);

scope_decl*
is_scope_decl(decl_base*);

scope_decl_sptr
is_scope_decl(const decl_base_sptr&);

bool
is_member_type(const type_base_sptr&);

bool
is_user_defined_type(const type_base*);

bool
is_user_defined_type(const type_base_sptr&);

void
remove_decl_from_scope(decl_base_sptr);

bool
get_member_is_static(const decl_base&);

bool
get_member_is_static(const decl_base*);

bool
get_member_is_static(const decl_base_sptr&);

void
set_member_is_static(decl_base&, bool);

void
set_member_is_static(const decl_base_sptr&, bool);

bool
is_data_member(const var_decl&);

var_decl*
is_data_member(const type_or_decl_base*);

bool
is_data_member(const var_decl*);

var_decl_sptr
is_data_member(const type_or_decl_base_sptr&);

bool
is_data_member(const var_decl_sptr);

var_decl_sptr
is_data_member(const decl_base_sptr&);

var_decl*
is_data_member(const decl_base *);

var_decl*
is_data_member(const decl_base *);

const var_decl_sptr
get_next_data_member(const class_or_union_sptr&, const var_decl_sptr&);

var_decl_sptr
get_last_data_member(const class_or_union_sptr&);

bool
is_anonymous_data_member(const decl_base&);

const var_decl*
is_anonymous_data_member(const type_or_decl_base*);

const var_decl*
is_anonymous_data_member(const decl_base*);

var_decl_sptr
is_anonymous_data_member(const type_or_decl_base_sptr&);

var_decl_sptr
is_anonymous_data_member(const decl_base_sptr&);

var_decl_sptr
is_anonymous_data_member(const var_decl_sptr&);

const var_decl*
is_anonymous_data_member(const var_decl*);

bool
is_anonymous_data_member(const var_decl&);

const var_decl_sptr
get_first_non_anonymous_data_member(const var_decl_sptr);

var_decl_sptr
find_data_member_from_anonymous_data_member(const var_decl_sptr&,
					    const string&);

class_or_union*
anonymous_data_member_to_class_or_union(const var_decl*);

class_or_union_sptr
anonymous_data_member_to_class_or_union(const var_decl_sptr&);

bool
scope_anonymous_or_typedef_named(const decl_base&);

bool
is_anonymous_or_typedef_named(const decl_base&);

const class_or_union_sptr
data_member_has_anonymous_type(const var_decl& d);

const class_or_union_sptr
data_member_has_anonymous_type(const var_decl* d);

const class_or_union_sptr
data_member_has_anonymous_type(const var_decl_sptr& d);

array_type_def*
is_array_type(const type_or_decl_base* decl);

array_type_def_sptr
is_array_type(const type_or_decl_base_sptr& decl);

array_type_def_sptr
is_array_of_qualified_element(const type_base_sptr&);

qualified_type_def_sptr
is_array_of_qualified_element(const array_type_def_sptr&);

array_type_def_sptr
is_typedef_of_array(const type_base_sptr&);

void
set_data_member_offset(var_decl_sptr, uint64_t);

uint64_t
get_data_member_offset(const var_decl&);

uint64_t
get_data_member_offset(const var_decl_sptr);

uint64_t
get_data_member_offset(const decl_base_sptr);

uint64_t
get_absolute_data_member_offset(const var_decl&);

bool
get_next_data_member_offset(const class_or_union_sptr&,
			    const var_decl_sptr&,
			    uint64_t&);

uint64_t
get_var_size_in_bits(const var_decl_sptr&);

void
set_data_member_is_laid_out(var_decl_sptr, bool);

bool
get_data_member_is_laid_out(const var_decl&);

bool
get_data_member_is_laid_out(const var_decl_sptr);

bool
is_member_function(const function_decl&);

bool
is_member_function(const function_decl*);

bool
is_member_function(const function_decl_sptr&);

bool
get_member_function_is_ctor(const function_decl&);

bool
get_member_function_is_ctor(const function_decl_sptr&);

void
set_member_function_is_ctor(const function_decl&, bool);

void
set_member_function_is_ctor(const function_decl_sptr&, bool);

bool
get_member_function_is_dtor(const function_decl&);

bool
get_member_function_is_dtor(const function_decl_sptr&);

void
set_member_function_is_dtor(function_decl&, bool);

void
set_member_function_is_dtor(const function_decl_sptr&, bool);

bool
get_member_function_is_const(const function_decl&);

bool
get_member_function_is_const(const function_decl_sptr&);

void
set_member_function_is_const(function_decl&, bool);

void
set_member_function_is_const(const function_decl_sptr&, bool);

bool
member_function_has_vtable_offset(const function_decl&);

ssize_t
get_member_function_vtable_offset(const function_decl&);

ssize_t
get_member_function_vtable_offset(const function_decl_sptr&);

void
set_member_function_vtable_offset(const function_decl& f,
				  ssize_t s);

void
set_member_function_vtable_offset(const function_decl_sptr &f,
				  ssize_t s);

bool
get_member_function_is_virtual(const function_decl&);

bool
get_member_function_is_virtual(const function_decl_sptr&);

bool
get_member_function_is_virtual(const function_decl*);

void
set_member_function_is_virtual(function_decl&, bool);

void
set_member_function_is_virtual(const function_decl_sptr&, bool);

type_base_sptr
strip_typedef(const type_base_sptr);

decl_base_sptr
strip_useless_const_qualification(const qualified_type_def_sptr t);

void
strip_redundant_quals_from_underyling_types(const qualified_type_def_sptr&);

type_base_sptr
peel_typedef_type(const type_base_sptr&);

const type_base*
peel_typedef_type(const type_base*);

type_base_sptr
peel_pointer_type(const type_base_sptr&);

const type_base*
peel_pointer_type(const type_base*);

type_base_sptr
peel_reference_type(const type_base_sptr&);

const type_base*
peel_reference_type(const type_base*);

const type_base_sptr
peel_array_type(const type_base_sptr&);

const type_base*
peel_array_type(const type_base*);

const type_base*
peel_qualified_type(const type_base*);

const type_base_sptr
peel_qualified_type(const type_base_sptr&);

type_base*
peel_qualified_or_typedef_type(const type_base* type);

type_base_sptr
peel_qualified_or_typedef_type(const type_base_sptr &type);

type_base_sptr
peel_typedef_pointer_or_reference_type(const type_base_sptr);

type_base*
peel_typedef_pointer_or_reference_type(const type_base* type);

type_base*
peel_typedef_pointer_or_reference_type(const type_base* type,
				       bool peel_qual_type);

type_base*
peel_pointer_or_reference_type(const type_base *type,
			       bool peel_qualified_type = true);

array_type_def_sptr
clone_array(const array_type_def_sptr& array);

typedef_decl_sptr
clone_typedef(const typedef_decl_sptr& t);

qualified_type_def_sptr
clone_qualified_type(const qualified_type_def_sptr& t);

type_base_sptr
clone_array_tree(const type_base_sptr t);

string
get_name(const type_or_decl_base*, bool qualified = true);

string
get_name(const type_or_decl_base_sptr&,
	 bool qualified = true);

location
get_location(const type_base_sptr& type);

location
get_location(const decl_base_sptr& decl);

string
build_qualified_name(const scope_decl* scope, const string& name);

string
build_qualified_name(const scope_decl* scope,
		     const type_base_sptr& type);

scope_decl*
get_type_scope(type_base*);

scope_decl*
get_type_scope(const type_base_sptr&);

interned_string
get_type_name(const type_base_sptr&,
	      bool qualified = true,
	      bool internal = false);

interned_string
get_type_name(const type_base*,
	      bool qualified = true,
	      bool internal = false);

interned_string
get_type_name(const type_base&,
	      bool qualified = true,
	      bool internal = false);

interned_string
get_name_of_pointer_to_type(const type_base& pointed_to_type,
			    bool qualified = true,
			    bool internal = false);

interned_string
get_name_of_reference_to_type(const type_base& pointed_to_type,
			      bool lvalue_reference = false,
			      bool qualified = true,
			      bool internal = false);

interned_string
get_function_type_name(const function_type_sptr&,
		       bool internal = false);

interned_string
get_function_type_name(const function_type*, bool internal = false);

interned_string
get_function_type_name(const function_type&, bool internal = false);

interned_string
get_method_type_name(const method_type_sptr&, bool internal = false);

interned_string
get_method_type_name(const method_type*, bool internal = false);

interned_string
get_method_type_name(const method_type&, bool internal = false);

string
get_pretty_representation(const decl_base*, bool internal = false);

string
get_pretty_representation(const type_base*, bool internal = false);

string
get_pretty_representation(const type_or_decl_base*, bool internal = false);

string
get_pretty_representation(const type_or_decl_base_sptr&,
			  bool internal = false);

string
get_pretty_representation(const decl_base_sptr&, bool internal = false);

string
get_pretty_representation(const type_base_sptr&, bool internal = false);

string
get_pretty_representation(const function_type&, bool internal = false);

string
get_pretty_representation(const function_type*, bool internal = false);

string
get_pretty_representation(const function_type_sptr&,
			  bool internal = false);

string
get_pretty_representation(const method_type&, bool internal = false);

string
get_pretty_representation(const method_type*, bool internal = false);

string
get_pretty_representation(const method_type_sptr&,
			  bool internal = false);

string
get_class_or_union_flat_representation(const class_or_union& cou,
				       const string& indent,
				       bool one_line,
				       bool internal,
				       bool qualified_name = true);

string
get_class_or_union_flat_representation(const class_or_union* cou,
				       const string& indent,
				       bool one_line,
				       bool internal,
				       bool qualified_name = true);

string
get_class_or_union_flat_representation(const class_or_union_sptr& cou,
				       const string& indent,
				       bool one_line,
				       bool internal,
				       bool qualified_name = true);

string
get_debug_representation(const type_or_decl_base*);

var_decl_sptr
get_data_member(class_or_union *, const char*);

var_decl_sptr
get_data_member(type_base *clazz, const char* member_name);

const location&
get_natural_or_artificial_location(const decl_base*);

const location&
get_artificial_or_natural_location(const decl_base*);

type_or_decl_base*
debug(const type_or_decl_base* artifact);

type_base*
debug(const type_base* artifact);

decl_base*
debug(const decl_base* artifact);

bool
debug_equals(const type_or_decl_base *l, const type_or_decl_base *r);

bool
odr_is_relevant(const type_or_decl_base&);

const decl_base*
get_type_declaration(const type_base*);

decl_base*
get_type_declaration(type_base*);

decl_base_sptr
get_type_declaration(const type_base_sptr);

bool
types_are_compatible(const type_base_sptr,
		     const type_base_sptr);

bool
types_are_compatible(const decl_base_sptr,
		     const decl_base_sptr);

const scope_decl*
get_top_most_scope_under(const decl_base*,
			 const scope_decl*);

const scope_decl*
get_top_most_scope_under(const decl_base_sptr,
			 const scope_decl*);

const scope_decl*
get_top_most_scope_under(const decl_base_sptr,
			 const scope_decl_sptr);

void
fqn_to_components(const std::string&,
		  std::list<string>&);

string
components_to_type_name(const std::list<string>&);

type_decl_sptr
lookup_basic_type(const type_decl&, const translation_unit&);

type_decl_sptr
lookup_basic_type(const interned_string&, const translation_unit&);

type_decl_sptr
lookup_basic_type(const string&, const translation_unit&);

type_decl_sptr
lookup_basic_type(const type_decl&, const corpus&);

type_decl_sptr
lookup_basic_type(const string&, const corpus&);

type_decl_sptr
lookup_basic_type(const interned_string&, const corpus&);

type_decl_sptr
lookup_basic_type_per_location(const interned_string&, const corpus&);

type_decl_sptr
lookup_basic_type_per_location(const string&, const corpus&);

class_decl_sptr
lookup_class_type(const class_decl&, const translation_unit&);

class_decl_sptr
lookup_class_type(const interned_string&, const translation_unit&);

class_decl_sptr
lookup_class_type(const string&, const translation_unit&);

class_decl_sptr
lookup_class_type(const class_decl&, const corpus&);

class_decl_sptr
lookup_class_type(const interned_string&, const corpus&);

const type_base_wptrs_type*
lookup_class_types(const interned_string&, const corpus&);

bool
lookup_decl_only_class_types(const interned_string&,
			     const corpus&,
			     type_base_wptrs_type&);

const type_base_wptrs_type*
lookup_class_types(const string&, const corpus&);

class_decl_sptr
lookup_class_type_per_location(const interned_string&, const corpus&);

class_decl_sptr
lookup_class_type_per_location(const string&, const corpus&);

class_decl_sptr
lookup_class_type(const string&, const corpus&);

class_decl_sptr
lookup_class_type_through_scopes(const std::list<string>&,
				 const translation_unit&);

union_decl_sptr
lookup_union_type(const interned_string&, const translation_unit&);

union_decl_sptr
lookup_union_type(const interned_string&, const corpus&);

union_decl_sptr
lookup_union_type_per_location(const interned_string&, const corpus&);

union_decl_sptr
lookup_union_type_per_location(const string&, const corpus&);

union_decl_sptr
lookup_union_type(const string&, const corpus&);

enum_type_decl_sptr
lookup_enum_type(const enum_type_decl&, const translation_unit&);

enum_type_decl_sptr
lookup_enum_type(const string&, const translation_unit&);

enum_type_decl_sptr
lookup_enum_type(const enum_type_decl&, const corpus&);

enum_type_decl_sptr
lookup_enum_type(const string&, const corpus&);

enum_type_decl_sptr
lookup_enum_type(const interned_string&, const corpus&);

const type_base_wptrs_type*
lookup_enum_types(const interned_string&, const corpus&);

const type_base_wptrs_type*
lookup_enum_types(const string&, const corpus&);

enum_type_decl_sptr
lookup_enum_type_per_location(const interned_string&, const corpus&);

enum_type_decl_sptr
lookup_enum_type_per_location(const string&, const corpus&);

typedef_decl_sptr
lookup_typedef_type(const typedef_decl&, const translation_unit&);

typedef_decl_sptr
lookup_typedef_type(const typedef_decl&, const corpus&);

typedef_decl_sptr
lookup_typedef_type(const interned_string& type_name,
		    const translation_unit& tu);

typedef_decl_sptr
lookup_typedef_type(const string& type_name, const translation_unit& tu);

typedef_decl_sptr
lookup_typedef_type(const interned_string&, const corpus&);

typedef_decl_sptr
lookup_typedef_type_per_location(const interned_string&, const corpus &);

typedef_decl_sptr
lookup_typedef_type_per_location(const string&, const corpus &);

typedef_decl_sptr
lookup_typedef_type(const string&, const corpus&);

type_base_sptr
lookup_class_or_typedef_type(const string&, const translation_unit&);

type_base_sptr
lookup_class_typedef_or_enum_type(const string&, const translation_unit&);

type_base_sptr
lookup_class_or_typedef_type(const string&, const corpus&);

type_base_sptr
lookup_class_typedef_or_enum_type(const string&, const corpus&);

qualified_type_def_sptr
lookup_qualified_type(const qualified_type_def&, const translation_unit&);

qualified_type_def_sptr
lookup_qualified_type(const string&, const translation_unit&);

qualified_type_def_sptr
lookup_qualified_type(const qualified_type_def&, const corpus&);

qualified_type_def_sptr
lookup_qualified_type(const interned_string&, const corpus&);

pointer_type_def_sptr
lookup_pointer_type(const pointer_type_def&, const translation_unit&);

pointer_type_def_sptr
lookup_pointer_type(const string&, const translation_unit&);

pointer_type_def_sptr
lookup_pointer_type(const type_base_sptr& pointed_to_type,
		    const translation_unit& tu);

pointer_type_def_sptr
lookup_pointer_type(const pointer_type_def&, const corpus&);

pointer_type_def_sptr
lookup_pointer_type(const interned_string&, const corpus&);

const reference_type_def_sptr
lookup_reference_type(const reference_type_def&, const translation_unit&);

const reference_type_def_sptr
lookup_reference_type(const string&, const translation_unit&);

const reference_type_def_sptr
lookup_reference_type(const type_base_sptr& pointed_to_type,
		      bool lvalue_reference,
		      const translation_unit& tu);

reference_type_def_sptr
lookup_reference_type(const reference_type_def&, const corpus&);

reference_type_def_sptr
lookup_reference_type(const interned_string&, const corpus&);

array_type_def_sptr
lookup_array_type(const array_type_def&, const translation_unit&);

array_type_def_sptr
lookup_array_type(const string&, const translation_unit&);

array_type_def_sptr
lookup_array_type(const array_type_def&, const corpus&);

array_type_def_sptr
lookup_array_type(const interned_string&, const corpus&);

function_type_sptr
lookup_function_type(const string&,
		     const translation_unit&);

function_type_sptr
lookup_function_type(const interned_string&,
		     const translation_unit&);

function_type_sptr
lookup_function_type(const function_type&,
		     const translation_unit&);

function_type_sptr
lookup_function_type(const function_type_sptr&,
		     const translation_unit&);

function_type_sptr
lookup_function_type(const function_type&, const corpus&);

function_type_sptr
lookup_function_type(const function_type_sptr&, const corpus&);

function_type_sptr
lookup_function_type(const function_type&, const corpus&);

function_type_sptr
lookup_function_type(const interned_string&, const corpus&);

type_base_sptr
lookup_type(const string&, const translation_unit&);

const type_base_sptr
lookup_type(const type_base_sptr, const translation_unit&);

type_base_sptr
lookup_type(const interned_string&, const corpus&);

type_base_sptr
lookup_type_per_location(const interned_string&, const corpus&);

type_base_sptr
lookup_type(const type_base&, const corpus&);

type_base_sptr
lookup_type(const type_base_sptr&, const corpus&);

type_base_sptr
lookup_type_through_scopes(const std::list<string>&,
			   const translation_unit&);

type_base_sptr
lookup_type_through_translation_units(const string&, const corpus&);

type_base_sptr
lookup_type_from_translation_unit(const string& type_name,
				  const string& tu_path,
				  const corpus& corp);

function_type_sptr
lookup_or_synthesize_fn_type(const function_type_sptr&,
			     const corpus&);

type_base_sptr
synthesize_type_from_translation_unit(const type_base_sptr&,
				      translation_unit&);

function_type_sptr
synthesize_function_type_from_translation_unit(const function_type&,
					       translation_unit&);

const type_base_sptr
lookup_type_in_scope(const string&,
		     const scope_decl_sptr&);

const type_base_sptr
lookup_type_in_scope(const std::list<string>&,
		     const scope_decl_sptr&);

const decl_base_sptr
lookup_var_decl_in_scope(const string&,
			 const scope_decl_sptr&);

const decl_base_sptr
lookup_var_decl_in_scope(const std::list<string>&,
			 const scope_decl_sptr&);

string
demangle_cplus_mangled_name(const string&);

type_base_sptr
type_or_void(const type_base_sptr, const environment&);

type_base_sptr
canonicalize(type_base_sptr);

type_base*
type_has_non_canonicalized_subtype(type_base_sptr t);

bool
type_has_sub_type_changes(type_base_sptr t_v1,
			  type_base_sptr t_v2);

void
keep_type_alive(type_base_sptr t);

size_t
hash_type(const type_base *t);

size_t
hash_type_or_decl(const type_or_decl_base *);

size_t
hash_type_or_decl(const type_or_decl_base_sptr &);

bool
is_non_canonicalized_type(const type_base *);

bool
is_non_canonicalized_type(const type_base_sptr&);

/// For a given type, return its exemplar type.
///
/// For a given type, its exemplar type is either its canonical type
/// or the canonical type of the definition type of a given
/// declaration-only type.  If the neither of those two types exist,
/// then the exemplar type is the given type itself.
///
/// @param type the input to consider.
///
/// @return the exemplar type.
type_base*
get_exemplar_type(const type_base* type);

bool
function_decl_is_less_than(const function_decl&f, const function_decl &s);

bool
types_have_similar_structure(const type_base_sptr& first,
			     const type_base_sptr& second,
			     bool indirect_type = false);

bool
types_have_similar_structure(const type_base* first,
			     const type_base* second,
			     bool indirect_type = false);

string
build_internal_underlying_enum_type_name(const string &base_name,
					 bool is_anonymous,
					 uint64_t size);

} // end namespace ir

using namespace abigail::ir;

namespace suppr
{
class suppression_base;

/// Convenience typedef for a shared pointer to a @ref suppression.
typedef shared_ptr<suppression_base> suppression_sptr;

/// Convenience typedef for a vector of @ref suppression_sptr
typedef vector<suppression_sptr> suppressions_type;

} // end namespace suppr

namespace symtab_reader
{

class symtab;
/// Convenience typedef for a shared pointer to a @ref symtab
typedef std::shared_ptr<symtab> symtab_sptr;

} // end namespace symtab_reader

void
dump(const decl_base_sptr, std::ostream&);

void
dump(const decl_base_sptr);

void
dump(const type_base_sptr, std::ostream&);

void
dump(const type_base_sptr);

void
dump(const var_decl_sptr, std::ostream&);

void
dump(const var_decl_sptr);

void
dump(const translation_unit&, std::ostream&);

void
dump(const translation_unit&);

void
dump(const translation_unit_sptr, std::ostream&);

void
dump(const translation_unit_sptr);

void
dump_decl_location(const decl_base&);

void
dump_decl_location(const decl_base*);

void
dump_decl_location(const decl_base_sptr&);

#ifndef ABG_ASSERT
/// This is a wrapper around the 'assert' glibc call.  It allows for
/// its argument to have side effects, so that it keeps working when
/// the code of libabigail is compiled with the NDEBUG macro defined.
#define ABG_ASSERT(cond) do {({bool __abg_cond__ = bool(cond); assert(__abg_cond__); !!__abg_cond__;});} while (false)
#endif

} // end namespace abigail
#endif // __ABG_IRFWD_H__