ELF/Section.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_SECTION_H
#define LIEF_ELF_SECTION_H
 
#include <string>
#include <ostream>
#include <vector>
#include <memory>
 
#include "LIEF/utils.hpp"
#include "LIEF/visibility.h"
#include "LIEF/Abstract/Section.hpp"
 
#include "LIEF/ELF/enums.hpp"
#include "LIEF/iterators.hpp"
 
namespace LIEF {
class SpanStream;
namespace ELF {
 
namespace DataHandler {
class Handler;
}
 
class Segment;
class Parser;
class Binary;
class Builder;
class ExeLayout;
class ObjectFileLayout;
 
class LIEF_API Section : public LIEF::Section {
  friend class Parser;
  friend class Binary;
  friend class Builder;
  friend class ExeLayout;
  friend class ObjectFileLayout;
 
  public:
  using segments_t        = std::vector<Segment*>;
  using it_segments       = ref_iterator<segments_t&>;
  using it_const_segments = const_ref_iterator<const segments_t&>;
 
  static constexpr uint32_t MAX_SECTION_SIZE = 2_GB;
 
  enum class TYPE : uint64_t {
    SHT_NULL_           = 0,  
    PROGBITS            = 1,  
    SYMTAB              = 2,  
    STRTAB              = 3,  
    RELA                = 4,  
    HASH                = 5,  
    DYNAMIC             = 6,  
    NOTE                = 7,  
    NOBITS              = 8,  
    REL                 = 9,  
    SHLIB               = 10, 
    DYNSYM              = 11, 
    INIT_ARRAY          = 14, 
    FINI_ARRAY          = 15, 
    PREINIT_ARRAY       = 16, 
    GROUP               = 17, 
    SYMTAB_SHNDX        = 18, 
    RELR                = 19, 
 
    ANDROID_REL         = 0x60000001, 
    ANDROID_RELA        = 0x60000002, 
    LLVM_ADDRSIG        = 0x6fff4c03, 
    ANDROID_RELR        = 0x6fffff00, 
    GNU_ATTRIBUTES      = 0x6ffffff5, 
    GNU_HASH            = 0x6ffffff6, 
    GNU_VERDEF          = 0x6ffffffd, 
    GNU_VERNEED         = 0x6ffffffe, 
    GNU_VERSYM          = 0x6fffffff, 
 
    _ID_SHIFT_ = 32,
    _ARM_ID_ = 1LLU, _HEX_ID_ = 2LLU, _X86_64_ID_ = 2LLU,
    _MIPS_ID_ = 3LLU, _RISCV_ID_ = 4LLU,
 
    ARM_EXIDX           = 0x70000001U + (_ARM_ID_ << _ID_SHIFT_), 
    ARM_PREEMPTMAP      = 0x70000002U + (_ARM_ID_ << _ID_SHIFT_), 
    ARM_ATTRIBUTES      = 0x70000003U + (_ARM_ID_ << _ID_SHIFT_), 
    ARM_DEBUGOVERLAY    = 0x70000004U + (_ARM_ID_ << _ID_SHIFT_),
    ARM_OVERLAYSECTION  = 0x70000005U + (_ARM_ID_ << _ID_SHIFT_),
 
    HEX_ORDERED         = 0x70000000 + (_HEX_ID_ << _ID_SHIFT_), 
 
    /* this section based on their sizes */
    X86_64_UNWIND       = 0x70000001 + (_X86_64_ID_ << _ID_SHIFT_), 
 
    MIPS_REGINFO        = 0x70000006 + (_MIPS_ID_ << _ID_SHIFT_), 
    MIPS_OPTIONS        = 0x7000000d + (_MIPS_ID_ << _ID_SHIFT_), 
    MIPS_ABIFLAGS       = 0x7000002a + (_MIPS_ID_ << _ID_SHIFT_), 
 
    RISCV_ATTRIBUTES    = 0x70000003 + (_RISCV_ID_ << _ID_SHIFT_),
  };
 
