Segment.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_ELF_SEGMENT_H
#define LIEF_ELF_SEGMENT_H
 
#include <string>
#include <vector>
#include <ostream>
#include <memory>
 
#include "LIEF/Object.hpp"
#include "LIEF/visibility.h"
#include "LIEF/errors.hpp"
#include "LIEF/iterators.hpp"
#include "LIEF/span.hpp"
 
#include "LIEF/ELF/enums.hpp"
 
namespace LIEF {
class SpanStream;
 
namespace ELF {
namespace DataHandler {
class Handler;
}
 
class Parser;
class Binary;
class Section;
class Builder;
class LIEF_API Segment : public Object {
 
  friend class Parser;
  friend class Section;
  friend class Binary;
  friend class Builder;
 
  public:
  using sections_t        = std::vector<Section*>;
  using it_sections       = ref_iterator<sections_t&>;
  using it_const_sections = const_ref_iterator<const sections_t&>;
 
  static constexpr uint64_t PT_BIT = 33;
  static constexpr uint64_t PT_MASK = (uint64_t(1) << PT_BIT) - 1;
 
  static constexpr uint64_t PT_ARM      = uint64_t(1) << PT_BIT;
  static constexpr uint64_t PT_AARCH64  = uint64_t(2) << PT_BIT;
  static constexpr uint64_t PT_MIPS     = uint64_t(3) << PT_BIT;
  static constexpr uint64_t PT_RISCV    = uint64_t(4) << PT_BIT;
 
  enum class TYPE : uint64_t {
    UNKNOWN       = uint64_t(-1),
    PT_NULL_      = 0, 
    LOAD          = 1, 
    DYNAMIC       = 2, 
    INTERP        = 3, 
    NOTE          = 4, 
    SHLIB         = 5, 
    PHDR          = 6, 
    TLS           = 7, 
 
    GNU_EH_FRAME  = 0x6474e550,
 
    GNU_STACK     = 0x6474e551, 
    GNU_PROPERTY  = 0x6474e553, 
    GNU_RELRO     = 0x6474e552, 
 
    ARM_ARCHEXT   = 0x70000000 | PT_ARM, 
    ARM_EXIDX     = 0x70000001 | PT_ARM,
 
    AARCH64_MEMTAG_MTE = 0x70000002 | PT_AARCH64,
 
    MIPS_REGINFO  = 0x70000000 | PT_MIPS,  
    MIPS_RTPROC   = 0x70000001 | PT_MIPS,  
    MIPS_OPTIONS  = 0x70000002 | PT_MIPS,  
    MIPS_ABIFLAGS = 0x70000003 | PT_MIPS,  
 
    RISCV_ATTRIBUTES = 0x70000003 | PT_RISCV,
  };
 
  enum class FLAGS {
    NONE = 0,
    X    = 1,
    W    = 2,
    R    = 4,
  };
 
  static TYPE type_from(uint64_t value, ARCH arch);
  static uint64_t to_value(TYPE type) {
    return static_cast<uint64_t>(type) & PT_MASK;
  }
 
  static result<Segment> from_raw(const uint8_t* ptr, size_t size);
  static result<Segment> from_raw(const std::vector<uint8_t>& raw) {
    return from_raw(raw.data(), raw.size());
  }
 
  Segment() = default;
 
  ~Segment() override = default;
 
  Segment& operator=(Segment other);
  Segment(const Segment& other);
 
  Segment& operator=(Segment&&) = default;
  Segment(Segment&&) = default;
 
  void swap(Segment& other);
 
  bool is_load() const {
    return type() == TYPE::LOAD;
  }
 
  bool is_interpreter() const {
    return type() == TYPE::INTERP;
  }
 
  bool is_phdr() const {
    return type() == TYPE::PHDR;
  }
  TYPE type() const {
    return type_;
  }

FLAGS flags() const {

return FLAGS(flags_);

}