aligned.hpp

Go to the documentation of this file.

//===- include/pstore/support/aligned.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_SUPPORT_ALIGNED_HPP
#define PSTORE_SUPPORT_ALIGNED_HPP

#include <cstdint>
#include <type_traits>

#include "pstore/support/assert.hpp"

namespace pstore {

    template <typename Ty, typename = typename std::enable_if<std::is_unsigned<Ty>::value>>
    constexpr bool is_power_of_two (Ty const n) noexcept {
        //  if a number n is a power of 2 then bitwise & of n and n-1 will be zero.
        return n > 0U && !(n & (n - 1U));
    }

    template <typename IntType, typename AlignType>
    constexpr IntType aligned (IntType const v, AlignType const align) noexcept {
        static_assert (std::is_unsigned<IntType>::value, "aligned() IntType must be unsigned");
        static_assert (std::is_unsigned<AlignType>::value, "aligned() AlignType must be unsigned");
        PSTORE_ASSERT (is_power_of_two (align));

        return (v + align - 1U) & static_cast<IntType> (~(align - 1U));
    }

    template <typename AlignType, typename IntType,
              typename = std::enable_if<std::is_integral<IntType>::value>>
    constexpr IntType aligned (IntType const v) noexcept {
        return aligned (v, alignof (AlignType));
    }

    template <typename PointeeType>
    constexpr PointeeType const * aligned (void const * const p) noexcept {
        return reinterpret_cast<PointeeType const *> (
            aligned (reinterpret_cast<std::uintptr_t> (p), alignof (PointeeType)));
    }
    template <typename PointeeType>
    constexpr PointeeType * aligned (void * const p) noexcept {
        return reinterpret_cast<PointeeType *> (
            aligned (reinterpret_cast<std::uintptr_t> (p), alignof (PointeeType)));
    }

    template <typename DestPointeeType, typename SrcPointeeType = DestPointeeType>
    constexpr DestPointeeType const * aligned_ptr (SrcPointeeType const * const p) noexcept {
        return aligned<DestPointeeType> (reinterpret_cast<void const *> (p));
    }
    template <typename DestPointeeType, typename SrcPointeeType = DestPointeeType>
    constexpr DestPointeeType * aligned_ptr (SrcPointeeType * const p) noexcept {
        return aligned<DestPointeeType> (reinterpret_cast<void *> (p));
    }

    template <typename Ty>
    constexpr Ty calc_alignment (Ty const v, std::size_t const align) noexcept {
        PSTORE_ASSERT (is_power_of_two (align));
        return (align == 0U) ? 0U : ((v + align - 1U) & ~(align - 1U)) - v;
    }

    template <typename Ty>
    constexpr Ty calc_alignment (Ty const v) noexcept {
        return calc_alignment (v, alignof (Ty));
    }

} // end namespace pstore

#endif // PSTORE_SUPPORT_ALIGNED_HPP