globals.h

Go to the documentation of this file.

#pragma once
 
#include <bit>
#include <cstdint>
#include <limits>
#include <type_traits>
 
#include "src/macros.h"
 
namespace broom {
constexpr const uintptr_t kNullUintPtr = 0;
constexpr const intptr_t kNullIntPtr = 0;
using MemoryAddress = uintptr_t;
using UintPtr = uintptr_t;
using IntPtr = intptr_t;
constexpr const MemoryAddress kNullMemoryAddress = 0;
constexpr const int kPointerSize = sizeof(void*);
constexpr const int kUintPtrSize = sizeof(UintPtr);
constexpr const int kIntPtrSize = sizeof(IntPtr);
 
constexpr const size_t KB = 1024;
constexpr const size_t MB = KB * 1024;
constexpr const size_t GB = MB * 1024;
constexpr const size_t TB = GB * 1024;
 
constexpr const int kPageSize = 4 * KB;
constexpr const int kHugePageSize = 2 * MB;
 
template <typename T, typename U>
concept StaticCastable = requires(T t) {
  { static_cast<U>(t) } -> std::same_as<U>;
};
 
template <typename T, typename U>
concept ReinterpretCastable = requires(T t) {
  { reinterpret_cast<U>(t) } -> std::same_as<U>;
};
 
class AllocatorCommonMetadata;
class AllocatorFrontMetadata;
 
template <typename T>
concept IsAllocatorMetadata = std::is_same_v<T, AllocatorFrontMetadata> ||
                              std::is_same_v<T, AllocatorCommonMetadata>;
 
template <typename T, typename U>
  requires StaticCastable<U, T> && (!IsAllocatorMetadata<T>)
constexpr inline T SafeCast(U v) {
  return static_cast<T>(v);
}
 
template <typename T, typename U>
  requires ReinterpretCastable<U, T> && (!StaticCastable<U, T>) &&
           (!IsAllocatorMetadata<T>)
constexpr inline T SafeCast(U v) {
  return reinterpret_cast<T>(v);
}
 
template <typename T, typename U>
constexpr inline T UnsafeCast(U v) {
  return std::bit_cast<T>(v);
}
 
template <size_t N, typename T>
  requires std::is_integral_v<T> && (N > 0) && (N % 2 == 0)
constexpr inline bool IsAligned(T value) {
  return (value & (N - 1)) == 0;
}
 
template <size_t N, typename T>
  requires(N > 0) && (N % 2 == 0)
constexpr inline bool IsAligned(T* value) {
  return IsAligned<N>(SafeCast<UintPtr>(value));
}
 
template <size_t N, typename T>
  requires std::is_integral_v<T> && (N > 0) && (N % 2 == 0)
constexpr inline T RoundDown(T value) {
  return value & static_cast<T>(-SafeCast<std::make_signed_t<T>>(N));
}
 
template <size_t N, typename T>
  requires std::is_integral_v<T> && (N > 0) && (N % 2 == 0)
constexpr inline T RoundUp(T value) {
  BASSERT_GE(std::numeric_limits<T>::max() - value, N - 1,
             "Unexpected overflow");
  return RoundDown<N, T>(static_cast<T>(value + (N - 1)));
}
 
template <typename T>
  requires std::is_unsigned_v<T>
constexpr inline bool AddOverflowChecked(T lhs, T rhs, T& destination) {
  if (rhs > 0 && lhs > std::numeric_limits<T>::max() - rhs) return true;
  destination = lhs + rhs;
  return false;
}
}  // namespace broom