latest/doxygen/ELF_2Binary_8hpp_source.html

/* Copyright 2017 - 2025 R. Thomas

 * Copyright 2017 - 2025 Quarkslab

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifndef LIEF_ELF_BINARY_H

#define LIEF_ELF_BINARY_H


#include <vector>

#include <memory>


#include "LIEF/visibility.h"

#include "LIEF/errors.hpp"

#include "LIEF/iterators.hpp"


#include "LIEF/Abstract/Binary.hpp"


#include "LIEF/ELF/Note.hpp"

#include "LIEF/ELF/DynamicEntry.hpp"

#include "LIEF/ELF/Header.hpp"

#include "LIEF/ELF/Section.hpp"

#include "LIEF/ELF/Segment.hpp"

#include "LIEF/ELF/Builder.hpp"


namespace LIEF {namespace ELF {


namespace DataHandler {

class Handler;

}

namespace DataHandler {…}


class ExeLayout;

class GnuHash;

class Layout;

class ObjectFileLayout;

class Parser;

class Relocation;

class Section;

class Segment;

class Symbol;

class SymbolVersion;

class SymbolVersionDefinition;

class SymbolVersionRequirement;

class DynamicEntryLibrary;

class SysvHash;

struct sizing_info_t;

class LIEF_API Binary : public LIEF::Binary {

  friend class Parser;

  friend class Builder;

  friend class ExeLayout;

  friend class Layout;

  friend class ObjectFileLayout;


  public:

  using string_list_t  = std::vector<std::string>;

  using notes_t = std::vector<std::unique_ptr<Note>>;

  using it_notes = ref_iterator<notes_t&, Note*>;

  using it_const_notes = const_ref_iterator<const notes_t&, const Note*>;

  using symbols_version_requirement_t = std::vector<std::unique_ptr<SymbolVersionRequirement>>;

  using it_symbols_version_requirement = ref_iterator<symbols_version_requirement_t&, SymbolVersionRequirement*>;

  using it_const_symbols_version_requirement = const_ref_iterator<const symbols_version_requirement_t&, const SymbolVersionRequirement*>;

  using symbols_version_definition_t = std::vector<std::unique_ptr<SymbolVersionDefinition>>;

  using it_symbols_version_definition       = ref_iterator<symbols_version_definition_t&, SymbolVersionDefinition*>;

  using it_const_symbols_version_definition = const_ref_iterator<const symbols_version_definition_t&, const SymbolVersionDefinition*>;

  using segments_t = std::vector<std::unique_ptr<Segment>>;

  using it_segments = ref_iterator<segments_t&, Segment*>;

  using it_const_segments = const_ref_iterator<const segments_t&, const Segment*>;

  using dynamic_entries_t = std::vector<std::unique_ptr<DynamicEntry>>;

  using it_dynamic_entries = ref_iterator<dynamic_entries_t&, DynamicEntry*>;

  using it_const_dynamic_entries = const_ref_iterator<const dynamic_entries_t&, const DynamicEntry*>;

  using symbols_version_t = std::vector<std::unique_ptr<SymbolVersion>>;

  using it_symbols_version = ref_iterator<symbols_version_t&, SymbolVersion*>;

  using it_const_symbols_version = const_ref_iterator<const symbols_version_t&, const SymbolVersion*>;

  using relocations_t = std::vector<std::unique_ptr<Relocation>>;

  using it_pltgot_relocations = filter_iterator<relocations_t&, Relocation*>;

  using it_const_pltgot_relocations = const_filter_iterator<const relocations_t&, const Relocation*>;

  using it_dynamic_relocations = filter_iterator<relocations_t&, Relocation*>;

  using it_const_dynamic_relocations = const_filter_iterator<const relocations_t&, const Relocation*>;

  using it_object_relocations = filter_iterator<relocations_t&, Relocation*>;

  using it_const_object_relocations = const_filter_iterator<const relocations_t&, const Relocation*>;

  using it_relocations = ref_iterator<relocations_t&, Relocation*>;

  using it_const_relocations = const_ref_iterator<const relocations_t&, const Relocation*>;

  using symbols_t = std::vector<std::unique_ptr<Symbol>>;

  using it_dynamic_symbols = ref_iterator<symbols_t&, Symbol*>;

  using it_const_dynamic_symbols = const_ref_iterator<const symbols_t&, const Symbol*>;

  using it_symtab_symbols = ref_iterator<symbols_t&, Symbol*>;

  using it_const_symtab_symbols = const_ref_iterator<const symbols_t&, const Symbol*>;

  using it_symbols = ref_iterator<std::vector<Symbol*>>;

  using it_const_symbols = const_ref_iterator<std::vector<Symbol*>>;

  using it_exported_symbols = filter_iterator<std::vector<Symbol*>>;

  using it_const_exported_symbols = const_filter_iterator<std::vector<Symbol*>>;

  using it_imported_symbols = filter_iterator<std::vector<Symbol*>>;

  using it_const_imported_symbols = const_filter_iterator<std::vector<Symbol*>>;

  using sections_t = std::vector<std::unique_ptr<Section>>;

  using it_sections = ref_iterator<sections_t&, Section*>;

  using it_const_sections = const_ref_iterator<const sections_t&, const Section*>;


  public:


  enum PHDR_RELOC {

    AUTO = 0,


    PIE_SHIFT,


    BSS_END,

    BINARY_END,

    SEGMENT_GAP,

  };

  enum PHDR_RELOC {…};


  public:

  Binary& operator=(const Binary& ) = delete;

  Binary(const Binary& copy) = delete;

  Header::CLASS type() const {

    return type_;

  }