[libbase] Format C++ CodeHEADmaster

Signed-off-by: Richard Qin <richard.qin.x@gmail.com>

6 files changed, 534 insertions, 315 deletions

diff --git a/libbase/include/core/adt/SmallVector.h b/libbase/include/core/adt/SmallVector.h
index f8de25e..37d974a 100644
--- a/libbase/include/core/adt/SmallVector.h
+++ b/libbase/include/core/adt/SmallVector.h
@@ -1681,7 +1681,7 @@ template <typename T> struct CalculateSmallVectorDefaultInlinedElements
 template <typename T,
           unsigned N = CalculateSmallVectorDefaultInlinedElements<T>::value>
 class LIBBASE_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
-                                  SmallVectorStorage<T, N>
+                                      SmallVectorStorage<T, N>
 {
 public:
   SmallVector () : SmallVectorImpl<T> (N)
diff --git a/libbase/include/core/compiler/Compiler.h b/libbase/include/core/compiler/Compiler.h
index b21d6a1..e0bc822 100644
--- a/libbase/include/core/compiler/Compiler.h
+++ b/libbase/include/core/compiler/Compiler.h
@@ -19,7 +19,8 @@
  <http://www.gnu.org/licenses/>.
 */
 
-//===-- core/compiler/Compiler.h - Compiler abstraction support --*- C++ -*-===//
+//===-- 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.
@@ -45,32 +46,32 @@
 #endif
 
 #ifndef __has_feature
-# define __has_feature(x) 0
+#define __has_feature(x) 0
 #endif
 
 #ifndef __has_extension
-# define __has_extension(x) 0
+#define __has_extension(x) 0
 #endif
 
 #ifndef __has_attribute
-# define __has_attribute(x) 0
+#define __has_attribute(x) 0
 #endif
 
 #ifndef __has_builtin
-# define __has_builtin(x) 0
+#define __has_builtin(x) 0
 #endif
 
 #ifndef __has_warning
-# define __has_warning(x) 0
+#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)
+#define LIBBASE_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute (x)
 #else
-# define LIBBASE_HAS_CPP_ATTRIBUTE(x) 0
+#define LIBBASE_HAS_CPP_ATTRIBUTE(x) 0
 #endif
 #endif
 
@@ -78,16 +79,16 @@
 /// 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
+#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
@@ -135,13 +136,15 @@
 /// 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__) &&            \
+#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")]]
+#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")))
+#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
@@ -159,13 +162,13 @@
 // 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")]]
+#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_ALWAYS_EXPORT __declspec (dllexport)
 #define LIBBASE_LIBRARY_VISIBILITY
 #define LIBBASE_LIBRARY_VISIBILITY_NAMESPACE
 #else
@@ -174,9 +177,9 @@
 #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 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
@@ -184,20 +187,22 @@
 /// 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_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_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.
+/// 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
@@ -208,24 +213,24 @@
 #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_ABI __declspec (dllexport)
 #define LIBBASE_TEMPLATE_ABI
-#define LIBBASE_EXPORT_TEMPLATE __declspec(dllexport)
+#define LIBBASE_EXPORT_TEMPLATE __declspec (dllexport)
 #else
-#define LIBBASE_ABI __declspec(dllimport)
-#define LIBBASE_TEMPLATE_ABI __declspec(dllimport)
+#define LIBBASE_ABI __declspec (dllimport)
+#define LIBBASE_TEMPLATE_ABI __declspec (dllimport)
 #define LIBBASE_EXPORT_TEMPLATE
 #endif
-#define LIBBASE_ABI_EXPORT __declspec(dllexport)
+#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_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_ABI __attribute__ ((visibility ("default")))
 #define LIBBASE_TEMPLATE_ABI
 #define LIBBASE_EXPORT_TEMPLATE
 #define LIBBASE_ABI_EXPORT LIBBASE_ABI
@@ -242,25 +247,26 @@
 #endif
 
 #if defined(__GNUC__)
-#define LIBBASE_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
+#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))
+#define LIBBASE_ATTRIBUTE_UNINITIALIZED __attribute__ ((uninitialized))
 #else
 #define LIBBASE_ATTRIBUTE_UNINITIALIZED
 #endif
 
 #if __has_attribute(used)
-#define LIBBASE_ATTRIBUTE_USED __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))
+#define LIBBASE_ATTRIBUTE_WARN_UNUSED __attribute__ ((warn_unused))
 #else
 #define LIBBASE_ATTRIBUTE_WARN_UNUSED
 #endif
@@ -270,7 +276,7 @@
 // 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__))
+#define LIBBASE_ATTRIBUTE_RETAIN __attribute__ ((__retain__))
 #else
 #define LIBBASE_ATTRIBUTE_RETAIN
 #endif
@@ -278,10 +284,10 @@
 // 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)))
+#define LIBBASE_DEPRECATED_WITH_FIXIT(MSG, FIX)                                \
+  __attribute__ ((deprecated (MSG, FIX)))
 #else
-#define LIBBASE_DEPRECATED_WITH_FIXIT(MSG, FIX) [[deprecated(MSG)]]
+#define LIBBASE_DEPRECATED_WITH_FIXIT(MSG, FIX) [[deprecated (MSG)]]
 #endif
 
 // clang-format off
@@ -325,7 +331,7 @@
 //   (void)unused_var_name;
 // Prefer cast-to-void wherever it is sufficient.
 #if __has_attribute(unused)
-#define LIBBASE_ATTRIBUTE_UNUSED __attribute__((__unused__))
+#define LIBBASE_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
 #else
 #define LIBBASE_ATTRIBUTE_UNUSED
 #endif
@@ -338,7 +344,7 @@
 #define LIBBASE_HAS_ATTRIBUTE_WEAK 0
 #endif
 #if LIBBASE_HAS_ATTRIBUTE_WEAK
-#define LIBBASE_ATTRIBUTE_WEAK __attribute__((__weak__))
+#define LIBBASE_ATTRIBUTE_WEAK __attribute__ ((__weak__))
 #else
 #define LIBBASE_ATTRIBUTE_WEAK
 #endif
@@ -347,46 +353,46 @@
 // __has_attribute(const), so assume it is supported.
 #if defined(__clang__) || defined(__GNUC__)
 // aka 'CONST' but following LLVM Conventions.
-#define LIBBASE_READNONE __attribute__((__const__))
+#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__))
+#define LIBBASE_READONLY __attribute__ ((__pure__))
 #else
 #define LIBBASE_READONLY
 #endif
 
 #if __has_attribute(minsize)
-#define LIBBASE_ATTRIBUTE_MINSIZE __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)
+#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".
+/// 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))
+#define LIBBASE_ATTRIBUTE_NOINLINE __attribute__ ((noinline))
 #elif defined(_MSC_VER)
-#define LIBBASE_ATTRIBUTE_NOINLINE __declspec(noinline)
+#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.
+/// 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))
+#define LIBBASE_ATTRIBUTE_ALWAYS_INLINE inline __attribute__ ((always_inline))
 #elif defined(_MSC_VER)
 #define LIBBASE_ATTRIBUTE_ALWAYS_INLINE __forceinline
 #else
@@ -397,7 +403,8 @@
 /// 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
+#define LIBBASE_ATTRIBUTE_ALWAYS_INLINE_UNLESS_DEBUG                           \
+  LIBBASE_ATTRIBUTE_ALWAYS_INLINE
 #else
 #define LIBBASE_ATTRIBUTE_ALWAYS_INLINE_UNLESS_DEBUG inline
 #endif
@@ -406,13 +413,13 @@
 /// so, mark a method "no debug" because debug info makes the debugger
 /// experience worse.
 #if __has_attribute(nodebug)
-#define LIBBASE_ATTRIBUTE_NODEBUG __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))
+#define LIBBASE_ATTRIBUTE_RETURNS_NONNULL __attribute__ ((returns_nonnull))
 #elif defined(_MSC_VER)
 #define LIBBASE_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_
 #else
@@ -427,33 +434,34 @@
 #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.
+/// \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__))
+#define LIBBASE_ATTRIBUTE_RETURNS_NOALIAS __attribute__ ((__malloc__))
 #elif defined(_MSC_VER)
-#define LIBBASE_ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
+#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)
+#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))
+#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.
+/// 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                                   \
+#define LIBBASE_REQUIRE_CONSTANT_INITIALIZATION                                \
   [[clang::require_constant_initialization]]
 #else
 #define LIBBASE_REQUIRE_CONSTANT_INITIALIZATION
@@ -495,16 +503,16 @@
 #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))
+#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                                   \
+#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
@@ -526,51 +534,51 @@
 /// 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()
+#define LIBBASE_BUILTIN_UNREACHABLE __builtin_unreachable ()
 #elif defined(_MSC_VER)
-# define LIBBASE_BUILTIN_UNREACHABLE __assume(false)
+#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.
+/// 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()
+#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()
+#define LIBBASE_BUILTIN_TRAP __debugbreak ()
 #else
-# define LIBBASE_BUILTIN_TRAP *(volatile int*)0x11 = 0
+#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()
+#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()
+#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
+#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)
+#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)))
+#define LIBBASE_ASSUME_ALIGNED(p, a)                                           \
+  (((uintptr_t (p) % (a)) == 0) ? (p) : (LIBBASE_BUILTIN_UNREACHABLE, (p)))
 #else
-# define LIBBASE_ASSUME_ALIGNED(p, a) (p)
+#define LIBBASE_ASSUME_ALIGNED(p, a) (p)
 #endif
 
 /// \macro LIBBASE_PACKED
@@ -592,50 +600,54 @@
 /// };
 /// 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))
+#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)")
+#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))
+#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
+#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
+#define LIBBASE_ADDRESS_SANITIZER_BUILD 1
 #if __has_include(<sanitizer/asan_interface.h>)
-# 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" {
+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);
+  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)
+#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
@@ -649,9 +661,9 @@ void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
 /// \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
