Restructure libbase and RCCCore build

24 files changed, 1911 insertions, 1601 deletions

diff --git a/libbase/CMakeLists.txt b/libbase/CMakeLists.txt
new file mode 100644
index 0000000..798c850
--- /dev/null
+++ b/libbase/CMakeLists.txt
@@ -0,0 +1,67 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+include(CheckSymbolExists)
+include(GNUInstallDirs)
+
+if(NOT DEFINED RCC_ENABLE_THREADS)
+  set(RCC_ENABLE_THREADS ON)
+endif()
+
+if(NOT DEFINED LIBBASE_ENABLE_THREADS)
+  set(LIBBASE_ENABLE_THREADS "${RCC_ENABLE_THREADS}")
+endif()
+if(NOT DEFINED LIBBASE_BUILD_SHARED_LIBS)
+  set(LIBBASE_BUILD_SHARED_LIBS "${BUILD_SHARED_LIBS}")
+endif()
+if(NOT DEFINED LIBBASE_BUILD_STATIC)
+  if(BUILD_SHARED_LIBS)
+    set(LIBBASE_BUILD_STATIC OFF)
+  else()
+    set(LIBBASE_BUILD_STATIC ON)
+  endif()
+endif()
+if(NOT DEFINED LIBBASE_BUILD_LIBBASE_DYLIB)
+  set(LIBBASE_BUILD_LIBBASE_DYLIB OFF)
+endif()
+
+set(LIBBASE_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
+set(LIBBASE_BINARY_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/include")
+file(MAKE_DIRECTORY "${LIBBASE_BINARY_INCLUDE_DIR}/core/config")
+
+check_symbol_exists(strerror_r "string.h" HAVE_STRERROR_R)
+check_symbol_exists(strerror_s "string.h" HAVE_DECL_STRERROR_S)
+
+configure_file(
+  "${LIBBASE_INCLUDE_DIR}/core/config/config.h.cmake"
+  "${LIBBASE_BINARY_INCLUDE_DIR}/core/config/config.h")
+configure_file(
+  "${LIBBASE_INCLUDE_DIR}/core/config/libbase-config.h.cmake"
+  "${LIBBASE_BINARY_INCLUDE_DIR}/core/config/libbase-config.h")
+
+add_library(RCCCore
+  src/core/math/MathExtras.cc
+  src/core/memory/MemAlloc.cpp
+  src/core/error/Errno.cc
+)
+
+target_compile_features(RCCCore PUBLIC cxx_std_23)
+target_compile_definitions(RCCCore PRIVATE LIBBASE_EXPORTS)
+
+target_include_directories(RCCCore
+  PUBLIC
+    "$<BUILD_INTERFACE:${LIBBASE_BINARY_INCLUDE_DIR}>"
+    "$<BUILD_INTERFACE:${LIBBASE_INCLUDE_DIR}>"
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
+
+install(TARGETS RCCCore
+  EXPORT RCCTargets
+  ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+  LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+  RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+
+install(DIRECTORY include/core DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+  FILES_MATCHING PATTERN "*.h" PATTERN "*.inc" PATTERN "*.def")
+install(DIRECTORY "${LIBBASE_BINARY_INCLUDE_DIR}/core"
+  DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+  FILES_MATCHING PATTERN "*.h" PATTERN "*.inc" PATTERN "*.def"
+  PATTERN "config.h" EXCLUDE)
diff --git a/libsupport/include/CoreLib/ADT/STLFunctionalExtras.h b/libbase/include/core/adt/STLFunctionalExtras.h
index 993acc0..915796b 100644
--- a/libsupport/include/CoreLib/ADT/STLFunctionalExtras.h
+++ b/libbase/include/core/adt/STLFunctionalExtras.h
@@ -33,10 +33,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef RCC_ADT_STLFUNCTIONALEXTRAS_H
-#define RCC_ADT_STLFUNCTIONALEXTRAS_H
+#ifndef LIBBASE_ADT_STLFUNCTIONALEXTRAS_H
+#define LIBBASE_ADT_STLFUNCTIONALEXTRAS_H
 
-#include "CoreLib/Compiler/Compiler.h"
+#include "core/compiler/Compiler.h"
 
 #include <cstddef
 #include <cstdint>
@@ -59,7 +59,7 @@ namespace rcc
 template <typename Fn> class function_ref;
 
 template <typename Ret, typename... Params>
-class RCC_GSL_POINTER function_ref<Ret (Params...)>
+class LIBBASE_GSL_POINTER function_ref<Ret (Params...)>
 {
   Ret (*callback) (intptr_t callable, Params... params) = nullptr;
   intptr_t callable = 0;
@@ -80,7 +80,7 @@ public:
 
   template <typename Callable>
   function_ref (
-      Callable &&callable RCC_LIFETIME_BOUND,
+      Callable &&callable LIBBASE_LIFETIME_BOUND,
       // This is not the copy-constructor.
       std::enable_if_t<!std::is_same<std::remove_cvref_t<Callable>,
                                      function_ref>::value> * = nullptr,
@@ -109,4 +109,4 @@ public:
 
 } // end namespace rcc
 
-#endif // RCC_ADT_STLFUNCTIONALEXTRAS_H
+#endif // LIBBASE_ADT_STLFUNCTIONALEXTRAS_H
diff --git a/libsupport/include/CoreLib/ADT/SmallVector.h b/libbase/include/core/adt/SmallVector.h
index 8b9826a..7b3c554 100644
--- a/libsupport/include/CoreLib/ADT/SmallVector.h
+++ b/libbase/include/core/adt/SmallVector.h
@@ -32,10 +32,10 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef RCC_ADT_SMALLVECTOR_H
-#define RCC_ADT_SMALLVECTOR_H
+#ifndef LIBBASE_ADT_SMALLVECTOR_H
+#define LIBBASE_ADT_SMALLVECTOR_H
 
-#include "CoreLib/Compiler/Compiler.h"
+#include "core/compiler/Compiler.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
@@ -97,14 +97,14 @@ protected:
   /// 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.
-  RCC_ABI void *
+  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.
-  RCC_ABI void
+  LIBBASE_ABI void
   grow_pod (void *FirstEl, size_t MinSize, size_t TSize);
 
 public:
@@ -245,7 +245,7 @@ protected:
   isSafeToReferenceAfterResize (const void *Elt, size_t NewSize)
   {
     // Past the end.
-    if (RCC_LIKELY (!isReferenceToStorage (Elt)))
+    if (LIBBASE_LIKELY (!isReferenceToStorage (Elt)))
     {
       return true;
     }
@@ -325,7 +325,7 @@ protected:
   reserveForParamAndGetAddressImpl (U *This, const T &Elt, size_t N)
   {
     size_t NewSize = This->size () + N;
-    if (RCC_LIKELY (NewSize <= This->capacity ()))
+    if (LIBBASE_LIKELY (NewSize <= This->capacity ()))
     {
       return &Elt;
     }
@@ -334,7 +334,7 @@ protected:
     int64_t Index = -1;
     if (!U::TakesParamByValue)
     {
-      if (RCC_UNLIKELY (This->isReferenceToStorage (&Elt)))
+      if (LIBBASE_UNLIKELY (This->isReferenceToStorage (&Elt)))
       {
         ReferencesStorage = true;
         Index = &Elt - This->begin ();
@@ -799,7 +799,7 @@ protected:
 
   // Out-of-line slow path so the inline push_back needs no callee-saved
   // registers or stack frame on its hot path.
-  RCC_ATTRIBUTE_NOINLINE void
+  LIBBASE_ATTRIBUTE_NOINLINE void
   growAndPushBack (ValueParamT Elt)
   {
     // Copy in case Elt is an internal reference invalidated by grow.
@@ -813,7 +813,7 @@ public:
   void
   push_back (ValueParamT Elt)
   {
-    if (RCC_UNLIKELY (this->size () >= this->capacity ()))
+    if (LIBBASE_UNLIKELY (this->size () >= this->capacity ()))
     {
       return growAndPushBack (Elt);
     }
@@ -1354,7 +1354,7 @@ public:
   reference
   emplace_back (ArgTypes &&...Args)
   {
-    if (RCC_UNLIKELY (this->size () >= this->capacity ()))
+    if (LIBBASE_UNLIKELY (this->size () >= this->capacity ()))
     {
       return this->growAndEmplaceBack (std::forward<ArgTypes> (Args)...);
     }
@@ -1605,7 +1605,7 @@ template <typename T> struct alignas (T) SmallVectorStorage<T, 0>
 /// Forward declaration of SmallVector so that
 /// calculateSmallVectorDefaultInlinedElements can reference
 /// `sizeof(SmallVector<T, 0>)`.
-template <typename T, unsigned N> class RCC_GSL_OWNER SmallVector;
+template <typename T, unsigned N> class LIBBASE_GSL_OWNER SmallVector;
 
 /// Helper class for calculating the default number of inline elements for
 /// `SmallVector<T>`.
@@ -1680,7 +1680,7 @@ template <typename T> struct CalculateSmallVectorDefaultInlinedElements
 /// \see https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h
 template <typename T,
           unsigned N = CalculateSmallVectorDefaultInlinedElements<T>::value>
-class RCC_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
+class LIBBASE_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
                                   SmallVectorStorage<T, N>
 {
 public:
@@ -1923,4 +1923,4 @@ swap (rcc::SmallVector<T, N> &LHS, rcc::SmallVector<T, N> &RHS)
 
 } // end namespace std
 
-#endif // RCC_ADT_SMALLVECTOR_H
+#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
+ <http://www.gnu.org/licenses/>.
+*/
+
+//===-- 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 <stddef.h>
+
+#if defined(_MSC_VER)
+#include <sal.h>
+#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 <sanitizer/msan_interface.h>
+# 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(<sanitizer/asan_interface.h>)
+# include <sanitizer/asan_interface.h>
+#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/rcc/include/rcc/DataTypes.h b/libbase/include/core/compiler/DataTypes.h
index 59e9b75..bfcf577 100644
--- a/rcc/include/rcc/DataTypes.h
+++ b/libbase/include/core/compiler/DataTypes.h
@@ -46,8 +46,8 @@ along with RCC-Project; see the file COPYING. If not see
  |*===----------------------------------------------------------------------===*/
 
 /* Please leave this file C-compatible. */
-#ifndef RCC_DATATYPES_H
-#define RCC_DATATYPES_H
+#ifndef LIBBASE_DATATYPES_H
+#define LIBBASE_DATATYPES_H
 
 #include <inttypes.h>
 #include <stdint.h>
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 <mach/mach.h> 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 <malloc/malloc.h> 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 <pthread.h> 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 <sys/mman.h> header file. */
+#cmakedefine HAVE_SYS_MMAN_H ${HAVE_SYS_MMAN_H}
+
+/* Define to 1 if you have the <sys/ioctl.h> 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 <unistd.h> 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
+ <http://www.gnu.org/licenses/>.
+*/
+
+/* 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 <sysexits.h> 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/libsupport/include/CoreLib/System/Errno.h b/libbase/include/core/error/Errno.h
index 2626ad9..01d4ff8 100644
--- a/libsupport/include/CoreLib/System/Errno.h
+++ b/libbase/include/core/error/Errno.h
@@ -21,10 +21,10 @@
 
 // This implementation is based on llvm/include/llvm/Support/Errno.h.
 
-#ifndef RCC_SUPPORT_ERRNO_H
-#define RCC_SUPPORT_ERRNO_H
+#ifndef LIBBASE_SUPPORT_ERRNO_H
+#define LIBBASE_SUPPORT_ERRNO_H
 
-#include "CoreLib/Compiler/Compiler.h"
+#include "core/compiler/Compiler.h"
 
 #include <cerrno>
 #include <string>
@@ -38,11 +38,11 @@ namespace sys
 /// 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.
-RCC_ABI std::string
+LIBBASE_ABI std::string
 StrError ();
 
 /// Like the no-argument version above, but uses \p errnum instead of errno.
-RCC_ABI std::string
+LIBBASE_ABI std::string
 StrError (int errnum);
 
 template <typename FailT, typename Fun, typename... Args>
@@ -61,4 +61,4 @@ RetryAfterSignal (const FailT &Fail, const Fun &F, const Args &...As)
 } // namespace sys
 } // namespace rcc
 
-#endif // RCC_SUPPORT_ERRNO_H
+#endif // LIBBASE_SUPPORT_ERRNO_H
diff --git a/libsupport/include/CoreLib/Error/ErrorHandling.h b/libbase/include/core/error/ErrorHandling.h
index 5ab5a9e..b27104c 100644
--- a/libsupport/include/CoreLib/Error/ErrorHandling.h
+++ b/libbase/include/core/error/ErrorHandling.h
@@ -32,10 +32,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef RCC_SUPPORT_ERRORHANDLING_H
-#define RCC_SUPPORT_ERRORHANDLING_H
+#ifndef LIBBASE_SUPPORT_ERRORHANDLING_H
+#define LIBBASE_SUPPORT_ERRORHANDLING_H
 
-#include "CoreLib/Compiler/Compiler.h"
+#include "core/compiler/Compiler.h"
 
 namespace rcc
 {
@@ -62,12 +62,12 @@ using fatal_error_handler_t = void (*) (void *user_data, const char *reason,
 ///
 /// \param user_data - An argument which will be passed to the install error
 /// handler.
-RCC_ABI void
+LIBBASE_ABI void
 install_fatal_error_handler (fatal_error_handler_t handler,
                              void *user_data = nullptr);
 
 /// Restores default error handling behaviour.
-RCC_ABI void
+LIBBASE_ABI void
 remove_fatal_error_handler ();
 
 /// ScopedFatalErrorHandler - This is a simple helper class which just
@@ -89,11 +89,11 @@ struct ScopedFatalErrorHandler
 
 /// @deprecated Use reportFatalInternalError() or reportFatalUsageError()
 /// instead.
-[[noreturn]] RCC_ABI void
+[[noreturn]] LIBBASE_ABI void
 report_fatal_error (const char *reason, bool gen_crash_diag = true);
-[[noreturn]] RCC_ABI void
+[[noreturn]] LIBBASE_ABI void
 report_fatal_error (StringRef reason, bool gen_crash_diag = true);
-[[noreturn]] RCC_ABI void
+[[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
@@ -103,11 +103,11 @@ report_fatal_error (const Twine &reason, bool gen_crash_diag = true);
 /// 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]] RCC_ABI void
+[[noreturn]] LIBBASE_ABI void
 reportFatalInternalError (const char *reason);
-[[noreturn]] RCC_ABI void
+[[noreturn]] LIBBASE_ABI void
 reportFatalInternalError (StringRef reason);
-[[noreturn]] RCC_ABI void
+[[noreturn]] LIBBASE_ABI void
 reportFatalInternalError (const Twine &reason);
 
 /// Report a fatal error that does not indicate a bug in LLVM.
@@ -124,11 +124,11 @@ reportFatalInternalError (const Twine &reason);
 /// 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]] RCC_ABI void
+[[noreturn]] LIBBASE_ABI void
 reportFatalUsageError (const char *reason);
-[[noreturn]] RCC_ABI void
+[[noreturn]] LIBBASE_ABI void
 reportFatalUsageError (StringRef reason);
-[[noreturn]] RCC_ABI void
+[[noreturn]] LIBBASE_ABI void
 reportFatalUsageError (const Twine &reason);
 
 /// Installs a new bad alloc error handler that should be used whenever a
@@ -147,15 +147,15 @@ reportFatalUsageError (const Twine &reason);
 ///
 /// \param user_data - An argument which will be passed to the installed error
 /// handler.
-RCC_ABI void
+LIBBASE_ABI void
 install_bad_alloc_error_handler (fatal_error_handler_t handler,
                                  void *user_data = nullptr);
 
 /// Restores default bad alloc error handling behavior.
-RCC_ABI void
+LIBBASE_ABI void
 remove_bad_alloc_error_handler ();
 
-RCC_ABI void
+LIBBASE_ABI void
 install_out_of_memory_new_handler ();
 
 /// Reports a bad alloc error, calling any user defined bad alloc
@@ -170,13 +170,13 @@ install_out_of_memory_new_handler ();
 /// 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]] RCC_ABI void
+[[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]] RCC_ABI void
+[[noreturn]] LIBBASE_ABI void
 rcc_unreachable_internal (const char *msg = nullptr, const char *file = nullptr,
                           unsigned line = 0);
 } // namespace rcc
@@ -201,16 +201,16 @@ rcc_unreachable_internal (const char *msg = nullptr, const char *file = nullptr,
 #ifndef NDEBUG
 #define rcc_unreachable(msg)                                                   \
   ::rcc::rcc_unreachable_internal (msg, __FILE__, __LINE__)
-#elif !defined(RCC_BUILTIN_UNREACHABLE)
+#elif !defined(LIBBASE_BUILTIN_UNREACHABLE)
 #define rcc_unreachable(msg) ::rcc::rcc_unreachable_internal ()
-#elif RCC_UNREACHABLE_OPTIMIZE
-#define rcc_unreachable(msg) RCC_BUILTIN_UNREACHABLE
+#elif LIBBASE_UNREACHABLE_OPTIMIZE
+#define rcc_unreachable(msg) LIBBASE_BUILTIN_UNREACHABLE
 #else
 #define rcc_unreachable(msg)                                                   \
   do                                                                           \
   {                                                                            \
-    RCC_BUILTIN_TRAP;                                                          \
-    RCC_BUILTIN_UNREACHABLE;                                                   \
+    LIBBASE_BUILTIN_TRAP;                                                          \
+    LIBBASE_BUILTIN_UNREACHABLE;                                                   \
   } while (false)
 #endif
 
diff --git a/libsupport/include/CoreLib/Math/MathExtras.h b/libbase/include/core/math/MathExtras.h
index a9c954d..880ba74 100644
--- a/libsupport/include/CoreLib/Math/MathExtras.h
+++ b/libbase/include/core/math/MathExtras.h
@@ -31,10 +31,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef RCC_SUPPORT_MATHEXTRAS_H
-#define RCC_SUPPORT_MATHEXTRAS_H
+#ifndef LIBBASE_SUPPORT_MATHEXTRAS_H
+#define LIBBASE_SUPPORT_MATHEXTRAS_H
 
-#include "CoreLib/Compiler/Compiler.h"
+#include "core/compiler/Compiler.h"
 #include <bit>
 #include <cassert>
 #include <climits>
@@ -894,7 +894,7 @@ SaturatingMultiplyAdd (T X, T Y, T A, bool *ResultOverflowed = nullptr)
 }
 
 /// Use this rather than HUGE_VALF; the latter causes warnings on MSVC.
-RCC_ABI extern const float huge_valf;
+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
@@ -1042,7 +1042,7 @@ using stack_float_t = float;
 #endif
 
 /// Returns the number of digits in the given integer.
-RCC_ABI int
+LIBBASE_ABI int
 NumDigitsBase10 (uint64_t X);
 
 } // namespace rcc
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
+ <http://www.gnu.org/licenses/>.
+ */
+
+//===-- 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 <cassert>
+#include <optional>
+#ifndef NDEBUG
+#include <string>
+#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 <size_t kValue> constexpr static Align Constant() {
+    return fromLog2(ConstantLog2<kValue>());
+  }
+
+  /// Allow constructions of constexpr Align from types.
+  /// Compile time equivalent to Align(alignof(T)).
+  template <typename T> constexpr static Align Of() {
+    return Constant<std::alignment_of_v<T>>();
+  }
+};
+
+/// 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<Align> {
+private:
+  using UP = std::optional<Align>;
+
+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<uintptr_t>(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<uintptr_t>(Addr);
+  assert(static_cast<uintptr_t>(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<uintptr_t>(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
+ <http://www.gnu.org/licenses/>.
+ */
+
+//===- 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 <type_traits>
+#include <utility>
+
+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 <typename DerivedT> 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<void *(AllocatorBase::*)(size_t, size_t)>(
+                      &AllocatorBase::Allocate) !=
+                      static_cast<void *(DerivedT::*)(size_t, size_t)>(
+                          &DerivedT::Allocate),
+                  "Class derives from AllocatorBase without implementing the "
+                  "core Allocate(size_t, size_t) overload!");
+#endif
+    return static_cast<DerivedT *>(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<void (AllocatorBase::*)(const void *, size_t, size_t)>(
+            &AllocatorBase::Deallocate) !=
+            static_cast<void (DerivedT::*)(const void *, size_t, size_t)>(
+                &DerivedT::Deallocate),
+        "Class derives from AllocatorBase without implementing the "
+        "core Deallocate(void *) overload!");
+#endif
+    return static_cast<DerivedT *>(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 <typename T> T *Allocate(size_t Num = 1) {
+    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
+  }
+
+  /// Deallocate space for a sequence of objects without constructing them.
+  template <typename T>
+  std::enable_if_t<!std::is_same_v<std::remove_cv_t<T>, void>, void>
+  Deallocate(T *Ptr, size_t Num = 1) {
+    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T), alignof(T));
+  }
+};
+
+class MallocAllocator : public AllocatorBase<MallocAllocator> {
+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<MallocAllocator>::Allocate;
+
+  void Deallocate(const void *Ptr, size_t Size, size_t Alignment) {
+    deallocate_buffer(const_cast<void *>(Ptr), Size, Alignment);
+  }
+
+  // Pull in base class overloads.
+  using AllocatorBase<MallocAllocator>::Deallocate;
+
+  void PrintStats() const {}
+};
+
+namespace detail {
+
+template <typename Alloc> 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 <typename Alloc> class AllocatorHolder<Alloc &> {
+  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/libsupport/include/CoreLib/Memory/MemAlloc.h b/libbase/include/core/memory/MemAlloc.h
index b7183c0..bd98864 100644
--- a/libsupport/include/CoreLib/Memory/MemAlloc.h
+++ b/libbase/include/core/memory/MemAlloc.h
@@ -34,17 +34,17 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef RCC_SUPPORT_MEMALLOC_H
-#define RCC_SUPPORT_MEMALLOC_H
+#ifndef LIBBASE_SUPPORT_MEMALLOC_H
+#define LIBBASE_SUPPORT_MEMALLOC_H
 
-#include "CoreLib/Compiler/Compiler.h"
-#include "CoreLib/Error/ErrorHandling.h"
+#include "core/compiler/Compiler.h"
+#include "core/error/ErrorHandling.h"
 #include <cstdlib>
 
 namespace rcc
 {
 
-RCC_ATTRIBUTE_RETURNS_NONNULL inline void *
+LIBBASE_ATTRIBUTE_RETURNS_NONNULL inline void *
 safe_malloc (size_t Sz)
 {
   void *Result = std::malloc (Sz);
@@ -62,7 +62,7 @@ safe_malloc (size_t Sz)
   return Result;
 }
 
-RCC_ATTRIBUTE_RETURNS_NONNULL inline void *
+LIBBASE_ATTRIBUTE_RETURNS_NONNULL inline void *
 safe_calloc (size_t Count, size_t Sz)
 {
   void *Result = std::calloc (Count, Sz);
@@ -80,7 +80,7 @@ safe_calloc (size_t Count, size_t Sz)
   return Result;
 }
 
-RCC_ATTRIBUTE_RETURNS_NONNULL inline void *
+LIBBASE_ATTRIBUTE_RETURNS_NONNULL inline void *
 safe_realloc (void *Ptr, size_t Sz)
 {
   void *Result = std::realloc (Ptr, Sz);
@@ -107,7 +107,7 @@ safe_realloc (void *Ptr, size_t Sz)
 /// 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.
-RCC_ABI RCC_ATTRIBUTE_RETURNS_NONNULL RCC_ATTRIBUTE_RETURNS_NOALIAS void *
+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.
@@ -117,7 +117,7 @@ allocate_buffer (size_t Size, size_t Alignment);
 ///
 /// The pointer must have been allocated with the corresponding new operator,
 /// most likely using the above helper.
-RCC_ABI void
+LIBBASE_ABI void
 deallocate_buffer (void *Ptr, size_t Size, size_t Alignment);
 
 } // namespace rcc
diff --git a/libsupport/src/corelib/system/Errno.cc b/libbase/src/core/error/Errno.cc
index 66ced94..3c85930 100644
--- a/libsupport/src/corelib/system/Errno.cc
+++ b/libbase/src/core/error/Errno.cc
@@ -21,8 +21,8 @@
 
 // This implementation is based on llvm/lib/Support/Errno.cpp.
 
-#include "CoreLib/System/Errno.h"
-#include "rcc/Config/config.h"
+#include "core/error/Errno.h"
+#include "core/config/config.h"
 
 #include <cstring>
 #include <errno.h>
diff --git a/libsupport/src/corelib/math/MathExtras.cc b/libbase/src/core/math/MathExtras.cc
index 99d7ba7..8d1798f 100644
--- a/libsupport/src/corelib/math/MathExtras.cc
+++ b/libbase/src/core/math/MathExtras.cc
@@ -31,7 +31,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "CoreLib/Math/MathExtras.h"
+#include "core/math/MathExtras.h"
 
 #ifdef _MSC_VER
 #include <limits>
diff --git a/libsupport/src/corelib/memory/MemAlloc.cpp b/libbase/src/core/memory/MemAlloc.cpp
index 9413922..b418d40 100644
--- a/libsupport/src/corelib/memory/MemAlloc.cpp
+++ b/libbase/src/core/memory/MemAlloc.cpp
@@ -27,12 +27,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "CoreLib/Memory/MemAlloc.h"
+#include "core/memory/MemAlloc.h"
 #include <new>
 
 // These are out of line to have __cpp_aligned_new not affect ABI.
 
-RCC_ATTRIBUTE_RETURNS_NONNULL RCC_ATTRIBUTE_RETURNS_NOALIAS void *
+LIBBASE_ATTRIBUTE_RETURNS_NONNULL LIBBASE_ATTRIBUTE_RETURNS_NOALIAS void *
 rcc::allocate_buffer (size_t Size, size_t Alignment)
 {
   void *Result = ::operator new (Size,
diff --git a/libsupport/CMakeLists.txt b/libsupport/CMakeLists.txt
deleted file mode 100644
index 0784f3b..0000000
--- a/libsupport/CMakeLists.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-add_rcc_library(RCCSupport
-  STATIC
-  src/corelib/math/MathExtras.cc
-  src/corelib/memory/MemAlloc.cpp
-  src/corelib/system/Errno.cc
-)
-
-target_include_directories(RCCSupport
-  PUBLIC
-    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
-    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-
-install(DIRECTORY include/CoreLib DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
diff --git a/libsupport/include/CoreLib/Compiler/Compiler.h b/libsupport/include/CoreLib/Compiler/Compiler.h
deleted file mode 100644
index 511c4cd..0000000
--- a/libsupport/include/CoreLib/Compiler/Compiler.h
+++ /dev/null
@@ -1,853 +0,0 @@
-/*
- 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
- <http://www.gnu.org/licenses/>.
-*/
-
-//===-- llvm/Support/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 RCC_SUPPORT_COMPILER_H
-#define RCC_SUPPORT_COMPILER_H
-
-#include "rcc/Config/rcc-config.h"
-
-#include <stddef.h>
-
-#if defined(_MSC_VER)
-#include <sal.h>
-#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 RCC_HAS_CPP_ATTRIBUTE
-#if defined(__cplusplus) && defined(__has_cpp_attribute)
-#define RCC_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute (x)
-#else
-#define RCC_HAS_CPP_ATTRIBUTE(x) 0
-#endif
-#endif
-
-/// \macro RCC_GNUC_PREREQ
-/// Extend the default __GNUC_PREREQ even if glibc's features.h isn't
-/// available.
-#ifndef RCC_GNUC_PREREQ
-#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
-#define RCC_GNUC_PREREQ(maj, min, patch)                                       \
-  ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >=          \
-   ((maj) << 20) + ((min) << 10) + (patch))
-#elif defined(__GNUC__) && defined(__GNUC_MINOR__)
-#define RCC_GNUC_PREREQ(maj, min, patch)                                       \
-  ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
-#else
-#define RCC_GNUC_PREREQ(maj, min, patch) 0
-#endif
-#endif
-
-/// \macro RCC_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 RCC_MSC_PREREQ(version) (_MSC_VER >= (version))
-
-// We require at least VS 2019.
-#if !defined(RCC_FORCE_USE_OLD_TOOLCHAIN)
-#if !RCC_MSC_PREREQ(1920)
-#error RCC requires at least VS 2019.
-#endif
-#endif
-
-#else
-#define RCC_MSC_PREREQ(version) 0
-#endif
-
-/// RCC_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.
-///
-/// RCC_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 RCC_HAS_CPP_ATTRIBUTE(gnu::visibility) && defined(__GNUC__) &&             \
-    !defined(__clang__)
-#define RCC_ATTRIBUTE_VISIBILITY_HIDDEN [[gnu::visibility ("hidden")]]
-#define RCC_ATTRIBUTE_VISIBILITY_DEFAULT [[gnu::visibility ("default")]]
-#elif __has_attribute(visibility)
-#define RCC_ATTRIBUTE_VISIBILITY_HIDDEN __attribute__ ((visibility ("hidden")))
-#define RCC_ATTRIBUTE_VISIBILITY_DEFAULT                                       \
-  __attribute__ ((visibility ("default")))
-#else
-#define RCC_ATTRIBUTE_VISIBILITY_HIDDEN
-#define RCC_ATTRIBUTE_VISIBILITY_DEFAULT
-#endif
-
-#if defined(RCC_BUILD_RCC_DYLIB) || defined(RCC_BUILD_SHARED_LIBS)
-#define RCC_EXTERNAL_VISIBILITY RCC_ATTRIBUTE_VISIBILITY_DEFAULT
-#else
-#define RCC_EXTERNAL_VISIBILITY
-#endif
-
-#if (!(defined(_WIN32) || defined(__CYGWIN__)) ||                              \
-     ((defined(__MINGW32__) || defined(__CYGWIN__)) && defined(__clang__)))
-#define RCC_LIBRARY_VISIBILITY RCC_ATTRIBUTE_VISIBILITY_HIDDEN
-// Clang compilers older then 15 do not support gnu style attributes on
-// namespaces.
-#if defined(__clang__) && __clang_major__ < 15
-#define RCC_LIBRARY_VISIBILITY_NAMESPACE [[gnu::visibility ("hidden")]]
-#else
-#define RCC_LIBRARY_VISIBILITY_NAMESPACE RCC_ATTRIBUTE_VISIBILITY_HIDDEN
-#endif
-#define RCC_ALWAYS_EXPORT RCC_ATTRIBUTE_VISIBILITY_DEFAULT
-#elif defined(_WIN32)
-#define RCC_ALWAYS_EXPORT __declspec (dllexport)
-#define RCC_LIBRARY_VISIBILITY
-#define RCC_LIBRARY_VISIBILITY_NAMESPACE
-#else
-#define RCC_LIBRARY_VISIBILITY
-#define RCC_ALWAYS_EXPORT
-#define RCC_LIBRARY_VISIBILITY_NAMESPACE
-#endif
-
-/// RCC_ABI is the main export/visibility macro to mark something as explicitly
-/// exported when rcc is built as a shared library with everything else that is
-/// unannotated will have internal visibility.
-///
-/// RCC_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 RCC_ABI.
-///
-/// RCC_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.
-///
-/// RCC_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.
-///
-/// RCC_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 RCC's public headers are part of the RCC public interface and
-/// should use RCC_ABI. RCC_ABI_FOR_TEST is reserved for internal headers,
-/// whose symbols could be conditionally excluded when not building tests in the
-/// future.
-///
-#ifndef RCC_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 RCC_ABI_NOT_EXPORTED
-// TODO(https://github.com/rcc/rcc-project/issues/145406): eliminate need for
-// two preprocessor definitions to gate RCC_ABI macro definitions.
-#if defined(RCC_ENABLE_RCC_EXPORT_ANNOTATIONS) && !defined(RCC_BUILD_STATIC)
-#if defined(_WIN32) && !defined(__MINGW32__)
-#if defined(RCC_EXPORTS)
-#define RCC_ABI __declspec (dllexport)
-#define RCC_TEMPLATE_ABI
-#define RCC_EXPORT_TEMPLATE __declspec (dllexport)
-#else
-#define RCC_ABI __declspec (dllimport)
-#define RCC_TEMPLATE_ABI __declspec (dllimport)
-#define RCC_EXPORT_TEMPLATE
-#endif
-#define RCC_ABI_EXPORT __declspec (dllexport)
-#elif __has_attribute(visibility)
-#if defined(__ELF__) || defined(__MINGW32__) || defined(_AIX) ||               \
-    defined(__MVS__) || defined(__CYGWIN__)
-#define RCC_ABI __attribute__ ((visibility ("default")))
-#define RCC_TEMPLATE_ABI RCC_ABI
-#define RCC_EXPORT_TEMPLATE
-#define RCC_ABI_EXPORT RCC_ABI
-#elif defined(__MACH__) || defined(__wasm__) || defined(__EMSCRIPTEN__)
-#define RCC_ABI __attribute__ ((visibility ("default")))
-#define RCC_TEMPLATE_ABI
-#define RCC_EXPORT_TEMPLATE
-#define RCC_ABI_EXPORT RCC_ABI
-#endif
-#endif
-#endif
-#if !defined(RCC_ABI)
-#define RCC_ABI
-#define RCC_TEMPLATE_ABI
-#define RCC_EXPORT_TEMPLATE
-#define RCC_ABI_EXPORT
-#endif
-#define RCC_ABI_FOR_TEST RCC_ABI
-#endif
-
-#if defined(__GNUC__)
-#define RCC_PREFETCH(addr, rw, locality) __builtin_prefetch (addr, rw, locality)
-#else
-#define RCC_PREFETCH(addr, rw, locality)
-#endif
-
-#if __has_attribute(uninitialized)
-#define RCC_ATTRIBUTE_UNINITIALIZED __attribute__ ((uninitialized))
-#else
-#define RCC_ATTRIBUTE_UNINITIALIZED
-#endif
-
-#if __has_attribute(used)
-#define RCC_ATTRIBUTE_USED __attribute__ ((__used__))
-#else
-#define RCC_ATTRIBUTE_USED
-#endif
-
-#if __has_attribute(warn_unused)
-#define RCC_ATTRIBUTE_WARN_UNUSED __attribute__ ((warn_unused))
-#else
-#define RCC_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 RCC_ATTRIBUTE_RETAIN __attribute__ ((__retain__))
-#else
-#define RCC_ATTRIBUTE_RETAIN
-#endif
-
-// For deprecations that are not a simple rename, use [[deprecated(MSG)]]
-// instead.
-#if defined(__clang__)
-#define RCC_DEPRECATED_WITH_FIXIT(MSG, FIX)                                    \
-  __attribute__ ((deprecated (MSG, FIX)))
-#else
-#define RCC_DEPRECATED_WITH_FIXIT(MSG, FIX) [[deprecated (MSG)]]
-#endif
-
-// clang-format off
-#if defined(__clang__) || defined(__GNUC__)
-#define RCC_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH                             \
-  _Pragma("GCC diagnostic push")                                               \
-  _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
-#define RCC_SUPPRESS_DEPRECATED_DECLARATIONS_POP                              \
-  _Pragma("GCC diagnostic pop")
-#elif defined(_MSC_VER)
-#define RCC_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH                             \
-  __pragma(warning(push))                                                     \
-  __pragma(warning(disable : 4996))
-#define RCC_SUPPRESS_DEPRECATED_DECLARATIONS_POP                              \
-  __pragma(warning(pop))
-#else
-#define RCC_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH
-#define RCC_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 RCC_HAS_CPP_ATTRIBUTE(clang::reinitializes)
-#define RCC_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
-#else
-#define RCC_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 RCC_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
-#else
-#define RCC_ATTRIBUTE_UNUSED
-#endif
-
-// FIXME: Provide this for PE/COFF targets.
-#if __has_attribute(weak) && !defined(__MINGW32__) && !defined(__CYGWIN__) &&  \
-    !defined(_WIN32)
-#define RCC_HAS_ATTRIBUTE_WEAK 1
-#else
-#define RCC_HAS_ATTRIBUTE_WEAK 0
-#endif
-#if RCC_HAS_ATTRIBUTE_WEAK
-#define RCC_ATTRIBUTE_WEAK __attribute__ ((__weak__))
-#else
-#define RCC_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 RCC Conventions.
-#define RCC_READNONE __attribute__ ((__const__))
-#else
-#define RCC_READNONE
-#endif
-
-#if __has_attribute(pure) || defined(__GNUC__)
-// aka 'PURE' but following RCC Conventions.
-#define RCC_READONLY __attribute__ ((__pure__))
-#else
-#define RCC_READONLY
-#endif
-
-#if __has_attribute(minsize)
-#define RCC_ATTRIBUTE_MINSIZE __attribute__ ((minsize))
-#else
-#define RCC_ATTRIBUTE_MINSIZE
-#endif
-
-#if __has_builtin(__builtin_expect) || defined(__GNUC__)
-#define RCC_LIKELY(EXPR) __builtin_expect ((bool)(EXPR), true)
-#define RCC_UNLIKELY(EXPR) __builtin_expect ((bool)(EXPR), false)
-#else
-#define RCC_LIKELY(EXPR) (EXPR)
-#define RCC_UNLIKELY(EXPR) (EXPR)
-#endif
-
-/// RCC_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
-/// mark a method "not for inlining".
-#if __has_attribute(noinline)
-#define RCC_ATTRIBUTE_NOINLINE __attribute__ ((noinline))
-#elif defined(_MSC_VER)
-#define RCC_ATTRIBUTE_NOINLINE __declspec (noinline)
-#else
-#define RCC_ATTRIBUTE_NOINLINE
-#endif
-
-/// RCC_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 RCC_ATTRIBUTE_ALWAYS_INLINE inline __attribute__ ((always_inline))
-#elif defined(_MSC_VER)
-#define RCC_ATTRIBUTE_ALWAYS_INLINE __forceinline
-#else
-#define RCC_ATTRIBUTE_ALWAYS_INLINE inline
-#endif
-
-/// RCC_ATTRIBUTE_ALWAYS_INLINE_UNLESS_DEBUG - Like
-/// RCC_ATTRIBUTE_ALWAYS_INLINE but disabled in debug builds to avoid stack
-/// overflow with deep recursion.
-#if defined(NDEBUG)
-#define RCC_ATTRIBUTE_ALWAYS_INLINE_UNLESS_DEBUG RCC_ATTRIBUTE_ALWAYS_INLINE
-#else
-#define RCC_ATTRIBUTE_ALWAYS_INLINE_UNLESS_DEBUG inline
-#endif
-
-/// RCC_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 RCC_ATTRIBUTE_NODEBUG __attribute__ ((nodebug))
-#else
-#define RCC_ATTRIBUTE_NODEBUG
-#endif
-
-#if __has_attribute(returns_nonnull)
-#define RCC_ATTRIBUTE_RETURNS_NONNULL __attribute__ ((returns_nonnull))
-#elif defined(_MSC_VER)
-#define RCC_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_
-#else
-#define RCC_ATTRIBUTE_RETURNS_NONNULL
-#endif
-
-/// RCC_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 RCC_ATTRIBUTE_RESTRICT __restrict
-#else
-#define RCC_ATTRIBUTE_RESTRICT
-#endif
-
-/// \macro RCC_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a
-/// pointer that does not alias any other valid pointer.
-#ifdef __GNUC__
-#define RCC_ATTRIBUTE_RETURNS_NOALIAS __attribute__ ((__malloc__))
-#elif defined(_MSC_VER)
-#define RCC_ATTRIBUTE_RETURNS_NOALIAS __declspec (restrict)
-#else
-#define RCC_ATTRIBUTE_RETURNS_NOALIAS
-#endif
-
-/// RCC_FALLTHROUGH - Mark fallthrough cases in switch statements.
-#if defined(__cplusplus) && __cplusplus > 201402L &&                           \
-    RCC_HAS_CPP_ATTRIBUTE(fallthrough)
-#define RCC_FALLTHROUGH [[fallthrough]]
-#elif RCC_HAS_CPP_ATTRIBUTE(gnu::fallthrough)
-#define RCC_FALLTHROUGH [[gnu::fallthrough]]
-#elif __has_attribute(fallthrough)
-#define RCC_FALLTHROUGH __attribute__ ((fallthrough))
-#elif RCC_HAS_CPP_ATTRIBUTE(clang::fallthrough)
-#define RCC_FALLTHROUGH [[clang::fallthrough]]
-#else
-#define RCC_FALLTHROUGH
-#endif
-
-/// RCC_REQUIRE_CONSTANT_INITIALIZATION - Apply this to globals to ensure that
-/// they are constant initialized.
-#if RCC_HAS_CPP_ATTRIBUTE(clang::require_constant_initialization)
-#define RCC_REQUIRE_CONSTANT_INITIALIZATION                                    \
-  [[clang::require_constant_initialization]]
-#else
-#define RCC_REQUIRE_CONSTANT_INITIALIZATION
-#endif
-
-/// RCC_GSL_OWNER - Apply this to owning classes like SmallVector to enable
-/// lifetime warnings.
-#if RCC_HAS_CPP_ATTRIBUTE(gsl::Owner)
-#define RCC_GSL_OWNER [[gsl::Owner]]
-#else
-#define RCC_GSL_OWNER
-#endif
-
-/// RCC_GSL_POINTER - Apply this to non-owning classes like
-/// StringRef to enable lifetime warnings.
-#if RCC_HAS_CPP_ATTRIBUTE(gsl::Pointer)
-#define RCC_GSL_POINTER [[gsl::Pointer]]
-#else
-#define RCC_GSL_POINTER
-#endif
-
-#if RCC_HAS_CPP_ATTRIBUTE(clang::lifetimebound)
-#define RCC_LIFETIME_BOUND [[clang::lifetimebound]]
-#else
-#define RCC_LIFETIME_BOUND
-#endif
-
-#if RCC_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L
-#define RCC_CTOR_NODISCARD [[nodiscard]]
-#else
-#define RCC_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 RCC_SUPPRESS_MSVC_ATTR_IS_VENDOR_EXT_PUSH
-#define RCC_SUPPRESS_MSVC_ATTR_IS_VENDOR_EXT_POP
-#else // MSVC < 19.43
-#define RCC_SUPPRESS_MSVC_ATTR_IS_VENDOR_EXT_PUSH                              \
-  __pragma (warning (push)) __pragma (warning (disable : 4848))
-#define RCC_SUPPRESS_MSVC_ATTR_IS_VENDOR_EXT_POP __pragma (warning (pop))
-#endif
-
-#if RCC_HAS_CPP_ATTRIBUTE(no_unique_address)
-#define RCC_NO_UNIQUE_ADDRESS [[no_unique_address]]
-#elif RCC_HAS_CPP_ATTRIBUTE(msvc::no_unique_address)
-#define RCC_NO_UNIQUE_ADDRESS                                                  \
-  RCC_SUPPRESS_MSVC_ATTR_IS_VENDOR_EXT_PUSH                                    \
-  [[msvc::no_unique_address]] RCC_SUPPRESS_MSVC_ATTR_IS_VENDOR_EXT_POP
-#else
-#define RCC_NO_UNIQUE_ADDRESS
-#endif
-
-/// RCC_EXTENSION - Support compilers where we have a keyword to suppress
-/// pedantic diagnostics.
-#ifdef __GNUC__
-#define RCC_EXTENSION __extension__
-#else
-#define RCC_EXTENSION
-#endif
-
-/// RCC_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.,
-/// RCC_ASSUME_ALIGNED and rcc_unreachable()) can detect whether
-/// RCC_BUILTIN_UNREACHABLE has a definition.
-#if __has_builtin(__builtin_unreachable) || defined(__GNUC__)
-#define RCC_BUILTIN_UNREACHABLE __builtin_unreachable ()
-#elif defined(_MSC_VER)
-#define RCC_BUILTIN_UNREACHABLE __assume (false)
-#endif
-
-/// RCC_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 RCC_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 RCC_BUILTIN_TRAP __debugbreak ()
-#else
-#define RCC_BUILTIN_TRAP *(volatile int *)0x11 = 0
-#endif
-
-/// RCC_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 RCC_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 RCC_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 RCC_BUILTIN_DEBUGTRAP
-#endif
-
-/// \macro RCC_ASSUME_ALIGNED
-/// Returns a pointer with an assumed alignment.
-#if __has_builtin(__builtin_assume_aligned) || defined(__GNUC__)
-#define RCC_ASSUME_ALIGNED(p, a) __builtin_assume_aligned (p, a)
-#elif defined(RCC_BUILTIN_UNREACHABLE)
-#define RCC_ASSUME_ALIGNED(p, a)                                               \
-  (((uintptr_t (p) % (a)) == 0) ? (p) : (RCC_BUILTIN_UNREACHABLE, (p)))
-#else
-#define RCC_ASSUME_ALIGNED(p, a) (p)
-#endif
-
-/// \macro RCC_PACKED
-/// Used to specify a packed structure.
-/// RCC_PACKED(
-///    struct A {
-///      int i;
-///      int j;
-///      int k;
-///      long long l;
-///   });
-///
-/// RCC_PACKED_START
-/// struct B {
-///   int i;
-///   int j;
-///   int k;
-///   long long l;
-/// };
-/// RCC_PACKED_END
-#ifdef _MSC_VER
-#define RCC_PACKED(d) __pragma (pack (push, 1)) d __pragma (pack (pop))
-#define RCC_PACKED_START __pragma (pack (push, 1))
-#define RCC_PACKED_END __pragma (pack (pop))
-#else
-#define RCC_PACKED(d) d __attribute__ ((packed))
-#define RCC_PACKED_START _Pragma ("pack(push, 1)")
-#define RCC_PACKED_END _Pragma ("pack(pop)")
-#endif
-
-/// \macro RCC_MEMORY_SANITIZER_BUILD
-/// Whether RCC itself is built with MemorySanitizer instrumentation.
-#if __has_feature(memory_sanitizer)
-#define RCC_MEMORY_SANITIZER_BUILD 1
-#include <sanitizer/msan_interface.h>
-#define RCC_NO_SANITIZE_MEMORY_ATTRIBUTE __attribute__ ((no_sanitize_memory))
-#else
-#define RCC_MEMORY_SANITIZER_BUILD 0
-#define __msan_allocated_memory(p, size)
-#define __msan_unpoison(p, size)
-#define RCC_NO_SANITIZE_MEMORY_ATTRIBUTE
-#endif
-
-/// \macro RCC_ADDRESS_SANITIZER_BUILD
-/// Whether RCC itself is built with AddressSanitizer instrumentation.
-#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
-#define RCC_ADDRESS_SANITIZER_BUILD 1
-#if __has_include(<sanitizer/asan_interface.h>)
-#include <sanitizer/asan_interface.h>
-#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 RCC_ADDRESS_SANITIZER_BUILD 0
-#define __asan_poison_memory_region(p, size)
-#define __asan_unpoison_memory_region(p, size)
-#endif
-
-/// \macro RCC_HWADDRESS_SANITIZER_BUILD
-/// Whether RCC itself is built with HWAddressSanitizer instrumentation.
-#if __has_feature(hwaddress_sanitizer)
-#define RCC_HWADDRESS_SANITIZER_BUILD 1
-#else
-#define RCC_HWADDRESS_SANITIZER_BUILD 0
-#endif
-
-/// \macro RCC_THREAD_SANITIZER_BUILD
-/// Whether RCC itself is built with ThreadSanitizer instrumentation.
-#if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__)
-#define RCC_THREAD_SANITIZER_BUILD 1
-#else
-#define RCC_THREAD_SANITIZER_BUILD 0
-#endif
-
-#if RCC_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 RCC_NO_SANITIZE
-/// Disable a particular sanitizer for a function.
-#if __has_attribute(no_sanitize)
-#define RCC_NO_SANITIZE(KIND) __attribute__ ((no_sanitize (KIND)))
-#else
-#define RCC_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(RCC_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(RCC_ENABLE_DUMP)
-#define RCC_DUMP_METHOD                                                        \
-  RCC_ATTRIBUTE_NOINLINE RCC_ATTRIBUTE_USED RCC_ATTRIBUTE_RETAIN
-#else
-#define RCC_DUMP_METHOD RCC_ATTRIBUTE_NOINLINE
-#endif
-
-/// \macro RCC_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 RCC_PRETTY_FUNCTION __FUNCSIG__
-#elif defined(__GNUC__) || defined(__clang__)
-#define RCC_PRETTY_FUNCTION __PRETTY_FUNCTION__
-#else
-#define RCC_PRETTY_FUNCTION __func__
-#endif
-
-/// \macro RCC_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 RCC_ENABLE_THREADS
-#if __has_feature(cxx_thread_local) || defined(_MSC_VER)
-#define RCC_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 RCC_THREAD_LOCAL __thread
-#endif
-#else // !RCC_ENABLE_THREADS
-// If threading is disabled entirely, this compiles to nothing and you get
-// a normal global variable.
-#define RCC_THREAD_LOCAL
-#endif
-
-/// \macro RCC_ENABLE_EXCEPTIONS
-/// Whether RCC is built with exception support.
-#if __has_feature(cxx_exceptions)
-#define RCC_ENABLE_EXCEPTIONS 1
-#elif defined(__GNUC__) && defined(__EXCEPTIONS)
-#define RCC_ENABLE_EXCEPTIONS 1
-#elif defined(_MSC_VER) && defined(_CPPUNWIND)
-#define RCC_ENABLE_EXCEPTIONS 1
-#endif
-
-/// \macro RCC_NO_PROFILE_INSTRUMENT_FUNCTION
-/// Disable the profile instrument for a function.
-#if __has_attribute(no_profile_instrument_function)
-#define RCC_NO_PROFILE_INSTRUMENT_FUNCTION                                     \
-  __attribute__ ((no_profile_instrument_function))
-#else
-#define RCC_NO_PROFILE_INSTRUMENT_FUNCTION
-#endif
-
-/// \macro RCC_PREFERRED_TYPE
-/// Adjust type of bit-field in debug info.
-#if __has_attribute(preferred_type)
-#define RCC_PREFERRED_TYPE(T) __attribute__ ((preferred_type (T)))
-#else
-#define RCC_PREFERRED_TYPE(T)
-#endif
-
-#if RCC_HAS_CPP_ATTRIBUTE(clang::ptrauth_vtable_pointer) &&                    \
-    (defined(__PTRAUTH__) || __has_feature(ptrauth_calls))
-#define RCC_MOVABLE_POLYMORPHIC_TYPE                                           \
-  [[clang::ptrauth_vtable_pointer (default_key, no_address_discrimination,     \
-                                   default_extra_discrimination)]]
-#else
-#define RCC_MOVABLE_POLYMORPHIC_TYPE
-#endif
-
-/// \macro RCC_VIRTUAL_ANCHOR_FUNCTION
-/// This macro is used to adhere to RCC'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 RCC_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 RCC_DECLARE_VIRTUAL_ANCHOR_FUNCTION()                            \
-      virtual void anchor()
-  #endif
-#else // defined(__clang__)
-  #define RCC_DECLARE_VIRTUAL_ANCHOR_FUNCTION()                              \
-    virtual void anchor()
-#endif
-// clang-format on
-
-/// \macro RCC_IS_X86
-/// Whether the target architecture is x86 / x86-64.
-#if defined(__x86_64__) || defined(__i386__)
-#define RCC_IS_X86 1
-#else
-#define RCC_IS_X86 0
-#endif
-
-/// \macro RCC_TARGET_SSE42
-/// Function attribute to compile a function with SSE4.2 enabled.
-#if defined(__has_attribute) && __has_attribute(target)
-#define RCC_TARGET_SSE42 __attribute__ ((target ("sse4.2")))
-#else
-#define RCC_TARGET_SSE42
-#endif
-
-#if __has_builtin(__builtin_cpu_supports) &&                                   \
-    (defined(__linux__) || defined(__APPLE__))
-#define RCC_CPU_SUPPORTS(feature) __builtin_cpu_supports (feature)
-#else
-#define RCC_CPU_SUPPORTS(feature) 0
-#endif
-
-/// \macro RCC_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 RCC_CPU_SUPPORTS_SSE42 1
-#else
-#define RCC_CPU_SUPPORTS_SSE42 RCC_CPU_SUPPORTS ("sse4.2")
-#endif
-
-#endif
diff --git a/libsupport/include/CoreLib/Error/ErrorOr.h b/libsupport/include/CoreLib/Error/ErrorOr.h
deleted file mode 100644
index 0e17822..0000000
--- a/libsupport/include/CoreLib/Error/ErrorOr.h
+++ /dev/null
@@ -1,378 +0,0 @@
-/*
- 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
- <http://www.gnu.org/licenses/>.
-*/
-
-//===- llvm/Support/ErrorOr.h - Error Smart Pointer -------------*- 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
-///
-/// Provides ErrorOr<T> smart pointer.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef RCC_SUPPORT_ERROROR_H
-#define RCC_SUPPORT_ERROROR_H
-
-#include <cassert>
-#include <functional> // for std::reference_wrapper
-#include <system_error>
-#include <type_traits>
-#include <utility>
-
-namespace rcc
-{
-
-/// Represents either an error or a value T.
-///
-/// ErrorOr<T> is a pointer-like class that represents the result of an
-/// operation. The result is either an error, or a value of type T. This is
-/// designed to emulate the usage of returning a pointer where nullptr indicates
-/// failure. However instead of just knowing that the operation failed, we also
-/// have an error_code that describes why it failed.
-///
-/// It is used like the following.
-/// \code
-///   ErrorOr<Buffer> getBuffer();
-///
-///   auto buffer = getBuffer();
-///   if (error_code ec = buffer.getError())
-///     return ec;
-///   buffer->write("adena");
-/// \endcode
-///
-///
-/// Implicit conversion to bool returns true if there is a usable value. The
-/// unary * and -> operators provide pointer like access to the value. Accessing
-/// the value when there is an error has undefined behavior.
-///
-/// When T is a reference type the behavior is slightly different. The reference
-/// is held in a std::reference_wrapper<std::remove_reference<T>::type>, and
-/// there is special handling to make operator -> work as if T was not a
-/// reference.
-///
-/// T cannot be a rvalue reference.
-template <class T> class ErrorOr
-{
-  template <class OtherT> friend class ErrorOr;
-
-  static constexpr bool isRef = std::is_reference_v<T>;
-
-  using wrap = std::reference_wrapper<std::remove_reference_t<T>>;
-
-public:
-  using storage_type = std::conditional_t<isRef, wrap, T>;
-
-private:
-  using reference = std::remove_reference_t<T> &;
-  using const_reference = const std::remove_reference_t<T> &;
-  using pointer = std::remove_reference_t<T> *;
-  using const_pointer = const std::remove_reference_t<T> *;
-
-public:
-  template <class E>
-  ErrorOr (E ErrorCode,
-           std::enable_if_t<std::is_error_code_enum<E>::value ||
-                                std::is_error_condition_enum<E>::value,
-                            void *> = nullptr)
-      : HasError (true)
-  {
-    new (getErrorStorage ()) std::error_code (make_error_code (ErrorCode));
-  }
-
-  ErrorOr (std::error_code EC) : HasError (true)
-  {
-    new (getErrorStorage ()) std::error_code (EC);
-  }
-
-  template <class OtherT>
-  ErrorOr (OtherT &&Val,
-           std::enable_if_t<std::is_convertible_v<OtherT, T>> * = nullptr)
-      : HasError (false)
-  {
-    new (getStorage ()) storage_type (std::forward<OtherT> (Val));
-  }
-
-  ErrorOr (const ErrorOr &Other)
-  {
-    copyConstruct (Other);
-  }
-
-  template <class OtherT>
-  ErrorOr (const ErrorOr<OtherT> &Other,
-           std::enable_if_t<std::is_convertible_v<OtherT, T>> * = nullptr)
-  {
-    copyConstruct (Other);
-  }
-
-  template <class OtherT>
-  explicit ErrorOr (
-      const ErrorOr<OtherT> &Other,
-      std::enable_if_t<!std::is_convertible_v<OtherT, const T &>> * = nullptr)
-  {
-    copyConstruct (Other);
-  }
-
-  ErrorOr (ErrorOr &&Other)
-  {
-    moveConstruct (std::move (Other));
-  }
-
-  template <class OtherT>
-  ErrorOr (ErrorOr<OtherT> &&Other,
-           std::enable_if_t<std::is_convertible_v<OtherT, T>> * = nullptr)
-  {
-    moveConstruct (std::move (Other));
-  }
-
-  // This might eventually need SFINAE but it's more complex than is_convertible
-  // & I'm too lazy to write it right now.
-  template <class OtherT>
-  explicit ErrorOr (
-      ErrorOr<OtherT> &&Other,
-      std::enable_if_t<!std::is_convertible_v<OtherT, T>> * = nullptr)
-  {
-    moveConstruct (std::move (Other));
-  }
-
-  ErrorOr &
-  operator= (const ErrorOr &Other)
-  {
-    copyAssign (Other);
-    return *this;
-  }
-
-  ErrorOr &
-  operator= (ErrorOr &&Other)
-  {
-    moveAssign (std::move (Other));
-    return *this;
-  }
-
-  ~ErrorOr ()
-  {
-    if (!HasError)
-    {
-      getStorage ()->~storage_type ();
-    }
-  }
-
-  /// Return false if there is an error.
-  explicit
-  operator bool () const
-  {
-    return !HasError;
-  }
-
-  reference
-  get ()
-  {
-    return *getStorage ();
-  }
-  const_reference
-  get () const
-  {
-    return const_cast<ErrorOr<T> *> (this)->get ();
-  }
-
-  std::error_code
-  getError () const
-  {
-    return HasError ? *getErrorStorage () : std::error_code ();
-  }
-
-  pointer
-  operator->()
-  {
-    return toPointer (getStorage ());
-  }
-
-  const_pointer
-  operator->() const
-  {
-    return toPointer (getStorage ());
-  }
-
-  reference
-  operator* ()
-  {
-    return *getStorage ();
-  }
-
-  const_reference
-  operator* () const
-  {
-    return *getStorage ();
-  }
-
-private:
-  template <class OtherT>
-  void
-  copyConstruct (const ErrorOr<OtherT> &Other)
-  {
-    if (!Other.HasError)
-    {
-      // Get the other value.
-      HasError = false;
-      new (getStorage ()) storage_type (*Other.getStorage ());
-    }
-    else
-    {
-      // Get other's error.
-      HasError = true;
-      new (getErrorStorage ()) std::error_code (Other.getError ());
-    }
-  }
-
-  template <class T1>
-  static bool
-  compareThisIfSameType (const T1 &a, const T1 &b)
-  {
-    return &a == &b;
-  }
-
-  template <class T1, class T2>
-  static bool
-  compareThisIfSameType (const T1 &, const T2 &)
-  {
-    return false;
-  }
-
-  template <class OtherT>
-  void
-  copyAssign (const ErrorOr<OtherT> &Other)
-  {
-    if (compareThisIfSameType (*this, Other))
-    {
-      return;
-    }
-
-    this->~ErrorOr ();
-    new (this) ErrorOr (Other);
-  }
-
-  template <class OtherT>
-  void
-  moveConstruct (ErrorOr<OtherT> &&Other)
-  {
-    if (!Other.HasError)
-    {
-      // Get the other value.
-      HasError = false;
-      new (getStorage ()) storage_type (std::move (*Other.getStorage ()));
-    }
-    else
-    {
-      // Get other's error.
-      HasError = true;
-      new (getErrorStorage ()) std::error_code (Other.getError ());
-    }
-  }
-
-  template <class OtherT>
-  void
-  moveAssign (ErrorOr<OtherT> &&Other)
-  {
-    if (compareThisIfSameType (*this, Other))
-    {
-      return;
-    }
-
-    this->~ErrorOr ();
-    new (this) ErrorOr (std::move (Other));
-  }
-
-  pointer
-  toPointer (pointer Val)
-  {
-    return Val;
-  }
-
-  const_pointer
-  toPointer (const_pointer Val) const
-  {
-    return Val;
-  }
-
-  pointer
-  toPointer (wrap *Val)
-  {
-    return &Val->get ();
-  }
-
-  const_pointer
-  toPointer (const wrap *Val) const
-  {
-    return &Val->get ();
-  }
-
-  storage_type *
-  getStorage ()
-  {
-    assert (!HasError && "Cannot get value when an error exists!");
-    return &TStorage;
-  }
-
-  const storage_type *
-  getStorage () const
-  {
-    assert (!HasError && "Cannot get value when an error exists!");
-    return &TStorage;
-  }
-
-  std::error_code *
-  getErrorStorage ()
-  {
-    assert (HasError && "Cannot get error when a value exists!");
-    return &ErrorStorage;
-  }
-
-  const std::error_code *
-  getErrorStorage () const
-  {
-    assert (HasError && "Cannot get error when a value exists!");
-    return &ErrorStorage;
-  }
-
-  union
-  {
-    storage_type TStorage;
-    std::error_code ErrorStorage;
-  };
-  bool HasError : 1;
-};
-
-template <class T, class E>
-std::enable_if_t<std::is_error_code_enum<E>::value ||
-                     std::is_error_condition_enum<E>::value,
-                 bool>
-operator== (const ErrorOr<T> &Err, E Code)
-{
-  return Err.getError () == Code;
-}
-
-} // end namespace rcc
-
-#endif // RCC_SUPPORT_ERROROR_H
diff --git a/rcc/CMakeLists.txt b/rcc/CMakeLists.txt
index 3825e8a..1fb86a0 100644
--- a/rcc/CMakeLists.txt
+++ b/rcc/CMakeLists.txt
@@ -53,20 +53,15 @@ configure_file(
   "${RCC_MAIN_INCLUDE_DIR}/rcc/Config/rcc-config.h.cmake"
   "${RCC_INCLUDE_DIR}/rcc/Config/rcc-config.h")
 
-add_library(RCCHeaders INTERFACE)
-target_compile_features(RCCHeaders INTERFACE cxx_std_23)
-target_include_directories(RCCHeaders INTERFACE
-  "$<BUILD_INTERFACE:${RCC_SOURCE_DIR}/include>"
-  "$<BUILD_INTERFACE:${RCC_BINARY_DIR}/include>"
-  "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-install(TARGETS RCCHeaders EXPORT RCCTargets)
 install(DIRECTORY include/rcc DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
   FILES_MATCHING PATTERN "*.h" PATTERN "*.inc" PATTERN "*.def")
-install(DIRECTORY "${RCC_BINARY_DIR}/include/rcc" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+install(DIRECTORY "${RCC_BINARY_DIR}/include/rcc/Config" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/rcc"
   FILES_MATCHING PATTERN "*.h" PATTERN "*.inc" PATTERN "*.def"
-  PATTERN "CMakeFiles" EXCLUDE PATTERN "config.h" EXCLUDE)
+  PATTERN "config.h" EXCLUDE)
 
-add_subdirectory("${RCC_SOURCE_DIR}/../libsupport" "${CMAKE_CURRENT_BINARY_DIR}/libsupport")
+set(RCC_LIBBASE_SOURCE_DIR "${RCC_SOURCE_DIR}/../libbase")
+set(RCC_LIBBASE_BINARY_DIR "${RCC_BINARY_DIR}/libbase")
+add_subdirectory("${RCC_LIBBASE_SOURCE_DIR}" "${RCC_LIBBASE_BINARY_DIR}")
 add_subdirectory(tools)
 foreach(rccProject IN LISTS RCC_ENABLE_PROJECTS)
   if(NOT rccProject STREQUAL "cfront")
diff --git a/rcc/cmake/modules/AddRCC.cmake b/rcc/cmake/modules/AddRCC.cmake
index 11bd92e..738df5f 100644
--- a/rcc/cmake/modules/AddRCC.cmake
+++ b/rcc/cmake/modules/AddRCC.cmake
@@ -162,7 +162,13 @@ endfunction()
 function(add_rcc_library name)
   cmake_parse_arguments(PARSE_ARGV 1 arg "DISABLE_PCH_REUSE;NO_INSTALL_RPATH" "" "LINK_LIBS;PRECOMPILE_HEADERS")
   add_library(${name} ${arg_UNPARSED_ARGUMENTS})
-  target_link_libraries(${name} PUBLIC RCCHeaders ${arg_LINK_LIBS})
+  target_link_libraries(${name} PUBLIC RCCCore ${arg_LINK_LIBS})
+  target_compile_features(${name} PUBLIC cxx_std_23)
+  target_compile_definitions(${name} PRIVATE RCC_EXPORTS)
+  target_include_directories(${name} PUBLIC
+    "$<BUILD_INTERFACE:${RCC_SOURCE_DIR}/include>"
+    "$<BUILD_INTERFACE:${RCC_BINARY_DIR}/include>"
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
   rcc_configure_target(${name})
   install(TARGETS ${name} EXPORT RCCTargets
     ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
@@ -173,7 +179,11 @@ endfunction()
 function(add_rcc_executable name)
   cmake_parse_arguments(PARSE_ARGV 1 arg "DISABLE_PCH_REUSE;NO_INSTALL_RPATH" "" "LINK_LIBS;PRECOMPILE_HEADERS")
   add_executable(${name} ${arg_UNPARSED_ARGUMENTS})
-  target_link_libraries(${name} PRIVATE RCCHeaders ${arg_LINK_LIBS})
+  target_link_libraries(${name} PRIVATE RCCCore ${arg_LINK_LIBS})
+  target_compile_features(${name} PRIVATE cxx_std_23)
+  target_include_directories(${name} PRIVATE
+    "${RCC_SOURCE_DIR}/include"
+    "${RCC_BINARY_DIR}/include")
   rcc_configure_target(${name})
 endfunction()
 
diff --git a/rcc/include/rcc/Config/config.h.cmake b/rcc/include/rcc/Config/config.h.cmake
index 32761c1..8830412 100644
--- a/rcc/include/rcc/Config/config.h.cmake
+++ b/rcc/include/rcc/Config/config.h.cmake
@@ -1,5 +1,5 @@
-#ifndef CONFIG_H
-#define CONFIG_H
+#ifndef RCC_PRIVATE_CONFIG_H
+#define RCC_PRIVATE_CONFIG_H
 
 // Include this header only under the rcc source tree.
 // This is a private header.
@@ -10,38 +10,6 @@
 /* Bug report URL. */
 #define BUG_REPORT_URL "${BUG_REPORT_URL}"
 
-/* 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 prefer
-   backslashes. */
-#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 we can register EH frames on this platform. */
 #cmakedefine HAVE_REGISTER_FRAME ${HAVE_REGISTER_FRAME}
 
@@ -60,177 +28,12 @@
 /* Define to 1 if you have the <ffi.h> header file. */
 #cmakedefine HAVE_FFI_H ${HAVE_FFI_H}
 
-/* 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 `pfm' library (-lpfm). */
 #cmakedefine HAVE_LIBPFM ${HAVE_LIBPFM}
 
 /* Define to 1 if the `perf_branch_entry' struct has field cycles. */
 #cmakedefine LIBPFM_HAS_FIELD_CYCLES ${LIBPFM_HAS_FIELD_CYCLES}
 
-/* 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 <mach/mach.h> 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 <malloc/malloc.h> 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 <pthread.h> 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 <sys/mman.h> header file. */
-#cmakedefine HAVE_SYS_MMAN_H ${HAVE_SYS_MMAN_H}
-
-/* Define to 1 if you have the <sys/ioctl.h> 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 <unistd.h> 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
-
 /* Linker version detected at compile time. */
 #cmakedefine HOST_LINK_VERSION "${HOST_LINK_VERSION}"
 
@@ -267,25 +70,13 @@
 /* Define to the vendor of this package. */
 #cmakedefine PACKAGE_VENDOR "${PACKAGE_VENDOR}"
 
-/* Define to a function implementing stricmp */
-#cmakedefine stricmp ${stricmp}
-
-/* Define to a function implementing strdup */
-#cmakedefine strdup ${strdup}
-
 /* Whether GlobalISel rule coverage is being collected */
 #cmakedefine01 RCC_GISEL_COV_ENABLED
 
 /* Define to the default GlobalISel coverage file prefix */
 #cmakedefine RCC_GISEL_COV_PREFIX "${RCC_GISEL_COV_PREFIX}"
 
-/* Whether Timers signpost passes in Xcode Instruments */
-#cmakedefine01 RCC_SUPPORT_XCODE_SIGNPOSTS
-
-#cmakedefine HAVE_PROC_PID_RUSAGE 1
-
+/* Have host's builtin thread pointer. */
 #cmakedefine HAVE_BUILTIN_THREAD_POINTER ${HAVE_BUILTIN_THREAD_POINTER}
 
-#cmakedefine HAVE_GETAUXVAL ${HAVE_GETAUXVAL}
-
 #endif
diff --git a/rcc/include/rcc/Config/rcc-config.h.cmake b/rcc/include/rcc/Config/rcc-config.h.cmake
index 9c0ba18..fb76d22 100644
--- a/rcc/include/rcc/Config/rcc-config.h.cmake
+++ b/rcc/include/rcc/Config/rcc-config.h.cmake
@@ -14,19 +14,10 @@
 #ifndef RCC_CONFIG_H
 #define RCC_CONFIG_H
 
-/* Define if RCC_ENABLE_DUMP is enabled */
-#cmakedefine RCC_ENABLE_DUMP
-
 /* Target triple RCC will generate code for by default */
 /* Doesn't use `cmakedefine` because it is allowed to be empty. */
 #define RCC_DEFAULT_TARGET_TRIPLE "${RCC_DEFAULT_TARGET_TRIPLE}"
 
-/* Define if threads enabled */
-#cmakedefine01 RCC_ENABLE_THREADS
-
-/* Has gcc/MSVC atomic intrinsics */
-#cmakedefine01 RCC_HAS_ATOMICS
-
 /* Host triple RCC will be executed on */
 #cmakedefine RCC_HOST_TRIPLE "${RCC_HOST_TRIPLE}"
 
@@ -54,9 +45,6 @@
 /* RCC name for the native target MCA init function, if available */
 #cmakedefine RCC_NATIVE_TARGETMCA RCCInitialize${RCC_NATIVE_ARCH}TargetMCA
 
-/* Define if this is Unixish platform */
-#cmakedefine RCC_ON_UNIX ${RCC_ON_UNIX}
-
 /* Define if we have the Intel JIT API runtime support library */
 #cmakedefine01 RCC_USE_INTEL_JITEVENTS
 
@@ -78,69 +66,24 @@
 /* RCC version string */
 #define RCC_VERSION_STRING "${PACKAGE_VERSION}"
 
-/* Whether RCC records statistics for use with GetStatistics(),
- * PrintStatistics() or PrintStatisticsJSON()
- */
-#cmakedefine01 RCC_FORCE_ENABLE_STATS
-
-/* Define if we have z3 and want to build it */
-#cmakedefine RCC_WITH_Z3 ${RCC_WITH_Z3}
-
-/* Define if we have curl and want to use it */
-#cmakedefine RCC_ENABLE_CURL ${RCC_ENABLE_CURL}
-
-/* Define if we have cpp-httplib and want to use it */
-#cmakedefine RCC_ENABLE_HTTPLIB ${RCC_ENABLE_HTTPLIB}
-
-/* Define if zlib compression is available */
-#cmakedefine01 RCC_ENABLE_ZLIB
-
-/* Define if zstd compression is available */
-#cmakedefine01 RCC_ENABLE_ZSTD
-
-/* Define if xz (lzma) decompression is available */
-#cmakedefine01 RCC_ENABLE_LZMA
-
 /* Define if RCC is using tflite */
 #cmakedefine RCC_HAVE_TFLITE
 
 /* Define if we want to check profile consistency in lit tests */
 #cmakedefine RCC_ENABLE_PROFCHECK
 
-/* Define to 1 if you have the <sysexits.h> header file. */
-#cmakedefine HAVE_SYSEXITS_H ${HAVE_SYSEXITS_H}
-
 /* Define if building libRCC shared library */
 #cmakedefine RCC_BUILD_RCC_DYLIB
 
-/* Define if building RCC with BUILD_SHARED_LIBS */
-#cmakedefine RCC_BUILD_SHARED_LIBS
-
-/* Define if exporting RCC public interface for shared library */
-#cmakedefine RCC_ENABLE_RCC_EXPORT_ANNOTATIONS
-
 /* Define if exporting RCC-C public interface for shared library */
 #cmakedefine RCC_ENABLE_RCC_C_EXPORT_ANNOTATIONS
 
-/* Define if building RCC with RCC_FORCE_USE_OLD_TOOLCHAIN_LIBS */
-#cmakedefine RCC_FORCE_USE_OLD_TOOLCHAIN ${RCC_FORCE_USE_OLD_TOOLCHAIN}
-
-/* Define if rcc_unreachable should be optimized with undefined behavior
- * in non assert builds */
-#cmakedefine01 RCC_UNREACHABLE_OPTIMIZE
-
-/* Define if building RCC with RCC_ENABLE_IO_SANDBOX */
-#cmakedefine01 RCC_ENABLE_IO_SANDBOX
-
 /* Define to 1 if you have the DIA SDK installed, and to 0 if you don't. */
 #cmakedefine01 RCC_ENABLE_DIA_SDK
 
 /* Define if plugins enabled */
 #cmakedefine RCC_ENABLE_PLUGINS
 
-/* Define if logf128 is available */
-#cmakedefine RCC_HAS_LOGF128
-
 /* Define if building RCC with RCC_ENABLE_TELEMETRY */
 #cmakedefine01 RCC_ENABLE_TELEMETRY
 
@@ -152,7 +95,4 @@
    coverage bugs, and to 0 otherwise. */
 #cmakedefine01 RCC_ENABLE_DEBUGLOC_TRACKING_ORIGIN
 
-/* Define to 1 to enable RCC OnDisk Content Addressable Storage */
-#cmakedefine01 RCC_ENABLE_ONDISK_CAS
-
 #endif
diff --git a/rcc/include/rcc/Support/Compiler.h b/rcc/include/rcc/Support/Compiler.h
new file mode 100644
index 0000000..1076827
--- /dev/null
+++ b/rcc/include/rcc/Support/Compiler.h
@@ -0,0 +1,106 @@
+/*
+ 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
+ <http://www.gnu.org/licenses/>.
+*/
+
+//===-- rcc/Support/Compiler.h - RCC ABI 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef RCC_SUPPORT_COMPILER_H
+#define RCC_SUPPORT_COMPILER_H
+
+#include "core/compiler/Compiler.h"
+#include "rcc/Config/rcc-config.h"
+
+/// RCC_EXTERNAL_VISIBILITY - classes, functions, and variables marked with
+/// this attribute will be made public and visible outside of a shared library.
+#if defined(RCC_BUILD_RCC_DYLIB) || defined(RCC_BUILD_SHARED_LIBS)
+#define RCC_EXTERNAL_VISIBILITY LIBBASE_ATTRIBUTE_VISIBILITY_DEFAULT
+#else
+#define RCC_EXTERNAL_VISIBILITY
+#endif
+
+/// RCC_LIBRARY_VISIBILITY - Mark symbols private to the RCC shared library.
+#if (!(defined(_WIN32) || defined(__CYGWIN__)) ||                            \
+     ((defined(__MINGW32__) || defined(__CYGWIN__)) && defined(__clang__)))
+#define RCC_LIBRARY_VISIBILITY LIBBASE_ATTRIBUTE_VISIBILITY_HIDDEN
+#if defined(__clang__) && __clang_major__ < 15
+#define RCC_LIBRARY_VISIBILITY_NAMESPACE [[gnu::visibility("hidden")]]
+#else
+#define RCC_LIBRARY_VISIBILITY_NAMESPACE LIBBASE_ATTRIBUTE_VISIBILITY_HIDDEN
+#endif
+#define RCC_ALWAYS_EXPORT LIBBASE_ATTRIBUTE_VISIBILITY_DEFAULT
+#elif defined(_WIN32)
+#define RCC_ALWAYS_EXPORT __declspec(dllexport)
+#define RCC_LIBRARY_VISIBILITY
+#define RCC_LIBRARY_VISIBILITY_NAMESPACE
+#else
+#define RCC_LIBRARY_VISIBILITY
+#define RCC_ALWAYS_EXPORT
+#define RCC_LIBRARY_VISIBILITY_NAMESPACE
+#endif
+
+/// RCC_ABI is the main export macro for the RCC public interface.
+/// RCC_ABI_EXPORT always exports a symbol from the defining library.
+/// RCC_EXPORT_TEMPLATE marks explicit template instantiations.
+/// RCC_TEMPLATE_ABI marks extern template declarations.
+#ifndef RCC_ABI_GENERATING_ANNOTATIONS
+#define RCC_ABI_NOT_EXPORTED
+#if defined(RCC_ENABLE_RCC_EXPORT_ANNOTATIONS) && !defined(RCC_BUILD_STATIC)
+#if defined(_WIN32) && !defined(__MINGW32__)
+#if defined(RCC_EXPORTS)
+#define RCC_ABI __declspec(dllexport)
+#define RCC_TEMPLATE_ABI
+#define RCC_EXPORT_TEMPLATE __declspec(dllexport)
+#else
+#define RCC_ABI __declspec(dllimport)
+#define RCC_TEMPLATE_ABI __declspec(dllimport)
+#define RCC_EXPORT_TEMPLATE
+#endif
+#define RCC_ABI_EXPORT __declspec(dllexport)
+#elif __has_attribute(visibility)
+#if defined(__ELF__) || defined(__MINGW32__) || defined(_AIX) ||               \
+    defined(__MVS__) || defined(__CYGWIN__)
+#define RCC_ABI LIBBASE_ATTRIBUTE_VISIBILITY_DEFAULT
+#define RCC_TEMPLATE_ABI RCC_ABI
+#define RCC_EXPORT_TEMPLATE
+#define RCC_ABI_EXPORT RCC_ABI
+#elif defined(__MACH__) || defined(__wasm__) || defined(__EMSCRIPTEN__)
+#define RCC_ABI LIBBASE_ATTRIBUTE_VISIBILITY_DEFAULT
+#define RCC_TEMPLATE_ABI
+#define RCC_EXPORT_TEMPLATE
+#define RCC_ABI_EXPORT RCC_ABI
+#endif
+#endif
+#endif
+#if !defined(RCC_ABI)
+#define RCC_ABI
+#define RCC_TEMPLATE_ABI
+#define RCC_EXPORT_TEMPLATE
+#define RCC_ABI_EXPORT
+#endif
+#define RCC_ABI_FOR_TEST RCC_ABI
+#endif
+
+#endif