abg-elf-reader.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// -*- Mode: C++ -*-
//
// Copyright (C) 2022-2023 Red Hat, Inc.
//
// Author: Dodji Seketeli
 
/// @file
///
/// This file contains the declarations for the @ref fe_iface a.k.a
/// "Front End Interface".
 
#ifndef __ABG_ELF_READER_H__
#define __ABG_ELF_READER_H__
 
#include <memory>
#include <string>
 
#include <elfutils/libdwfl.h>
 
#include "abg-fe-iface.h"
#include "abg-ir.h"
#include "abg-suppression.h"
 
namespace abigail
{
 
/// The namespace for the ELF Reader.
namespace elf
{
 
/// The kind of ELF file we are looking at.
enum elf_type : unsigned
{
  /// A normal executable binary
  ELF_TYPE_EXEC,
  /// A Position Independant Executable binary
  ELF_TYPE_PI_EXEC,
  /// A dynamic shared object, a.k.a shared library binary.
  ELF_TYPE_DSO,
  /// A relocatalbe binary.
  ELF_TYPE_RELOCATABLE,
  /// An unknown kind of binary.
  ELF_TYPE_UNKNOWN
};
 
/// This is the interface an ELF reader.
///
/// It knows how to open an ELF file, read its content and expose an
/// interface for its symbol table and other properties.
///
/// Note that the ABI corpus returned by the elf::read_corpus()
/// member function doesn't contain any type representation.  It only
/// contains the representations of the the ELF symbols found in the
/// ELF file.
///
/// To construct the type representations for the functions and global
/// variables present in the ELF file, please use the implementations
/// of the @ref elf_based_reader interface.  Those know how to read
/// the debug information from the ELF file to build type
/// representation in the @ref abigail::ir::corpus instance.
class reader : public fe_iface
{
  struct priv;
  priv *priv_;
 
 public:
 
  reader(const std::string& elf_path,
     const vector<char**>&  debug_info_roots,
     environment&       env);
 
  ~reader();
 
  virtual void
  initialize(const std::string& elf_path,
         const vector<char**>&  debug_info_roots);
 
  virtual void
  initialize(const std::string& elf_path);
 
  const vector<char**>&
  debug_info_root_paths() const;
 
  const Dwfl_Callbacks&
  dwfl_offline_callbacks() const;
 
  Dwfl_Callbacks&
  dwfl_offline_callbacks();
 
  Elf*
  elf_handle() const;
 
  const Dwarf*
  dwarf_debug_info() const;
 
  bool
  has_dwarf_debug_info() const;
 
  bool
  has_ctf_debug_info() const;
 
  bool
  has_btf_debug_info() const;
 
  const Dwarf*
  alternate_dwarf_debug_info() const;
 
  const string&
  alternate_dwarf_debug_info_path() const;
 
  bool
  refers_to_alt_debug_info(string& alt_di_path) const;
 
  const Elf_Scn*
  find_symbol_table_section() const;
 
  void
  reset_symbol_table_section();
 
  const Elf_Scn*
  find_ctf_section() const;
 
  const Elf_Scn*
  find_alternate_ctf_section() const;
 
  const Elf_Scn*
  find_btf_section() const;
 
  const vector<string>&
  dt_needed()const;
 
  const string&
  elf_architecture() const;
 
  symtab_reader::symtab_sptr&
  symtab() const;
 
  elf_symbol_sptr
  function_symbol_is_exported(GElf_Addr symbol_address) const;
 
  elf_symbol_sptr
  variable_symbol_is_exported(GElf_Addr symbol_address) const;
 
  elf_symbol_sptr
  function_symbol_is_exported(const string& name) const;
 
  elf_symbol_sptr
  variable_symbol_is_exported(const string& name) const;
 
  elf_symbol_sptr
  function_symbol_is_undefined(const string& name) const;
 
  elf_symbol_sptr
  variable_symbol_is_undefined(const string& name) const;
 
  void
  load_dt_soname_and_needed();
 
  void
  load_elf_architecture();
 
  void
  load_elf_properties();
 
  virtual ir::corpus_sptr
  read_corpus(status& status);
};//end class reader.
 
/// A convenience typedef for a smart pointer to a
/// elf::reader.
typedef shared_ptr<elf::reader> reader_sptr;
 
bool
get_soname_of_elf_file(const string& path, string &soname);
 
bool
get_type_of_elf_file(const string& path, elf_type& type);
} // end namespace elf.
} // end namespace abigail
 
#endif // __ABG_ELF_READER_H__