section.hpp

//===- include/pstore/mcrepo/section.hpp ------------------*- mode: C++ -*-===//
//*                _   _              *
//*  ___  ___  ___| |_(_) ___  _ __   *
//* / __|/ _ \/ __| __| |/ _ \| '_ \  *
//* \__ \  __/ (__| |_| | (_) | | | | *
//* |___/\___|\___|\__|_|\___/|_| |_| *
//*                                   *
//===----------------------------------------------------------------------===//
//
// Part of the pstore project, under the Apache License v2.0 with LLVM Exceptions.
// See https://github.com/SNSystems/pstore/blob/master/LICENSE.txt for license
// information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef PSTORE_MCREPO_SECTION_HPP
#define PSTORE_MCREPO_SECTION_HPP

#include <cassert>
#include <cstdint>
#include <cstdlib>
#include <iosfwd>
#include <type_traits>

#include "pstore/support/assert.hpp"

namespace pstore {
    namespace repo {

#define PSTORE_MCREPO_SECTION_KINDS                                                                \
    X (text)                                                                                       \
    X (data)                                                                                       \
    X (bss)                                                                                        \
    X (rel_ro)                                                                                     \
    X (mergeable_1_byte_c_string)                                                                  \
    X (mergeable_2_byte_c_string)                                                                  \
    X (mergeable_4_byte_c_string)                                                                  \
    X (mergeable_const_4)                                                                          \
    X (mergeable_const_8)                                                                          \
    X (mergeable_const_16)                                                                         \
    X (mergeable_const_32)                                                                         \
    X (read_only)                                                                                  \
    X (thread_data)                                                                                \
    X (thread_bss)                                                                                 \
    X (debug_line)                                                                                 \
    X (debug_string)                                                                               \
    X (debug_ranges)                                                                               \
    X (linked_definitions)

#define X(a) a,
        enum class section_kind : std::uint8_t {
            PSTORE_MCREPO_SECTION_KINDS last // always last, never used.
        };
#undef X
        constexpr auto num_section_kinds =
            static_cast<std::underlying_type<section_kind>::type> (section_kind::last);

        std::ostream & operator<< (std::ostream & os, section_kind kind);

        constexpr auto first_repo_metadata_section = section_kind::linked_definitions;

        constexpr bool is_target_section (section_kind const t) noexcept {
            using utype = std::underlying_type<section_kind>::type;
            return static_cast<utype> (t) < static_cast<utype> (first_repo_metadata_section);
        }


        struct section_base {};


        template <typename T>
        unsigned section_alignment (T const & section) noexcept;

        template <typename T>
        std::uint64_t section_size (T const & section) noexcept;

        //*                  _   _               _ _               _      _             *
        //*  __ _ _ ___ __ _| |_(_)___ _ _    __| (_)____ __  __ _| |_ __| |_  ___ _ _  *
        //* / _| '_/ -_) _` |  _| / _ \ ' \  / _` | (_-< '_ \/ _` |  _/ _| ' \/ -_) '_| *
        //* \__|_| \___\__,_|\__|_\___/_||_| \__,_|_/__/ .__/\__,_|\__\__|_||_\___|_|   *
        //*                                            |_|                              *
        class section_creation_dispatcher {
        public:
            explicit section_creation_dispatcher (section_kind const kind) noexcept
                    : kind_{kind} {}
            section_creation_dispatcher (section_creation_dispatcher const &) = delete;
            section_creation_dispatcher (section_creation_dispatcher &&) = delete;
            virtual ~section_creation_dispatcher () noexcept;

            section_creation_dispatcher & operator= (section_creation_dispatcher const &) = delete;
            section_creation_dispatcher & operator= (section_creation_dispatcher &&) = delete;

            section_kind const & kind () const noexcept { return kind_; }

            template <typename IntType, typename = std::enable_if<std::is_unsigned<IntType>::value>>
            std::size_t aligned (IntType a) const {
                static_assert (sizeof (std::uintptr_t) >= sizeof (IntType),
                               "sizeof uintptr_t must be at least sizeof IntType");
                return static_cast<std::size_t> (
                    this->aligned_impl (static_cast<std::uintptr_t> (a)));
            }
            std::uint8_t * aligned (std::uint8_t * const a) const {
                return reinterpret_cast<std::uint8_t *> (
                    this->aligned_impl (reinterpret_cast<std::uintptr_t> (a)));
            }

            virtual std::size_t size_bytes () const = 0;

            virtual std::uint8_t * write (std::uint8_t * out) const = 0;

        private:
            virtual std::uintptr_t aligned_impl (std::uintptr_t v) const = 0;

            section_kind const kind_;
        };

        template <typename T>
        struct section_to_creation_dispatcher {};

        template <typename ValueType>
        class container {
        public:
            using value_type = ValueType const;
            using size_type = std::size_t;
            using difference_type = std::ptrdiff_t;
            using reference = ValueType const &;
            using const_reference = reference;
            using pointer = ValueType const *;
            using const_pointer = pointer;
            using iterator = const_pointer;
            using const_iterator = iterator;

            container () = default;
            container (const_pointer begin, const_pointer end)
                    : begin_{begin}
                    , end_{end} {
                PSTORE_ASSERT (end >= begin);
            }
            iterator begin () const { return begin_; }
            iterator end () const { return end_; }
            const_iterator cbegin () const { return begin (); }
            const_iterator cend () const { return end (); }

            const_pointer data () const { return begin_; }

            size_type size () const noexcept {
                PSTORE_ASSERT (end_ >= begin_);
                return static_cast<size_type> (end_ - begin_);
            }
            bool empty () const noexcept { return size () == 0U; }

        private:
            const_pointer begin_;
            const_pointer end_;
        };

        struct internal_fixup;
        struct external_fixup;

        class dispatcher {
        public:
            virtual ~dispatcher () noexcept;

            virtual std::size_t size_bytes () const = 0;
            virtual unsigned align () const = 0;
            virtual std::size_t size () const = 0;
            virtual container<internal_fixup> ifixups () const = 0;
            virtual container<external_fixup> xfixups () const = 0;
            virtual container<std::uint8_t> payload () const = 0;
        };


        template <typename T>
        struct section_to_dispatcher {};

    } // end namespace repo
} // end namespace pstore

#endif // PSTORE_MCREPO_SECTION_HPP