grpc 1.81.1 → 1.85.0

data/third_party/abseil-cpp/absl/types/span.h

@@ -30,23 +30,25 @@
 // `Span<const T>` when such types may be difficult to identify due to issues
 // with implicit conversion.
 //
-// The C++20 draft standard includes a `std::span` type. As of June 2020, the
+// The C++20 standard includes a `std::span` type. As of January 2026, the
 // differences between `absl::Span` and `std::span` are:
 //    * `absl::Span` has `operator==` (which is likely a design bug,
 //       per https://abseil.io/blog/20180531-regular-types)
 //    * `absl::Span` has the factory functions `MakeSpan()` and
 //      `MakeConstSpan()`
 //    * bounds-checked access to `absl::Span` is accomplished with `at()`
+//      however `std::span` now supports the same as of the draft C++26 standard
 //    * `absl::Span` has compiler-provided move and copy constructors and
 //      assignment. This is due to them being specified as `constexpr`, but that
 //      implies const in C++11.
-//    * A read-only `absl::Span<const T>` can be implicitly constructed from an
-//      initializer list.
 //    * `absl::Span` has no `bytes()`, `size_bytes()`, `as_bytes()`, or
 //      `as_writable_bytes()` methods
 //    * `absl::Span` has no static extent template parameter, nor constructors
 //      which exist only because of the static extent parameter.
 //    * `absl::Span` has an explicit mutable-reference constructor
+//    * `absl::Span::subspan(pos, len)` always truncates `len` to
+//      `size() - pos`, whereas `std::span::subspan()` only truncates when the
+//      `len` parameter is defaulted.
 //
 // For more information, see the class comments below.
 #ifndef ABSL_TYPES_SPAN_H_
@@ -62,11 +64,12 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
-#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/internal/hardening.h"
 #include "absl/base/macros.h"
 #include "absl/base/nullability.h"
 #include "absl/base/optimization.h"
 #include "absl/base/port.h"  // TODO(strel): remove this include
+#include "absl/base/throw_delegate.h"
 #include "absl/hash/internal/weakly_mixed_integer.h"
 #include "absl/meta/type_traits.h"
 #include "absl/types/internal/span.h"
@@ -91,10 +94,10 @@ ABSL_NAMESPACE_END
 #if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L
 #include <ranges>  // NOLINT(build/c++20)
 template <typename T>
- // NOLINTNEXTLINE(build/c++20)
+// NOLINTNEXTLINE(build/c++20)
 inline constexpr bool std::ranges::enable_view<absl::Span<T>> = true;
 template <typename T>
- // NOLINTNEXTLINE(build/c++20)
+// NOLINTNEXTLINE(build/c++20)
 inline constexpr bool std::ranges::enable_borrowed_range<absl::Span<T>> = true;
 #endif
 
