Abstract/Binary.hpp

Go to the documentation of this file.

/* 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_ABSTRACT_BINARY_H
#define LIEF_ABSTRACT_BINARY_H
 
#include <vector>
#include <memory>
#include <unordered_map>
 
#include "LIEF/visibility.h"
#include "LIEF/Object.hpp"
#include "LIEF/iterators.hpp"
#include "LIEF/errors.hpp"
#include "LIEF/span.hpp"
 
#include "LIEF/Abstract/Header.hpp"
#include "LIEF/Abstract/Function.hpp"
 
#include "LIEF/asm/Instruction.hpp"
 
namespace llvm {
class MCInst;
}
namespace LIEF {
class Section;
class Relocation;
class Symbol;
 
class DebugInfo;
 
namespace assembly {
class Engine;
}
class LIEF_API Binary : public Object {
  public:
  enum class VA_TYPES {
    AUTO = 0, 
    RVA  = 1, 
    VA   = 2, 
  };

enum FORMATS {

UNKNOWN = 0,

ELF,

PE,

MACHO,

OAT,

};

using functions_t = std::vector<Function>;

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

using it_sections = ref_iterator<sections_t>;

using it_const_sections = const_ref_iterator<sections_t>;

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

using it_symbols = ref_iterator<symbols_t>;

using it_const_symbols = const_ref_iterator<symbols_t>;

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

using it_relocations = ref_iterator<relocations_t>;

using it_const_relocations = const_ref_iterator<relocations_t>;

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

public:

Binary();

Binary(FORMATS fmt);

~Binary() override;

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

Binary(const Binary&) = delete;

FORMATS format() const {

return format_;

}