stable/doxygen/MachO_2Binary_8hpp_source.html

/* Copyright 2017 - 2024 R. Thomas

 * Copyright 2017 - 2024 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_MACHO_BINARY_H

#define LIEF_MACHO_BINARY_H


#include <vector>

#include <map>

#include <set>

#include <memory>


#include "LIEF/MachO/LoadCommand.hpp"

#include "LIEF/MachO/Header.hpp"

#include "LIEF/MachO/BindingInfoIterator.hpp"

#include "LIEF/MachO/BuildVersion.hpp"

#include "LIEF/MachO/Stub.hpp"

#include "LIEF/MachO/Builder.hpp"


#include "LIEF/visibility.h"

#include "LIEF/utils.hpp"


#include "LIEF/Abstract/Binary.hpp"


#include "LIEF/iterators.hpp"

#include "LIEF/errors.hpp"


namespace LIEF {


namespace objc {

class Metadata;

}


namespace MachO {


class BinaryParser;

class Builder;

class CodeSignature;

class CodeSignatureDir;

class DataInCode;

class DyldChainedFixups;

class DyldEnvironment;

class DyldExportsTrie;

class DyldInfo;

class DylibCommand;

class DylinkerCommand;

class DynamicSymbolCommand;

class EncryptionInfo;

class ExportInfo;

class FunctionStarts;

class Header;

class IndirectBindingInfo;

class LinkerOptHint;

class MainCommand;

class Parser;

class RPathCommand;

class Relocation;

class Routine;

class Section;

class SegmentCommand;

class SegmentSplitInfo;

class SourceVersion;

class SubClient;

class SubFramework;

class Symbol;

class SymbolCommand;

class ThreadCommand;

class TwoLevelHints;

class UUIDCommand;

class VersionMin;

class LIEF_API Binary : public LIEF::Binary  {


  friend class Parser;

  friend class BinaryParser;

  friend class Builder;

  friend class DyldInfo;

  friend class BindingInfoIterator;


  public:


  struct range_t {

    uint64_t start = 0;

    uint64_t end   = 0;


    uint64_t size() const {

      return end - start;

    }


    bool empty() const {

      return start == end;

    }


  };


  using commands_t = std::vector<std::unique_ptr<LoadCommand>>;

  using it_commands = ref_iterator<commands_t&, LoadCommand*>;

  using it_const_commands = const_ref_iterator<const commands_t&, LoadCommand*>;

  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 it_exported_symbols = filter_iterator<symbols_t&, Symbol*>;

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

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

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

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

  using it_sections = ref_iterator<sections_cache_t&>;

  using it_const_sections = const_ref_iterator<const sections_cache_t&>;

  using segments_cache_t = std::vector<SegmentCommand*>;

  using it_segments = ref_iterator<segments_cache_t&>;

  using it_const_segments = const_ref_iterator<const segments_cache_t&>;

  using libraries_cache_t = std::vector<DylibCommand*>;

  using it_libraries = ref_iterator<libraries_cache_t&>;

  using it_const_libraries = const_ref_iterator<const libraries_cache_t&>;

  using fileset_binaries_t = std::vector<std::unique_ptr<Binary>>;

  using it_fileset_binaries = ref_iterator<fileset_binaries_t&, Binary*>;

  using it_const_fileset_binaries = const_ref_iterator<const fileset_binaries_t&, Binary*>;


  struct KeyCmp {

    bool operator() (const Relocation* lhs, const Relocation* rhs) const;

  };


  using relocations_t = std::set<Relocation*, KeyCmp>;

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

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

  using it_rpaths = filter_iterator<commands_t&, RPathCommand*>;

  using it_const_rpaths = const_filter_iterator<const commands_t&, const RPathCommand*>;

  using it_sub_clients = filter_iterator<commands_t&, SubClient*>;

  using it_const_sub_clients = const_filter_iterator<const commands_t&, const SubClient*>;


  using it_bindings = iterator_range<BindingInfoIterator>;

  using stub_iterator = iterator_range<Stub::Iterator>;


  public:

  Binary(const Binary&) = delete;

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

  Header& header() {

    return header_;

  }