@@ -186,8 +189,9 @@ class ABSL_ATTRIBUTE_VIEW Span {
   // type C.
   template <typename C>
   using EnableIfConvertibleFrom =
-      typename std::enable_if<span_internal::HasData<T, C>::value &&
-                              span_internal::HasSize<C>::value>::type;
+      std::enable_if_t<!std::is_same_v<Span, std::remove_reference_t<C>> &&
+                       span_internal::HasData<T, C>::value &&
+                       span_internal::HasSize<C>::value>;
 
   // Used to SFINAE-enable a function when the slice elements are const.
   template <typename U>
@@ -201,7 +205,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
 
  public:
   using element_type = T;
-  using value_type = absl::remove_cv_t<T>;
+  using value_type = std::remove_cv_t<T>;
   // TODO(b/316099902) - pointer should be absl_nullable, but this makes it hard
   // to recognize foreach loops as safe. absl_nullability_unknown is currently
   // used to suppress -Wnullability-completeness warnings.
@@ -332,7 +336,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
   //
   // Returns a reference to the i'th element of this span.
   constexpr reference operator[](size_type i) const noexcept {
-    ABSL_HARDENING_ASSERT(i < size());
+    absl::base_internal::HardeningAssertLT(i, size());
     return ptr_[i];
   }
 
@@ -342,8 +346,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
   constexpr reference at(size_type i) const {
     return ABSL_PREDICT_TRUE(i < size())  //
                ? *(data() + i)
-               : (base_internal::ThrowStdOutOfRange(
-                      "Span::at failed bounds check"),
+               : (ThrowStdOutOfRange("Span::at failed bounds check"),
                   *(data() + i));
   }
 
@@ -352,7 +355,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
   // Returns a reference to the first element of this span. The span must not
   // be empty.
   constexpr reference front() const noexcept {
-    ABSL_HARDENING_ASSERT(size() > 0);
+    absl::base_internal::HardeningAssertGT(size(), static_cast<size_t>(0));
     return *data();
   }
 
@@ -361,7 +364,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
   // Returns a reference to the last element of this span. The span must not
   // be empty.
   constexpr reference back() const noexcept {
-    ABSL_HARDENING_ASSERT(size() > 0);
+    absl::base_internal::HardeningAssertGT(size(), static_cast<size_t>(0));
     return *(data() + size() - 1);
   }
 
@@ -427,7 +430,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
   //
   // Removes the first `n` elements from the span.
   void remove_prefix(size_type n) noexcept {
-    ABSL_HARDENING_ASSERT(size() >= n);
+    absl::base_internal::HardeningAssertGE(size(), n);
     ptr_ += n;
     len_ -= n;
   }
@@ -436,7 +439,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
   //
   // Removes the last `n` elements from the span.
   void remove_suffix(size_type n) noexcept {
-    ABSL_HARDENING_ASSERT(size() >= n);
+    absl::base_internal::HardeningAssertGE(size(), n);
     len_ -= n;
   }
 
@@ -448,6 +451,11 @@ class ABSL_ATTRIBUTE_VIEW Span {
   // will be trimmed to at most size() - `pos`. A default `len` value of `npos`
   // ensures the returned subspan continues until the end of the span.
   //
+  // Note that trimming behavior differs from `std::span::subspan()`.
+  // `std::span::subspan()` requires `len == npos || pos + len <= size()`.
+  // In other words, `std::span::subspan()` only trims `len` when its value is
+  // defaulted.
+  //
   // Examples:
   //
   //   std::vector<int> vec = {10, 11, 12, 13};
@@ -457,9 +465,8 @@ class ABSL_ATTRIBUTE_VIEW Span {
   //   absl::MakeSpan(vec).subspan(4);     // {}
   //   absl::MakeSpan(vec).subspan(5);     // throws std::out_of_range
   constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
-    return (pos <= size())
-               ? Span(data() + pos, (std::min)(size() - pos, len))
-               : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
+    return (pos <= size()) ? Span(data() + pos, (std::min)(size() - pos, len))
+                           : (ThrowStdOutOfRange("pos > size()"), Span());
   }
 
   // Span::first()
@@ -474,9 +481,8 @@ class ABSL_ATTRIBUTE_VIEW Span {
   //   absl::MakeSpan(vec).first(3);  // {10, 11, 12}
   //   absl::MakeSpan(vec).first(5);  // throws std::out_of_range
   constexpr Span first(size_type len) const {
-    return (len <= size())
-               ? Span(data(), len)
-               : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
+    return (len <= size()) ? Span(data(), len)
+                           : (ThrowStdOutOfRange("len > size()"), Span());
   }
 
   // Span::last()
@@ -491,16 +497,14 @@ class ABSL_ATTRIBUTE_VIEW Span {
   //   absl::MakeSpan(vec).last(3);  // {11, 12, 13}
   //   absl::MakeSpan(vec).last(5);  // throws std::out_of_range
   constexpr Span last(size_type len) const {
-    return (len <= size())
-               ? Span(size() - len + data(), len)
-               : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
+    return (len <= size()) ? Span(size() - len + data(), len)
+                           : (ThrowStdOutOfRange("len > size()"), Span());
   }
 
   // Support for absl::Hash.
   template <typename H>
   friend H AbslHashValue(H h, Span v) {
-    return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()),
-                      hash_internal::WeaklyMixedInteger{v.size()});
+    return H::combine_contiguous(std::move(h), v.data(), v.size());
   }
 
  private:
@@ -726,24 +730,38 @@ ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>=(Span<T> a, const U& b) {
 //   }
 //
 template <int&... ExplicitArgumentBarrier, typename T>
-constexpr Span<T> MakeSpan(T* absl_nullable ptr, size_t size) noexcept {
+constexpr Span<T> MakeSpan(T* absl_nullable ptr ABSL_ATTRIBUTE_LIFETIME_BOUND,
+                           size_t size) noexcept {
   return Span<T>(ptr, size);
 }
 
 template <int&... ExplicitArgumentBarrier, typename T>
-Span<T> MakeSpan(T* absl_nullable begin, T* absl_nullable end) noexcept {
-  ABSL_HARDENING_ASSERT(begin <= end);
+Span<T> MakeSpan(T* absl_nullable begin ABSL_ATTRIBUTE_LIFETIME_BOUND,
+                 T* absl_nullable end) noexcept {
+  absl::base_internal::HardeningAssertLE(begin, end);
   return Span<T>(begin, static_cast<size_t>(end - begin));
 }
 
 template <int&... ExplicitArgumentBarrier, typename C>
 constexpr auto MakeSpan(C& c) noexcept  // NOLINT(runtime/references)
-    -> decltype(absl::MakeSpan(span_internal::GetData(c), c.size())) {
+    -> std::enable_if_t<span_internal::IsView<C>::value,
+                        decltype(absl::MakeSpan(span_internal::GetData(c),
+                                                c.size()))> {
+  return MakeSpan(span_internal::GetData(c), c.size());
+}
+
+template <int&... ExplicitArgumentBarrier, typename C>
+constexpr auto MakeSpan(
+    C& c ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept  // NOLINT(runtime/references)
+    -> std::enable_if_t<!span_internal::IsView<C>::value,
+                        decltype(absl::MakeSpan(span_internal::GetData(c),
+                                                c.size()))> {
   return MakeSpan(span_internal::GetData(c), c.size());
 }
 
 template <int&... ExplicitArgumentBarrier, typename T, size_t N>
-constexpr Span<T> MakeSpan(T (&array)[N]) noexcept {
+constexpr Span<T> MakeSpan(
+    T (&array ABSL_ATTRIBUTE_LIFETIME_BOUND)[N]) noexcept {
   return Span<T>(array, N);
 }
 
@@ -772,25 +790,36 @@ constexpr Span<T> MakeSpan(T (&array)[N]) noexcept {
 //   ProcessInts(absl::MakeConstSpan(std::vector<int>{ 0, 0, 0 }));
 //
 template <int&... ExplicitArgumentBarrier, typename T>
-constexpr Span<const T> MakeConstSpan(T* absl_nullable ptr,
-                                      size_t size) noexcept {
+constexpr Span<const T> MakeConstSpan(
+    T* absl_nullable ptr ABSL_ATTRIBUTE_LIFETIME_BOUND, size_t size) noexcept {
   return Span<const T>(ptr, size);
 }
 
 template <int&... ExplicitArgumentBarrier, typename T>
-Span<const T> MakeConstSpan(T* absl_nullable begin,
+Span<const T> MakeConstSpan(T* absl_nullable begin
+                                ABSL_ATTRIBUTE_LIFETIME_BOUND,
                             T* absl_nullable end) noexcept {
-  ABSL_HARDENING_ASSERT(begin <= end);
+  absl::base_internal::HardeningAssertLE(begin, end);
   return Span<const T>(begin, end - begin);
 }
 
 template <int&... ExplicitArgumentBarrier, typename C>
-constexpr auto MakeConstSpan(const C& c) noexcept -> decltype(MakeSpan(c)) {
+constexpr auto MakeConstSpan(const C& c) noexcept
+    -> std::enable_if_t<span_internal::IsView<C>::value,
+                        decltype(MakeSpan(c))> {
+  return MakeSpan(c);
+}
+
+template <int&... ExplicitArgumentBarrier, typename C>
+constexpr auto MakeConstSpan(const C& c ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+    -> std::enable_if_t<!span_internal::IsView<C>::value,
+                        decltype(MakeSpan(c))> {
   return MakeSpan(c);
 }
 
 template <int&... ExplicitArgumentBarrier, typename T, size_t N>
-constexpr Span<const T> MakeConstSpan(const T (&array)[N]) noexcept {
+constexpr Span<const T> MakeConstSpan(
+    const T (&array ABSL_ATTRIBUTE_LIFETIME_BOUND)[N]) noexcept {
   return Span<const T>(array, N);
 }
 ABSL_NAMESPACE_END

data/third_party/abseil-cpp/absl/types/variant.h

@@ -23,25 +23,82 @@
 #ifndef ABSL_TYPES_VARIANT_H_
 #define ABSL_TYPES_VARIANT_H_
 
+#include <stddef.h>
+
 #include <variant>
 
 #include "absl/base/config.h"
+#include "absl/base/macros.h"
 #include "absl/utility/utility.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
-using std::bad_variant_access;
-using std::get;
-using std::get_if;
-using std::holds_alternative;
-using std::monostate;
-using std::variant;
-using std::variant_alternative;
-using std::variant_alternative_t;
-using std::variant_npos;
-using std::variant_size;
-using std::variant_size_v;
-using std::visit;
+
+using bad_variant_access ABSL_REFACTOR_INLINE
+    = std::bad_variant_access;
+
+template <size_t I, typename... Args>
+[[deprecated]] constexpr auto get(Args&&... args)
+    -> decltype(std::get<I>(std::forward<Args>(args)...)) {
+  return std::get<I>(std::forward<Args>(args)...);
+}
+
+template <typename T, typename... Args>
+[[deprecated]] constexpr decltype(std::get<T>(std::declval<Args>()...)) get(
+    Args&&... args) {
+  return std::get<T>(std::forward<Args>(args)...);
+}
+
+template <size_t I, typename... Args>
+[[deprecated]] constexpr decltype(std::get_if<I>(std::declval<Args>()...))
+get_if(Args&&... args) {
+  return std::get_if<I>(std::forward<Args>(args)...);
+}
+
+template <typename T, typename... Args>
+[[deprecated]] constexpr decltype(std::get_if<T>(std::declval<Args>()...))
+get_if(Args&&... args) {
+  return std::get_if<T>(std::forward<Args>(args)...);
+}
+
+template <typename T, typename... Args>
+[[deprecated]] constexpr decltype(std::holds_alternative<T>(
+    std::declval<Args>()...))
+holds_alternative(Args&&... args) {
+  return std::holds_alternative<T>(std::forward<Args>(args)...);
+}
+
+using monostate ABSL_REFACTOR_INLINE
+    = std::monostate;
+
+template <typename... Types>
+using variant ABSL_REFACTOR_INLINE
+    = std::variant<Types...>;
+
+template <size_t I, typename T>
+using variant_alternative ABSL_REFACTOR_INLINE
+    = std::variant_alternative<I, T>;
+
+template <size_t I, typename T>
+using variant_alternative_t ABSL_REFACTOR_INLINE
+    = std::variant_alternative_t<I, T>;
+
+inline constexpr size_t variant_npos ABSL_REFACTOR_INLINE
+    = std::variant_npos;
+
+template <typename T>
+using variant_size ABSL_REFACTOR_INLINE
+    = std::variant_size<T>;
+
+template <typename T>
+inline constexpr size_t variant_size_v ABSL_REFACTOR_INLINE
+    = std::variant_size_v<T>;
+
+template <typename... Args>
+[[deprecated]] constexpr decltype(std::visit(std::declval<Args>()...)) visit(
+    Args&&... args) {
+  return std::visit(std::forward<Args>(args)...);
+}
 
 namespace variant_internal {
 // Helper visitor for converting a variant<Ts...>` into another type (mostly
@@ -57,23 +114,23 @@ struct ConversionVisitor {
 
 // ConvertVariantTo()
 //
-// Helper functions to convert an `absl::variant` to a variant of another set of
+// Helper functions to convert an `std::variant` to a variant of another set of
 // types, provided that the alternative type of the new variant type can be
 // converted from any type in the source variant.
 //
 // Example:
 //
-//   absl::variant<name1, name2, float> InternalReq(const Req&);
+//   std::variant<name1, name2, float> InternalReq(const Req&);
 //
 //   // name1 and name2 are convertible to name
-//   absl::variant<name, float> ExternalReq(const Req& req) {
-//     return absl::ConvertVariantTo<absl::variant<name, float>>(
+//   std::variant<name, float> ExternalReq(const Req& req) {
+//     return absl::ConvertVariantTo<std::variant<name, float>>(
 //              InternalReq(req));
 //   }
 template <typename To, typename Variant>
 To ConvertVariantTo(Variant&& variant) {
-  return absl::visit(variant_internal::ConversionVisitor<To>{},
-                     std::forward<Variant>(variant));
+  return std::visit(variant_internal::ConversionVisitor<To>{},
+                    std::forward<Variant>(variant));
 }
 
 ABSL_NAMESPACE_END

data/third_party/abseil-cpp/absl/utility/utility.h

@@ -18,13 +18,18 @@
 #include <cstddef>
 #include <cstdlib>
 #include <tuple>
+#include <type_traits>
 #include <utility>
 
+#include "absl/base/attributes.h"
 #include "absl/base/config.h"
+#include "absl/base/macros.h"
 
 // TODO(b/290784225): Include what you use cleanup required.
 #include "absl/meta/type_traits.h"
 
+// TODO(b/509512528): Deprecate the C++14/C++17 symbols publicly, in all files.
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
@@ -32,22 +37,113 @@ ABSL_NAMESPACE_BEGIN
 // abstractions for platforms that had not yet provided them. Those
 // platforms are no longer supported. New code should simply use the
 // the ones from std directly.
-using std::apply;
-using std::exchange;
-using std::forward;
-using std::in_place;
-using std::in_place_index;
-using std::in_place_index_t;
-using std::in_place_t;
-using std::in_place_type;
-using std::in_place_type_t;
-using std::index_sequence;
-using std::index_sequence_for;
-using std::integer_sequence;
-using std::make_from_tuple;
-using std::make_index_sequence;
-using std::make_integer_sequence;
-using std::move;
+template <class F, class T>
+ABSL_DEPRECATE_AND_INLINE()
+constexpr decltype(auto)
+    apply(F&& f, T&& t) noexcept(noexcept(std::apply(std::declval<F>(),
+                                                     std::declval<T>()))) {
+  return std::apply(std::forward<F>(f), std::forward<T>(t));
+}
+
+template <class T1, class T2 = T1>
+ABSL_DEPRECATE_AND_INLINE()
+constexpr T1 exchange(T1& obj, T2&& new_value) noexcept(
+    noexcept(std::exchange(std::declval<T1&>(), std::declval<T2>()))) {
+  return std::exchange(obj, std::forward<T2>(new_value));
+}
+
+template <class T>
+[[deprecated("Use std::forward instead.")]] [[nodiscard]] constexpr T&& forward(
+    std::remove_reference_t<T>& arg ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept {
+  // NOLINTNEXTLINE: Avoid warnings about T not being the spelled type of arg.
+  return std::forward<T>(arg);
+}
+
+template <class T>
+[[deprecated("Use std::forward instead.")]] [[nodiscard]] constexpr T&& forward(
+    std::remove_reference_t<T>&& arg ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept {
+  // NOLINTNEXTLINE: Avoid warnings about T not being the spelled type of arg.
+  return std::forward<T>(arg);
+}
+
+inline constexpr const std::in_place_t& in_place ABSL_DEPRECATE_AND_INLINE() =
+    std::in_place;
+
+template <size_t I>
+inline constexpr const std::in_place_index_t<I>& in_place_index
+    [[deprecated("Use std::in_place_index<I> instead.")]] =
+        std::in_place_index<I>;
+
+template <size_t I>
+using in_place_index_t [[deprecated("Use std::in_place_index_t<I> instead.")]] =
+    std::in_place_index_t<I>;
+
+using in_place_t ABSL_DEPRECATE_AND_INLINE() = std::in_place_t;
+
+template <class T>
+inline constexpr const std::in_place_type_t<T>& in_place_type
+ABSL_DEPRECATE_AND_INLINE() = std::in_place_type<T>;
+
+template <class T>
+using in_place_type_t ABSL_DEPRECATE_AND_INLINE() = std::in_place_type_t<T>;
+
+template <size_t... I>
+using index_sequence [[deprecated("Use std::index_sequence instead.")]] =
+    std::index_sequence<I...>;
+
+template <class T, T... I>
+using integer_sequence [[deprecated("Use std::integer_sequence instead.")]] =
+    std::integer_sequence<T, I...>;
+
+template <class... T>
+using index_sequence_for
+    [[deprecated("Use std::index_sequence_for instead.")]] =
+        std::index_sequence_for<T...>;
+
+template <class T, class Tuple>
+ABSL_DEPRECATE_AND_INLINE()
+[[nodiscard]] constexpr decltype(std::make_from_tuple<T>(std::declval<Tuple>()))
+    make_from_tuple(Tuple&& arg) noexcept(
+        noexcept(std::make_from_tuple<T>(std::declval<Tuple>()))) {
+  return std::make_from_tuple<T>(std::forward<Tuple>(arg));
+}
+
+template <size_t N>
+using make_index_sequence
+    [[deprecated("Use std::make_index_sequence instead.")]] =
+        std::make_index_sequence<N>;
+
+template <class T, T N>
+using make_integer_sequence
+    [[deprecated("Use std::make_integer_sequence instead.")]] =
+        std::make_integer_sequence<T, N>;
+
+template <class It, class OutIt>
+[[deprecated("Use std::move instead.")]]
+constexpr OutIt move(It&& begin, It&& end, OutIt&& output) {
+  return std::move(std::forward<It>(begin), std::forward<It>(end),
+                   std::forward<OutIt>(output));
+}
+
+template <class T>
+[[deprecated("Use std::move instead.")]]
+[[nodiscard]] constexpr std::remove_reference_t<T>&&
+move(T&& arg ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept {
+  return std::move(arg);  // NOLINT(bugprone-move-forwarding-reference)
+}
+
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
+// Backfill for std::nontype_t. An instance of this class can be provided as a
+// disambiguation tag to `absl::function_ref` to pass the address of a known
+// callable at compile time.
+// Requires C++20 due to `auto` template parameter.
+template <auto>
+struct nontype_t {
+  explicit nontype_t() = default;
+};
+template <auto V>
+constexpr nontype_t<V> nontype{};
+#endif
 
 ABSL_NAMESPACE_END
 }  // namespace absl

data/third_party/boringssl-with-bazel/crypto/aes/aes.cc

@@ -18,6 +18,9 @@
 
 #include "../fipsmodule/bcm_interface.h"
 
+
+using namespace bssl;
+
 void AES_encrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key) {
   BCM_aes_encrypt(in, out, key);
 }

data/third_party/boringssl-with-bazel/crypto/armv8_feature_parsing.h

@@ -0,0 +1,67 @@
+#ifndef OPENSSL_CRYPTO_CPU_ARMV8_FEATURE_PARSING_H
+#define OPENSSL_CRYPTO_CPU_ARMV8_FEATURE_PARSING_H
+
+#include <openssl/cpu.h>
+#include <stdint.h>
+
+#include "internal.h"
+
+#if defined(OPENSSL_AARCH64)
+
+BSSL_NAMESPACE_BEGIN
+namespace armcap {
+
+// Common field indices based on ARM architecture specification for
+// ID_AA64ISAR0_EL1. These are indices (multiplied by 4 for the bit shift).
+// Note: SHA3_FIELD_IDX 8 * 4 = 32 (ID_AA64ISAR0_EL1_SHA3_SHIFT value)
+#define ID_AA64ISAR0_AES_FIELD_IDX 1   // Bits [7:4]
+#define ID_AA64ISAR0_SHA1_FIELD_IDX 2  // Bits [11:8]
+#define ID_AA64ISAR0_SHA2_FIELD_IDX 3  // Bits [15:12]
+#define ID_AA64ISAR0_SHA3_FIELD_IDX 8  // Bits [35:32]
+#define NBITS_ID_FIELD 4
+
+// Helper function to extract a 4-bit field based on its index.
+inline unsigned GetIDField(uint64_t reg, unsigned field_idx) {
+  // We mask with 0xf to ensure only the 4 relevant bits are returned.
+  return (reg >> (field_idx * NBITS_ID_FIELD)) & 0xf;
+}
+
+// The core function that converts the raw ID_AA64ISAR0 register value
+// into the OR'd capability flags (ARMV8_AES, ARMV8_SHA3, etc.).
+inline uint32_t ParseISAR0Flags(uint64_t isar0) {
+  uint32_t armcap = 0;
+  // AES and PMULL check
+  unsigned aes = GetIDField(isar0, ID_AA64ISAR0_AES_FIELD_IDX);
+  if (aes > 0) {
+    armcap |= ARMV8_AES;
+  }
+  if (aes > 1) {
+    armcap |= ARMV8_PMULL;
+  }
+  // SHA1 check
+  unsigned sha1 = GetIDField(isar0, ID_AA64ISAR0_SHA1_FIELD_IDX);
+  if (sha1 > 0) {
+    armcap |= ARMV8_SHA1;
+  }
+  // SHA256 and SHA512 check
+  unsigned sha2 = GetIDField(isar0, ID_AA64ISAR0_SHA2_FIELD_IDX);
+  if (sha2 > 0) {
+    armcap |= ARMV8_SHA256;
+  }
+  if (sha2 > 1) {
+    armcap |= ARMV8_SHA512;
+  }
+  // SHA3 (EOR3) check
+  unsigned sha3 = GetIDField(isar0, ID_AA64ISAR0_SHA3_FIELD_IDX);
+  if (sha3 > 0) {
+    armcap |= ARMV8_SHA3;
+  }
+  return armcap;
+}
+
+}  // namespace armcap
+BSSL_NAMESPACE_END
+
+#endif  // OPENSSL_AARCH64
+
+#endif  // OPENSSL_CRYPTO_CPU_ARMV8_FEATURE_PARSING_H