+#define LIBBASE_THREAD_SANITIZER_BUILD 1
 #else
-# define LIBBASE_THREAD_SANITIZER_BUILD 0
+#define LIBBASE_THREAD_SANITIZER_BUILD 0
 #endif
 
 #if LIBBASE_THREAD_SANITIZER_BUILD
@@ -659,12 +671,17 @@ void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
 // 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);
+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
@@ -672,27 +689,27 @@ void AnnotateIgnoreWritesEnd(const char *file, int line);
 // 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)
+#define TsanHappensBefore(cv) AnnotateHappensBefore (__FILE__, __LINE__, cv)
 
 // This marker defines the destination of a happens-before arc.
-# define TsanHappensAfter(cv) AnnotateHappensAfter(__FILE__, __LINE__, cv)
+#define TsanHappensAfter(cv) AnnotateHappensAfter (__FILE__, __LINE__, cv)
 
 // Ignore any races on writes between here and the next TsanIgnoreWritesEnd.
-# define TsanIgnoreWritesBegin() AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
+#define TsanIgnoreWritesBegin() AnnotateIgnoreWritesBegin (__FILE__, __LINE__)
 
 // Resume checking for racy writes.
-# define TsanIgnoreWritesEnd() AnnotateIgnoreWritesEnd(__FILE__, __LINE__)
+#define TsanIgnoreWritesEnd() AnnotateIgnoreWritesEnd (__FILE__, __LINE__)
 #else
