latest/doxygen/COFF_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_COFF_BINARY_H

#define LIEF_COFF_BINARY_H

#include "LIEF/visibility.h"

#include "LIEF/iterators.hpp"

#include "LIEF/span.hpp"


#include "LIEF/COFF/String.hpp"


#include "LIEF/asm/Instruction.hpp"


#include <memory>

#include <vector>

#include <unordered_map>


namespace LIEF {


namespace assembly {

class Engine;

}


namespace COFF {

class Header;

class Parser;

class Section;

class Relocation;

class Symbol;

class LIEF_API Binary {

  public:

  friend class Parser;

  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*>;

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

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

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

  using strings_table_t = std::vector<String>;

  using it_strings_table = ref_iterator<strings_table_t&>;

  using it_const_strings_table = const_ref_iterator<const strings_table_t&>;

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

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

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

  using instructions_it = iterator_range<assembly::Instruction::Iterator>;

  using it_functions = filter_iterator<symbols_t&, Symbol*>;

  using it_const_function = const_filter_iterator<const symbols_t&, const Symbol*>;

  const Header& header() const {

    return *header_;

  }