BigObjHeader.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_COFF_BIGOBJ_HEADER_H
#define LIEF_COFF_BIGOBJ_HEADER_H
#include <cstdint>
#include <array>
 
#include "LIEF/COFF/Header.hpp"
 
#include "LIEF/compiler_attributes.hpp"
#include "LIEF/visibility.h"
#include "LIEF/span.hpp"
 
namespace LIEF {
namespace COFF {

class LIEF_API BigObjHeader : public Header {
  public:
  static constexpr auto UUID_SZ = 16;
  BigObjHeader() :
    Header(KIND::BIGOBJ) {}
 
  static std::unique_ptr<BigObjHeader> create(BinaryStream& stream);
 
  BigObjHeader& operator=(const BigObjHeader&) = default;
  BigObjHeader(const BigObjHeader&) = default;
 
  BigObjHeader& operator=(BigObjHeader&&) = default;
  BigObjHeader(BigObjHeader&&) = default;
 
  std::unique_ptr<Header> clone() const override {
    return std::unique_ptr<Header>(new BigObjHeader(*this));
  }

  uint16_t version() const {
    return version_;
  }

  span<const uint8_t> uuid() const LIEF_LIFETIMEBOUND {
    return uuid_;
  }

  uint32_t sizeof_data() const {
    return sizeof_data_;
  }

  uint32_t flags() const {
    return flags_;
  }

  uint32_t metadata_size() const {
    return metadata_size_;
  }

  uint32_t metadata_offset() const {
    return metadata_offset_;
  }
 
  void version(uint16_t value) {
    version_ = value;
  }
 
  void sizeof_data(uint32_t value) {
    sizeof_data_ = value;
  }
 
  void flags(uint32_t value) {
    flags_ = value;
  }
 
  void metadata_size(uint32_t value) {
    metadata_size_ = value;
  }
 
  void metadata_offset(uint32_t value) {
    metadata_offset_ = value;
  }
 
  static bool classof(const Header* header) {
    return header->kind() == Header::KIND::BIGOBJ;
  }
 
  ~BigObjHeader() override = default;
 
  std::string to_string() const override;
 
  protected:
  uint16_t version_ = 0;
  std::array<uint8_t, UUID_SZ> uuid_ = {};
 
  uint32_t sizeof_data_ = 0;
  uint32_t flags_ = 0;
  uint32_t metadata_size_ = 0;
  uint32_t metadata_offset_ = 0;
};
 
}
}
#endif