-# define TsanHappensBefore(cv)
-# define TsanHappensAfter(cv)
-# define TsanIgnoreWritesBegin()
-# define TsanIgnoreWritesEnd()
+#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)))
+#define LIBBASE_NO_SANITIZE(KIND) __attribute__ ((no_sanitize (KIND)))
 #else
 #define LIBBASE_NO_SANITIZE(KIND)
 #endif
@@ -704,7 +721,7 @@ void AnnotateIgnoreWritesEnd(const char *file, int line);
 /// 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                                                       \
+#define LIBBASE_DUMP_METHOD                                                    \
   LIBBASE_ATTRIBUTE_NOINLINE LIBBASE_ATTRIBUTE_USED LIBBASE_ATTRIBUTE_RETAIN
 #else
 #define LIBBASE_DUMP_METHOD LIBBASE_ATTRIBUTE_NOINLINE
@@ -761,8 +778,8 @@ void AnnotateIgnoreWritesEnd(const char *file, int line);
 /// \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))
+#define LIBBASE_NO_PROFILE_INSTRUMENT_FUNCTION                                 \
+  __attribute__ ((no_profile_instrument_function))
 #else
 #define LIBBASE_NO_PROFILE_INSTRUMENT_FUNCTION
 #endif
@@ -770,16 +787,16 @@ void AnnotateIgnoreWritesEnd(const char *file, int line);
 /// \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)))