  enum class FLAGS : uint64_t {
    NONE                 = 0x000000000,
    WRITE                = 0x000000001,  
    ALLOC                = 0x000000002,  
    EXECINSTR            = 0x000000004,  
    MERGE                = 0x000000010,  
    STRINGS              = 0x000000020,  
    INFO_LINK            = 0x000000040,  
    LINK_ORDER           = 0x000000080,  
    OS_NONCONFORMING     = 0x000000100,  
    GROUP                = 0x000000200,  
    TLS                  = 0x000000400,  
    COMPRESSED           = 0x000000800,
    GNU_RETAIN           = 0x000200000,
    EXCLUDE              = 0x080000000,
 
    _ID_SHIFT_ = 32,
    _XCORE_ID_ = 1LLU, _HEX_ID_ = 3LLU, _X86_64_ID_ = 2LLU,
    _MIPS_ID_  = 4LLU, _ARM_ID_ = 5LLU,
 
    XCORE_SHF_DP_SECTION = 0x010000000 + (_XCORE_ID_ << _ID_SHIFT_),
    XCORE_SHF_CP_SECTION = 0x020000000 + (_XCORE_ID_ << _ID_SHIFT_),
 
    X86_64_LARGE         = 0x010000000 + (_X86_64_ID_ << _ID_SHIFT_),
 
    HEX_GPREL            = 0x010000000 + (_HEX_ID_ << _ID_SHIFT_),
 
    MIPS_NODUPES         = 0x001000000 + (_MIPS_ID_ << _ID_SHIFT_),
    MIPS_NAMES           = 0x002000000 + (_MIPS_ID_ << _ID_SHIFT_),
    MIPS_LOCAL           = 0x004000000 + (_MIPS_ID_ << _ID_SHIFT_),
    MIPS_NOSTRIP         = 0x008000000 + (_MIPS_ID_ << _ID_SHIFT_),
    MIPS_GPREL           = 0x010000000 + (_MIPS_ID_ << _ID_SHIFT_),
    MIPS_MERGE           = 0x020000000 + (_MIPS_ID_ << _ID_SHIFT_),
    MIPS_ADDR            = 0x040000000 + (_MIPS_ID_ << _ID_SHIFT_),
    MIPS_STRING          = 0x080000000 + (_MIPS_ID_ << _ID_SHIFT_),
 
    ARM_PURECODE         = 0x020000000 + (_ARM_ID_  << _ID_SHIFT_),
  };
 
  static constexpr uint64_t FLAG_MASK = (uint64_t(1) << uint8_t(FLAGS::_ID_SHIFT_)) - 1;
  static constexpr uint64_t TYPE_MASK = (uint64_t(1) << uint8_t(TYPE::_ID_SHIFT_)) - 1;
 
  static TYPE type_from(uint32_t value, ARCH arch);
  static uint32_t to_value(TYPE type) {
    return static_cast<uint64_t>(type) & TYPE_MASK;
  }
 
  Section(const std::string& name, TYPE type = TYPE::PROGBITS) :
    LIEF::Section(name),
    type_{type}
  {}
 
  Section() = default;
  ~Section() override = default;
 
  Section& operator=(Section other) {
    swap(other);
    return *this;
  }
  Section(const Section& other);
  void swap(Section& other) noexcept;
 
  TYPE type() const {
    return type_;
  }
  span<const uint8_t> content() const override;
  void content(const std::vector<uint8_t>& data) override;
 
  void content(std::vector<uint8_t>&& data);
  uint64_t flags() const {
    return flags_;
  }

bool has(FLAGS flag) const;

bool has(const Segment& segment) const;

std::vector<FLAGS> flags_list() const;

uint64_t size() const override {

return size_;

}

void size(uint64_t size) override;

void offset(uint64_t offset) override;

uint64_t offset() const override {

return offset_;

}

uint64_t file_offset() const {

return this->offset();

}