DyldInfo.hpp

Go to the documentation of this file.

/* 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_DYLD_INFO_COMMAND_H
#define LIEF_MACHO_DYLD_INFO_COMMAND_H
#include <string>
#include <set>
#include <vector>
#include <ostream>
#include <memory>
 
#include "LIEF/visibility.h"
#include "LIEF/span.hpp"
 
#include "LIEF/MachO/LoadCommand.hpp"
#include "LIEF/MachO/type_traits.hpp"
#include "LIEF/iterators.hpp"
 
namespace LIEF {
class vector_iostream;
class BinaryStream;
namespace MachO {
 
class Binary;
class BinaryParser;
class BindingInfoIterator;
class Builder;
class DyldBindingInfo;
class ExportInfo;
class LinkEdit;
class RelocationDyld;
 
namespace details {
struct dyld_info_command;
}
class LIEF_API DyldInfo : public LoadCommand {
 
  friend class BinaryParser;
  friend class Binary;
  friend class Builder;
  friend class LinkEdit;
  friend class BindingInfoIterator;
 
  public:  using info_t = std::pair<uint32_t, uint32_t>;
  using binding_info_t = std::vector<std::unique_ptr<DyldBindingInfo>>;
  using it_binding_info = ref_iterator<binding_info_t&, DyldBindingInfo*>;
  using it_const_binding_info = const_ref_iterator<const binding_info_t&, DyldBindingInfo*>;
  using export_info_t = std::vector<std::unique_ptr<ExportInfo>>;
  using it_export_info = ref_iterator<export_info_t&, ExportInfo*>;
  using it_const_export_info = const_ref_iterator<const export_info_t&, ExportInfo*>;
 
  enum class BINDING_ENCODING_VERSION {
    UNKNOWN = 0,
    V1,
    V2
  };
 
  enum class REBASE_TYPE: uint64_t  {
    POINTER         = 1u,
    TEXT_ABSOLUTE32 = 2u,
    TEXT_PCREL32    = 3u,
    THREADED        = 102u,
  };
 
  enum class REBASE_OPCODES: uint8_t {
    DONE                               = 0x00u, 
    SET_TYPE_IMM                       = 0x10u, 
    SET_SEGMENT_AND_OFFSET_ULEB        = 0x20u, 
    ADD_ADDR_ULEB                      = 0x30u, 
    ADD_ADDR_IMM_SCALED                = 0x40u, 
    DO_REBASE_IMM_TIMES                = 0x50u, 
    DO_REBASE_ULEB_TIMES               = 0x60u, 
    DO_REBASE_ADD_ADDR_ULEB            = 0x70u, 
    DO_REBASE_ULEB_TIMES_SKIPPING_ULEB = 0x80u  
  };
  enum class BIND_OPCODES: uint8_t {
    DONE                             = 0x00u, 
    SET_DYLIB_ORDINAL_IMM            = 0x10u, 
    SET_DYLIB_ORDINAL_ULEB           = 0x20u, 
    SET_DYLIB_SPECIAL_IMM            = 0x30u, 
    SET_SYMBOL_TRAILING_FLAGS_IMM    = 0x40u, 
    SET_TYPE_IMM                     = 0x50u, 
    SET_ADDEND_SLEB                  = 0x60u, 
    SET_SEGMENT_AND_OFFSET_ULEB      = 0x70u, 
    ADD_ADDR_ULEB                    = 0x80u, 
    DO_BIND                          = 0x90u, 
    DO_BIND_ADD_ADDR_ULEB            = 0xA0u, 
    DO_BIND_ADD_ADDR_IMM_SCALED      = 0xB0u, 
    DO_BIND_ULEB_TIMES_SKIPPING_ULEB = 0xC0u, 
    THREADED                         = 0xD0u,
 
    THREADED_APPLY                            = 0xD0u | 0x01u,
    THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB = 0xD0u | 0x00u,
  };

enum class BIND_SUBOPCODE_THREADED: uint8_t {

SET_BIND_ORDINAL_TABLE_SIZE_ULEB = 0x00u,

APPLY = 0x01u,

};

enum BIND_SYMBOL_FLAGS {

WEAK_IMPORT = 0x1u,

NON_WEAK_DEFINITION = 0x8u,

};

static constexpr auto OPCODE_MASK = uint32_t(0xF0);

static constexpr auto IMMEDIATE_MASK = uint32_t(0x0F);

DyldInfo();

DyldInfo(const details::dyld_info_command& dyld_info_cmd);

DyldInfo& operator=(DyldInfo other);

DyldInfo(const DyldInfo& copy);

void swap(DyldInfo& other) noexcept;

std::unique_ptr<LoadCommand> clone() const override {

return std::unique_ptr<DyldInfo>(new DyldInfo(*this));

}

~DyldInfo() override;

const info_t& rebase() const {

return rebase_;

}