MachO/Symbol.hpp

/* 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_SYMBOL_H
#define LIEF_MACHO_SYMBOL_H
 
#include <ostream>
 
#include "LIEF/visibility.h"
 
#include "LIEF/Abstract/Symbol.hpp"
 
#include "LIEF/MachO/LoadCommand.hpp"
 
namespace LIEF {
namespace MachO {
 
class BinaryParser;
class BindingInfo;
class ExportInfo;
class DylibCommand;
class Binary;
 
namespace details {
struct nlist_32;
struct nlist_64;
}
 
class LIEF_API Symbol : public LIEF::Symbol {
 
  friend class BinaryParser;
  friend class Binary;
 
  public:
 
  enum class CATEGORY : uint32_t {
    NONE = 0,
    LOCAL,
    EXTERNAL,
    UNDEFINED,
 
    INDIRECT_ABS,
    INDIRECT_LOCAL,
  };
 
  enum class ORIGIN : uint32_t {
    UNKNOWN     = 0,
    DYLD_EXPORT = 1,
    DYLD_BIND   = 2, 
    LC_SYMTAB   = 3,
  };
 
  enum class TYPE : uint32_t{
    UNDEFINED     = 0x0u, 
    ABSOLUTE_SYM  = 0x2u, 
    SECTION       = 0xeu, 
    PREBOUND      = 0xcu, 
    INDIRECT      = 0xau  
  };
 
  static constexpr uint32_t TYPE_MASK = 0x0e;
 
  Symbol() = default;
 
  Symbol(const details::nlist_32& cmd);
  Symbol(const details::nlist_64& cmd);
 
  Symbol& operator=(Symbol other);
  Symbol(const Symbol& other);
  void swap(Symbol& other) noexcept;
 
  ~Symbol() override = default;
 
  uint8_t raw_type() const {
    return type_;
  }
 
  TYPE type() const {
    return TYPE(type_ & TYPE_MASK);
  }
 
  uint8_t numberof_sections() const {
    return numberof_sections_;
  }
 
  uint16_t description() const {
    return description_;
  }
 
  bool has_export_info() const {
    return export_info() != nullptr;
  }
 
  const ExportInfo* export_info() const {
    return export_info_;
  }
  ExportInfo* export_info() {
    return export_info_;
  }
 
  bool has_binding_info() const {
    return binding_info() != nullptr;
  }
 
  const BindingInfo* binding_info() const {
    return binding_info_;
  }
 
  BindingInfo* binding_info() {
    return binding_info_;
  }
 
  std::string demangled_name() const;
 
  bool is_external() const {
    return type() == TYPE::UNDEFINED;
  }
 
  const DylibCommand* library() const {
    return library_;
  }
 
  DylibCommand* library() {
    return library_;
  }
 
  ORIGIN origin() const {
    return origin_;
  }
 
  CATEGORY category() const {
    return category_;
  }
 
  void raw_type(uint8_t type) {
    type_ = type;
  }
  void numberof_sections(uint8_t nbsections) {
    numberof_sections_ = nbsections;
  }
  void description(uint16_t desc) {
    description_ = desc;
  }
 
  void accept(Visitor& visitor) const override;
 
  LIEF_API friend std::ostream& operator<<(std::ostream& os, const Symbol& symbol);
 
  static const Symbol& indirect_abs();
  static const Symbol& indirect_local();
 
  private:
  Symbol(CATEGORY cat) :
    category_(cat)
  {}
  void library(DylibCommand& library) {
    this->library_ = &library;
  }
 
  uint8_t type_ = 0;
  uint8_t numberof_sections_ = 0;
  uint16_t description_ = 0;
 
  BindingInfo* binding_info_ = nullptr;
  ExportInfo* export_info_ = nullptr;
 
  DylibCommand* library_ = nullptr;
 
  ORIGIN origin_ = ORIGIN::UNKNOWN;
  CATEGORY category_ = CATEGORY::NONE;
};
 
LIEF_API const char* to_string(Symbol::ORIGIN e);
LIEF_API const char* to_string(Symbol::CATEGORY e);
LIEF_API const char* to_string(Symbol::TYPE e);
 
}
}
#endif