DyldInfo.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2026 R. Thomas
 * Copyright 2017 - 2026 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/compiler_attributes.hpp"
#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_;
  }

  span<const uint8_t> rebase_opcodes() const LIEF_LIFETIMEBOUND {
    return rebase_opcodes_;
  }
  span<uint8_t> rebase_opcodes() LIEF_LIFETIMEBOUND {
    return rebase_opcodes_;
  }

  void rebase_opcodes(buffer_t raw);

  std::string show_rebases_opcodes() const;

  const info_t& bind() const {
    return bind_;
  }

  span<const uint8_t> bind_opcodes() const LIEF_LIFETIMEBOUND {
    return bind_opcodes_;
  }
  span<uint8_t> bind_opcodes() LIEF_LIFETIMEBOUND {
    return bind_opcodes_;
  }

  void bind_opcodes(buffer_t raw);

  std::string show_bind_opcodes() const;

  const info_t& weak_bind() const {
    return weak_bind_;
  }

  span<const uint8_t> weak_bind_opcodes() const LIEF_LIFETIMEBOUND {
    return weak_bind_opcodes_;
  }
  span<uint8_t> weak_bind_opcodes() LIEF_LIFETIMEBOUND {
    return weak_bind_opcodes_;
  }

  void weak_bind_opcodes(buffer_t raw);

  std::string show_weak_bind_opcodes() const;

  const info_t& lazy_bind() const {
    return lazy_bind_;
  }

  span<const uint8_t> lazy_bind_opcodes() const LIEF_LIFETIMEBOUND {
    return lazy_bind_opcodes_;
  }
  span<uint8_t> lazy_bind_opcodes() LIEF_LIFETIMEBOUND {
    return lazy_bind_opcodes_;
  }

  void lazy_bind_opcodes(buffer_t raw);

  std::string show_lazy_bind_opcodes() const;

  it_binding_info bindings() LIEF_LIFETIMEBOUND {
    return binding_info_;
  }
 
  it_const_binding_info bindings() const LIEF_LIFETIMEBOUND {
    return binding_info_;
  }

  const info_t& export_info() const {
    return export_;
  }

  it_export_info exports() LIEF_LIFETIMEBOUND {
    return export_info_;
  }
  it_const_export_info exports() const LIEF_LIFETIMEBOUND {
    return export_info_;
  }

  span<const uint8_t> export_trie() const LIEF_LIFETIMEBOUND {
    return export_trie_;
  }
  span<uint8_t> export_trie() LIEF_LIFETIMEBOUND {
    return export_trie_;
  }

  void export_trie(buffer_t raw);

  std::string show_export_trie() const;
 
  void rebase(const info_t& info) {
    rebase_ = info;
  }
  void bind(const info_t& info) {
    bind_ = info;
  }
  void weak_bind(const info_t& info) {
    weak_bind_ = info;
  }
  void lazy_bind(const info_t& info) {
    lazy_bind_ = info;
  }
  void export_info(const info_t& info) {
    export_ = info;
  }
 
  void set_rebase_offset(uint32_t offset) {
    rebase_ = {offset, std::get<1>(rebase())};
  }
  void set_rebase_size(uint32_t size) {
    rebase_ = {std::get<0>(rebase()), size};
  }
 
  void set_bind_offset(uint32_t offset) {
    bind_ = {offset, std::get<1>(bind())};
  }
  void set_bind_size(uint32_t size) {
    bind_ = {std::get<0>(bind()), size};
  }
 
  void set_weak_bind_offset(uint32_t offset) {
    weak_bind_ = {offset, std::get<1>(weak_bind())};
  }
  void set_weak_bind_size(uint32_t size) {
    weak_bind_ = {std::get<0>(weak_bind()), size};
  }
 
  void set_lazy_bind_offset(uint32_t offset) {
    lazy_bind_ = {offset, std::get<1>(lazy_bind())};
  }
  void set_lazy_bind_size(uint32_t size) {
    lazy_bind_ = {std::get<0>(lazy_bind()), size};
  }
 
  void set_export_offset(uint32_t offset) {
    export_ = {offset, std::get<1>(export_info())};
  }
 
  void set_export_size(uint32_t size) {
    export_ = {std::get<0>(export_info()), size};
  }
 
  ExportInfo* add(std::unique_ptr<ExportInfo> info) LIEF_LIFETIMEBOUND;
 
  void accept(Visitor& visitor) const override;
 
  std::ostream& print(std::ostream& os) const override;
 
  static bool classof(const LoadCommand* cmd) {
    const LoadCommand::TYPE type = cmd->command();
    return type == LoadCommand::TYPE::DYLD_INFO ||
           type == LoadCommand::TYPE::DYLD_INFO_ONLY;
  }
 
  private:
  using bind_container_t =
      std::set<DyldBindingInfo*,
               std::function<bool(DyldBindingInfo*, DyldBindingInfo*)>>;
 
  LIEF_LOCAL void show_bindings(std::ostream& os, span<const uint8_t> buffer,
                                bool is_lazy = false) const;
 
  LIEF_LOCAL void show_trie(std::ostream& output, std::string output_prefix,
                            BinaryStream& stream, uint64_t start, uint64_t end,
                            const std::string& prefix) const;
 
  LIEF_LOCAL DyldInfo& update_standard_bindings(const bind_container_t& bindings,
                                                vector_iostream& stream);
  LIEF_LOCAL DyldInfo&
      update_standard_bindings_v1(const bind_container_t& bindings,
                                  vector_iostream& stream);
  LIEF_LOCAL DyldInfo&
      update_standard_bindings_v2(const bind_container_t& bindings,
                                  std::vector<RelocationDyld*> rebases,
                                  vector_iostream& stream);
 
  LIEF_LOCAL DyldInfo& update_weak_bindings(const bind_container_t& bindings,
                                            vector_iostream& stream);
  LIEF_LOCAL DyldInfo& update_lazy_bindings(const bind_container_t& bindings,
                                            vector_iostream& stream);
 
  LIEF_LOCAL DyldInfo& update_rebase_info(vector_iostream& stream);
  LIEF_LOCAL DyldInfo& update_binding_info(vector_iostream& stream,
                                           details::dyld_info_command& cmd);
  LIEF_LOCAL DyldInfo& update_export_trie(vector_iostream& stream);
 
  info_t rebase_;
  span<uint8_t> rebase_opcodes_;
 
  info_t bind_;
  span<uint8_t> bind_opcodes_;
 
  info_t weak_bind_;
  span<uint8_t> weak_bind_opcodes_;
 
  info_t lazy_bind_;
  span<uint8_t> lazy_bind_opcodes_;
 
  info_t export_;
  span<uint8_t> export_trie_;
 
  export_info_t export_info_;
  binding_info_t binding_info_;
 
  BINDING_ENCODING_VERSION binding_encoding_version_ =
      BINDING_ENCODING_VERSION::UNKNOWN;
 
  Binary* binary_ = nullptr;
};
 
LIEF_API const char* to_string(DyldInfo::REBASE_TYPE e);
LIEF_API const char* to_string(DyldInfo::REBASE_OPCODES e);
LIEF_API const char* to_string(DyldInfo::BIND_OPCODES e);
LIEF_API const char* to_string(DyldInfo::BIND_SUBOPCODE_THREADED e);
 
 
}
}
#endif