From e3c4c7709f65404bcf8ce195a518e7d445e768d2 Mon Sep 17 00:00:00 2001 From: Richard Qin Date: Mon, 2 Nov 2026 02:07:38 +0800 Subject: Restructure libbase and RCCCore build --- libbase/include/core/adt/STLFunctionalExtras.h | 112 ++ libbase/include/core/adt/SmallVector.h | 1926 ++++++++++++++++++++ libbase/include/core/compiler/Compiler.h | 843 +++++++++ libbase/include/core/compiler/DataTypes.h | 105 ++ libbase/include/core/config/config.h.cmake | 219 +++ libbase/include/core/config/libbase-config.h.cmake | 89 + libbase/include/core/error/Errno.h | 64 + libbase/include/core/error/ErrorHandling.h | 217 +++ libbase/include/core/math/MathExtras.h | 1050 +++++++++++ libbase/include/core/memory/Alignment.h | 342 ++++ libbase/include/core/memory/AllocatorBase.h | 154 ++ libbase/include/core/memory/MemAlloc.h | 124 ++ 12 files changed, 5245 insertions(+) create mode 100644 libbase/include/core/adt/STLFunctionalExtras.h create mode 100644 libbase/include/core/adt/SmallVector.h create mode 100644 libbase/include/core/compiler/Compiler.h create mode 100644 libbase/include/core/compiler/DataTypes.h create mode 100644 libbase/include/core/config/config.h.cmake create mode 100644 libbase/include/core/config/libbase-config.h.cmake create mode 100644 libbase/include/core/error/Errno.h create mode 100644 libbase/include/core/error/ErrorHandling.h create mode 100644 libbase/include/core/math/MathExtras.h create mode 100644 libbase/include/core/memory/Alignment.h create mode 100644 libbase/include/core/memory/AllocatorBase.h create mode 100644 libbase/include/core/memory/MemAlloc.h (limited to 'libbase/include') diff --git a/libbase/include/core/adt/STLFunctionalExtras.h b/libbase/include/core/adt/STLFunctionalExtras.h new file mode 100644 index 0000000..915796b --- /dev/null +++ b/libbase/include/core/adt/STLFunctionalExtras.h @@ -0,0 +1,112 @@ +/* + R *CC-Project + + Copyright (C) 2026 Richard Qin + + This file is part of RCC-Project. + + RCC-Project is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at your option) any + later version. + + RCC-Project is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR + A PARTICULAR PURPOSE. See the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along with + RCC-Project; see the file COPYING. If not see + . + */ + +//===- llvm/ADT/STLFunctionalExtras.h - Extras for -*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file contains some extension to . +// +// No library is required when using these functions. +// +//===----------------------------------------------------------------------===// + +#ifndef LIBBASE_ADT_STLFUNCTIONALEXTRAS_H +#define LIBBASE_ADT_STLFUNCTIONALEXTRAS_H + +#include "core/compiler/Compiler.h" + +#include +#include +#include + +namespace rcc +{ + +//===----------------------------------------------------------------------===// +// Extra additions to +//===----------------------------------------------------------------------===// + +/// An efficient, type-erasing, non-owning reference to a callable. This is +/// intended for use as the type of a function parameter that is not used +/// after the function in question returns. +/// +/// This class does not own the callable, so it is not in general safe to store +/// a function_ref. +template class function_ref; + +template +class LIBBASE_GSL_POINTER function_ref +{ + Ret (*callback) (intptr_t callable, Params... params) = nullptr; + intptr_t callable = 0; + + template + static Ret + callback_fn (intptr_t callable, Params... params) + { + return (*reinterpret_cast (callable)) ( + std::forward (params)...); + } + +public: + function_ref () = default; + function_ref (std::nullptr_t) + { + } + + template + function_ref ( + Callable &&callable LIBBASE_LIFETIME_BOUND, + // This is not the copy-constructor. + std::enable_if_t, + function_ref>::value> * = nullptr, + // Functor must be callable and return a suitable type. + std::enable_if_t::value || + std::is_convertible () ( + std::declval ()...)), + Ret>::value> * = nullptr) + : callback (callback_fn>), + callable (reinterpret_cast (&callable)) + { + } + + Ret + operator() (Params... params) const + { + return callback (callable, std::forward (params)...); + } + + explicit + operator bool () const + { + return callback; + } +}; + +} // end namespace rcc + +#endif // LIBBASE_ADT_STLFUNCTIONALEXTRAS_H diff --git a/libbase/include/core/adt/SmallVector.h b/libbase/include/core/adt/SmallVector.h new file mode 100644 index 0000000..7b3c554 --- /dev/null +++ b/libbase/include/core/adt/SmallVector.h @@ -0,0 +1,1926 @@ +/* + R *CC-Project + + Copyright (C) 2026 Richard Qin + + This file is part of RCC-Project. + + RCC-Project is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at your option) any + later version. + + RCC-Project is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A + PARTICULAR PURPOSE. See the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along with + RCC-Project; see the file COPYING. If not see + . + */ + +//===- rcc/ADT/SmallVector.h - 'Normally small' vectors --------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This file defines the SmallVector class. +/// +//===----------------------------------------------------------------------===// + +#ifndef LIBBASE_ADT_SMALLVECTOR_H +#define LIBBASE_ADT_SMALLVECTOR_H + +#include "core/compiler/Compiler.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace rcc +{ + +template class ArrayRef; + +template class iterator_range; + +template +using HasIteratorTag = std::is_convertible< + typename std::iterator_traits::iterator_category, Tag>; + +template +using EnableIfConvertibleToInputIterator = + std::enable_if_t::value>; + +/// This is all the stuff common to all SmallVectors. +/// +/// The template parameter specifies the type which should be used to hold the +/// Size and Capacity of the SmallVector, so it can be adjusted. +/// Using 32 bit size is desirable to shrink the size of the SmallVector. +/// Using 64 bit size is desirable for cases like SmallVector, where a +/// 32 bit size would limit the vector to ~4GB. SmallVectors are used for +/// buffering bitcode output - which can exceed 4GB. +template class SmallVectorBase +{ +protected: + void *BeginX; + Size_T Size = 0, Capacity; + + /// The maximum value of the Size_T used. + static constexpr size_t + SizeTypeMax () + { + return std::numeric_limits::max (); + } + + SmallVectorBase () = delete; + SmallVectorBase (void *FirstEl, size_t TotalCapacity) + : BeginX (FirstEl), Capacity (static_cast (TotalCapacity)) + { + } + + /// This is a helper for \a grow() that's out of line to reduce code + /// duplication. This function will report a fatal error if it can't grow at + /// least to \p MinSize. + LIBBASE_ABI void * + mallocForGrow (void *FirstEl, size_t MinSize, size_t TSize, + size_t &NewCapacity); + + /// This is an implementation of the grow() method which only works + /// on POD-like data types and is out of line to reduce code duplication. + /// This function will report a fatal error if it cannot increase capacity. + LIBBASE_ABI void + grow_pod (void *FirstEl, size_t MinSize, size_t TSize); + +public: + size_t + size () const + { + return Size; + } + size_t + capacity () const + { + return Capacity; + } + + [[nodiscard]] bool + empty () const + { + return !Size; + } + +protected: + /// Set the array size to \p N, which the current array must have enough + /// capacity for. + /// + /// This does not construct or destroy any elements in the vector. + void + set_size (size_t N) + { + assert (N <= capacity ()); // implies no overflow in assignment + Size = static_cast (N); + } + + /// Set the array data pointer to \p Begin and capacity to \p N. + /// + /// This does not construct or destroy any elements in the vector. + // This does not clean up any existing allocation. + void + set_allocation_range (void *Begin, size_t N) + { + assert (N <= SizeTypeMax ()); + BeginX = Begin; + Capacity = static_cast (N); + } +}; + +template +using SmallVectorSizeType = + std::conditional_t= 8, uint64_t, + uint32_t>; + +/// Figure out the offset of the first element. +template struct SmallVectorAlignmentAndSize +{ + alignas (SmallVectorBase>) char Base[sizeof ( + SmallVectorBase>)]; + alignas (T) char FirstEl[sizeof (T)]; +}; + +/// This is the part of SmallVectorTemplateBase which does not depend on whether +/// the type T is a POD. The extra dummy template argument is used by ArrayRef +/// to avoid unnecessarily requiring T to be complete. +template +class SmallVectorTemplateCommon : public SmallVectorBase> +{ + using Base = SmallVectorBase>; + +protected: + /// Find the address of the first element. For this pointer math to be valid + /// with small-size of 0 for T with lots of alignment, it's important that + /// SmallVectorStorage is properly-aligned even for small-size of 0. + void * + getFirstEl () const + { + return const_cast (reinterpret_cast ( + reinterpret_cast (this) + + offsetof (SmallVectorAlignmentAndSize, FirstEl))); + } + // Space after 'FirstEl' is clobbered, do not add any instance vars after it. + + SmallVectorTemplateCommon (size_t SizeArg) : Base (getFirstEl (), SizeArg) + { + } + + void + grow_pod (size_t MinSize, size_t TSize) + { + Base::grow_pod (getFirstEl (), MinSize, TSize); + } + + /// Return true if this is a smallvector which has not had dynamic + /// memory allocated for it. + bool + isSmall () const + { + return this->BeginX == getFirstEl (); + } + + /// Put this vector in a state of being small. + void + resetToSmall () + { + this->BeginX = getFirstEl (); + // The inline capacity is unknown here. SmallVector restores it when moving + // from the same concrete type; moves through SmallVectorImpl leave it at 0. + this->Size = this->Capacity = 0; + } + + /// Return true if V is an internal reference to the given range. + bool + isReferenceToRange (const void *V, const void *First, const void *Last) const + { + // Use std::less to avoid UB. + std::less<> LessThan; + return !LessThan (V, First) && LessThan (V, Last); + } + + /// Return true if V is an internal reference to this vector. + bool + isReferenceToStorage (const void *V) const + { + return isReferenceToRange (V, this->begin (), this->end ()); + } + + /// Return true if First and Last form a valid (possibly empty) range in this + /// vector's storage. + bool + isRangeInStorage (const void *First, const void *Last) const + { + // Use std::less to avoid UB. + std::less<> LessThan; + return !LessThan (First, this->begin ()) && !LessThan (Last, First) && + !LessThan (this->end (), Last); + } + + /// Return true unless Elt will be invalidated by resizing the vector to + /// NewSize. + bool + isSafeToReferenceAfterResize (const void *Elt, size_t NewSize) + { + // Past the end. + if (LIBBASE_LIKELY (!isReferenceToStorage (Elt))) + { + return true; + } + + // Return false if Elt will be destroyed by shrinking. + if (NewSize <= this->size ()) + { + return Elt < this->begin () + NewSize; + } + + // Return false if we need to grow. + return NewSize <= this->capacity (); + } + + /// Check whether Elt will be invalidated by resizing the vector to NewSize. + void + assertSafeToReferenceAfterResize (const void *Elt, size_t NewSize) + { + assert (isSafeToReferenceAfterResize (Elt, NewSize) && + "Attempting to reference an element of the vector in an operation " + "that invalidates it"); + } + + /// Check whether Elt will be invalidated by increasing the size of the + /// vector by N. + void + assertSafeToAdd (const void *Elt, size_t N = 1) + { + this->assertSafeToReferenceAfterResize (Elt, this->size () + N); + } + + /// Check whether any part of the range will be invalidated by clearing. + template + void + assertSafeToReferenceAfterClear (ItTy From, ItTy To) + { + if constexpr (std::is_pointer_v && + std::is_same_v< + std::remove_const_t>, + std::remove_const_t>) + { + if (From == To) + { + return; + } + this->assertSafeToReferenceAfterResize (From, 0); + this->assertSafeToReferenceAfterResize (To - 1, 0); + } + (void)From; + (void)To; + } + + /// Check whether any part of the range will be invalidated by growing. + template + void + assertSafeToAddRange (ItTy From, ItTy To) + { + if constexpr (std::is_pointer_v && + std::is_same_v>, + T>) + { + if (From == To) + { + return; + } + this->assertSafeToAdd (From, To - From); + this->assertSafeToAdd (To - 1, To - From); + } + (void)From; + (void)To; + } + + /// Reserve enough space to add one element, and return the updated element + /// pointer in case it was a reference to the storage. + template + static const T * + reserveForParamAndGetAddressImpl (U *This, const T &Elt, size_t N) + { + size_t NewSize = This->size () + N; + if (LIBBASE_LIKELY (NewSize <= This->capacity ())) + { + return &Elt; + } + + bool ReferencesStorage = false; + int64_t Index = -1; + if (!U::TakesParamByValue) + { + if (LIBBASE_UNLIKELY (This->isReferenceToStorage (&Elt))) + { + ReferencesStorage = true; + Index = &Elt - This->begin (); + } + } + This->grow (NewSize); + return ReferencesStorage ? This->begin () + Index : &Elt; + } + +public: + using size_type = size_t; + using difference_type = ptrdiff_t; + using value_type = T; + using iterator = T *; + using const_iterator = const T *; + + using const_reverse_iterator = std::reverse_iterator; + using reverse_iterator = std::reverse_iterator; + + using reference = T &; + using const_reference = const T &; + using pointer = T *; + using const_pointer = const T *; + + using Base::capacity; + using Base::empty; + using Base::size; + + // forward iterator creation methods. + iterator + begin () + { + return (iterator)this->BeginX; + } + const_iterator + begin () const + { + return (const_iterator)this->BeginX; + } + iterator + end () + { + return begin () + size (); + } + const_iterator + end () const + { + return begin () + size (); + } + + // reverse iterator creation methods. + reverse_iterator + rbegin () + { + return reverse_iterator (end ()); + } + const_reverse_iterator + rbegin () const + { + return const_reverse_iterator (end ()); + } + reverse_iterator + rend () + { + return reverse_iterator (begin ()); + } + const_reverse_iterator + rend () const + { + return const_reverse_iterator (begin ()); + } + + size_type + size_in_bytes () const + { + return size () * sizeof (T); + } + size_type + max_size () const + { + return std::min (this->SizeTypeMax (), size_type (-1) / sizeof (T)); + } + + size_t + capacity_in_bytes () const + { + return capacity () * sizeof (T); + } + + /// Return a pointer to the vector's buffer, even if empty(). + pointer + data () + { + return pointer (begin ()); + } + /// Return a pointer to the vector's buffer, even if empty(). + const_pointer + data () const + { + return const_pointer (begin ()); + } + + reference + operator[] (size_type idx) + { + assert (idx < size ()); + return begin ()[idx]; + } + const_reference + operator[] (size_type idx) const + { + assert (idx < size ()); + return begin ()[idx]; + } + + reference + front () + { + assert (!empty ()); + return begin ()[0]; + } + const_reference + front () const + { + assert (!empty ()); + return begin ()[0]; + } + + reference + back () + { + assert (!empty ()); + return end ()[-1]; + } + const_reference + back () const + { + assert (!empty ()); + return end ()[-1]; + } +}; + +/// SmallVectorTemplateBase - This is where we put +/// method implementations that are designed to work with non-trivial T's. +/// +/// We approximate is_trivially_copyable with trivial move/copy construction and +/// trivial destruction. While the standard doesn't specify that you're allowed +/// copy these types with memcpy, there is no way for the type to observe this. +/// This catches the important case of std::pair, which is not +/// trivially assignable. +template ::value) && + (std::is_trivially_move_constructible::value) && + std::is_trivially_destructible::value> +class SmallVectorTemplateBase : public SmallVectorTemplateCommon +{ + friend class SmallVectorTemplateCommon; + +protected: + static constexpr bool TakesParamByValue = false; + using ValueParamT = const T &; + + SmallVectorTemplateBase (size_t SizeArg) + : SmallVectorTemplateCommon (SizeArg) + { + } + + static void + destroy_range (T *S, T *E) + { + while (S != E) + { + --E; + E->~T (); + } + } + + /// Move the range [I, E) into the uninitialized memory starting with "Dest", + /// constructing elements as needed. + template + static void + uninitialized_move (It1 I, It1 E, It2 Dest) + { + std::uninitialized_move (I, E, Dest); + } + + /// Copy the range [I, E) onto the uninitialized memory starting with "Dest", + /// constructing elements as needed. + template + static void + uninitialized_copy (It1 I, It1 E, It2 Dest) + { + std::uninitialized_copy (I, E, Dest); + } + + /// Grow the allocated memory (without initializing new elements), doubling + /// the size of the allocated memory. Guarantees space for at least one more + /// element, or MinSize more elements if specified. + void + grow (size_t MinSize = 0); + + /// Create a new allocation big enough for \p MinSize and pass back its size + /// in \p NewCapacity. This is the first section of \a grow(). + T * + mallocForGrow (size_t MinSize, size_t &NewCapacity); + + /// Move existing elements over to the new allocation \p NewElts, the middle + /// section of \a grow(). + void + moveElementsForGrow (T *NewElts); + + /// Transfer ownership of the allocation, finishing up \a grow(). + void + takeAllocationForGrow (T *NewElts, size_t NewCapacity); + + /// Reserve enough space to add one element, and return the updated element + /// pointer in case it was a reference to the storage. + const T * + reserveForParamAndGetAddress (const T &Elt, size_t N = 1) + { + return this->reserveForParamAndGetAddressImpl (this, Elt, N); + } + + /// Reserve enough space to add one element, and return the updated element + /// pointer in case it was a reference to the storage. + T * + reserveForParamAndGetAddress (T &Elt, size_t N = 1) + { + return const_cast ( + this->reserveForParamAndGetAddressImpl (this, Elt, N)); + } + + static T && + forward_value_param (T &&V) + { + return std::move (V); + } + static const T & + forward_value_param (const T &V) + { + return V; + } + + void + growAndAssign (size_t NumElts, const T &Elt) + { + // Grow manually in case Elt is an internal reference. + size_t NewCapacity; + T *NewElts = mallocForGrow (NumElts, NewCapacity); + std::uninitialized_fill_n (NewElts, NumElts, Elt); + this->destroy_range (this->begin (), this->end ()); + takeAllocationForGrow (NewElts, NewCapacity); + this->set_size (NumElts); + } + + template + T & + growAndEmplaceBack (ArgTypes &&...Args) + { + // Grow manually in case one of Args is an internal reference. + size_t NewCapacity; + T *NewElts = mallocForGrow (0, NewCapacity); + ::new ((void *)(NewElts + this->size ())) + T (std::forward (Args)...); + moveElementsForGrow (NewElts); + takeAllocationForGrow (NewElts, NewCapacity); + this->set_size (this->size () + 1); + return this->back (); + } + +public: + void + push_back (const T &Elt) + { + const T *EltPtr = reserveForParamAndGetAddress (Elt); + ::new ((void *)this->end ()) T (*EltPtr); + this->set_size (this->size () + 1); + } + + void + push_back (T &&Elt) + { + T *EltPtr = reserveForParamAndGetAddress (Elt); + ::new ((void *)this->end ()) T (::std::move (*EltPtr)); + this->set_size (this->size () + 1); + } + + void + pop_back () + { + this->set_size (this->size () - 1); + this->end ()->~T (); + } +}; + +// Define this out-of-line to dissuade the C++ compiler from inlining it. +template +void +SmallVectorTemplateBase::grow (size_t MinSize) +{ + size_t NewCapacity; + T *NewElts = mallocForGrow (MinSize, NewCapacity); + moveElementsForGrow (NewElts); + takeAllocationForGrow (NewElts, NewCapacity); +} + +template +T * +SmallVectorTemplateBase::mallocForGrow ( + size_t MinSize, size_t &NewCapacity) +{ + return static_cast ( + SmallVectorBase>::mallocForGrow ( + this->getFirstEl (), MinSize, sizeof (T), NewCapacity)); +} + +// Define this out-of-line to dissuade the C++ compiler from inlining it. +template +void +SmallVectorTemplateBase::moveElementsForGrow (T *NewElts) +{ + // Move the elements over. + this->uninitialized_move (this->begin (), this->end (), NewElts); + + // Destroy the original elements. + destroy_range (this->begin (), this->end ()); +} + +// Define this out-of-line to dissuade the C++ compiler from inlining it. +template +void +SmallVectorTemplateBase::takeAllocationForGrow ( + T *NewElts, size_t NewCapacity) +{ + // If this wasn't grown from the inline copy, deallocate the old space. + if (!this->isSmall ()) + { + free (this->begin ()); + } + + this->set_allocation_range (NewElts, NewCapacity); +} + +/// SmallVectorTemplateBase - This is where we put +/// method implementations that are designed to work with trivially copyable +/// T's. This allows using memcpy in place of copy/move construction and +/// skipping destruction. +template +class SmallVectorTemplateBase : public SmallVectorTemplateCommon +{ + friend class SmallVectorTemplateCommon; + +protected: + /// True if it's cheap enough to take parameters by value. Doing so avoids + /// overhead related to mitigations for reference invalidation. + static constexpr bool TakesParamByValue = sizeof (T) <= 2 * sizeof (void *); + + /// Either const T& or T, depending on whether it's cheap enough to take + /// parameters by value. + using ValueParamT = std::conditional_t; + + SmallVectorTemplateBase (size_t SizeArg) + : SmallVectorTemplateCommon (SizeArg) + { + } + + // No need to do a destroy loop for POD's. + static void + destroy_range (T *, T *) + { + } + + /// Move the range [I, E) onto the uninitialized memory + /// starting with "Dest", constructing elements into it as needed. + template + static void + uninitialized_move (It1 I, It1 E, It2 Dest) + { + // Just do a copy. + uninitialized_copy (I, E, Dest); + } + + /// Copy the range [I, E) onto the uninitialized memory + /// starting with "Dest", constructing elements into it as needed. + template + static void + uninitialized_copy (It1 I, It1 E, It2 Dest) + { + if constexpr (std::is_pointer_v && std::is_pointer_v && + std::is_same_v< + std::remove_const_t>, + std::remove_pointer_t>) + { + // Use memcpy for PODs iterated by pointers (which includes SmallVector + // iterators): std::uninitialized_copy optimizes to memmove, but we can + // use memcpy here. Note that I and E are iterators and thus might be + // invalid for memcpy if they are equal. + if (I != E) + { + std::memcpy (reinterpret_cast (Dest), I, (E - I) * sizeof (T)); + } + } + else + { + // Arbitrary iterator types; just use the basic implementation. + std::uninitialized_copy (I, E, Dest); + } + } + + /// Double the size of the allocated memory, guaranteeing space for at + /// least one more element or MinSize if specified. + void + grow (size_t MinSize = 0) + { + this->grow_pod (MinSize, sizeof (T)); + } + + /// Reserve enough space to add one element, and return the updated element + /// pointer in case it was a reference to the storage. + const T * + reserveForParamAndGetAddress (const T &Elt, size_t N = 1) + { + return this->reserveForParamAndGetAddressImpl (this, Elt, N); + } + + /// Reserve enough space to add one element, and return the updated element + /// pointer in case it was a reference to the storage. + T * + reserveForParamAndGetAddress (T &Elt, size_t N = 1) + { + return const_cast ( + this->reserveForParamAndGetAddressImpl (this, Elt, N)); + } + + /// Copy \p V or return a reference, depending on \a ValueParamT. + static ValueParamT + forward_value_param (ValueParamT V) + { + return V; + } + + void + growAndAssign (size_t NumElts, T Elt) + { + // Elt has been copied in case it's an internal reference, side-stepping + // reference invalidation problems without losing the realloc optimization. + this->set_size (0); + this->grow (NumElts); + std::uninitialized_fill_n (this->begin (), NumElts, Elt); + this->set_size (NumElts); + } + + template + T & + growAndEmplaceBack (ArgTypes &&...Args) + { + // Use push_back with a copy in case Args has an internal reference, + // side-stepping reference invalidation problems without losing the realloc + // optimization. + push_back (T (std::forward (Args)...)); + return this->back (); + } + + // Out-of-line slow path so the inline push_back needs no callee-saved + // registers or stack frame on its hot path. + LIBBASE_ATTRIBUTE_NOINLINE void + growAndPushBack (ValueParamT Elt) + { + // Copy in case Elt is an internal reference invalidated by grow. + T Tmp = Elt; + this->grow (this->size () + 1); + std::memcpy (reinterpret_cast (this->end ()), &Tmp, sizeof (T)); + this->set_size (this->size () + 1); + } + +public: + void + push_back (ValueParamT Elt) + { + if (LIBBASE_UNLIKELY (this->size () >= this->capacity ())) + { + return growAndPushBack (Elt); + } + std::memcpy (reinterpret_cast (this->end ()), &Elt, sizeof (T)); + this->set_size (this->size () + 1); + } + + void + pop_back () + { + this->set_size (this->size () - 1); + } +}; + +/// This class consists of common code factored out of the SmallVector class to +/// reduce code duplication based on the SmallVector 'N' template parameter. +template class SmallVectorImpl : public SmallVectorTemplateBase +{ + using SuperClass = SmallVectorTemplateBase; + +public: + using iterator = typename SuperClass::iterator; + using const_iterator = typename SuperClass::const_iterator; + using reference = typename SuperClass::reference; + using size_type = typename SuperClass::size_type; + +protected: + using SmallVectorTemplateBase::TakesParamByValue; + using ValueParamT = typename SuperClass::ValueParamT; + + // Default ctor - Initialize to empty. + explicit SmallVectorImpl (unsigned N) : SmallVectorTemplateBase (N) + { + } + + void + assignRemote (SmallVectorImpl &&RHS) + { + this->destroy_range (this->begin (), this->end ()); + if (!this->isSmall ()) + { + free (this->begin ()); + } + this->BeginX = RHS.BeginX; + this->Size = RHS.Size; + this->Capacity = RHS.Capacity; + RHS.resetToSmall (); + } + + void + moveConstructFrom (SmallVectorImpl &&RHS) + { + assert (this->empty () && "move construction requires an empty vector"); + if (!RHS.isSmall ()) + { + assignRemote (std::move (RHS)); + return; + } + + // Construct inline elements directly instead of requiring T to be move + // assignable through the general move-assignment implementation. + size_type RHSSize = RHS.size (); + reserve (RHSSize); + this->uninitialized_move (RHS.begin (), RHS.end (), this->begin ()); + this->set_size (RHSSize); + RHS.clear (); + } + + ~SmallVectorImpl () + { + // Subclass has already destructed this vector's elements. + // If this wasn't grown from the inline copy, deallocate the old space. + if (!this->isSmall ()) + { + free (this->begin ()); + } + } + +public: + SmallVectorImpl (const SmallVectorImpl &) = delete; + + void + clear () + { + this->destroy_range (this->begin (), this->end ()); + this->Size = 0; + } + +private: + // Make set_size() private to avoid misuse in subclasses. + using SuperClass::set_size; + + template + void + resizeImpl (size_type N) + { + if (N == this->size ()) + { + return; + } + + if (N < this->size ()) + { + this->truncate (N); + return; + } + + this->reserve (N); + for (auto I = this->end (), E = this->begin () + N; I != E; ++I) + { + if (ForOverwrite) + { + new (&*I) T; + } + else + { + new (&*I) T (); + } + } + this->set_size (N); + } + +public: + void + resize (size_type N) + { + resizeImpl (N); + } + + /// Like resize, but \ref T is POD, the new values won't be initialized. + void + resize_for_overwrite (size_type N) + { + resizeImpl (N); + } + + /// Like resize, but requires that \p N is less than \a size(). + void + truncate (size_type N) + { + assert (this->size () >= N && "Cannot increase size with truncate"); + this->destroy_range (this->begin () + N, this->end ()); + this->set_size (N); + } + + void + resize (size_type N, ValueParamT NV) + { + if (N == this->size ()) + { + return; + } + + if (N < this->size ()) + { + this->truncate (N); + return; + } + + // N > this->size(). Defer to append. + this->append (N - this->size (), NV); + } + + void + reserve (size_type N) + { + if (this->capacity () < N) + { + this->grow (N); + } + } + + void + pop_back_n (size_type NumItems) + { + assert (this->size () >= NumItems); + truncate (this->size () - NumItems); + } + + [[nodiscard]] T + pop_back_val () + { + T Result = ::std::move (this->back ()); + this->pop_back (); + return Result; + } + + void + swap (SmallVectorImpl &RHS); + + /// Add the specified range to the end of the SmallVector. + template > + void + append (ItTy in_start, ItTy in_end) + { + if constexpr (HasIteratorTag::value) + { + this->assertSafeToAddRange (in_start, in_end); + size_type NumInputs = std::distance (in_start, in_end); + this->reserve (this->size () + NumInputs); + this->uninitialized_copy (in_start, in_end, this->end ()); + this->set_size (this->size () + NumInputs); + } + else + { + // Input iterator, we can't know ahead how many elements we'll add. + for (; in_start != in_end; ++in_start) + { + this->emplace_back (*in_start); + } + } + } + + /// Append \p NumInputs copies of \p Elt to the end. + void + append (size_type NumInputs, ValueParamT Elt) + { + const T *EltPtr = this->reserveForParamAndGetAddress (Elt, NumInputs); + std::uninitialized_fill_n (this->end (), NumInputs, *EltPtr); + this->set_size (this->size () + NumInputs); + } + + void + append (std::initializer_list IL) + { + append (IL.begin (), IL.end ()); + } + + void + append (const SmallVectorImpl &RHS) + { + append (RHS.begin (), RHS.end ()); + } + + void + assign (size_type NumElts, ValueParamT Elt) + { + // Note that Elt could be an internal reference. + if (NumElts > this->capacity ()) + { + this->growAndAssign (NumElts, Elt); + return; + } + + // Assign over existing elements. + std::fill_n (this->begin (), std::min (NumElts, this->size ()), Elt); + if (NumElts > this->size ()) + { + std::uninitialized_fill_n (this->end (), NumElts - this->size (), Elt); + } + else if (NumElts < this->size ()) + { + this->destroy_range (this->begin () + NumElts, this->end ()); + } + this->set_size (NumElts); + } + + // FIXME: Consider assigning over existing elements, rather than clearing & + // re-initializing them - for all assign(...) variants. + + template > + void + assign (ItTy in_start, ItTy in_end) + { + this->assertSafeToReferenceAfterClear (in_start, in_end); + clear (); + append (in_start, in_end); + } + + void + assign (std::initializer_list IL) + { + clear (); + append (IL); + } + + void + assign (const SmallVectorImpl &RHS) + { + assign (RHS.begin (), RHS.end ()); + } + + template >> + void + assign (ArrayRef AR) + { + assign (AR.begin (), AR.end ()); + } + + iterator + erase (const_iterator CI) + { + // Just cast away constness because this is a non-const member function. + iterator I = const_cast (CI); + + assert (this->isReferenceToStorage (CI) && + "Iterator to erase is out of bounds."); + + iterator N = I; + // Shift all elts down one. + std::move (I + 1, this->end (), I); + // Drop the last elt. + this->pop_back (); + return (N); + } + + iterator + erase (const_iterator CS, const_iterator CE) + { + // Just cast away constness because this is a non-const member function. + iterator S = const_cast (CS); + iterator E = const_cast (CE); + + assert (this->isRangeInStorage (S, E) && + "Range to erase is out of bounds."); + + iterator N = S; + // Shift all elts down. + iterator I = std::move (E, this->end (), S); + // Drop the last elts. + this->destroy_range (I, this->end ()); + this->set_size (I - this->begin ()); + return (N); + } + +private: + template + iterator + insert_one_impl (iterator I, ArgType &&Elt) + { + // Callers ensure that ArgType is derived from T. + static_assert ( + std::is_same>, + T>::value, + "ArgType must be derived from T!"); + + if (I == this->end ()) + { // Important special case for empty vector. + this->push_back (::std::forward (Elt)); + return this->end () - 1; + } + + assert (this->isReferenceToStorage (I) && + "Insertion iterator is out of bounds."); + + // Grow if necessary. + size_t Index = I - this->begin (); + std::remove_reference_t *EltPtr = + this->reserveForParamAndGetAddress (Elt); + I = this->begin () + Index; + + ::new ((void *)this->end ()) T (::std::move (this->back ())); + // Push everything else over. + std::move_backward (I, this->end () - 1, this->end ()); + this->set_size (this->size () + 1); + + // If we just moved the element we're inserting, be sure to update + // the reference (never happens if TakesParamByValue). + static_assert (!TakesParamByValue || std::is_same::value, + "ArgType must be 'T' when taking by value!"); + if (!TakesParamByValue && + this->isReferenceToRange (EltPtr, I, this->end ())) + { + ++EltPtr; + } + + *I = ::std::forward (*EltPtr); + return I; + } + +public: + iterator + insert (iterator I, T &&Elt) + { + return insert_one_impl (I, this->forward_value_param (std::move (Elt))); + } + + iterator + insert (iterator I, const T &Elt) + { + return insert_one_impl (I, this->forward_value_param (Elt)); + } + + iterator + insert (iterator I, size_type NumToInsert, ValueParamT Elt) + { + // Convert iterator to elt# to avoid invalidating iterator when we reserve() + size_t InsertElt = I - this->begin (); + + if (I == this->end ()) + { // Important special case for empty vector. + append (NumToInsert, Elt); + return this->begin () + InsertElt; + } + + assert (this->isReferenceToStorage (I) && + "Insertion iterator is out of bounds."); + + // Ensure there is enough space, and get the (maybe updated) address of + // Elt. + const T *EltPtr = this->reserveForParamAndGetAddress (Elt, NumToInsert); + + // Uninvalidate the iterator. + I = this->begin () + InsertElt; + + // If there are more elements between the insertion point and the end of the + // range than there are being inserted, we can use a simple approach to + // insertion. Since we already reserved space, we know that this won't + // reallocate the vector. + if (size_t (this->end () - I) >= NumToInsert) + { + T *OldEnd = this->end (); + append (std::move_iterator (this->end () - NumToInsert), + std::move_iterator (this->end ())); + + // Copy the existing elements that get replaced. + std::move_backward (I, OldEnd - NumToInsert, OldEnd); + + // If we just moved the element we're inserting, be sure to update + // the reference (never happens if TakesParamByValue). + if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end ()) + { + EltPtr += NumToInsert; + } + + std::fill_n (I, NumToInsert, *EltPtr); + return I; + } + + // Otherwise, we're inserting more elements than exist already, and we're + // not inserting at the end. + + // Move over the elements that we're about to overwrite. + T *OldEnd = this->end (); + this->set_size (this->size () + NumToInsert); + size_t NumOverwritten = OldEnd - I; + this->uninitialized_move (I, OldEnd, this->end () - NumOverwritten); + + // If we just moved the element we're inserting, be sure to update + // the reference (never happens if TakesParamByValue). + if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end ()) + { + EltPtr += NumToInsert; + } + + // Replace the overwritten part. + std::fill_n (I, NumOverwritten, *EltPtr); + + // Insert the non-overwritten middle part. + std::uninitialized_fill_n (OldEnd, NumToInsert - NumOverwritten, *EltPtr); + return I; + } + + template > + iterator + insert (iterator I, ItTy From, ItTy To) + { + // Convert iterator to elt# to avoid invalidating iterator when we reserve() + size_t InsertElt = I - this->begin (); + + if (I == this->end ()) + { // Important special case for empty vector. + append (From, To); + return this->begin () + InsertElt; + } + + if constexpr (!HasIteratorTag::value) + { + // For input iterators, we don't know the number of elements to insert. + size_t OldSize = this->size (); + append (From, To); + I = this->begin () + InsertElt; // Uninvalidate the iterator. + std::rotate (I, this->begin () + OldSize, this->end ()); + return I; + } + + assert (this->isReferenceToStorage (I) && + "Insertion iterator is out of bounds."); + + // Check that the reserve that follows doesn't invalidate the iterators. + this->assertSafeToAddRange (From, To); + + size_t NumToInsert = std::distance (From, To); + + // Ensure there is enough space. + reserve (this->size () + NumToInsert); + + // Uninvalidate the iterator. + I = this->begin () + InsertElt; + + // If there are more elements between the insertion point and the end of the + // range than there are being inserted, we can use a simple approach to + // insertion. Since we already reserved space, we know that this won't + // reallocate the vector. + if (size_t (this->end () - I) >= NumToInsert) + { + T *OldEnd = this->end (); + append (std::move_iterator (this->end () - NumToInsert), + std::move_iterator (this->end ())); + + // Copy the existing elements that get replaced. + std::move_backward (I, OldEnd - NumToInsert, OldEnd); + + std::copy (From, To, I); + return I; + } + + // Otherwise, we're inserting more elements than exist already, and we're + // not inserting at the end. + + // Move over the elements that we're about to overwrite. + T *OldEnd = this->end (); + this->set_size (this->size () + NumToInsert); + size_t NumOverwritten = OldEnd - I; + this->uninitialized_move (I, OldEnd, this->end () - NumOverwritten); + + // Replace the overwritten part. + for (T *J = I; NumOverwritten > 0; --NumOverwritten) + { + *J = *From; + ++J; + ++From; + } + + // Insert the non-overwritten middle part. + this->uninitialized_copy (From, To, OldEnd); + return I; + } + + void + insert (iterator I, std::initializer_list IL) + { + insert (I, IL.begin (), IL.end ()); + } + + template + reference + emplace_back (ArgTypes &&...Args) + { + if (LIBBASE_UNLIKELY (this->size () >= this->capacity ())) + { + return this->growAndEmplaceBack (std::forward (Args)...); + } + + ::new ((void *)this->end ()) T (std::forward (Args)...); + this->set_size (this->size () + 1); + return this->back (); + } + + SmallVectorImpl & + operator= (const SmallVectorImpl &RHS); + + SmallVectorImpl & + operator= (SmallVectorImpl &&RHS); + + bool + operator== (const SmallVectorImpl &RHS) const + { + if (this->size () != RHS.size ()) + { + return false; + } + return std::equal (this->begin (), this->end (), RHS.begin ()); + } + bool + operator!= (const SmallVectorImpl &RHS) const + { + return !(*this == RHS); + } + + bool + operator< (const SmallVectorImpl &RHS) const + { + return std::lexicographical_compare (this->begin (), this->end (), + RHS.begin (), RHS.end ()); + } + bool + operator> (const SmallVectorImpl &RHS) const + { + return RHS < *this; + } + bool + operator<= (const SmallVectorImpl &RHS) const + { + return !(*this > RHS); + } + bool + operator>= (const SmallVectorImpl &RHS) const + { + return !(*this < RHS); + } +}; + +template +void +SmallVectorImpl::swap (SmallVectorImpl &RHS) +{ + if (this == &RHS) + { + return; + } + + // We can only avoid copying elements if neither vector is small. + if (!this->isSmall () && !RHS.isSmall ()) + { + std::swap (this->BeginX, RHS.BeginX); + std::swap (this->Size, RHS.Size); + std::swap (this->Capacity, RHS.Capacity); + return; + } + this->reserve (RHS.size ()); + RHS.reserve (this->size ()); + + // Swap the shared elements. + size_t NumShared = this->size (); + if (NumShared > RHS.size ()) + { + NumShared = RHS.size (); + } + for (size_type i = 0; i != NumShared; ++i) + { + std::swap ((*this)[i], RHS[i]); + } + + // Copy over the extra elts. + if (this->size () > RHS.size ()) + { + size_t EltDiff = this->size () - RHS.size (); + this->uninitialized_copy (this->begin () + NumShared, this->end (), + RHS.end ()); + RHS.set_size (RHS.size () + EltDiff); + this->destroy_range (this->begin () + NumShared, this->end ()); + this->set_size (NumShared); + } + else if (RHS.size () > this->size ()) + { + size_t EltDiff = RHS.size () - this->size (); + this->uninitialized_copy (RHS.begin () + NumShared, RHS.end (), + this->end ()); + this->set_size (this->size () + EltDiff); + this->destroy_range (RHS.begin () + NumShared, RHS.end ()); + RHS.set_size (NumShared); + } +} + +template +SmallVectorImpl & +SmallVectorImpl::operator= (const SmallVectorImpl &RHS) +{ + // Avoid self-assignment. + if (this == &RHS) + { + return *this; + } + + // If we already have sufficient space, assign the common elements, then + // destroy any excess. + size_t RHSSize = RHS.size (); + size_t CurSize = this->size (); + if (CurSize >= RHSSize) + { + // Assign common elements. + iterator NewEnd; + if (RHSSize) + { + NewEnd = std::copy (RHS.begin (), RHS.begin () + RHSSize, this->begin ()); + } + else + { + NewEnd = this->begin (); + } + + // Destroy excess elements. + this->destroy_range (NewEnd, this->end ()); + + // Trim. + this->set_size (RHSSize); + return *this; + } + + // If we have to grow to have enough elements, destroy the current elements. + // This allows us to avoid copying them during the grow. + // FIXME: don't do this if they're efficiently moveable. + if (this->capacity () < RHSSize) + { + // Destroy current elements. + this->clear (); + CurSize = 0; + this->grow (RHSSize); + } + else if (CurSize) + { + // Otherwise, use assignment for the already-constructed elements. + std::copy (RHS.begin (), RHS.begin () + CurSize, this->begin ()); + } + + // Copy construct the new elements in place. + this->uninitialized_copy (RHS.begin () + CurSize, RHS.end (), + this->begin () + CurSize); + + // Set end. + this->set_size (RHSSize); + return *this; +} + +template +SmallVectorImpl & +SmallVectorImpl::operator= (SmallVectorImpl &&RHS) +{ + // Avoid self-assignment. + if (this == &RHS) + { + return *this; + } + + // If the RHS isn't small, clear this vector and then steal its buffer. + if (!RHS.isSmall ()) + { + this->assignRemote (std::move (RHS)); + return *this; + } + + // If we already have sufficient space, assign the common elements, then + // destroy any excess. + size_t RHSSize = RHS.size (); + size_t CurSize = this->size (); + if (CurSize >= RHSSize) + { + // Assign common elements. + iterator NewEnd = this->begin (); + if (RHSSize) + { + NewEnd = std::move (RHS.begin (), RHS.end (), NewEnd); + } + + // Destroy excess elements and trim the bounds. + this->destroy_range (NewEnd, this->end ()); + this->set_size (RHSSize); + + // Clear the RHS. + RHS.clear (); + + return *this; + } + + // If we have to grow to have enough elements, destroy the current elements. + // This allows us to avoid copying them during the grow. + // FIXME: this may not actually make any sense if we can efficiently move + // elements. + if (this->capacity () < RHSSize) + { + // Destroy current elements. + this->clear (); + CurSize = 0; + this->grow (RHSSize); + } + else if (CurSize) + { + // Otherwise, use assignment for the already-constructed elements. + std::move (RHS.begin (), RHS.begin () + CurSize, this->begin ()); + } + + // Move-construct the new elements in place. + this->uninitialized_move (RHS.begin () + CurSize, RHS.end (), + this->begin () + CurSize); + + // Set end. + this->set_size (RHSSize); + + RHS.clear (); + return *this; +} + +/// Storage for the SmallVector elements. This is specialized for the N=0 case +/// to avoid allocating unnecessary storage. +template struct SmallVectorStorage +{ + alignas (T) char InlineElts[N * sizeof (T)]; +}; + +/// We need the storage to be properly aligned even for small-size of 0 so that +/// the pointer math in \a SmallVectorTemplateCommon::getFirstEl() is +/// well-defined. +template struct alignas (T) SmallVectorStorage +{ +}; + +/// Forward declaration of SmallVector so that +/// calculateSmallVectorDefaultInlinedElements can reference +/// `sizeof(SmallVector)`. +template class LIBBASE_GSL_OWNER SmallVector; + +/// Helper class for calculating the default number of inline elements for +/// `SmallVector`. +/// +/// This should be migrated to a constexpr function when our minimum +/// compiler support is enough for multi-statement constexpr functions. +template struct CalculateSmallVectorDefaultInlinedElements +{ + // Parameter controlling the default number of inlined elements + // for `SmallVector`. + // + // The default number of inlined elements ensures that + // 1. There is at least one inlined element. + // 2. `sizeof(SmallVector) <= kPreferredSmallVectorSizeof` unless + // it contradicts 1. + static constexpr size_t kPreferredSmallVectorSizeof = 64; + + // static_assert that sizeof(T) is not "too big". + // + // Because our policy guarantees at least one inlined element, it is possible + // for an arbitrarily large inlined element to allocate an arbitrarily large + // amount of inline storage. We generally consider it an antipattern for a + // SmallVector to allocate an excessive amount of inline storage, so we want + // to call attention to these cases and make sure that users are making an + // intentional decision if they request a lot of inline storage. + // + // We want this assertion to trigger in pathological cases, but otherwise + // not be too easy to hit. To accomplish that, the cutoff is actually somewhat + // larger than kPreferredSmallVectorSizeof (otherwise, + // `SmallVector>` would be one easy way to trip it, and that + // pattern seems useful in practice). + // + // One wrinkle is that this assertion is in theory non-portable, since + // sizeof(T) is in general platform-dependent. However, we don't expect this + // to be much of an issue, because most LLVM development happens on 64-bit + // hosts, and therefore sizeof(T) is expected to *decrease* when compiled for + // 32-bit hosts, dodging the issue. The reverse situation, where development + // happens on a 32-bit host and then fails due to sizeof(T) *increasing* on a + // 64-bit host, is expected to be very rare. + static_assert ( + sizeof (T) <= 256, + "You are trying to use a default number of inlined elements for " + "`SmallVector` but `sizeof(T)` is really big! Please use an " + "explicit number of inlined elements with `SmallVector` to make " + "sure you really want that much inline storage."); + + // Discount the size of the header itself when calculating the maximum inline + // bytes. + static constexpr size_t PreferredInlineBytes = + kPreferredSmallVectorSizeof - sizeof (SmallVector); + static constexpr size_t NumElementsThatFit = + PreferredInlineBytes / sizeof (T); + static constexpr size_t value = + NumElementsThatFit == 0 ? 1 : NumElementsThatFit; +}; + +/// This is a 'vector' (really, a variable-sized array), optimized +/// for the case when the array is small. It contains some number of elements +/// in-place, which allows it to avoid heap allocation when the actual number of +/// elements is below that threshold. This allows normal "small" cases to be +/// fast without losing generality for large inputs. +/// +/// \note +/// In the absence of a well-motivated choice for the number of inlined +/// elements \p N, it is recommended to use \c SmallVector (that is, +/// omitting the \p N). This will choose a default number of inlined elements +/// reasonable for allocation on the stack (for example, trying to keep \c +/// sizeof(SmallVector) around 64 bytes). +/// +/// \warning This does not attempt to be exception safe. +/// +/// \see https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h +template ::value> +class LIBBASE_GSL_OWNER SmallVector : public SmallVectorImpl, + SmallVectorStorage +{ +public: + SmallVector () : SmallVectorImpl (N) + { + } + + ~SmallVector () + { + // Destroy the constructed elements in the vector. + this->destroy_range (this->begin (), this->end ()); + } + + explicit SmallVector (size_t SizeArg) : SmallVectorImpl (N) + { + this->resize (SizeArg); + } + + SmallVector (size_t SizeArg, const T &Value) : SmallVectorImpl (N) + { + this->assign (SizeArg, Value); + } + + template > + SmallVector (ItTy S, ItTy E) : SmallVectorImpl (N) + { + this->append (S, E); + } + + template + explicit SmallVector (const iterator_range &R) + : SmallVectorImpl (N) + { + this->append (R.begin (), R.end ()); + } + + SmallVector (std::initializer_list IL) : SmallVectorImpl (N) + { + this->append (IL); + } + + template >> + explicit SmallVector (ArrayRef A) : SmallVectorImpl (N) + { + this->append (A.begin (), A.end ()); + } + + SmallVector (const SmallVector &RHS) : SmallVectorImpl (N) + { + if (!RHS.empty ()) + { + SmallVectorImpl::operator= (RHS); + } + } + + SmallVector & + operator= (const SmallVector &RHS) + { + SmallVectorImpl::operator= (RHS); + return *this; + } + + // Reuse the move-assignment instantiation for trivially move-assignable + // elements. Calling moveConstructFrom unconditionally would emit an + // additional per-T wrapper at -O0, increasing object size. + // std::is_move_assignable_v is too broad: it can be a false positive for + // types with an unconstrained assignment operator whose body is ill-formed. + SmallVector (SmallVector &&RHS) : SmallVectorImpl (N) + { + if (!RHS.empty ()) + { + bool StoleAllocation = N > 0 && !RHS.isSmall (); + if constexpr (std::is_trivially_move_assignable_v) + { + SmallVectorImpl::operator= (::std::move (RHS)); + } + else + { + this->moveConstructFrom (::std::move (RHS)); + } + if constexpr (N > 0) + { + if (StoleAllocation) + { + RHS.set_allocation_range (RHS.begin (), N); + } + } + } + } + + SmallVector (SmallVectorImpl &&RHS) : SmallVectorImpl (N) + { + if (!RHS.empty ()) + { + if constexpr (std::is_trivially_move_assignable_v) + { + SmallVectorImpl::operator= (::std::move (RHS)); + } + else + { + this->moveConstructFrom (::std::move (RHS)); + } + } + } + + SmallVector & + operator= (SmallVector &&RHS) + { + if (N) + { + bool StoleAllocation = this != &RHS && !RHS.isSmall (); + SmallVectorImpl::operator= (::std::move (RHS)); + // Restore the inline capacity after stealing RHS's allocation. + if (StoleAllocation) + { + RHS.set_allocation_range (RHS.begin (), N); + } + return *this; + } + // SmallVectorImpl::operator= does not leverage N==0. Optimize the + // case. + if (this == &RHS) + { + return *this; + } + if (RHS.empty ()) + { + this->destroy_range (this->begin (), this->end ()); + this->Size = 0; + } + else + { + this->assignRemote (std::move (RHS)); + } + return *this; + } + + SmallVector & + operator= (SmallVectorImpl &&RHS) + { + SmallVectorImpl::operator= (::std::move (RHS)); + return *this; + } + + SmallVector & + operator= (std::initializer_list IL) + { + this->assign (IL); + return *this; + } +}; + +template +inline size_t +capacity_in_bytes (const SmallVector &X) +{ + return X.capacity_in_bytes (); +} + +template +using ValueTypeFromRangeType = std::ranges::range_value_t; + +/// Given a range of type R, iterate the entire range and return a +/// SmallVector with elements of the vector. This is useful, for example, +/// when you want to iterate a range and then sort the results. +template +SmallVector, Size> +to_vector (R &&Range) +{ + return SmallVector, Size> ( + std::ranges::begin (Range), std::ranges::end (Range)); +} +template +SmallVector> +to_vector (R &&Range) +{ + return SmallVector> (std::ranges::begin (Range), + std::ranges::end (Range)); +} + +template +SmallVector +to_vector_of (R &&Range) +{ + return SmallVector (std::ranges::begin (Range), + std::ranges::end (Range)); +} + +template +SmallVector +to_vector_of (R &&Range) +{ + return SmallVector (std::ranges::begin (Range), + std::ranges::end (Range)); +} + +// Explicit instantiations +extern template class rcc::SmallVectorBase; +#if SIZE_MAX > UINT32_MAX +extern template class rcc::SmallVectorBase; +#endif + +} // end namespace rcc + +namespace std +{ + +template struct hash> +{ + size_t + operator() (const rcc::SmallVector &Value) const + { + size_t Seed = 0; + for (const T &Element : Value) + { + size_t ElementHash = std::hash{}(Element); + Seed ^= ElementHash + static_cast (0x9e3779b9U) + (Seed << 6) + + (Seed >> 2); + } + return Seed; + } +}; + +/// Implement std::swap in terms of SmallVector swap. +template +inline void +swap (rcc::SmallVectorImpl &LHS, rcc::SmallVectorImpl &RHS) +{ + LHS.swap (RHS); +} + +/// Implement std::swap in terms of SmallVector swap. +template +inline void +swap (rcc::SmallVector &LHS, rcc::SmallVector &RHS) +{ + LHS.swap (RHS); +} + +} // end namespace std + +#endif // LIBBASE_ADT_SMALLVECTOR_H diff --git a/libbase/include/core/compiler/Compiler.h b/libbase/include/core/compiler/Compiler.h new file mode 100644 index 0000000..b21d6a1 --- /dev/null +++ b/libbase/include/core/compiler/Compiler.h @@ -0,0 +1,843 @@ +/* + RCC-Project + + Copyright (C) 2026 Richard Qin + + This file is part of RCC-Project. + + RCC-Project is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at your option) any + later version. + + RCC-Project is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR + A PARTICULAR PURPOSE. See the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along with + RCC-Project; see the file COPYING. If not see + . +*/ + +//===-- core/compiler/Compiler.h - Compiler abstraction support --*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines several macros, based on the current compiler. This allows +// use of compiler-specific features in a way that remains portable. This header +// can be included from either C or C++. +// +//===----------------------------------------------------------------------===// + +#ifndef LIBBASE_CORE_COMPILER_H +#define LIBBASE_CORE_COMPILER_H + +#include "core/config/libbase-config.h" + +#include + +#if defined(_MSC_VER) +#include +#endif + +#ifndef __has_feature +# define __has_feature(x) 0 +#endif + +#ifndef __has_extension +# define __has_extension(x) 0 +#endif + +#ifndef __has_attribute +# define __has_attribute(x) 0 +#endif + +#ifndef __has_builtin +# define __has_builtin(x) 0 +#endif + +#ifndef __has_warning +# define __has_warning(x) 0 +#endif + +// Only use __has_cpp_attribute in C++ mode. GCC defines __has_cpp_attribute in +// C mode, but the :: in __has_cpp_attribute(scoped::attribute) is invalid. +#ifndef LIBBASE_HAS_CPP_ATTRIBUTE +#if defined(__cplusplus) && defined(__has_cpp_attribute) +# define LIBBASE_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) +#else +# define LIBBASE_HAS_CPP_ATTRIBUTE(x) 0 +#endif +#endif + +/// \macro LIBBASE_GNUC_PREREQ +/// Extend the default __GNUC_PREREQ even if glibc's features.h isn't +/// available. +#ifndef LIBBASE_GNUC_PREREQ +# if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) +# define LIBBASE_GNUC_PREREQ(maj, min, patch) \ + ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \ + ((maj) << 20) + ((min) << 10) + (patch)) +# elif defined(__GNUC__) && defined(__GNUC_MINOR__) +# define LIBBASE_GNUC_PREREQ(maj, min, patch) \ + ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10)) +# else +# define LIBBASE_GNUC_PREREQ(maj, min, patch) 0 +# endif +#endif + +/// \macro LIBBASE_MSC_PREREQ +/// Is the compiler MSVC of at least the specified version? +/// The common \param version values to check for are: +/// * 1910: VS2017, version 15.1 & 15.2 +/// * 1911: VS2017, version 15.3 & 15.4 +/// * 1912: VS2017, version 15.5 +/// * 1913: VS2017, version 15.6 +/// * 1914: VS2017, version 15.7 +/// * 1915: VS2017, version 15.8 +/// * 1916: VS2017, version 15.9 +/// * 1920: VS2019, version 16.0 +/// * 1921: VS2019, version 16.1 +/// * 1922: VS2019, version 16.2 +/// * 1923: VS2019, version 16.3 +/// * 1924: VS2019, version 16.4 +/// * 1925: VS2019, version 16.5 +/// * 1926: VS2019, version 16.6 +/// * 1927: VS2019, version 16.7 +/// * 1928: VS2019, version 16.8 + 16.9 +/// * 1929: VS2019, version 16.10 + 16.11 +/// * 1930: VS2022, version 17.0 +#ifdef _MSC_VER +#define LIBBASE_MSC_PREREQ(version) (_MSC_VER >= (version)) + +// We require at least VS 2019. +#if !defined(LIBBASE_FORCE_USE_OLD_TOOLCHAIN) +#if !LIBBASE_MSC_PREREQ(1920) +#error LLVM requires at least VS 2019. +#endif +#endif + +#else +#define LIBBASE_MSC_PREREQ(version) 0 +#endif + +/// LIBBASE_LIBRARY_VISIBILITY - If a class marked with this attribute is linked +/// into a shared library, then the class should be private to the library and +/// not accessible from outside it. Can also be used to mark variables and +/// functions, making them private to any shared library they are linked into. +/// On PE/COFF targets, library visibility is the default, so this isn't needed. +/// +/// LIBBASE_EXTERNAL_VISIBILITY - classes, functions, and variables marked with +/// this attribute will be made public and visible outside of any shared library +/// they are linked in to. + +#if LIBBASE_HAS_CPP_ATTRIBUTE(gnu::visibility) && defined(__GNUC__) && \ + !defined(__clang__) +#define LIBBASE_ATTRIBUTE_VISIBILITY_HIDDEN [[gnu::visibility("hidden")]] +#define LIBBASE_ATTRIBUTE_VISIBILITY_DEFAULT [[gnu::visibility("default")]] +#elif __has_attribute(visibility) +#define LIBBASE_ATTRIBUTE_VISIBILITY_HIDDEN __attribute__((visibility("hidden"))) +#define LIBBASE_ATTRIBUTE_VISIBILITY_DEFAULT __attribute__((visibility("default"))) +#else +#define LIBBASE_ATTRIBUTE_VISIBILITY_HIDDEN +#define LIBBASE_ATTRIBUTE_VISIBILITY_DEFAULT +#endif + +#if defined(LIBBASE_BUILD_SHARED_LIBS) +#define LIBBASE_EXTERNAL_VISIBILITY LIBBASE_ATTRIBUTE_VISIBILITY_DEFAULT +#else +#define LIBBASE_EXTERNAL_VISIBILITY +#endif + +#if (!(defined(_WIN32) || defined(__CYGWIN__)) || \ + ((defined(__MINGW32__) || defined(__CYGWIN__)) && defined(__clang__))) +#define LIBBASE_LIBRARY_VISIBILITY LIBBASE_ATTRIBUTE_VISIBILITY_HIDDEN +// Clang compilers older then 15 do not support gnu style attributes on +// namespaces. +#if defined(__clang__) && __clang_major__ < 15 +#define LIBBASE_LIBRARY_VISIBILITY_NAMESPACE [[gnu::visibility("hidden")]] +#else +#define LIBBASE_LIBRARY_VISIBILITY_NAMESPACE LIBBASE_ATTRIBUTE_VISIBILITY_HIDDEN +#endif +#define LIBBASE_ALWAYS_EXPORT LIBBASE_ATTRIBUTE_VISIBILITY_DEFAULT +#elif defined(_WIN32) +#define LIBBASE_ALWAYS_EXPORT __declspec(dllexport) +#define LIBBASE_LIBRARY_VISIBILITY +#define LIBBASE_LIBRARY_VISIBILITY_NAMESPACE +#else +#define LIBBASE_LIBRARY_VISIBILITY +#define LIBBASE_ALWAYS_EXPORT +#define LIBBASE_LIBRARY_VISIBILITY_NAMESPACE +#endif + +/// LIBBASE_ABI is the main export/visibility macro to mark something as explicitly +/// exported when llvm is built as a shared library with everything else that is +/// unannotated will have internal visibility. +/// +/// LIBBASE_ABI_EXPORT is for the special case for things like plugin symbol +/// declarations or definitions where we don't want the macro to be switching +/// between dllexport and dllimport on windows based on what codebase is being +/// built, it will only be dllexport. For non windows platforms this macro +/// behaves the same as LIBBASE_ABI. +/// +/// LIBBASE_EXPORT_TEMPLATE is used on explicit template instantiations in source +/// files that were declared extern in a header. This macro is only set as a +/// compiler export attribute on windows, on other platforms it does nothing. +/// +/// LIBBASE_TEMPLATE_ABI is for annotating extern template declarations in headers +/// for both functions and classes. On windows its turned in to dllimport for +/// library consumers, for other platforms its a default visibility attribute. +/// +/// LIBBASE_ABI_FOR_TEST is for annotating symbols that are exported from a +/// library-internal header solely so that unit tests can link against them. +/// Symbols in LLVM's public headers are part of the LLVM public interface and +/// should use LIBBASE_ABI. LIBBASE_ABI_FOR_TEST is reserved for internal headers, +/// whose symbols could be conditionally excluded when not building tests in the +/// future. +/// +#ifndef LIBBASE_ABI_GENERATING_ANNOTATIONS +// Marker to add to classes or functions in public headers that should not have +// export macros added to them by the clang tool +#define LIBBASE_ABI_NOT_EXPORTED +// TODO(https://github.com/llvm/llvm-project/issues/145406): eliminate need for +// two preprocessor definitions to gate LIBBASE_ABI macro definitions. +#if defined(LIBBASE_ENABLE_EXPORT_ANNOTATIONS) && !defined(LIBBASE_BUILD_STATIC) +#if defined(_WIN32) && !defined(__MINGW32__) +#if defined(LIBBASE_EXPORTS) +#define LIBBASE_ABI __declspec(dllexport) +#define LIBBASE_TEMPLATE_ABI +#define LIBBASE_EXPORT_TEMPLATE __declspec(dllexport) +#else +#define LIBBASE_ABI __declspec(dllimport) +#define LIBBASE_TEMPLATE_ABI __declspec(dllimport) +#define LIBBASE_EXPORT_TEMPLATE +#endif +#define LIBBASE_ABI_EXPORT __declspec(dllexport) +#elif __has_attribute(visibility) +#if defined(__ELF__) || defined(__MINGW32__) || defined(_AIX) || \ + defined(__MVS__) || defined(__CYGWIN__) +#define LIBBASE_ABI __attribute__((visibility("default"))) +#define LIBBASE_TEMPLATE_ABI LIBBASE_ABI +#define LIBBASE_EXPORT_TEMPLATE +#define LIBBASE_ABI_EXPORT LIBBASE_ABI +#elif defined(__MACH__) || defined(__wasm__) || defined(__EMSCRIPTEN__) +#define LIBBASE_ABI __attribute__((visibility("default"))) +#define LIBBASE_TEMPLATE_ABI +#define LIBBASE_EXPORT_TEMPLATE +#define LIBBASE_ABI_EXPORT LIBBASE_ABI +#endif +#endif +#endif +#if !defined(LIBBASE_ABI) +#define LIBBASE_ABI +#define LIBBASE_TEMPLATE_ABI +#define LIBBASE_EXPORT_TEMPLATE +#define LIBBASE_ABI_EXPORT +#endif +#define LIBBASE_ABI_FOR_TEST LIBBASE_ABI +#endif + +#if defined(__GNUC__) +#define LIBBASE_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality) +#else +#define LIBBASE_PREFETCH(addr, rw, locality) +#endif + +#if __has_attribute(uninitialized) +#define LIBBASE_ATTRIBUTE_UNINITIALIZED __attribute__((uninitialized)) +#else +#define LIBBASE_ATTRIBUTE_UNINITIALIZED +#endif + +#if __has_attribute(used) +#define LIBBASE_ATTRIBUTE_USED __attribute__((__used__)) +#else +#define LIBBASE_ATTRIBUTE_USED +#endif + +#if __has_attribute(warn_unused) +#define LIBBASE_ATTRIBUTE_WARN_UNUSED __attribute__((warn_unused)) +#else +#define LIBBASE_ATTRIBUTE_WARN_UNUSED +#endif + +// Only enabled for clang: +// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99587 +// GCC may produce "warning: 'retain' attribute ignored" (despite +// __has_attribute(retain) being 1). +#if defined(__clang__) && __has_attribute(retain) +#define LIBBASE_ATTRIBUTE_RETAIN __attribute__((__retain__)) +#else +#define LIBBASE_ATTRIBUTE_RETAIN +#endif + +// For deprecations that are not a simple rename, use [[deprecated(MSG)]] +// instead. +#if defined(__clang__) +#define LIBBASE_DEPRECATED_WITH_FIXIT(MSG, FIX) \ + __attribute__((deprecated(MSG, FIX))) +#else +#define LIBBASE_DEPRECATED_WITH_FIXIT(MSG, FIX) [[deprecated(MSG)]] +#endif + +// clang-format off +#if defined(__clang__) || defined(__GNUC__) +#define LIBBASE_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH \ + _Pragma("GCC diagnostic push") \ + _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#define LIBBASE_SUPPRESS_DEPRECATED_DECLARATIONS_POP \ + _Pragma("GCC diagnostic pop") +#elif defined(_MSC_VER) +#define LIBBASE_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH \ + __pragma(warning(push)) \ + __pragma(warning(disable : 4996)) +#define LIBBASE_SUPPRESS_DEPRECATED_DECLARATIONS_POP \ + __pragma(warning(pop)) +#else +#define LIBBASE_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH +#define LIBBASE_SUPPRESS_DEPRECATED_DECLARATIONS_POP +#endif +// clang-format on + +// Indicate that a non-static, non-const C++ member function reinitializes +// the entire object to a known state, independent of the previous state of +// the object. +// +// The clang-tidy check bugprone-use-after-move recognizes this attribute as a +// marker that a moved-from object has left the indeterminate state and can be +// reused. +#if LIBBASE_HAS_CPP_ATTRIBUTE(clang::reinitializes) +#define LIBBASE_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]] +#else +#define LIBBASE_ATTRIBUTE_REINITIALIZES +#endif + +// Some compilers warn about unused functions. When a function is sometimes +// used or not depending on build settings (e.g. a function only called from +// within "assert"), this attribute can be used to suppress such warnings. +// +// However, it shouldn't be used for unused *variables*, as those have a much +// more portable solution: +// (void)unused_var_name; +// Prefer cast-to-void wherever it is sufficient. +#if __has_attribute(unused) +#define LIBBASE_ATTRIBUTE_UNUSED __attribute__((__unused__)) +#else +#define LIBBASE_ATTRIBUTE_UNUSED +#endif + +// FIXME: Provide this for PE/COFF targets. +#if __has_attribute(weak) && !defined(__MINGW32__) && !defined(__CYGWIN__) && \ + !defined(_WIN32) +#define LIBBASE_HAS_ATTRIBUTE_WEAK 1 +#else +#define LIBBASE_HAS_ATTRIBUTE_WEAK 0 +#endif +#if LIBBASE_HAS_ATTRIBUTE_WEAK +#define LIBBASE_ATTRIBUTE_WEAK __attribute__((__weak__)) +#else +#define LIBBASE_ATTRIBUTE_WEAK +#endif + +// Prior to clang 3.2, clang did not accept any spelling of +// __has_attribute(const), so assume it is supported. +#if defined(__clang__) || defined(__GNUC__) +// aka 'CONST' but following LLVM Conventions. +#define LIBBASE_READNONE __attribute__((__const__)) +#else +#define LIBBASE_READNONE +#endif + +#if __has_attribute(pure) || defined(__GNUC__) +// aka 'PURE' but following LLVM Conventions. +#define LIBBASE_READONLY __attribute__((__pure__)) +#else +#define LIBBASE_READONLY +#endif + +#if __has_attribute(minsize) +#define LIBBASE_ATTRIBUTE_MINSIZE __attribute__((minsize)) +#else +#define LIBBASE_ATTRIBUTE_MINSIZE +#endif + +#if __has_builtin(__builtin_expect) || defined(__GNUC__) +#define LIBBASE_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true) +#define LIBBASE_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false) +#else +#define LIBBASE_LIKELY(EXPR) (EXPR) +#define LIBBASE_UNLIKELY(EXPR) (EXPR) +#endif + +/// LIBBASE_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so, +/// mark a method "not for inlining". +#if __has_attribute(noinline) +#define LIBBASE_ATTRIBUTE_NOINLINE __attribute__((noinline)) +#elif defined(_MSC_VER) +#define LIBBASE_ATTRIBUTE_NOINLINE __declspec(noinline) +#else +#define LIBBASE_ATTRIBUTE_NOINLINE +#endif + +/// LIBBASE_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do +/// so, mark a method "always inline" because it is performance sensitive. +#if __has_attribute(always_inline) +#define LIBBASE_ATTRIBUTE_ALWAYS_INLINE inline __attribute__((always_inline)) +#elif defined(_MSC_VER) +#define LIBBASE_ATTRIBUTE_ALWAYS_INLINE __forceinline +#else +#define LIBBASE_ATTRIBUTE_ALWAYS_INLINE inline +#endif + +/// LIBBASE_ATTRIBUTE_ALWAYS_INLINE_UNLESS_DEBUG - Like +/// LIBBASE_ATTRIBUTE_ALWAYS_INLINE but disabled in debug builds to avoid stack +/// overflow with deep recursion. +#if defined(NDEBUG) +#define LIBBASE_ATTRIBUTE_ALWAYS_INLINE_UNLESS_DEBUG LIBBASE_ATTRIBUTE_ALWAYS_INLINE +#else +#define LIBBASE_ATTRIBUTE_ALWAYS_INLINE_UNLESS_DEBUG inline +#endif + +/// LIBBASE_ATTRIBUTE_NO_DEBUG - On compilers where we have a directive to do +/// so, mark a method "no debug" because debug info makes the debugger +/// experience worse. +#if __has_attribute(nodebug) +#define LIBBASE_ATTRIBUTE_NODEBUG __attribute__((nodebug)) +#else +#define LIBBASE_ATTRIBUTE_NODEBUG +#endif + +#if __has_attribute(returns_nonnull) +#define LIBBASE_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull)) +#elif defined(_MSC_VER) +#define LIBBASE_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_ +#else +#define LIBBASE_ATTRIBUTE_RETURNS_NONNULL +#endif + +/// LIBBASE_ATTRIBUTE_RESTRICT - Annotates a pointer to tell the compiler that +/// it is not aliased in the current scope. +#if defined(__clang__) || defined(__GNUC__) || defined(_MSC_VER) +#define LIBBASE_ATTRIBUTE_RESTRICT __restrict +#else +#define LIBBASE_ATTRIBUTE_RESTRICT +#endif + +/// \macro LIBBASE_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a +/// pointer that does not alias any other valid pointer. +#ifdef __GNUC__ +#define LIBBASE_ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__)) +#elif defined(_MSC_VER) +#define LIBBASE_ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict) +#else +#define LIBBASE_ATTRIBUTE_RETURNS_NOALIAS +#endif + +/// LIBBASE_FALLTHROUGH - Mark fallthrough cases in switch statements. +#if defined(__cplusplus) && __cplusplus > 201402L && LIBBASE_HAS_CPP_ATTRIBUTE(fallthrough) +#define LIBBASE_FALLTHROUGH [[fallthrough]] +#elif LIBBASE_HAS_CPP_ATTRIBUTE(gnu::fallthrough) +#define LIBBASE_FALLTHROUGH [[gnu::fallthrough]] +#elif __has_attribute(fallthrough) +#define LIBBASE_FALLTHROUGH __attribute__((fallthrough)) +#elif LIBBASE_HAS_CPP_ATTRIBUTE(clang::fallthrough) +#define LIBBASE_FALLTHROUGH [[clang::fallthrough]] +#else +#define LIBBASE_FALLTHROUGH +#endif + +/// LIBBASE_REQUIRE_CONSTANT_INITIALIZATION - Apply this to globals to ensure that +/// they are constant initialized. +#if LIBBASE_HAS_CPP_ATTRIBUTE(clang::require_constant_initialization) +#define LIBBASE_REQUIRE_CONSTANT_INITIALIZATION \ + [[clang::require_constant_initialization]] +#else +#define LIBBASE_REQUIRE_CONSTANT_INITIALIZATION +#endif + +/// LIBBASE_GSL_OWNER - Apply this to owning classes like SmallVector to enable +/// lifetime warnings. +#if LIBBASE_HAS_CPP_ATTRIBUTE(gsl::Owner) +#define LIBBASE_GSL_OWNER [[gsl::Owner]] +#else +#define LIBBASE_GSL_OWNER +#endif + +/// LIBBASE_GSL_POINTER - Apply this to non-owning classes like +/// StringRef to enable lifetime warnings. +#if LIBBASE_HAS_CPP_ATTRIBUTE(gsl::Pointer) +#define LIBBASE_GSL_POINTER [[gsl::Pointer]] +#else +#define LIBBASE_GSL_POINTER +#endif + +#if LIBBASE_HAS_CPP_ATTRIBUTE(clang::lifetimebound) +#define LIBBASE_LIFETIME_BOUND [[clang::lifetimebound]] +#else +#define LIBBASE_LIFETIME_BOUND +#endif + +#if LIBBASE_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L +#define LIBBASE_CTOR_NODISCARD [[nodiscard]] +#else +#define LIBBASE_CTOR_NODISCARD +#endif + +// Macro to suppress the MSVC warning C4848: +// "support for attribute [[msvc::no_unique_address]] in C++17 and earlier +// is a vendor extension". +// This warning is removed in versions >= 19.43. +#if !defined(_MSC_VER) || _MSC_VER >= 1943 || defined(__clang__) +#define LIBBASE_SUPPRESS_MSVC_ATTR_IS_VENDOR_EXT_PUSH +#define LIBBASE_SUPPRESS_MSVC_ATTR_IS_VENDOR_EXT_POP +#else // MSVC < 19.43 +#define LIBBASE_SUPPRESS_MSVC_ATTR_IS_VENDOR_EXT_PUSH \ + __pragma(warning(push)) __pragma(warning(disable : 4848)) +#define LIBBASE_SUPPRESS_MSVC_ATTR_IS_VENDOR_EXT_POP __pragma(warning(pop)) +#endif + +#if LIBBASE_HAS_CPP_ATTRIBUTE(no_unique_address) +#define LIBBASE_NO_UNIQUE_ADDRESS [[no_unique_address]] +#elif LIBBASE_HAS_CPP_ATTRIBUTE(msvc::no_unique_address) +#define LIBBASE_NO_UNIQUE_ADDRESS \ + LIBBASE_SUPPRESS_MSVC_ATTR_IS_VENDOR_EXT_PUSH \ + [[msvc::no_unique_address]] LIBBASE_SUPPRESS_MSVC_ATTR_IS_VENDOR_EXT_POP +#else +#define LIBBASE_NO_UNIQUE_ADDRESS +#endif + +/// LIBBASE_EXTENSION - Support compilers where we have a keyword to suppress +/// pedantic diagnostics. +#ifdef __GNUC__ +#define LIBBASE_EXTENSION __extension__ +#else +#define LIBBASE_EXTENSION +#endif + +/// LIBBASE_BUILTIN_UNREACHABLE - On compilers which support it, expands +/// to an expression which states that it is undefined behavior for the +/// compiler to reach this point. Otherwise is not defined. +/// +/// '#else' is intentionally left out so that other macro logic (e.g., +/// LIBBASE_ASSUME_ALIGNED and llvm_unreachable()) can detect whether +/// LIBBASE_BUILTIN_UNREACHABLE has a definition. +#if __has_builtin(__builtin_unreachable) || defined(__GNUC__) +# define LIBBASE_BUILTIN_UNREACHABLE __builtin_unreachable() +#elif defined(_MSC_VER) +# define LIBBASE_BUILTIN_UNREACHABLE __assume(false) +#endif + +/// LIBBASE_BUILTIN_TRAP - On compilers which support it, expands to an expression +/// which causes the program to exit abnormally. +#if __has_builtin(__builtin_trap) || defined(__GNUC__) +# define LIBBASE_BUILTIN_TRAP __builtin_trap() +#elif defined(_MSC_VER) +// The __debugbreak intrinsic is supported by MSVC, does not require forward +// declarations involving platform-specific typedefs (unlike RaiseException), +// results in a call to vectored exception handlers, and encodes to a short +// instruction that still causes the trapping behavior we want. +# define LIBBASE_BUILTIN_TRAP __debugbreak() +#else +# define LIBBASE_BUILTIN_TRAP *(volatile int*)0x11 = 0 +#endif + +/// LIBBASE_BUILTIN_DEBUGTRAP - On compilers which support it, expands to +/// an expression which causes the program to break while running +/// under a debugger. +#if __has_builtin(__builtin_debugtrap) +# define LIBBASE_BUILTIN_DEBUGTRAP __builtin_debugtrap() +#elif defined(_MSC_VER) +// The __debugbreak intrinsic is supported by MSVC and breaks while +// running under the debugger, and also supports invoking a debugger +// when the OS is configured appropriately. +# define LIBBASE_BUILTIN_DEBUGTRAP __debugbreak() +#else +// Just continue execution when built with compilers that have no +// support. This is a debugging aid and not intended to force the +// program to abort if encountered. +# define LIBBASE_BUILTIN_DEBUGTRAP +#endif + +/// \macro LIBBASE_ASSUME_ALIGNED +/// Returns a pointer with an assumed alignment. +#if __has_builtin(__builtin_assume_aligned) || defined(__GNUC__) +# define LIBBASE_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a) +#elif defined(LIBBASE_BUILTIN_UNREACHABLE) +# define LIBBASE_ASSUME_ALIGNED(p, a) \ + (((uintptr_t(p) % (a)) == 0) ? (p) : (LIBBASE_BUILTIN_UNREACHABLE, (p))) +#else +# define LIBBASE_ASSUME_ALIGNED(p, a) (p) +#endif + +/// \macro LIBBASE_PACKED +/// Used to specify a packed structure. +/// LIBBASE_PACKED( +/// struct A { +/// int i; +/// int j; +/// int k; +/// long long l; +/// }); +/// +/// LIBBASE_PACKED_START +/// struct B { +/// int i; +/// int j; +/// int k; +/// long long l; +/// }; +/// LIBBASE_PACKED_END +#ifdef _MSC_VER +# define LIBBASE_PACKED(d) __pragma(pack(push, 1)) d __pragma(pack(pop)) +# define LIBBASE_PACKED_START __pragma(pack(push, 1)) +# define LIBBASE_PACKED_END __pragma(pack(pop)) +#else +# define LIBBASE_PACKED(d) d __attribute__((packed)) +# define LIBBASE_PACKED_START _Pragma("pack(push, 1)") +# define LIBBASE_PACKED_END _Pragma("pack(pop)") +#endif + +/// \macro LIBBASE_MEMORY_SANITIZER_BUILD +/// Whether LLVM itself is built with MemorySanitizer instrumentation. +#if __has_feature(memory_sanitizer) +# define LIBBASE_MEMORY_SANITIZER_BUILD 1 +# include +# define LIBBASE_NO_SANITIZE_MEMORY_ATTRIBUTE __attribute__((no_sanitize_memory)) +#else +# define LIBBASE_MEMORY_SANITIZER_BUILD 0 +# define __msan_allocated_memory(p, size) +# define __msan_unpoison(p, size) +# define LIBBASE_NO_SANITIZE_MEMORY_ATTRIBUTE +#endif + +/// \macro LIBBASE_ADDRESS_SANITIZER_BUILD +/// Whether LLVM itself is built with AddressSanitizer instrumentation. +#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) +# define LIBBASE_ADDRESS_SANITIZER_BUILD 1 +#if __has_include() +# include +#else +// These declarations exist to support ASan with MSVC. If MSVC eventually ships +// asan_interface.h in their headers, then we can remove this. +#ifdef __cplusplus +extern "C" { +#endif +void __asan_poison_memory_region(void const volatile *addr, size_t size); +void __asan_unpoison_memory_region(void const volatile *addr, size_t size); +#ifdef __cplusplus +} // extern "C" +#endif +#endif +#else +# define LIBBASE_ADDRESS_SANITIZER_BUILD 0 +# define __asan_poison_memory_region(p, size) +# define __asan_unpoison_memory_region(p, size) +#endif + +/// \macro LIBBASE_HWADDRESS_SANITIZER_BUILD +/// Whether LLVM itself is built with HWAddressSanitizer instrumentation. +#if __has_feature(hwaddress_sanitizer) +#define LIBBASE_HWADDRESS_SANITIZER_BUILD 1 +#else +#define LIBBASE_HWADDRESS_SANITIZER_BUILD 0 +#endif + +/// \macro LIBBASE_THREAD_SANITIZER_BUILD +/// Whether LLVM itself is built with ThreadSanitizer instrumentation. +#if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__) +# define LIBBASE_THREAD_SANITIZER_BUILD 1 +#else +# define LIBBASE_THREAD_SANITIZER_BUILD 0 +#endif + +#if LIBBASE_THREAD_SANITIZER_BUILD +// Thread Sanitizer is a tool that finds races in code. +// See http://code.google.com/p/data-race-test/wiki/DynamicAnnotations . +// tsan detects these exact functions by name. +#ifdef __cplusplus +extern "C" { +#endif +void AnnotateHappensAfter(const char *file, int line, const volatile void *cv); +void AnnotateHappensBefore(const char *file, int line, const volatile void *cv); +void AnnotateIgnoreWritesBegin(const char *file, int line); +void AnnotateIgnoreWritesEnd(const char *file, int line); +#ifdef __cplusplus +} +#endif + +// This marker is used to define a happens-before arc. The race detector will +// infer an arc from the begin to the end when they share the same pointer +// argument. +# define TsanHappensBefore(cv) AnnotateHappensBefore(__FILE__, __LINE__, cv) + +// This marker defines the destination of a happens-before arc. +# define TsanHappensAfter(cv) AnnotateHappensAfter(__FILE__, __LINE__, cv) + +// Ignore any races on writes between here and the next TsanIgnoreWritesEnd. +# define TsanIgnoreWritesBegin() AnnotateIgnoreWritesBegin(__FILE__, __LINE__) + +// Resume checking for racy writes. +# define TsanIgnoreWritesEnd() AnnotateIgnoreWritesEnd(__FILE__, __LINE__) +#else +# define TsanHappensBefore(cv) +# define TsanHappensAfter(cv) +# define TsanIgnoreWritesBegin() +# define TsanIgnoreWritesEnd() +#endif + +/// \macro LIBBASE_NO_SANITIZE +/// Disable a particular sanitizer for a function. +#if __has_attribute(no_sanitize) +#define LIBBASE_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND))) +#else +#define LIBBASE_NO_SANITIZE(KIND) +#endif + +/// Mark debug helper function definitions like dump() that should not be +/// stripped from debug builds. +/// Note that you should also surround dump() functions with +/// `#if !defined(NDEBUG) || defined(LIBBASE_ENABLE_DUMP)` so they do always +/// get stripped in release builds. +// FIXME: Move this to a private config.h as it's not usable in public headers. +#if !defined(NDEBUG) || defined(LIBBASE_ENABLE_DUMP) +#define LIBBASE_DUMP_METHOD \ + LIBBASE_ATTRIBUTE_NOINLINE LIBBASE_ATTRIBUTE_USED LIBBASE_ATTRIBUTE_RETAIN +#else +#define LIBBASE_DUMP_METHOD LIBBASE_ATTRIBUTE_NOINLINE +#endif + +/// \macro LIBBASE_PRETTY_FUNCTION +/// Gets a user-friendly looking function signature for the current scope +/// using the best available method on each platform. The exact format of the +/// resulting string is implementation specific and non-portable, so this should +/// only be used, for example, for logging or diagnostics. +#if defined(_MSC_VER) +#define LIBBASE_PRETTY_FUNCTION __FUNCSIG__ +#elif defined(__GNUC__) || defined(__clang__) +#define LIBBASE_PRETTY_FUNCTION __PRETTY_FUNCTION__ +#else +#define LIBBASE_PRETTY_FUNCTION __func__ +#endif + +/// \macro LIBBASE_THREAD_LOCAL +/// A thread-local storage specifier which can be used with globals, +/// extern globals, and static globals. +/// +/// This is essentially an extremely restricted analog to C++11's thread_local +/// support. It uses thread_local if available, falling back on gcc __thread +/// if not. __thread doesn't support many of the C++11 thread_local's +/// features. You should only use this for PODs that you can statically +/// initialize to some constant value. In almost all circumstances this is most +/// appropriate for use with a pointer, integer, or small aggregation of +/// pointers and integers. +#if LIBBASE_ENABLE_THREADS +#if __has_feature(cxx_thread_local) || defined(_MSC_VER) +#define LIBBASE_THREAD_LOCAL thread_local +#else +// Clang, GCC, and other compatible compilers used __thread prior to C++11 and +// we only need the restricted functionality that provides. +#define LIBBASE_THREAD_LOCAL __thread +#endif +#else // !LIBBASE_ENABLE_THREADS +// If threading is disabled entirely, this compiles to nothing and you get +// a normal global variable. +#define LIBBASE_THREAD_LOCAL +#endif + +/// \macro LIBBASE_ENABLE_EXCEPTIONS +/// Whether LLVM is built with exception support. +#if __has_feature(cxx_exceptions) +#define LIBBASE_ENABLE_EXCEPTIONS 1 +#elif defined(__GNUC__) && defined(__EXCEPTIONS) +#define LIBBASE_ENABLE_EXCEPTIONS 1 +#elif defined(_MSC_VER) && defined(_CPPUNWIND) +#define LIBBASE_ENABLE_EXCEPTIONS 1 +#endif + +/// \macro LIBBASE_NO_PROFILE_INSTRUMENT_FUNCTION +/// Disable the profile instrument for a function. +#if __has_attribute(no_profile_instrument_function) +#define LIBBASE_NO_PROFILE_INSTRUMENT_FUNCTION \ + __attribute__((no_profile_instrument_function)) +#else +#define LIBBASE_NO_PROFILE_INSTRUMENT_FUNCTION +#endif + +/// \macro LIBBASE_PREFERRED_TYPE +/// Adjust type of bit-field in debug info. +#if __has_attribute(preferred_type) +#define LIBBASE_PREFERRED_TYPE(T) __attribute__((preferred_type(T))) +#else +#define LIBBASE_PREFERRED_TYPE(T) +#endif + +#if LIBBASE_HAS_CPP_ATTRIBUTE(clang::ptrauth_vtable_pointer) && \ + (defined(__PTRAUTH__) || __has_feature(ptrauth_calls)) +#define LIBBASE_MOVABLE_POLYMORPHIC_TYPE \ + [[clang::ptrauth_vtable_pointer(default_key, no_address_discrimination, \ + default_extra_discrimination)]] +#else +#define LIBBASE_MOVABLE_POLYMORPHIC_TYPE +#endif + +/// \macro LIBBASE_VIRTUAL_ANCHOR_FUNCTION +/// This macro is used to adhere to LLVM's policy that each class with a vtable +/// must have at least one out-of-line virtual function. This macro allows us +/// to declare such a function in `final` classes without triggering a warning. +// clang-format off +// Autoformatting makes this look awful. +#if defined(__clang__) + // Make sure this is only parsed if __clang__ is defined + #if __has_warning("-Wunnecessary-virtual-specifier") + #define LIBBASE_DECLARE_VIRTUAL_ANCHOR_FUNCTION() \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Wunnecessary-virtual-specifier\"") \ + virtual void anchor() \ + _Pragma("clang diagnostic pop") + #else // __has_warning + #define LIBBASE_DECLARE_VIRTUAL_ANCHOR_FUNCTION() \ + virtual void anchor() + #endif +#else // defined(__clang__) + #define LIBBASE_DECLARE_VIRTUAL_ANCHOR_FUNCTION() \ + virtual void anchor() +#endif +// clang-format on + +/// \macro LIBBASE_IS_X86 +/// Whether the target architecture is x86 / x86-64. +#if defined(__x86_64__) || defined(__i386__) +#define LIBBASE_IS_X86 1 +#else +#define LIBBASE_IS_X86 0 +#endif + +/// \macro LIBBASE_TARGET_SSE42 +/// Function attribute to compile a function with SSE4.2 enabled. +#if defined(__has_attribute) && __has_attribute(target) +#define LIBBASE_TARGET_SSE42 __attribute__((target("sse4.2"))) +#else +#define LIBBASE_TARGET_SSE42 +#endif + +#if __has_builtin(__builtin_cpu_supports) && \ + (defined(__linux__) || defined(__APPLE__)) +#define LIBBASE_CPU_SUPPORTS(feature) __builtin_cpu_supports(feature) +#else +#define LIBBASE_CPU_SUPPORTS(feature) 0 +#endif + +/// \macro LIBBASE_CPU_SUPPORTS_SSE42 +/// Expands to true if the runtime cpu supports SSE4.2, or if compiled with +/// SSE4.2 enabled. +#if defined(__SSE4_2__) +#define LIBBASE_CPU_SUPPORTS_SSE42 1 +#else +#define LIBBASE_CPU_SUPPORTS_SSE42 LIBBASE_CPU_SUPPORTS("sse4.2") +#endif + +#endif diff --git a/libbase/include/core/compiler/DataTypes.h b/libbase/include/core/compiler/DataTypes.h new file mode 100644 index 0000000..bfcf577 --- /dev/null +++ b/libbase/include/core/compiler/DataTypes.h @@ -0,0 +1,105 @@ +/* + RCC-Project + + Copyright (C) 2026 Richard Qin + + This file is part of RCC-Project. + + RCC-Project is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3, or (at your option) any later + version. + + RCC-Project is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + +You should have received a copy of the GNU General Public License +along with RCC-Project; see the file COPYING. If not see +. +*/ + +// This implementation is based on include/llvm-c/DataTypes.h +/*===-- include/llvm-c/DataTypes.h - Define fixed size types ------*- C -*-===*\ + | * *|* + |* Part of the LLVM Project, under the Apache License v2.0 with LLVM *| + |* Exceptions. *| + |* See https://llvm.org/LICENSE.txt for license information. *| + |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception *| + |* *| + |*===----------------------------------------------------------------------===*| + |* *| + |* This file contains definitions to figure out the size of _HOST_ data + types.*| + |* This file is important because different host OS's define different + macros,*| + |* which makes portability tough. This file exports the following *| + |* definitions: *| + |* *| + |* [u]int(32|64)_t : typedefs for signed and unsigned 32/64 bit system + types*| + |* [U]INT(8|16|32|64)_(MIN|MAX) : Constants for the min and max values. *| + |* *| + |* No library is required when using these functions. *| + |* *| + |*===----------------------------------------------------------------------===*/ + +/* Please leave this file C-compatible. */ +#ifndef LIBBASE_DATATYPES_H +#define LIBBASE_DATATYPES_H + +#include +#include + +#ifndef _MSC_VER + +#if !defined(UINT32_MAX) +#error "The standard header is not C++11 compliant. Must #define "\ + "__STDC_LIMIT_MACROS before #including llvm-c/DataTypes.h" +#endif + +#if !defined(UINT32_C) +#error "The standard header is not C++11 compliant. Must #define "\ + "__STDC_CONSTANT_MACROS before #including llvm-c/DataTypes.h" +#endif + +/* Note that includes , if this is a C99 system. */ +#include + +#ifdef _AIX +// GCC is strict about defining large constants: they must have LL modifier. +#undef INT64_MAX +#undef INT64_MIN +#endif + +#else /* _MSC_VER */ +#ifdef __cplusplus +#include +#include +#else +#include +#include +#endif +#include + +#if defined(_WIN64) +typedef signed __int64 ssize_t; +#else +typedef signed int ssize_t; +#endif /* _WIN64 */ + +#endif /* _MSC_VER */ + +/* Set defaults for constants which we cannot find. */ +#if !defined(INT64_MAX) +#define INT64_MAX 9223372036854775807LL +#endif +#if !defined(INT64_MIN) +#define INT64_MIN ((-INT64_MAX) - 1) +#endif +#if !defined(UINT64_MAX) +#define UINT64_MAX 0xffffffffffffffffULL +#endif + +#endif diff --git a/libbase/include/core/config/config.h.cmake b/libbase/include/core/config/config.h.cmake new file mode 100644 index 0000000..cf9b602 --- /dev/null +++ b/libbase/include/core/config/config.h.cmake @@ -0,0 +1,219 @@ +#ifndef LIBBASE_PRIVATE_CONFIG_H +#define LIBBASE_PRIVATE_CONFIG_H + +// Include this header only under the libbase source tree. +// This is a private header. + +/* Exported configuration */ +#include "core/config/libbase-config.h" + +/* Define to 1 to enable backtraces, and to 0 otherwise. */ +#cmakedefine01 ENABLE_BACKTRACES + +/* Define to 1 to enable crash overrides, and to 0 otherwise. */ +#cmakedefine01 ENABLE_CRASH_OVERRIDES + +/* Define to 1 to enable crash memory dumps, and to 0 otherwise. */ +#cmakedefine01 RCC_ENABLE_CRASH_DUMPS + +/* Define to 1 to prefer forward slashes on Windows, and to 0 otherwise. */ +#cmakedefine01 RCC_WINDOWS_PREFER_FORWARD_SLASH + +/* Define to 1 if you have the `backtrace' function. */ +#cmakedefine HAVE_BACKTRACE ${HAVE_BACKTRACE} + +#define BACKTRACE_HEADER <${BACKTRACE_HEADER}> + +/* can use __crashreporter_info__ */ +#cmakedefine01 HAVE_CRASHREPORTER_INFO + +/* Define to 1 if you have the declaration of `arc4random', and to 0 if you + don't. */ +#cmakedefine01 HAVE_DECL_ARC4RANDOM + +/* Define to 1 if you have the declaration of `strerror_s', and to 0 if you + don't. */ +#cmakedefine01 HAVE_DECL_STRERROR_S + +/* Define if dlopen() is available on this platform. */ +#cmakedefine HAVE_DLOPEN ${HAVE_DLOPEN} + +/* Define to 1 if you have the `futimens' function. */ +#cmakedefine HAVE_FUTIMENS ${HAVE_FUTIMENS} + +/* Define to 1 if you have the `futimes' function. */ +#cmakedefine HAVE_FUTIMES ${HAVE_FUTIMES} + +/* Define to 1 if you have the `getpagesize' function. */ +#cmakedefine HAVE_GETPAGESIZE ${HAVE_GETPAGESIZE} + +/* Define to 1 if you have the `getrusage' function. */ +#cmakedefine HAVE_GETRUSAGE ${HAVE_GETRUSAGE} + +/* Define to 1 if you have the `isatty' function. */ +#cmakedefine HAVE_ISATTY 1 + +/* Define to 1 if you have the `edit' library (-ledit). */ +#cmakedefine HAVE_LIBEDIT ${HAVE_LIBEDIT} + +/* Define to 1 if you have the `psapi' library (-lpsapi). */ +#cmakedefine HAVE_LIBPSAPI ${HAVE_LIBPSAPI} + +/* Define to 1 if you have the `pthread' library (-lpthread). */ +#cmakedefine HAVE_LIBPTHREAD ${HAVE_LIBPTHREAD} + +/* Define to 1 if you have the `pthread_getname_np' function. */ +#cmakedefine HAVE_PTHREAD_GETNAME_NP ${HAVE_PTHREAD_GETNAME_NP} + +/* Define to 1 if you have the `pthread_setname_np' function. */ +#cmakedefine HAVE_PTHREAD_SETNAME_NP ${HAVE_PTHREAD_SETNAME_NP} + +/* Define to 1 if you have the `pthread_get_name_np' function. */ +#cmakedefine HAVE_PTHREAD_GET_NAME_NP ${HAVE_PTHREAD_GET_NAME_NP} + +/* Define to 1 if you have the `pthread_set_name_np' function. */ +#cmakedefine HAVE_PTHREAD_SET_NAME_NP ${HAVE_PTHREAD_SET_NAME_NP} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_MACH_MACH_H ${HAVE_MACH_MACH_H} + +/* Define to 1 if you have the `mallctl' function. */ +#cmakedefine HAVE_MALLCTL ${HAVE_MALLCTL} + +/* Define to 1 if you have the `mallinfo' function. */ +#cmakedefine HAVE_MALLINFO ${HAVE_MALLINFO} + +/* Define to 1 if you have the `mallinfo2' function. */ +#cmakedefine HAVE_MALLINFO2 ${HAVE_MALLINFO2} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_MALLOC_MALLOC_H ${HAVE_MALLOC_MALLOC_H} + +/* Define to 1 if you have the `malloc_zone_statistics' function. */ +#cmakedefine HAVE_MALLOC_ZONE_STATISTICS ${HAVE_MALLOC_ZONE_STATISTICS} + +/* Define to 1 if you have the `posix_spawn' function. */ +#cmakedefine HAVE_POSIX_SPAWN ${HAVE_POSIX_SPAWN} + +/* Define to 1 if you have the `pread' function. */ +#cmakedefine HAVE_PREAD ${HAVE_PREAD} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_PTHREAD_H ${HAVE_PTHREAD_H} + +/* Have pthread_rwlock_init */ +#cmakedefine HAVE_PTHREAD_RWLOCK_INIT ${HAVE_PTHREAD_RWLOCK_INIT} + +/* Define to 1 if you have the `sbrk' function. */ +#cmakedefine HAVE_SBRK ${HAVE_SBRK} + +/* Define to 1 if you have the `setenv' function. */ +#cmakedefine HAVE_SETENV ${HAVE_SETENV} + +/* Define to 1 if you have the `sigaltstack' function. */ +#cmakedefine HAVE_SIGALTSTACK ${HAVE_SIGALTSTACK} + +/* Define to 1 if you have the `strerror_r' function. */ +#cmakedefine HAVE_STRERROR_R ${HAVE_STRERROR_R} + +/* Define to 1 if you have the `sysconf' function. */ +#cmakedefine HAVE_SYSCONF ${HAVE_SYSCONF} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_MMAN_H ${HAVE_SYS_MMAN_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_IOCTL_H ${HAVE_SYS_IOCTL_H} + +/* Define to 1 if stat struct has st_mtimespec member .*/ +#cmakedefine HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC ${HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC} + +/* Define to 1 if stat struct has st_mtim member. */ +#cmakedefine HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC ${HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_UNISTD_H ${HAVE_UNISTD_H} + +/* Have host's _alloca */ +#cmakedefine HAVE__ALLOCA ${HAVE__ALLOCA} + +/* Define to 1 if you have the `_chsize_s' function. */ +#cmakedefine HAVE__CHSIZE_S ${HAVE__CHSIZE_S} + +/* Define to 1 if you have the `_Unwind_Backtrace' function. */ +#cmakedefine HAVE__UNWIND_BACKTRACE ${HAVE__UNWIND_BACKTRACE} + +/* Have host's __alloca */ +#cmakedefine HAVE___ALLOCA ${HAVE___ALLOCA} + +/* Have host's __ashldi3 */ +#cmakedefine HAVE___ASHLDI3 ${HAVE___ASHLDI3} + +/* Have host's __ashrdi3 */ +#cmakedefine HAVE___ASHRDI3 ${HAVE___ASHRDI3} + +/* Have host's __chkstk */ +#cmakedefine HAVE___CHKSTK ${HAVE___CHKSTK} + +/* Have host's __chkstk_ms */ +#cmakedefine HAVE___CHKSTK_MS ${HAVE___CHKSTK_MS} + +/* Have host's __cmpdi2 */ +#cmakedefine HAVE___CMPDI2 ${HAVE___CMPDI2} + +/* Have host's __divdi3 */ +#cmakedefine HAVE___DIVDI3 ${HAVE___DIVDI3} + +/* Have host's __fixdfdi */ +#cmakedefine HAVE___FIXDFDI ${HAVE___FIXDFDI} + +/* Have host's __fixsfdi */ +#cmakedefine HAVE___FIXSFDI ${HAVE___FIXSFDI} + +/* Have host's __floatdidf */ +#cmakedefine HAVE___FLOATDIDF ${HAVE___FLOATDIDF} + +/* Have host's __lshrdi3 */ +#cmakedefine HAVE___LSHRDI3 ${HAVE___LSHRDI3} + +/* Have host's __main */ +#cmakedefine HAVE___MAIN ${HAVE___MAIN} + +/* Have host's __moddi3 */ +#cmakedefine HAVE___MODDI3 ${HAVE___MODDI3} + +/* Have host's __udivdi3 */ +#cmakedefine HAVE___UDIVDI3 ${HAVE___UDIVDI3} + +/* Have host's __umoddi3 */ +#cmakedefine HAVE___UMODDI3 ${HAVE___UMODDI3} + +/* Have host's ___chkstk */ +#cmakedefine HAVE____CHKSTK ${HAVE____CHKSTK} + +/* Have host's ___chkstk_ms */ +#cmakedefine HAVE____CHKSTK_MS ${HAVE____CHKSTK_MS} + +/* Define if ICU library is available */ +#cmakedefine01 HAVE_ICU + +/* Define if Windows vendored ICU is available */ +#cmakedefine01 HAVE_WINDOWS_ICU + +/* Define if iconv library is available */ +#cmakedefine01 HAVE_ICONV + +/* Define to a function implementing stricmp */ +#cmakedefine stricmp ${stricmp} + +/* Define to a function implementing strdup */ +#cmakedefine strdup ${strdup} + +/* Whether Timers signpost passes in Xcode Instruments */ +#cmakedefine01 RCC_SUPPORT_XCODE_SIGNPOSTS + +#cmakedefine HAVE_PROC_PID_RUSAGE 1 + +#cmakedefine HAVE_GETAUXVAL ${HAVE_GETAUXVAL} + +#endif diff --git a/libbase/include/core/config/libbase-config.h.cmake b/libbase/include/core/config/libbase-config.h.cmake new file mode 100644 index 0000000..2ea111b --- /dev/null +++ b/libbase/include/core/config/libbase-config.h.cmake @@ -0,0 +1,89 @@ +/* + RCC-Project + + Copyright (C) 2026 Richard Qin + + This file is part of RCC-Project. + + RCC-Project is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at your option) any + later version. + + RCC-Project is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR + A PARTICULAR PURPOSE. See the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along with + RCC-Project; see the file COPYING. If not see + . +*/ + +/* This file enumerates variables from the libbase configuration so that they + can be used by exported headers without depending on RCC configuration. */ + +#ifndef LIBBASE_CONFIG_H +#define LIBBASE_CONFIG_H + +/* Define if libbase dump support is enabled. */ +#cmakedefine LIBBASE_ENABLE_DUMP + +/* Define if threads are enabled in libbase. */ +#cmakedefine01 LIBBASE_ENABLE_THREADS + +/* Has gcc/MSVC atomic intrinsics. */ +#cmakedefine01 LIBBASE_HAS_ATOMICS + +/* Define if this is a Unixish platform. */ +#cmakedefine LIBBASE_ON_UNIX ${LIBBASE_ON_UNIX} + +/* Whether libbase records statistics. */ +#cmakedefine01 LIBBASE_FORCE_ENABLE_STATS + +/* Define if libbase has z3 support. */ +#cmakedefine LIBBASE_WITH_Z3 ${LIBBASE_WITH_Z3} + +/* Define if libbase has curl support. */ +#cmakedefine LIBBASE_ENABLE_CURL ${LIBBASE_ENABLE_CURL} + +/* Define if libbase has cpp-httplib support. */ +#cmakedefine LIBBASE_ENABLE_HTTPLIB ${LIBBASE_ENABLE_HTTPLIB} + +/* Define if zlib compression is available to libbase. */ +#cmakedefine01 LIBBASE_ENABLE_ZLIB + +/* Define if zstd compression is available to libbase. */ +#cmakedefine01 LIBBASE_ENABLE_ZSTD + +/* Define if xz (lzma) decompression is available to libbase. */ +#cmakedefine01 LIBBASE_ENABLE_LZMA + +/* Define to 1 if libbase has the header file. */ +#cmakedefine LIBBASE_HAVE_SYSEXITS_H ${LIBBASE_HAVE_SYSEXITS_H} + +/* Define if libbase is built with BUILD_SHARED_LIBS. */ +#cmakedefine LIBBASE_BUILD_SHARED_LIBS + +/* Define if libbase is built as a static library. */ +#cmakedefine LIBBASE_BUILD_STATIC + +/* Define if exporting the libbase public interface for a shared library. */ +#cmakedefine LIBBASE_ENABLE_EXPORT_ANNOTATIONS + +/* Define if libbase uses the old toolchain behavior. */ +#cmakedefine LIBBASE_FORCE_USE_OLD_TOOLCHAIN ${LIBBASE_FORCE_USE_OLD_TOOLCHAIN} + +/* Define if libbase_unreachable should be optimized with undefined behavior + * in non-assert builds. */ +#cmakedefine01 LIBBASE_UNREACHABLE_OPTIMIZE + +/* Define if libbase provides I/O sandbox support. */ +#cmakedefine01 LIBBASE_ENABLE_IO_SANDBOX + +/* Define if logf128 is available to libbase. */ +#cmakedefine LIBBASE_HAS_LOGF128 + +/* Define if libbase provides on-disk content-addressable storage. */ +#cmakedefine01 LIBBASE_ENABLE_ONDISK_CAS + +#endif diff --git a/libbase/include/core/error/Errno.h b/libbase/include/core/error/Errno.h new file mode 100644 index 0000000..01d4ff8 --- /dev/null +++ b/libbase/include/core/error/Errno.h @@ -0,0 +1,64 @@ +/* + RCC-Project + + Copyright (C) 2026 Richard Qin + + This file is part of RCC-Project. + + RCC-Project is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at your option) any + later version. + + RCC-Project is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR + A PARTICULAR PURPOSE. See the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along with + RCC-Project; see the file COPYING. If not see + . +*/ + +// This implementation is based on llvm/include/llvm/Support/Errno.h. + +#ifndef LIBBASE_SUPPORT_ERRNO_H +#define LIBBASE_SUPPORT_ERRNO_H + +#include "core/compiler/Compiler.h" + +#include +#include + +namespace rcc +{ +namespace sys +{ + +/// Returns a string representation of the errno value, using whatever +/// thread-safe variant of strerror() is available. Be sure to call this +/// immediately after the function that set errno, or errno may have been +/// overwritten by an intervening call. +LIBBASE_ABI std::string +StrError (); + +/// Like the no-argument version above, but uses \p errnum instead of errno. +LIBBASE_ABI std::string +StrError (int errnum); + +template +inline decltype (auto) +RetryAfterSignal (const FailT &Fail, const Fun &F, const Args &...As) +{ + decltype (F (As...)) Res; + do + { + errno = 0; + Res = F (As...); + } while (Res == Fail && errno == EINTR); + return Res; +} + +} // namespace sys +} // namespace rcc + +#endif // LIBBASE_SUPPORT_ERRNO_H diff --git a/libbase/include/core/error/ErrorHandling.h b/libbase/include/core/error/ErrorHandling.h new file mode 100644 index 0000000..b27104c --- /dev/null +++ b/libbase/include/core/error/ErrorHandling.h @@ -0,0 +1,217 @@ +/* + RCC-Project + + Copyright (C) 2026 Richard Qin + + This file is part of RCC-Project. + + RCC-Project is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at your option) any + later version. + + RCC-Project is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR + A PARTICULAR PURPOSE. See the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along with + RCC-Project; see the file COPYING. If not see + . + */ + +//===- llvm/Support/ErrorHandling.h - Fatal error handling ------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines an API used to indicate fatal error conditions. Non-fatal +// errors (most of them) should be handled through LLVMContext. +// +//===----------------------------------------------------------------------===// + +#ifndef LIBBASE_SUPPORT_ERRORHANDLING_H +#define LIBBASE_SUPPORT_ERRORHANDLING_H + +#include "core/compiler/Compiler.h" + +namespace rcc +{ +class StringRef; +class Twine; + +/// An error handler callback. +using fatal_error_handler_t = void (*) (void *user_data, const char *reason, + bool gen_crash_diag); + +/// install_fatal_error_handler - Installs a new error handler to be used +/// whenever a serious (non-recoverable) error is encountered by LLVM. +/// +/// If no error handler is installed the default is to print the error message +/// to stderr, and call exit(1). If an error handler is installed then it is +/// the handler's responsibility to log the message, it will no longer be +/// printed to stderr. If the error handler returns, then exit(1) will be +/// called. +/// +/// It is dangerous to naively use an error handler which throws an exception. +/// Even though some applications desire to gracefully recover from arbitrary +/// faults, blindly throwing exceptions through unfamiliar code isn't a way to +/// achieve this. +/// +/// \param user_data - An argument which will be passed to the install error +/// handler. +LIBBASE_ABI void +install_fatal_error_handler (fatal_error_handler_t handler, + void *user_data = nullptr); + +/// Restores default error handling behaviour. +LIBBASE_ABI void +remove_fatal_error_handler (); + +/// ScopedFatalErrorHandler - This is a simple helper class which just +/// calls install_fatal_error_handler in its constructor and +/// remove_fatal_error_handler in its destructor. +struct ScopedFatalErrorHandler +{ + explicit ScopedFatalErrorHandler (fatal_error_handler_t handler, + void *user_data = nullptr) + { + install_fatal_error_handler (handler, user_data); + } + + ~ScopedFatalErrorHandler () + { + remove_fatal_error_handler (); + } +}; + +/// @deprecated Use reportFatalInternalError() or reportFatalUsageError() +/// instead. +[[noreturn]] LIBBASE_ABI void +report_fatal_error (const char *reason, bool gen_crash_diag = true); +[[noreturn]] LIBBASE_ABI void +report_fatal_error (StringRef reason, bool gen_crash_diag = true); +[[noreturn]] LIBBASE_ABI void +report_fatal_error (const Twine &reason, bool gen_crash_diag = true); + +/// Report a fatal error that likely indicates a bug in LLVM. It serves a +/// similar purpose as an assertion, but is always enabled, regardless of the +/// value of NDEBUG. +/// +/// This will call installed error handlers (or print the message by default) +/// and then abort. This will produce a crash trace and *will* ask users to +/// report an LLVM bug. +[[noreturn]] LIBBASE_ABI void +reportFatalInternalError (const char *reason); +[[noreturn]] LIBBASE_ABI void +reportFatalInternalError (StringRef reason); +[[noreturn]] LIBBASE_ABI void +reportFatalInternalError (const Twine &reason); + +/// Report a fatal error that does not indicate a bug in LLVM. +/// +/// This can be used in contexts where a proper error reporting mechanism +/// (such as Error/Expected or DiagnosticInfo) is currently not supported, and +/// would be too involved to introduce at the moment. +/// +/// Examples where this function should be used instead of +/// reportFatalInternalError() include invalid inputs or options, but also +/// environment error conditions outside LLVM's control. It should also be used +/// for known unsupported/unimplemented functionality. +/// +/// This will call installed error handlers (or print the message by default) +/// and then exit with code 1. It will not produce a crash trace and will +/// *not* ask users to report an LLVM bug. +[[noreturn]] LIBBASE_ABI void +reportFatalUsageError (const char *reason); +[[noreturn]] LIBBASE_ABI void +reportFatalUsageError (StringRef reason); +[[noreturn]] LIBBASE_ABI void +reportFatalUsageError (const Twine &reason); + +/// Installs a new bad alloc error handler that should be used whenever a +/// bad alloc error, e.g. failing malloc/calloc, is encountered by LLVM. +/// +/// The user can install a bad alloc handler, in order to define the behavior +/// in case of failing allocations, e.g. throwing an exception. Note that this +/// handler must not trigger any additional allocations itself. +/// +/// If no error handler is installed the default is to print the error message +/// to stderr, and call exit(1). If an error handler is installed then it is +/// the handler's responsibility to log the message, it will no longer be +/// printed to stderr. If the error handler returns, then exit(1) will be +/// called. +/// +/// +/// \param user_data - An argument which will be passed to the installed error +/// handler. +LIBBASE_ABI void +install_bad_alloc_error_handler (fatal_error_handler_t handler, + void *user_data = nullptr); + +/// Restores default bad alloc error handling behavior. +LIBBASE_ABI void +remove_bad_alloc_error_handler (); + +LIBBASE_ABI void +install_out_of_memory_new_handler (); + +/// Reports a bad alloc error, calling any user defined bad alloc +/// error handler. In contrast to the generic 'report_fatal_error' +/// functions, this function might not terminate, e.g. the user +/// defined error handler throws an exception, but it won't return. +/// +/// Note: When throwing an exception in the bad alloc handler, make sure that +/// the following unwind succeeds, e.g. do not trigger additional allocations +/// in the unwind chain. +/// +/// If no error handler is installed (default), throws a bad_alloc exception +/// if LLVM is compiled with exception support. Otherwise prints the error +/// to standard error and calls abort(). +[[noreturn]] LIBBASE_ABI void +report_bad_alloc_error (const char *Reason, bool GenCrashDiag = true); + +/// This function calls abort(), and prints the optional message to stderr. +/// Use the llvm_unreachable macro (that adds location info), instead of +/// calling this function directly. +[[noreturn]] LIBBASE_ABI void +rcc_unreachable_internal (const char *msg = nullptr, const char *file = nullptr, + unsigned line = 0); +} // namespace rcc + +/// Marks that the current location is not supposed to be reachable. +/// In !NDEBUG builds, prints the message and location info to stderr. +/// In NDEBUG builds, if the platform does not support a builtin unreachable +/// then we call an internal LLVM runtime function. Otherwise the behavior is +/// controlled by the CMake flag +/// -DLLVM_UNREACHABLE_OPTIMIZE +/// * When "ON" (default) llvm_unreachable() becomes an optimizer hint +/// that the current location is not supposed to be reachable: the hint +/// turns such code path into undefined behavior. On compilers that don't +/// support such hints, prints a reduced message instead and aborts the +/// program. +/// * When "OFF", a builtin_trap is emitted instead of an +// optimizer hint or printing a reduced message. +/// +/// Use this instead of assert(0). It conveys intent more clearly, suppresses +/// diagnostics for unreachable code paths, and allows compilers to omit +/// unnecessary code. +#ifndef NDEBUG +#define rcc_unreachable(msg) \ + ::rcc::rcc_unreachable_internal (msg, __FILE__, __LINE__) +#elif !defined(LIBBASE_BUILTIN_UNREACHABLE) +#define rcc_unreachable(msg) ::rcc::rcc_unreachable_internal () +#elif LIBBASE_UNREACHABLE_OPTIMIZE +#define rcc_unreachable(msg) LIBBASE_BUILTIN_UNREACHABLE +#else +#define rcc_unreachable(msg) \ + do \ + { \ + LIBBASE_BUILTIN_TRAP; \ + LIBBASE_BUILTIN_UNREACHABLE; \ + } while (false) +#endif + +#endif diff --git a/libbase/include/core/math/MathExtras.h b/libbase/include/core/math/MathExtras.h new file mode 100644 index 0000000..880ba74 --- /dev/null +++ b/libbase/include/core/math/MathExtras.h @@ -0,0 +1,1050 @@ +/* + RCC-Project + + Copyright (C) 2026 Richard Qin + + This file is part of RCC-Project. + + RCC-Project is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at your option) any + later version. + + RCC-Project is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR + A PARTICULAR PURPOSE. See the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along with + RCC-Project; see the file COPYING. If not see + . +*/ + +//===-- llvm/Support/MathExtras.h - Useful math functions -------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file contains some functions that are useful for math stuff. +// +//===----------------------------------------------------------------------===// + +#ifndef LIBBASE_SUPPORT_MATHEXTRAS_H +#define LIBBASE_SUPPORT_MATHEXTRAS_H + +#include "core/compiler/Compiler.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace rcc +{ +/// Some template parameter helpers to optimize for bitwidth, for functions that +/// take multiple arguments. + +// We can't verify signedness, since callers rely on implicit coercions to +// signed/unsigned. +template +using enableif_int = + std::enable_if_t && std::is_integral_v>; + +// Use std::common_type_t to widen only up to the widest argument. +template > +using common_uint = + std::common_type_t, std::make_unsigned_t>; +template > +using common_sint = + std::common_type_t, std::make_signed_t>; + +/// Mathematical constants. +namespace numbers +{ +// clang-format off +inline constexpr float ef = std::numbers::e_v; +inline constexpr float egammaf = std::numbers::egamma_v; +inline constexpr float ln2f = std::numbers::ln2_v; +inline constexpr float ln10f = std::numbers::ln10_v; +inline constexpr float log2ef = std::numbers::log2e_v; +inline constexpr float log10ef = std::numbers::log10e_v; +inline constexpr float pif = std::numbers::pi_v; +inline constexpr float inv_pif = std::numbers::inv_pi_v; +inline constexpr float inv_sqrtpif = std::numbers::inv_sqrtpi_v; +inline constexpr float sqrt2f = std::numbers::sqrt2_v; +inline constexpr float inv_sqrt2f = 1.0f / std::numbers::sqrt2_v; +inline constexpr float sqrt3f = std::numbers::sqrt3_v; +inline constexpr float inv_sqrt3f = std::numbers::inv_sqrt3_v; +inline constexpr float phif = std::numbers::phi_v; + +// sqrtpi is not in C++20 std::numbers. +template >> +inline constexpr T sqrtpi_v = T(0x1.c5bf891b4ef6bP+0); // (1.7724538509055160273) https://oeis.org/A002161 +inline constexpr double sqrtpi = sqrtpi_v; +inline constexpr float sqrtpif = sqrtpi_v; + +// These string literals are taken from below: +// https://github.com/bminor/glibc/blob/8543577b04ded6d979ffcc5a818930e4d74d0645/math/math.h#L1215-L1229 +constexpr const char *pis = "3.141592653589793238462643383279502884", + *inv_pis = "0.318309886183790671537767526745028724"; +// clang-format on +} // namespace numbers + +/// Create a bitmask with the N right-most bits set to 1, and all other +/// bits set to 0. Only unsigned types are allowed. +template +constexpr T +maskTrailingOnes (unsigned N) +{ + static_assert (std::is_unsigned_v, "Invalid type!"); + const unsigned Bits = CHAR_BIT * sizeof (T); + assert (N <= Bits && "Invalid bit index"); + if (N == 0) + { + return 0; + } + return T (-1) >> (Bits - N); +} + +/// Create a bitmask with the N left-most bits set to 1, and all other +/// bits set to 0. Only unsigned types are allowed. +template +constexpr T +maskLeadingOnes (unsigned N) +{ + return ~maskTrailingOnes (CHAR_BIT * sizeof (T) - N); +} + +/// Create a bitmask with the N right-most bits set to 0, and all other +/// bits set to 1. Only unsigned types are allowed. +template +constexpr T +maskTrailingZeros (unsigned N) +{ + return maskLeadingOnes (CHAR_BIT * sizeof (T) - N); +} + +/// Create a bitmask with the N left-most bits set to 0, and all other +/// bits set to 1. Only unsigned types are allowed. +template +constexpr T +maskLeadingZeros (unsigned N) +{ + return maskTrailingOnes (CHAR_BIT * sizeof (T) - N); +} + +/// Macro compressed bit reversal table for 256 bits. +/// +/// http://graphics.stanford.edu/~seander/bithacks.html#BitReverseTable +static const unsigned char BitReverseTable256[256] = { +#define R2(n) n, n + 2 * 64, n + 1 * 64, n + 3 * 64 +#define R4(n) R2 (n), R2 (n + 2 * 16), R2 (n + 1 * 16), R2 (n + 3 * 16) +#define R6(n) R4 (n), R4 (n + 2 * 4), R4 (n + 1 * 4), R4 (n + 3 * 4) + R6 (0), R6 (2), R6 (1), R6 (3) +#undef R2 +#undef R4 +#undef R6 +}; + +/// Reverse the bits in \p Val. +template +constexpr T +reverseBits (T Val) +{ +#if __has_builtin(__builtin_bitreverse8) + if constexpr (std::is_same_v) + { + return __builtin_bitreverse8 (Val); + } +#endif +#if __has_builtin(__builtin_bitreverse16) + if constexpr (std::is_same_v) + { + return __builtin_bitreverse16 (Val); + } +#endif +#if __has_builtin(__builtin_bitreverse32) + if constexpr (std::is_same_v) + { + return __builtin_bitreverse32 (Val); + } +#endif +#if __has_builtin(__builtin_bitreverse64) + if constexpr (std::is_same_v) + { + return __builtin_bitreverse64 (Val); + } +#endif + + unsigned char in[sizeof (Val)]; + unsigned char out[sizeof (Val)]; + std::memcpy (in, &Val, sizeof (Val)); + for (unsigned i = 0; i < sizeof (Val); ++i) + { + out[(sizeof (Val) - i) - 1] = BitReverseTable256[in[i]]; + } + std::memcpy (&Val, out, sizeof (Val)); + return Val; +} + +// NOTE: The following support functions use the _32/_64 extensions instead of +// type overloading so that signed and unsigned integers can be used without +// ambiguity. + +/// Return the high 32 bits of a 64 bit value. +constexpr uint32_t +Hi_32 (uint64_t Value) +{ + return static_cast (Value >> 32); +} + +/// Return the low 32 bits of a 64 bit value. +constexpr uint32_t +Lo_32 (uint64_t Value) +{ + return static_cast (Value); +} + +/// Make a 64-bit integer from a high / low pair of 32-bit integers. +constexpr uint64_t +Make_64 (uint32_t High, uint32_t Low) +{ + return ((uint64_t)High << 32) | (uint64_t)Low; +} + +/// Checks if an integer fits into the given bit width. +template +constexpr bool +isInt (int64_t x) +{ + if constexpr (N == 0) + { + return 0 == x; + } + if constexpr (N == 8) + { + return static_cast (x) == x; + } + if constexpr (N == 16) + { + return static_cast (x) == x; + } + if constexpr (N == 32) + { + return static_cast (x) == x; + } + if constexpr (N < 64) + { + return -(INT64_C (1) << (N - 1)) <= x && x < (INT64_C (1) << (N - 1)); + } + (void)x; // MSVC v19.25 warns that x is unused. + return true; +} + +/// Checks if a signed integer is an N bit number shifted left by S. +template +constexpr bool +isShiftedInt (int64_t x) +{ + static_assert (S < 64, "isShiftedInt with S >= 64 is too much."); + static_assert (N + S <= 64, + "isShiftedInt with N + S > 64 is too wide."); + return isInt (x) && (x % (UINT64_C (1) << S) == 0); +} + +/// Checks if an unsigned integer fits into the given bit width. +template +constexpr bool +isUInt (uint64_t x) +{ + if constexpr (N < 64) + { + return (x >> N) == 0; + } + (void)x; // MSVC v19.25 warns that x is unused. + return true; +} + +/// Checks if a unsigned integer is an N bit number shifted left by S. +template +constexpr bool +isShiftedUInt (uint64_t x) +{ + static_assert (S < 64, "isShiftedUInt with S >= 64 is too much."); + static_assert (N + S <= 64, + "isShiftedUInt with N + S > 64 is too wide."); + // S must be strictly less than 64. So 1 << S is not undefined behavior. + return isUInt (x) && (x % (UINT64_C (1) << S) == 0); +} + +/// Gets the maximum value for a N-bit unsigned integer. +inline constexpr uint64_t +maxUIntN (uint64_t N) +{ + assert (N <= 64 && "integer width out of range"); + + // uint64_t(1) << 64 is undefined behavior, so we can't do + // (uint64_t(1) << N) - 1 + // without checking first that N != 64. But this works and doesn't have a + // branch for N != 0. + // Unfortunately, shifting a uint64_t right by 64 bit is undefined + // behavior, so the condition on N == 0 is necessary. Fortunately, most + // optimizers do not emit branches for this check. + if (N == 0) + { + return 0; + } + return UINT64_MAX >> (64 - N); +} + +/// Gets the minimum value for a N-bit signed integer. +inline constexpr int64_t +minIntN (int64_t N) +{ + assert (N <= 64 && "integer width out of range"); + + if (N == 0) + { + return 0; + } + return UINT64_MAX << (N - 1); +} + +/// Gets the maximum value for a N-bit signed integer. +inline constexpr int64_t +maxIntN (int64_t N) +{ + assert (N <= 64 && "integer width out of range"); + + // This relies on two's complement wraparound when N == 64, so we convert to + // int64_t only at the very end to avoid UB. + if (N == 0) + { + return 0; + } + return (UINT64_C (1) << (N - 1)) - 1; +} + +/// Checks if an unsigned integer fits into the given (dynamic) bit width. +inline constexpr bool +isUIntN (unsigned N, uint64_t x) +{ + return N >= 64 || (x >> N) == 0; +} + +/// Checks if an signed integer fits into the given (dynamic) bit width. +inline constexpr bool +isIntN (unsigned N, int64_t x) +{ + return N >= 64 || (minIntN (N) <= x && x <= maxIntN (N)); +} + +/// Return true if the argument is a non-empty sequence of ones starting at the +/// least significant bit with the remainder zero (32 bit version). +/// Ex. isMask_32(0x0000FFFFU) == true. +constexpr bool +isMask_32 (uint32_t Value) +{ + return Value && ((Value + 1) & Value) == 0; +} + +/// Return true if the argument is a non-empty sequence of ones starting at the +/// least significant bit with the remainder zero (64 bit version). +constexpr bool +isMask_64 (uint64_t Value) +{ + return Value && ((Value + 1) & Value) == 0; +} + +/// Return true if the argument contains a non-empty sequence of ones with the +/// remainder zero (32 bit version.) Ex. isShiftedMask_32(0x0000FF00U) == true. +constexpr bool +isShiftedMask_32 (uint32_t Value) +{ + return Value && isMask_32 ((Value - 1) | Value); +} + +/// Return true if the argument contains a non-empty sequence of ones with the +/// remainder zero (64 bit version.) +constexpr bool +isShiftedMask_64 (uint64_t Value) +{ + return Value && isMask_64 ((Value - 1) | Value); +} + +/// Return true if the argument is a power of two > 0. +/// Ex. isPowerOf2_32(0x00100000U) == true (32 bit edition.) +constexpr bool +isPowerOf2_32 (uint32_t Value) +{ + return std::has_single_bit (Value); +} + +/// Return true if the argument is a power of two > 0 (64 bit edition.) +constexpr bool +isPowerOf2_64 (uint64_t Value) +{ + return std::has_single_bit (Value); +} + +/// Return true if the argument contains a non-empty sequence of ones with the +/// remainder zero (32 bit version.) Ex. isShiftedMask_32(0x0000FF00U) == true. +/// If true, \p MaskIdx will specify the index of the lowest set bit and \p +/// MaskLen is updated to specify the length of the mask, else neither are +/// updated. +inline bool +isShiftedMask_32 (uint32_t Value, unsigned &MaskIdx, unsigned &MaskLen) +{ + if (!isShiftedMask_32 (Value)) + { + return false; + } + MaskIdx = std::countr_zero (Value); + MaskLen = std::popcount (Value); + return true; +} + +/// Return true if the argument contains a non-empty sequence of ones with the +/// remainder zero (64 bit version.) If true, \p MaskIdx will specify the index +/// of the lowest set bit and \p MaskLen is updated to specify the length of the +/// mask, else neither are updated. +inline bool +isShiftedMask_64 (uint64_t Value, unsigned &MaskIdx, unsigned &MaskLen) +{ + if (!isShiftedMask_64 (Value)) + { + return false; + } + MaskIdx = std::countr_zero (Value); + MaskLen = std::popcount (Value); + return true; +} + +/// Compile time Log2. +/// Valid only for positive powers of two. +template +constexpr size_t +ConstantLog2 () +{ + static_assert (rcc::isPowerOf2_64 (kValue), + "Value is not a valid power of 2"); + return std::countr_zero (kValue); +} + +/// Return the floor log base 2 of the specified value, -1 if the value is zero. +/// (32 bit edition.) +/// Ex. Log2_32(32) == 5, Log2_32(1) == 0, Log2_32(0) == -1, Log2_32(6) == 2 +inline unsigned +Log2_32 (uint32_t Value) +{ + return 31 - std::countl_zero (Value); +} + +/// Return the floor log base 2 of the specified value, -1 if the value is zero. +/// (64 bit edition.) +inline unsigned +Log2_64 (uint64_t Value) +{ + return 63 - std::countl_zero (Value); +} + +/// Return the ceil log base 2 of the specified value, 32 if the value is zero. +/// (32 bit edition). +/// Ex. Log2_32_Ceil(32) == 5, Log2_32_Ceil(1) == 0, Log2_32_Ceil(6) == 3 +inline unsigned +Log2_32_Ceil (uint32_t Value) +{ + return 32 - std::countl_zero (Value - 1); +} + +/// Return the ceil log base 2 of the specified value, 64 if the value is zero. +/// (64 bit edition.) +inline unsigned +Log2_64_Ceil (uint64_t Value) +{ + return 64 - std::countl_zero (Value - 1); +} + +/// A and B are either alignments or offsets. Return the minimum alignment that +/// may be assumed after adding the two together. +template > +constexpr T +MinAlign (U A, V B) +{ + // The largest power of 2 that divides both A and B. + // + // Replace "-Value" by "1+~Value" in the following commented code to avoid + // MSVC warning C4146 + // return (A | B) & -(A | B); + return (A | B) & (1 + ~(A | B)); +} + +/// Fallback when arguments aren't integral. +constexpr uint64_t +MinAlign (uint64_t A, uint64_t B) +{ + return (A | B) & (1 + ~(A | B)); +} + +/// Returns the next power of two (in 64-bits) that is strictly greater than A. +/// Returns zero on overflow. +constexpr uint64_t +NextPowerOf2 (uint64_t A) +{ + A |= (A >> 1); + A |= (A >> 2); + A |= (A >> 4); + A |= (A >> 8); + A |= (A >> 16); + A |= (A >> 32); + return A + 1; +} + +/// Returns the power of two which is greater than or equal to the given value. +/// Essentially, it is a ceil operation across the domain of powers of two. +inline uint64_t +PowerOf2Ceil (uint64_t A) +{ + if (!A || A > UINT64_MAX / 2) + { + return 0; + } + return UINT64_C (1) << Log2_64_Ceil (A); +} + +/// Returns the integer ceil(Numerator / Denominator). Unsigned version. +/// Guaranteed to never overflow. +template > +constexpr T +divideCeil (U Numerator, V Denominator) +{ + assert (Denominator && "Division by zero"); + T Bias = (Numerator != 0); + return (Numerator - Bias) / Denominator + Bias; +} + +/// Fallback when arguments aren't integral. +constexpr uint64_t +divideCeil (uint64_t Numerator, uint64_t Denominator) +{ + assert (Denominator && "Division by zero"); + uint64_t Bias = (Numerator != 0); + return (Numerator - Bias) / Denominator + Bias; +} + +// Check whether divideCeilSigned or divideFloorSigned would overflow. This +// happens only when Numerator = INT_MIN and Denominator = -1. +template +constexpr bool +divideSignedWouldOverflow (U Numerator, V Denominator) +{ + return Numerator == std::numeric_limits::min () && Denominator == -1; +} + +/// Returns the integer ceil(Numerator / Denominator). Signed version. +/// Overflow is explicitly forbidden with an assert. +template > +constexpr T +divideCeilSigned (U Numerator, V Denominator) +{ + assert (Denominator && "Division by zero"); + assert (!divideSignedWouldOverflow (Numerator, Denominator) && + "Divide would overflow"); + if (!Numerator) + { + return 0; + } + // C's integer division rounds towards 0. + T Bias = Denominator >= 0 ? 1 : -1; + bool SameSign = (Numerator >= 0) == (Denominator >= 0); + return SameSign ? (Numerator - Bias) / Denominator + 1 + : Numerator / Denominator; +} + +/// Returns the integer floor(Numerator / Denominator). Signed version. +/// Overflow is explicitly forbidden with an assert. +template > +constexpr T +divideFloorSigned (U Numerator, V Denominator) +{ + assert (Denominator && "Division by zero"); + assert (!divideSignedWouldOverflow (Numerator, Denominator) && + "Divide would overflow"); + if (!Numerator) + { + return 0; + } + // C's integer division rounds towards 0. + T Bias = Denominator >= 0 ? -1 : 1; + bool SameSign = (Numerator >= 0) == (Denominator >= 0); + return SameSign ? Numerator / Denominator + : (Numerator - Bias) / Denominator - 1; +} + +/// Returns the remainder of the Euclidean division of LHS by RHS. Result is +/// always non-negative. +template > +constexpr T +mod (U Numerator, V Denominator) +{ + assert (Denominator >= 1 && "Mod by non-positive number"); + T Mod = Numerator % Denominator; + return Mod < 0 ? Mod + Denominator : Mod; +} + +/// Returns (Numerator / Denominator) rounded by round-half-up. Guaranteed to +/// never overflow. +template > +constexpr T +divideNearest (U Numerator, V Denominator) +{ + assert (Denominator && "Division by zero"); + T Mod = Numerator % Denominator; + return (Numerator / Denominator) + + (Mod > (static_cast (Denominator) - 1) / 2); +} + +/// Returns the next integer (mod 2**nbits) that is greater than or equal to +/// \p Value and is a multiple of \p Align. \p Align must be non-zero. +/// +/// Examples: +/// \code +/// alignTo(5, 8) = 8 +/// alignTo(17, 8) = 24 +/// alignTo(~0LL, 8) = 0 +/// alignTo(321, 255) = 510 +/// \endcode +/// +/// Will overflow only if result is not representable in T. +template > +constexpr T +alignTo (U Value, V Align) +{ + assert (Align != 0u && "Align can't be 0."); + T CeilDiv = divideCeil (Value, Align); + return CeilDiv * Align; +} + +/// Fallback when arguments aren't integral. +constexpr uint64_t +alignTo (uint64_t Value, uint64_t Align) +{ + assert (Align != 0u && "Align can't be 0."); + uint64_t CeilDiv = divideCeil (Value, Align); + return CeilDiv * Align; +} + +/// Will overflow only if result is not representable in T. +template > +constexpr T +alignToPowerOf2 (U Value, V Align) +{ + assert (Align != 0 && (Align & (Align - 1)) == 0 && + "Align must be a power of 2"); + T NegAlign = static_cast (0) - Align; + return (Value + (Align - 1)) & NegAlign; +} + +/// Fallback when arguments aren't integral. +constexpr uint64_t +alignToPowerOf2 (uint64_t Value, uint64_t Align) +{ + assert (Align != 0 && (Align & (Align - 1)) == 0 && + "Align must be a power of 2"); + uint64_t NegAlign = 0 - Align; + return (Value + (Align - 1)) & NegAlign; +} + +/// If non-zero \p Skew is specified, the return value will be a minimal integer +/// that is greater than or equal to \p Size and equal to \p A * N + \p Skew for +/// some integer N. If \p Skew is larger than \p A, its value is adjusted to '\p +/// Skew mod \p A'. \p Align must be non-zero. +/// +/// Examples: +/// \code +/// alignTo(5, 8, 7) = 7 +/// alignTo(17, 8, 1) = 17 +/// alignTo(~0LL, 8, 3) = 3 +/// alignTo(321, 255, 42) = 552 +/// \endcode +/// +/// May overflow. +template , W>> +constexpr T +alignTo (U Value, V Align, W Skew) +{ + assert (Align != 0u && "Align can't be 0."); + Skew %= Align; + return alignTo (Value - Skew, Align) + Skew; +} + +/// Returns the next integer (mod 2**nbits) that is greater than or equal to +/// \p Value and is a multiple of \c Align. \c Align must be non-zero. +/// +/// Will overflow only if result is not representable in T. +template > +constexpr T +alignTo (V Value) +{ + static_assert (Align != 0u, "Align must be non-zero"); + T CeilDiv = divideCeil (Value, Align); + return CeilDiv * Align; +} + +/// Returns the largest unsigned integer less than or equal to \p Value and is +/// \p Skew mod \p Align. \p Align must be non-zero. Guaranteed to never +/// overflow. +template , W>> +constexpr T +alignDown (U Value, V Align, W Skew = 0) +{ + assert (Align != 0u && "Align can't be 0."); + Skew %= Align; + return (Value - Skew) / Align * Align + Skew; +} + +/// Sign-extend the number in the bottom B bits of X to a 32-bit integer. +/// Requires B <= 32. +template +constexpr int32_t +SignExtend32 (uint32_t X) +{ + static_assert (B <= 32, "Bit width out of range."); + if constexpr (B == 0) + { + return 0; + } + return int32_t (X << (32 - B)) >> (32 - B); +} + +/// Sign-extend the number in the bottom B bits of X to a 32-bit integer. +/// Requires B <= 32. +inline int32_t +SignExtend32 (uint32_t X, unsigned B) +{ + assert (B <= 32 && "Bit width out of range."); + if (B == 0) + { + return 0; + } + return int32_t (X << (32 - B)) >> (32 - B); +} + +/// Sign-extend the number in the bottom B bits of X to a 64-bit integer. +/// Requires B <= 64. +template +constexpr int64_t +SignExtend64 (uint64_t x) +{ + static_assert (B <= 64, "Bit width out of range."); + if constexpr (B == 0) + { + return 0; + } + return int64_t (x << (64 - B)) >> (64 - B); +} + +/// Sign-extend the number in the bottom B bits of X to a 64-bit integer. +/// Requires B <= 64. +inline int64_t +SignExtend64 (uint64_t X, unsigned B) +{ + assert (B <= 64 && "Bit width out of range."); + if (B == 0) + { + return 0; + } + return int64_t (X << (64 - B)) >> (64 - B); +} + +/// Return the absolute value of a signed integer, converted to the +/// corresponding unsigned integer type. Avoids undefined behavior in std::abs +/// when you pass it INT_MIN or similar. +template > +constexpr U +AbsoluteValue (T X) +{ + // If X is negative, cast it to the unsigned type _before_ negating it. + return X < 0 ? -static_cast (X) : X; +} + +/// Subtract two unsigned integers, X and Y, of type T and return the absolute +/// value of the result. +template > +constexpr T +AbsoluteDifference (U X, V Y) +{ + return X > Y ? (X - Y) : (Y - X); +} + +/// Add two unsigned integers, X and Y, of type T. Clamp the result to the +/// maximum representable value of T on overflow. ResultOverflowed indicates if +/// the result is larger than the maximum representable value of type T. +template +std::enable_if_t, T> +SaturatingAdd (T X, T Y, bool *ResultOverflowed = nullptr) +{ + bool Dummy; + bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy; + // Hacker's Delight, p. 29 + T Z = X + Y; + Overflowed = (Z < X || Z < Y); + if (Overflowed) + { + return std::numeric_limits::max (); + } + else + { + return Z; + } +} + +/// Add multiple unsigned integers of type T. Clamp the result to the +/// maximum representable value of T on overflow. +template +std::enable_if_t, T> +SaturatingAdd (T X, T Y, T Z, Ts... Args) +{ + bool Overflowed = false; + T XY = SaturatingAdd (X, Y, &Overflowed); + if (Overflowed) + { + return SaturatingAdd (std::numeric_limits::max (), T (1), Args...); + } + return SaturatingAdd (XY, Z, Args...); +} + +/// Multiply two unsigned integers, X and Y, of type T. Clamp the result to the +/// maximum representable value of T on overflow. ResultOverflowed indicates if +/// the result is larger than the maximum representable value of type T. +template +std::enable_if_t, T> +SaturatingMultiply (T X, T Y, bool *ResultOverflowed = nullptr) +{ + bool Dummy; + bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy; + + // Hacker's Delight, p. 30 has a different algorithm, but we don't use that + // because it fails for uint16_t (where multiplication can have undefined + // behavior due to promotion to int), and requires a division in addition + // to the multiplication. + + Overflowed = false; + + // Log2(Z) would be either Log2Z or Log2Z + 1. + // Special case: if X or Y is 0, Log2_64 gives -1, and Log2Z + // will necessarily be less than Log2Max as desired. + int Log2Z = Log2_64 (X) + Log2_64 (Y); + const T Max = std::numeric_limits::max (); + int Log2Max = Log2_64 (Max); + if (Log2Z < Log2Max) + { + return X * Y; + } + if (Log2Z > Log2Max) + { + Overflowed = true; + return Max; + } + + // We're going to use the top bit, and maybe overflow one + // bit past it. Multiply all but the bottom bit then add + // that on at the end. + T Z = (X >> 1) * Y; + if (Z & ~(Max >> 1)) + { + Overflowed = true; + return Max; + } + Z <<= 1; + if (X & 1) + { + return SaturatingAdd (Z, Y, ResultOverflowed); + } + + return Z; +} + +/// Multiply two unsigned integers, X and Y, and add the unsigned integer, A to +/// the product. Clamp the result to the maximum representable value of T on +/// overflow. ResultOverflowed indicates if the result is larger than the +/// maximum representable value of type T. +template +std::enable_if_t, T> +SaturatingMultiplyAdd (T X, T Y, T A, bool *ResultOverflowed = nullptr) +{ + bool Dummy; + bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy; + + T Product = SaturatingMultiply (X, Y, &Overflowed); + if (Overflowed) + { + return Product; + } + + return SaturatingAdd (A, Product, &Overflowed); +} + +/// Use this rather than HUGE_VALF; the latter causes warnings on MSVC. +LIBBASE_ABI extern const float huge_valf; + +/// Add two signed integers, computing the two's complement truncated result, +/// returning a pair {result, overflow}, where "overflow" is a boolean value +/// indicating whether an overflow occurred. +template +constexpr std::enable_if_t, std::pair> +AddOverflow (T X, T Y) +{ + // Perform the unsigned addition. + using U = std::make_unsigned_t; + const U UX = static_cast (X); + const U UY = static_cast (Y); + const U UResult = UX + UY; + + // Convert to signed. + auto Result = static_cast (UResult); + + // Adding two positive numbers should result in a positive number. + if (X > 0 && Y > 0) + { + return {Result, Result <= 0}; + } + // Adding two negatives should result in a negative number. + if (X < 0 && Y < 0) + { + return {Result, Result >= 0}; + } + return {Result, false}; +} + +/// Add two signed integers, computing the two's complement truncated result, +/// returning true if overflow occurred. +template +std::enable_if_t, bool> +AddOverflow (T X, T Y, T &Result) +{ +#if __has_builtin(__builtin_add_overflow) + return __builtin_add_overflow (X, Y, &Result); +#else + auto [Res, Ovf] = AddOverflow (X, Y); + Result = Res; + return Ovf; +#endif +} + +/// Subtract two signed integers, computing the two's complement truncated +/// result, returning a pair {result, overflow}, where "overflow" is a +/// boolean value indicating whether an overflow occurred. +template +constexpr std::enable_if_t, std::pair> +SubOverflow (T X, T Y) +{ + // Perform the unsigned addition. + using U = std::make_unsigned_t; + const U UX = static_cast (X); + const U UY = static_cast (Y); + const U UResult = UX - UY; + + // Convert to signed. + auto Result = static_cast (UResult); + + // Subtracting a positive number from a negative results in a negative number. + if (X <= 0 && Y > 0) + { + return {Result, Result >= 0}; + } + // Subtracting a negative number from a positive results in a positive number. + if (X >= 0 && Y < 0) + { + return {Result, Result <= 0}; + } + return {Result, false}; +} + +/// Subtract two signed integers, computing the two's complement truncated +/// result, returning true if an overflow occurred. +template +std::enable_if_t, bool> +SubOverflow (T X, T Y, T &Result) +{ +#if __has_builtin(__builtin_sub_overflow) + return __builtin_sub_overflow (X, Y, &Result); +#else + auto [Res, Ovf] = SubOverflow (X, Y); + Result = Res; + return Ovf; +#endif +} + +/// Multiply two signed integers, computing the two's complement truncated +/// result, returning a pair {result, overflow}, where "overflow" is a +/// boolean value indicating whether an overflow occurred. +template +constexpr std::enable_if_t, std::pair> +MulOverflow (T X, T Y) +{ + // Perform the unsigned multiplication on absolute values. + using U = std::make_unsigned_t; + const U UX = X < 0 ? (0 - static_cast (X)) : static_cast (X); + const U UY = Y < 0 ? (0 - static_cast (Y)) : static_cast (Y); + const U UResult = UX * UY; + + // Convert to signed. + const bool IsNegative = (X < 0) ^ (Y < 0); + auto Result = IsNegative ? (0 - UResult) : UResult; + + // If any of the args was 0, result is 0 and no overflow occurs. + if (UX == 0 || UY == 0) + { + return {Result, false}; + } + + // UX and UY are in [1, 2^n], where n is the number of digits. + // Check how the max allowed absolute value (2^n for negative, 2^(n-1) for + // positive) divided by an argument compares to the other. + bool Overflow = + IsNegative + ? UX > (static_cast (std::numeric_limits::max ()) + U (1)) / UY + : UX > (static_cast (std::numeric_limits::max ())) / UY; + + return {Result, Overflow}; +} + +/// Multiply two signed integers, computing the two's complement truncated +/// result, returning true if an overflow occurred. +template +std::enable_if_t, bool> +MulOverflow (T X, T Y, T &Result) +{ +#if __has_builtin(__builtin_mul_overflow) + return __builtin_mul_overflow (X, Y, &Result); +#else + auto [Res, Ovf] = MulOverflow (X, Y); + Result = Res; + return Ovf; +#endif +} + +/// Type to force float point values onto the stack, so that x86 doesn't add +/// hidden precision, avoiding rounding differences on various platforms. +#if defined(__i386__) || defined(_M_IX86) +using stack_float_t = volatile float; +#else +using stack_float_t = float; +#endif + +/// Returns the number of digits in the given integer. +LIBBASE_ABI int +NumDigitsBase10 (uint64_t X); + +} // namespace rcc + +#endif diff --git a/libbase/include/core/memory/Alignment.h b/libbase/include/core/memory/Alignment.h new file mode 100644 index 0000000..a3b5d38 --- /dev/null +++ b/libbase/include/core/memory/Alignment.h @@ -0,0 +1,342 @@ +/* + R *CC-Project + + Copyright (C) 2026 Richard Qin + + This file is part of RCC-Project. + + RCC-Project is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at your option) any + later version. + + RCC-Project is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A + PARTICULAR PURPOSE. See the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along with + RCC-Project; see the file COPYING. If not see + . + */ + +//===-- rcc/Memory/Alignment.h - Useful alignment functions ---*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file contains types to represent alignments. +// They are instrumented to guarantee some invariants are preserved and prevent +// invalid manipulations. +// +// - Align represents an alignment in bytes, it is always set and always a valid +// power of two, its minimum value is 1 which means no alignment requirements. +// +// - MaybeAlign is an optional type, it may be undefined or set. When it's set +// you can get the underlying Align type by using the value() method. +// +//===----------------------------------------------------------------------===// + +#ifndef LIBBASE_SUPPORT_ALIGNMENT_H_ +#define LIBBASE_SUPPORT_ALIGNMENT_H_ + +#include "core/math/MathExtras.h" +#include +#include +#ifndef NDEBUG +#include +#endif // NDEBUG + +namespace rcc { + +#define ALIGN_CHECK_ISPOSITIVE(decl) \ + assert(decl > 0 && (#decl " should be defined")) + +/// This struct is a compact representation of a valid (non-zero power of two) +/// alignment. +/// It is suitable for use as static global constants. +struct Align { +private: + uint8_t ShiftValue = 0; /// The log2 of the required alignment. + /// ShiftValue is less than 64 by construction. + + friend struct MaybeAlign; + friend unsigned Log2(Align); + friend bool operator==(Align Lhs, Align Rhs); + friend bool operator!=(Align Lhs, Align Rhs); + friend bool operator<=(Align Lhs, Align Rhs); + friend bool operator>=(Align Lhs, Align Rhs); + friend bool operator<(Align Lhs, Align Rhs); + friend bool operator>(Align Lhs, Align Rhs); + friend unsigned encode(struct MaybeAlign A); + friend struct MaybeAlign decodeMaybeAlign(unsigned Value); + +public: + /// Default is byte-aligned. + constexpr Align() = default; + /// Do not perform checks in case of copy/move construct/assign, because the + /// checks have been performed when building `Other`. + constexpr Align(const Align &Other) = default; + constexpr Align(Align &&Other) = default; + constexpr Align &operator=(const Align &Other) = default; + constexpr Align &operator=(Align &&Other) = default; + + explicit Align(uint64_t Value) { + assert(Value > 0 && "Value must not be 0"); + assert(rcc::isPowerOf2_64(Value) && "Alignment is not a power of 2"); + ShiftValue = Log2_64(Value); + assert(ShiftValue < 64 && "Broken invariant"); + } + + /// Returns an alignment of `1 << Log2Value` bytes. + constexpr static Align fromLog2(unsigned Log2Value) { + assert(Log2Value < 64 && "Alignment exponent is too large"); + Align Out; + Out.ShiftValue = Log2Value; + return Out; + } + + /// This is a hole in the type system and should not be abused. + /// Needed to interact with C for instance. + constexpr uint64_t value() const { return uint64_t(1) << ShiftValue; } + + // Returns the previous alignment. + Align previous() const { + assert(ShiftValue != 0 && "Undefined operation"); + Align Out; + Out.ShiftValue = ShiftValue - 1; + return Out; + } + + /// Allow constructions of constexpr Align. + template constexpr static Align Constant() { + return fromLog2(ConstantLog2()); + } + + /// Allow constructions of constexpr Align from types. + /// Compile time equivalent to Align(alignof(T)). + template constexpr static Align Of() { + return Constant>(); + } +}; + +/// Treats the value 0 as a 1, so Align is always at least 1. +inline Align assumeAligned(uint64_t Value) { + return Value ? Align(Value) : Align(); +} + +/// This struct is a compact representation of a valid (power of two) or +/// undefined (0) alignment. +struct MaybeAlign : std::optional { +private: + using UP = std::optional; + +public: + /// Default is undefined. + MaybeAlign() = default; + /// Do not perform checks in case of copy/move construct/assign, because the + /// checks have been performed when building `Other`. + MaybeAlign(const MaybeAlign &Other) = default; + MaybeAlign &operator=(const MaybeAlign &Other) = default; + MaybeAlign(MaybeAlign &&Other) = default; + MaybeAlign &operator=(MaybeAlign &&Other) = default; + + constexpr MaybeAlign(std::nullopt_t None) : UP(None) {} + constexpr MaybeAlign(Align Value) : UP(Value) {} + explicit MaybeAlign(uint64_t Value) { + assert((Value == 0 || rcc::isPowerOf2_64(Value)) && + "Alignment is neither 0 nor a power of 2"); + if (Value) + emplace(Value); + } + + /// For convenience, returns a valid alignment or 1 if undefined. + Align valueOrOne() const { return value_or(Align()); } +}; + +/// Checks that SizeInBytes is a multiple of the alignment. +inline bool isAligned(Align Lhs, uint64_t SizeInBytes) { + return SizeInBytes % Lhs.value() == 0; +} + +/// Checks that Addr is a multiple of the alignment. +inline bool isAddrAligned(Align Lhs, const void *Addr) { + return isAligned(Lhs, reinterpret_cast(Addr)); +} + +/// Returns a multiple of A needed to store `Size` bytes. +constexpr inline uint64_t alignTo(uint64_t Size, Align A) { + const uint64_t Value = A.value(); + // The following line is equivalent to `(Size + Value - 1) / Value * Value`. + + // The division followed by a multiplication can be thought of as a right + // shift followed by a left shift which zeros out the extra bits produced in + // the bump; `~(Value - 1)` is a mask where all those bits being zeroed out + // are just zero. + + // Most compilers can generate this code but the pattern may be missed when + // multiple functions gets inlined. + return (Size + Value - 1) & ~(Value - 1U); +} + +/// If non-zero \p Skew is specified, the return value will be a minimal integer +/// that is greater than or equal to \p Size and equal to \p A * N + \p Skew for +/// some integer N. If \p Skew is larger than \p A, its value is adjusted to '\p +/// Skew mod \p A'. +/// +/// Examples: +/// \code +/// alignTo(5, Align(8), 7) = 7 +/// alignTo(17, Align(8), 1) = 17 +/// alignTo(~0LL, Align(8), 3) = 3 +/// \endcode +inline uint64_t alignTo(uint64_t Size, Align A, uint64_t Skew) { + const uint64_t Value = A.value(); + Skew %= Value; + return alignTo(Size - Skew, A) + Skew; +} + +/// Aligns `Addr` to `Alignment` bytes, rounding up. +inline uintptr_t alignAddr(const void *Addr, Align Alignment) { + uintptr_t ArithAddr = reinterpret_cast(Addr); + assert(static_cast(ArithAddr + Alignment.value() - 1) >= + ArithAddr && + "Overflow"); + return alignTo(ArithAddr, Alignment); +} + +/// Returns the offset to the next integer (mod 2**64) that is greater than +/// or equal to \p Value and is a multiple of \p Align. +inline uint64_t offsetToAlignment(uint64_t Value, Align Alignment) { + return alignTo(Value, Alignment) - Value; +} + +/// Returns the necessary adjustment for aligning `Addr` to `Alignment` +/// bytes, rounding up. +inline uint64_t offsetToAlignedAddr(const void *Addr, Align Alignment) { + return offsetToAlignment(reinterpret_cast(Addr), Alignment); +} + +/// Returns the log2 of the alignment. +inline unsigned Log2(Align A) { return A.ShiftValue; } + +/// Returns the alignment that satisfies both alignments. +/// Same semantic as MinAlign. +inline Align commonAlignment(Align A, uint64_t Offset) { + return Align(MinAlign(A.value(), Offset)); +} + +/// Returns a representation of the alignment that encodes undefined as 0. +inline unsigned encode(MaybeAlign A) { return A ? A->ShiftValue + 1 : 0; } + +/// Dual operation of the encode function above. +inline MaybeAlign decodeMaybeAlign(unsigned Value) { + if (Value == 0) + return MaybeAlign(); + Align Out; + Out.ShiftValue = Value - 1; + return Out; +} + +/// Returns a representation of the alignment, the encoded value is positive by +/// definition. +inline unsigned encode(Align A) { return encode(MaybeAlign(A)); } + +/// Comparisons between Align and scalars. Rhs must be positive. +inline bool operator==(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() == Rhs; +} +inline bool operator!=(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() != Rhs; +} +inline bool operator<=(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() <= Rhs; +} +inline bool operator>=(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() >= Rhs; +} +inline bool operator<(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() < Rhs; +} +inline bool operator>(Align Lhs, uint64_t Rhs) { + ALIGN_CHECK_ISPOSITIVE(Rhs); + return Lhs.value() > Rhs; +} + +/// Comparisons operators between Align. +inline bool operator==(Align Lhs, Align Rhs) { + return Lhs.ShiftValue == Rhs.ShiftValue; +} +inline bool operator!=(Align Lhs, Align Rhs) { + return Lhs.ShiftValue != Rhs.ShiftValue; +} +inline bool operator<=(Align Lhs, Align Rhs) { + return Lhs.ShiftValue <= Rhs.ShiftValue; +} +inline bool operator>=(Align Lhs, Align Rhs) { + return Lhs.ShiftValue >= Rhs.ShiftValue; +} +inline bool operator<(Align Lhs, Align Rhs) { + return Lhs.ShiftValue < Rhs.ShiftValue; +} +inline bool operator>(Align Lhs, Align Rhs) { + return Lhs.ShiftValue > Rhs.ShiftValue; +} + +// Don't allow relational comparisons with MaybeAlign. +bool operator<=(Align Lhs, MaybeAlign Rhs) = delete; +bool operator>=(Align Lhs, MaybeAlign Rhs) = delete; +bool operator<(Align Lhs, MaybeAlign Rhs) = delete; +bool operator>(Align Lhs, MaybeAlign Rhs) = delete; + +bool operator<=(MaybeAlign Lhs, Align Rhs) = delete; +bool operator>=(MaybeAlign Lhs, Align Rhs) = delete; +bool operator<(MaybeAlign Lhs, Align Rhs) = delete; +bool operator>(MaybeAlign Lhs, Align Rhs) = delete; + +bool operator<=(MaybeAlign Lhs, MaybeAlign Rhs) = delete; +bool operator>=(MaybeAlign Lhs, MaybeAlign Rhs) = delete; +bool operator<(MaybeAlign Lhs, MaybeAlign Rhs) = delete; +bool operator>(MaybeAlign Lhs, MaybeAlign Rhs) = delete; + +// Allow equality comparisons between Align and MaybeAlign. +inline bool operator==(MaybeAlign Lhs, Align Rhs) { return Lhs && *Lhs == Rhs; } +inline bool operator!=(MaybeAlign Lhs, Align Rhs) { return !(Lhs == Rhs); } +inline bool operator==(Align Lhs, MaybeAlign Rhs) { return Rhs == Lhs; } +inline bool operator!=(Align Lhs, MaybeAlign Rhs) { return !(Rhs == Lhs); } +// Allow equality comparisons with MaybeAlign. +inline bool operator==(MaybeAlign Lhs, MaybeAlign Rhs) { + return (Lhs && Rhs && (*Lhs == *Rhs)) || (!Lhs && !Rhs); +} +inline bool operator!=(MaybeAlign Lhs, MaybeAlign Rhs) { return !(Lhs == Rhs); } +// Allow equality comparisons with std::nullopt. +inline bool operator==(MaybeAlign Lhs, std::nullopt_t) { return !bool(Lhs); } +inline bool operator!=(MaybeAlign Lhs, std::nullopt_t) { return bool(Lhs); } +inline bool operator==(std::nullopt_t, MaybeAlign Rhs) { return !bool(Rhs); } +inline bool operator!=(std::nullopt_t, MaybeAlign Rhs) { return bool(Rhs); } + +#ifndef NDEBUG +// For usage in LLVM_DEBUG macros. +inline std::string DebugStr(const Align &A) { + return std::to_string(A.value()); +} +// For usage in LLVM_DEBUG macros. +inline std::string DebugStr(const MaybeAlign &MA) { + if (MA) + return std::to_string(MA->value()); + return "None"; +} +#endif // NDEBUG + +#undef ALIGN_CHECK_ISPOSITIVE + +} // namespace rcc + +#endif // LIBBASE_SUPPORT_ALIGNMENT_H_ diff --git a/libbase/include/core/memory/AllocatorBase.h b/libbase/include/core/memory/AllocatorBase.h new file mode 100644 index 0000000..248ea9b --- /dev/null +++ b/libbase/include/core/memory/AllocatorBase.h @@ -0,0 +1,154 @@ +/* + R *CC-Project + + Copyright (C) 2026 Richard Qin + + This file is part of RCC-Project. + + RCC-Project is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at your option) any + later version. + + RCC-Project is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A + PARTICULAR PURPOSE. See the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along with + RCC-Project; see the file COPYING. If not see + . + */ + +//===- AllocatorBase.h - Simple memory allocation abstraction ---*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +/// \file +/// +/// This file defines MallocAllocator. MallocAllocator conforms to the LLVM +/// "Allocator" concept which consists of an Allocate method accepting a size +/// and alignment, and a Deallocate accepting a pointer and size. Further, the +/// LLVM "Allocator" concept has overloads of Allocate and Deallocate for +/// setting size and alignment based on the final type. These overloads are +/// typically provided by a base class template \c AllocatorBase. +/// +//===----------------------------------------------------------------------===// + +#ifndef LIBBASE_SUPPORT_ALLOCATORBASE_H +#define LIBBASE_SUPPORT_ALLOCATORBASE_H + +#ifdef _MSC_VER +#define LIBBASE_ALLOCATORHOLDER_EMPTYBASE __declspec(empty_bases) +#else +#define LIBBASE_ALLOCATORHOLDER_EMPTYBASE +#endif // _MSC_VER + +#include "core/compiler/Compiler.h" +#include "core/memory/MemAlloc.h" +#include +#include + +namespace rcc { + +/// CRTP base class providing obvious overloads for the core \c +/// Allocate() methods of LLVM-style allocators. +/// +/// This base class both documents the full public interface exposed by all +/// LLVM-style allocators, and redirects all of the overloads to a single core +/// set of methods which the derived class must define. +template class AllocatorBase { +public: + /// Allocate \a Size bytes of \a Alignment aligned memory. This method + /// must be implemented by \c DerivedT. + void *Allocate(size_t Size, size_t Alignment) { +#ifdef __clang__ + static_assert(static_cast( + &AllocatorBase::Allocate) != + static_cast( + &DerivedT::Allocate), + "Class derives from AllocatorBase without implementing the " + "core Allocate(size_t, size_t) overload!"); +#endif + return static_cast(this)->Allocate(Size, Alignment); + } + + /// Deallocate \a Ptr to \a Size bytes of memory allocated by this + /// allocator. + void Deallocate(const void *Ptr, size_t Size, size_t Alignment) { +#ifdef __clang__ + static_assert( + static_cast( + &AllocatorBase::Deallocate) != + static_cast( + &DerivedT::Deallocate), + "Class derives from AllocatorBase without implementing the " + "core Deallocate(void *) overload!"); +#endif + return static_cast(this)->Deallocate(Ptr, Size, Alignment); + } + + // The rest of these methods are helpers that redirect to one of the above + // core methods. + + /// Allocate space for a sequence of objects without constructing them. + template T *Allocate(size_t Num = 1) { + return static_cast(Allocate(Num * sizeof(T), alignof(T))); + } + + /// Deallocate space for a sequence of objects without constructing them. + template + std::enable_if_t, void>, void> + Deallocate(T *Ptr, size_t Num = 1) { + Deallocate(static_cast(Ptr), Num * sizeof(T), alignof(T)); + } +}; + +class MallocAllocator : public AllocatorBase { +public: + void Reset() {} + + LIBBASE_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, size_t Alignment) { + return allocate_buffer(Size, Alignment); + } + + // Pull in base class overloads. + using AllocatorBase::Allocate; + + void Deallocate(const void *Ptr, size_t Size, size_t Alignment) { + deallocate_buffer(const_cast(Ptr), Size, Alignment); + } + + // Pull in base class overloads. + using AllocatorBase::Deallocate; + + void PrintStats() const {} +}; + +namespace detail { + +template class AllocatorHolder : Alloc { +public: + AllocatorHolder() = default; + AllocatorHolder(const Alloc &A) : Alloc(A) {} + AllocatorHolder(Alloc &&A) : Alloc(std::move(A)) {} + Alloc &getAllocator() { return *this; } + const Alloc &getAllocator() const { return *this; } +}; + +template class AllocatorHolder { + Alloc &A; + +public: + AllocatorHolder(Alloc &A) : A(A) {} + Alloc &getAllocator() { return A; } + const Alloc &getAllocator() const { return A; } +}; + +} // namespace detail + +} // namespace rcc + +#endif // LIBBASE_SUPPORT_ALLOCATORBASE_H diff --git a/libbase/include/core/memory/MemAlloc.h b/libbase/include/core/memory/MemAlloc.h new file mode 100644 index 0000000..bd98864 --- /dev/null +++ b/libbase/include/core/memory/MemAlloc.h @@ -0,0 +1,124 @@ +/* + RCC-Project + + Copyright (C) 2026 Richard Qin + + This file is part of RCC-Project. + + RCC-Project is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at your option) any + later version. + + RCC-Project is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR + A PARTICULAR PURPOSE. See the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along with + RCC-Project; see the file COPYING. If not see + . + */ + +//===- MemAlloc.h - Memory allocation functions -----------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +/// \file +/// +/// This file defines counterparts of C library allocation functions defined in +/// the namespace 'std'. The new allocation functions crash on allocation +/// failure instead of returning null pointer. +/// +//===----------------------------------------------------------------------===// + +#ifndef LIBBASE_SUPPORT_MEMALLOC_H +#define LIBBASE_SUPPORT_MEMALLOC_H + +#include "core/compiler/Compiler.h" +#include "core/error/ErrorHandling.h" +#include + +namespace rcc +{ + +LIBBASE_ATTRIBUTE_RETURNS_NONNULL inline void * +safe_malloc (size_t Sz) +{ + void *Result = std::malloc (Sz); + if (Result == nullptr) + { + // It is implementation-defined whether allocation occurs if the space + // requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting + // non-zero, if the space requested was zero. + if (Sz == 0) + { + return safe_malloc (1); + } + report_bad_alloc_error ("Allocation failed"); + } + return Result; +} + +LIBBASE_ATTRIBUTE_RETURNS_NONNULL inline void * +safe_calloc (size_t Count, size_t Sz) +{ + void *Result = std::calloc (Count, Sz); + if (Result == nullptr) + { + // It is implementation-defined whether allocation occurs if the space + // requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting + // non-zero, if the space requested was zero. + if (Count == 0 || Sz == 0) + { + return safe_malloc (1); + } + report_bad_alloc_error ("Allocation failed"); + } + return Result; +} + +LIBBASE_ATTRIBUTE_RETURNS_NONNULL inline void * +safe_realloc (void *Ptr, size_t Sz) +{ + void *Result = std::realloc (Ptr, Sz); + if (Result == nullptr) + { + // It is implementation-defined whether allocation occurs if the space + // requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting + // non-zero, if the space requested was zero. + if (Sz == 0) + { + return safe_malloc (1); + } + report_bad_alloc_error ("Allocation failed"); + } + return Result; +} + +/// Allocate a buffer of memory with the given size and alignment. +/// +/// When the compiler supports aligned operator new, this will use it to +/// handle even over-aligned allocations. +/// +/// However, this doesn't make any attempt to leverage the fancier techniques +/// like posix_memalign due to portability. It is mostly intended to allow +/// compatibility with platforms that, after aligned allocation was added, use +/// reduced default alignment. +LIBBASE_ABI LIBBASE_ATTRIBUTE_RETURNS_NONNULL LIBBASE_ATTRIBUTE_RETURNS_NOALIAS void * +allocate_buffer (size_t Size, size_t Alignment); + +/// Deallocate a buffer of memory with the given size and alignment. +/// +/// If supported, this will used the sized delete operator. Also if supported, +/// this will pass the alignment to the delete operator. +/// +/// The pointer must have been allocated with the corresponding new operator, +/// most likely using the above helper. +LIBBASE_ABI void +deallocate_buffer (void *Ptr, size_t Size, size_t Alignment); + +} // namespace rcc +#endif -- cgit v1.2.3