+#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) &&                   \
+#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)]]
+#define LIBBASE_MOVABLE_POLYMORPHIC_TYPE                                       \
+  [[clang::ptrauth_vtable_pointer (default_key, no_address_discrimination,     \
+                                   default_extra_discrimination)]]
 #else
 #define LIBBASE_MOVABLE_POLYMORPHIC_TYPE
 #endif
@@ -819,14 +836,14 @@ void AnnotateIgnoreWritesEnd(const char *file, int line);
 /// \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")))
+#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)
+#define LIBBASE_CPU_SUPPORTS(feature) __builtin_cpu_supports (feature)
 #else
 #define LIBBASE_CPU_SUPPORTS(feature) 0
 #endif
@@ -837,7 +854,7 @@ void AnnotateIgnoreWritesEnd(const char *file, int line);
 #if defined(__SSE4_2__)
 #define LIBBASE_CPU_SUPPORTS_SSE42 1
 #else
-#define LIBBASE_CPU_SUPPORTS_SSE42 LIBBASE_CPU_SUPPORTS("sse4.2")
+#define LIBBASE_CPU_SUPPORTS_SSE42 LIBBASE_CPU_SUPPORTS ("sse4.2")
 #endif
 
 #endif
diff --git a/libbase/include/core/error/ErrorHandling.h b/libbase/include/core/error/ErrorHandling.h
index 485d2d1..67461c3 100644
--- a/libbase/include/core/error/ErrorHandling.h
+++ b/libbase/include/core/error/ErrorHandling.h
@@ -209,8 +209,8 @@ libbase_unreachable_internal (const char *msg = nullptr,
 #define libbase_unreachable(msg)                                               \
   do                                                                           \
   {                                                                            \
-    LIBBASE_BUILTIN_TRAP;                                                          \
-    LIBBASE_BUILTIN_UNREACHABLE;                                                   \
+    LIBBASE_BUILTIN_TRAP;                                                      \
+    LIBBASE_BUILTIN_UNREACHABLE;                                               \
   } while (false)
 #endif
 
diff --git a/libbase/include/core/memory/Alignment.h b/libbase/include/core/memory/Alignment.h
index 4078cd6..1391e06 100644
--- a/libbase/include/core/memory/Alignment.h
+++ b/libbase/include/core/memory/Alignment.h
@@ -49,50 +49,65 @@
 #include <string>
 #endif // NDEBUG
 
-namespace libbase {
+namespace libbase
+{
 
 #define ALIGN_CHECK_ISPOSITIVE(decl)                                           \
-  assert(decl > 0 && (#decl " should be defined"))
+  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 {
+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);
+  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;
+  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(libbase::isPowerOf2_64(Value) && "Alignment is not a power of 2");
-    ShiftValue = Log2_64(Value);
-    assert(ShiftValue < 64 && "Broken invariant");
+  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 (libbase::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");
+  constexpr static Align
+  fromLog2 (unsigned Log2Value)
+  {
+    assert (Log2Value < 64 && "Alignment exponent is too large");
     Align Out;
     Out.ShiftValue = Log2Value;
     return Out;
@@ -100,75 +115,109 @@ public:
 
   /// 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; }
+  constexpr uint64_t
+  value () const
+  {
+    return uint64_t (1) << ShiftValue;
+  }
 
   // Returns the previous alignment.
-  Align previous() const {
-    assert(ShiftValue != 0 && "Undefined operation");
+  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>());
+  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>>();
+  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();
+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> {
+struct MaybeAlign : std::optional<Align>
+{
 private:
   using UP = std::optional<Align>;
 
 public:
   /// Default is undefined.
-  MaybeAlign() = default;
+  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 || libbase::isPowerOf2_64(Value)) &&
-           "Alignment is neither 0 nor a power of 2");
+  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 || libbase::isPowerOf2_64 (Value)) &&
+            "Alignment is neither 0 nor a power of 2");
     if (Value)
-      emplace(Value);
+    {
+      emplace (Value);
+    }
   }
 
   /// For convenience, returns a valid alignment or 1 if undefined.
-  Align valueOrOne() const { return value_or(Align()); }
+  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;
+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));
+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();
+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
@@ -192,49 +241,71 @@ constexpr inline uint64_t alignTo(uint64_t Size, Align A) {
 ///   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();
+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;
+  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);
+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;
+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);
+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; }
+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));
+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; }
+inline unsigned
+encode (MaybeAlign A)
+{
+  return A ? A->ShiftValue + 1 : 0;
+}
 
 /// Dual operation of the encode function above.
-inline MaybeAlign decodeMaybeAlign(unsigned Value) {
+inline MaybeAlign
+decodeMaybeAlign (unsigned Value)
+{
   if (Value == 0)
-    return MaybeAlign();
+  {
+    return MaybeAlign ();
+  }
   Align Out;
   Out.ShiftValue = Value - 1;
   return Out;
@@ -242,95 +313,179 @@ inline MaybeAlign decodeMaybeAlign(unsigned Value) {
 
 /// Returns a representation of the alignment, the encoded value is positive by
 /// definition.
-inline unsigned encode(Align A) { return encode(MaybeAlign(A)); }
+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;
 }
-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) {
+inline bool
+operator== (Align Lhs, Align Rhs)
+{
   return Lhs.ShiftValue == Rhs.ShiftValue;
 }
-inline bool operator!=(Align Lhs, Align Rhs) {
+inline bool
+operator!= (Align Lhs, Align Rhs)
+{
   return Lhs.ShiftValue != Rhs.ShiftValue;
 }
-inline bool operator<=(Align Lhs, Align Rhs) {
+inline bool
+operator<= (Align Lhs, Align Rhs)
+{
   return Lhs.ShiftValue <= Rhs.ShiftValue;
 }
-inline bool operator>=(Align Lhs, Align Rhs) {
+inline bool
+operator>= (Align Lhs, Align Rhs)
+{
   return Lhs.ShiftValue >= Rhs.ShiftValue;
 }
-inline bool operator<(Align Lhs, Align Rhs) {
+inline bool
+operator< (Align Lhs, Align Rhs)
+{
   return Lhs.ShiftValue < Rhs.ShiftValue;
 }
-inline bool operator>(Align Lhs, Align Rhs) {
+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;
+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); }
+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) {
+inline bool
+operator== (MaybeAlign Lhs, MaybeAlign Rhs)
+{
   return (Lhs && Rhs && (*Lhs == *Rhs)) || (!Lhs && !Rhs);
 }
-inline bool operator!=(MaybeAlign Lhs, MaybeAlign Rhs) { return !(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); }
+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());
+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) {
+inline std::string
+DebugStr (const MaybeAlign &MA)
+{
   if (MA)
-    return std::to_string(MA->value());
+  {
+    return std::to_string (MA->value ());
+  }
   return "None";
 }
 #endif // NDEBUG
diff --git a/libbase/include/core/memory/AllocatorBase.h b/libbase/include/core/memory/AllocatorBase.h
index 0f7f9f1..af6f5ca 100644
--- a/libbase/include/core/memory/AllocatorBase.h
+++ b/libbase/include/core/memory/AllocatorBase.h
@@ -41,7 +41,7 @@
 #define LIBBASE_SUPPORT_ALLOCATORBASE_H
 
 #ifdef _MSC_VER
-#define LIBBASE_ALLOCATORHOLDER_EMPTYBASE __declspec(empty_bases)
+#define LIBBASE_ALLOCATORHOLDER_EMPTYBASE __declspec (empty_bases)
 #else
 #define LIBBASE_ALLOCATORHOLDER_EMPTYBASE
 #endif // _MSC_VER
@@ -51,7 +51,8 @@
 #include <type_traits>
 #include <utility>
 
-namespace libbase {
+namespace libbase
+{
 
 /// CRTP base class providing obvious overloads for the core \c
 /// Allocate() methods of LLVM-style allocators.
@@ -59,92 +60,137 @@ namespace libbase {
 /// 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 {
+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) {
+  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!");
+    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);
+    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) {
+  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)>(
+    static_assert (
+        static_cast<void (AllocatorBase::*) (const void *, size_t, size_t)> (
             &AllocatorBase::Deallocate) !=
-            static_cast<void (DerivedT::*)(const void *, size_t, size_t)>(
+            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);
+    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)));
+  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));
+  Deallocate (T *Ptr, size_t Num = 1)
+  {
+    Deallocate (static_cast<const void *> (Ptr), Num * sizeof (T), alignof (T));
   }
 };
 
-class MallocAllocator : public AllocatorBase<MallocAllocator> {
+class MallocAllocator : public AllocatorBase<MallocAllocator>
+{
 public:
-  void Reset() {}
+  void
+  Reset ()
+  {
+  }
 
-  LIBBASE_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, size_t Alignment) {
-    return allocate_buffer(Size, Alignment);
+  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);
+  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 {}
+  void
+  PrintStats () const
+  {
+  }
 };
 
-namespace detail {
+namespace detail
+{
 
-template <typename Alloc> class AllocatorHolder : Alloc {
+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; }
+  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 &> {
+template <typename Alloc> class AllocatorHolder<Alloc &>
+{
   Alloc &A;
 
 public:
-  AllocatorHolder(Alloc &A) : A(A) {}
-  Alloc &getAllocator() { return A; }
-  const Alloc &getAllocator() const { return A; }
+  AllocatorHolder (Alloc &A) : A (A)
+  {
+  }
+  Alloc &
+  getAllocator ()
+  {
+    return A;
+  }
+  const Alloc &
+  getAllocator () const
+  {
+    return A;
+  }
 };
 
 } // namespace detail
diff --git a/libbase/include/core/memory/MemAlloc.h b/libbase/include/core/memory/MemAlloc.h
index 7b00ceb..be7828e 100644
--- a/libbase/include/core/memory/MemAlloc.h
+++ b/libbase/include/core/memory/MemAlloc.h
@@ -107,8 +107,9 @@ 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.
-LIBBASE_ABI LIBBASE_ATTRIBUTE_RETURNS_NONNULL LIBBASE_ATTRIBUTE_RETURNS_NOALIAS void *
-allocate_buffer (size_t Size, size_t Alignment);
+LIBBASE_ABI
+    LIBBASE_ATTRIBUTE_RETURNS_NONNULL LIBBASE_ATTRIBUTE_RETURNS_NOALIAS void *
+    allocate_buffer (size_t Size, size_t Alignment);
 
 /// Deallocate a buffer of memory with the given size and alignment.
 ///