grpc 1.84.0 → 1.85.0.pre1

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

@@ -21,19 +21,25 @@
 #include <openssl/bio.h>
 #include <openssl/buf.h>
 #include <openssl/err.h>
-#include <openssl/lhash.h>
 #include <openssl/mem.h>
 
 #include "../internal.h"
+#include "../mem_internal.h"
 #include "internal.h"
 
 
+using namespace bssl;
+
+BSSL_NAMESPACE_BEGIN
+
 struct conf_section_st {
   char *name;
   // values contains non-owning pointers to the values in the section.
   STACK_OF(CONF_VALUE) *values;
 };
 
+BSSL_NAMESPACE_END
+
 static const char kDefaultSectionName[] = "default";
 
 static uint32_t conf_section_hash(const CONF_SECTION *s) {
@@ -60,46 +66,44 @@ static int conf_value_cmp(const CONF_VALUE *a, const CONF_VALUE *b) {
 }
 
 CONF *NCONF_new(void *method) {
-  if (method != NULL) {
-    return NULL;
+  if (method != nullptr) {
+    return nullptr;
   }
 
-  CONF *conf = reinterpret_cast<CONF *>(OPENSSL_malloc(sizeof(CONF)));
-  if (conf == NULL) {
-    return NULL;
+  CONF *conf = New<CONF>();
+  if (conf == nullptr) {
+    return nullptr;
   }
 
   conf->sections = lh_CONF_SECTION_new(conf_section_hash, conf_section_cmp);
   conf->values = lh_CONF_VALUE_new(conf_value_hash, conf_value_cmp);
-  if (conf->sections == NULL || conf->values == NULL) {
+  if (conf->sections == nullptr || conf->values == nullptr) {
     NCONF_free(conf);
-    return NULL;
+    return nullptr;
   }
 
   return conf;
 }
 
-CONF_VALUE *CONF_VALUE_new(void) {
-  return reinterpret_cast<CONF_VALUE *>(OPENSSL_zalloc(sizeof(CONF_VALUE)));
-}
+CONF_VALUE *bssl::CONF_VALUE_new() { return New<CONF_VALUE>(); }
 
 static void value_free(CONF_VALUE *value) {
-  if (value == NULL) {
+  if (value == nullptr) {
     return;
   }
   OPENSSL_free(value->section);
   OPENSSL_free(value->name);
   OPENSSL_free(value->value);
-  OPENSSL_free(value);
+  Delete(value);
 }
 
 static void section_free(CONF_SECTION *section) {
-  if (section == NULL) {
+  if (section == nullptr) {
     return;
   }
   OPENSSL_free(section->name);
   sk_CONF_VALUE_free(section->values);
-  OPENSSL_free(section);
+  Delete(section);
 }
 
 static void value_free_arg(CONF_VALUE *value, void *arg) { value_free(value); }
@@ -109,26 +113,25 @@ static void section_free_arg(CONF_SECTION *section, void *arg) {
 }
 
 void NCONF_free(CONF *conf) {
-  if (conf == NULL) {
+  if (conf == nullptr) {
     return;
   }
 
-  lh_CONF_SECTION_doall_arg(conf->sections, section_free_arg, NULL);
+  lh_CONF_SECTION_doall_arg(conf->sections, section_free_arg, nullptr);
   lh_CONF_SECTION_free(conf->sections);
-  lh_CONF_VALUE_doall_arg(conf->values, value_free_arg, NULL);
+  lh_CONF_VALUE_doall_arg(conf->values, value_free_arg, nullptr);
   lh_CONF_VALUE_free(conf->values);
-  OPENSSL_free(conf);
+  Delete(conf);
 }
 
 static CONF_SECTION *NCONF_new_section(const CONF *conf, const char *section) {
-  CONF_SECTION *s =
-      reinterpret_cast<CONF_SECTION *>(OPENSSL_malloc(sizeof(CONF_SECTION)));
+  CONF_SECTION *s = New<CONF_SECTION>();
   if (!s) {
-    return NULL;
+    return nullptr;
   }
   s->name = OPENSSL_strdup(section);
   s->values = sk_CONF_VALUE_new_null();
-  if (s->name == NULL || s->values == NULL) {
+  if (s->name == nullptr || s->values == nullptr) {
     goto err;
   }
 
@@ -141,7 +144,7 @@ static CONF_SECTION *NCONF_new_section(const CONF *conf, const char *section) {
 
 err:
   section_free(s);
-  return NULL;
+  return nullptr;
 }
 
 static int is_comment(char c) { return c == '#'; }
@@ -151,7 +154,7 @@ static int is_quote(char c) { return c == '"' || c == '\'' || c == '`'; }
 static int is_esc(char c) { return c == '\\'; }
 
 static int is_conf_ws(char c) {
-  // This differs from |OPENSSL_isspace| in that CONF does not accept '\v' and
+  // This differs from `OPENSSL_isspace` in that CONF does not accept '\v' and
   // '\f' as whitespace.
   return c == ' ' || c == '\t' || c == '\r' || c == '\n';
 }
@@ -170,7 +173,7 @@ static int str_copy(CONF *conf, char *section, char **pto, char *from) {
   BUF_MEM *buf;
 
   buf = BUF_MEM_new();
-  if (buf == NULL) {
+  if (buf == nullptr) {
     return 0;
   }
 
@@ -245,8 +248,8 @@ static CONF_SECTION *get_section(const CONF *conf, const char *section) {
 const STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf,
                                               const char *section) {
   const CONF_SECTION *section_obj = get_section(conf, section);
-  if (section_obj == NULL) {
-    return NULL;
+  if (section_obj == nullptr) {
+    return nullptr;
   }
   return section_obj->values;
 }
@@ -255,7 +258,7 @@ const char *NCONF_get_string(const CONF *conf, const char *section,
                              const char *name) {
   CONF_VALUE templ, *value;
 
-  if (section == NULL) {
+  if (section == nullptr) {
     section = kDefaultSectionName;
   }
 
@@ -263,8 +266,8 @@ const char *NCONF_get_string(const CONF *conf, const char *section,
   templ.section = (char *)section;
   templ.name = (char *)name;
   value = lh_CONF_VALUE_retrieve(conf->values, &templ);
-  if (value == NULL) {
-    return NULL;
+  if (value == nullptr) {
+    return nullptr;
   }
   return value->value;
 }
@@ -272,7 +275,7 @@ const char *NCONF_get_string(const CONF *conf, const char *section,
 static int add_string(const CONF *conf, CONF_SECTION *section,
                       CONF_VALUE *value) {
   value->section = OPENSSL_strdup(section->name);
-  if (value->section == NULL) {
+  if (value->section == nullptr) {
     return 0;
   }
 
@@ -282,12 +285,12 @@ static int add_string(const CONF *conf, CONF_SECTION *section,
 
   CONF_VALUE *old_value;
   if (!lh_CONF_VALUE_insert(conf->values, &old_value, value)) {
-    // Remove |value| from |section->values|, so we do not leave a dangling
+    // Remove `value` from `section->values`, so we do not leave a dangling
     // pointer.
     sk_CONF_VALUE_pop(section->values);
     return 0;
   }
-  if (old_value != NULL) {
+  if (old_value != nullptr) {
     (void)sk_CONF_VALUE_delete_ptr(section->values, old_value);
     value_free(old_value);
   }
@@ -371,27 +374,27 @@ static void clear_comments(char *p) {
 int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
   static const size_t CONFBUFSIZE = 512;
   int bufnum = 0, i, ii;
-  BUF_MEM *buff = NULL;
+  BUF_MEM *buff = nullptr;
   char *s, *p, *end;
   int again;
   long eline = 0;
-  CONF_VALUE *v = NULL;
-  CONF_SECTION *sv = NULL;
-  char *section = NULL, *buf;
+  CONF_VALUE *v = nullptr;
+  CONF_SECTION *sv = nullptr;
+  char *section = nullptr, *buf;
   char *start, *psection, *pname;
 
-  if ((buff = BUF_MEM_new()) == NULL) {
+  if ((buff = BUF_MEM_new()) == nullptr) {
     OPENSSL_PUT_ERROR(CONF, ERR_R_BUF_LIB);
     goto err;
   }
 
   section = OPENSSL_strdup(kDefaultSectionName);
-  if (section == NULL) {
+  if (section == nullptr) {
     goto err;
   }
 
   sv = NCONF_new_section(conf, section);
-  if (sv == NULL) {
+  if (sv == nullptr) {
     OPENSSL_PUT_ERROR(CONF, CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
     goto err;
   }
@@ -433,7 +436,7 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
     // i is the number of bytes
     bufnum += i;
 
-    v = NULL;
+    v = nullptr;
     // check for line continuation
     if (bufnum >= 1) {
       // If we have bytes and the last char '\\' and
@@ -473,20 +476,20 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
         goto err;
       }
       *end = '\0';
-      if (!str_copy(conf, NULL, &section, start)) {
+      if (!str_copy(conf, nullptr, &section, start)) {
         goto err;
       }
-      if ((sv = get_section(conf, section)) == NULL) {
+      if ((sv = get_section(conf, section)) == nullptr) {
         sv = NCONF_new_section(conf, section);
       }
-      if (sv == NULL) {
+      if (sv == nullptr) {
         OPENSSL_PUT_ERROR(CONF, CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
         goto err;
       }
       continue;
     } else {
       pname = s;
-      psection = NULL;
+      psection = nullptr;
       end = eat_name(s);
       if ((end[0] == ':') && (end[1] == ':')) {
         *end = '\0';
@@ -516,11 +519,11 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
       if (!(v = CONF_VALUE_new())) {
         goto err;
       }
-      if (psection == NULL) {
+      if (psection == nullptr) {
         psection = section;
       }
       v->name = OPENSSL_strdup(pname);
-      if (v->name == NULL) {
+      if (v->name == nullptr) {
         goto err;
       }
       if (!str_copy(conf, psection, &(v->value), start)) {
@@ -529,10 +532,10 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
 
       CONF_SECTION *tv;
       if (strcmp(psection, section) != 0) {
-        if ((tv = get_section(conf, psection)) == NULL) {
+        if ((tv = get_section(conf, psection)) == nullptr) {
           tv = NCONF_new_section(conf, psection);
         }
-        if (tv == NULL) {
+        if (tv == nullptr) {
           OPENSSL_PUT_ERROR(CONF, CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
           goto err;
         }
@@ -542,17 +545,17 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
       if (add_string(conf, tv, v) == 0) {
         goto err;
       }
-      v = NULL;
+      v = nullptr;
     }
   }
   BUF_MEM_free(buff);
-  OPENSSL_free(section);
+  Delete(section);
   return 1;
 
 err:
   BUF_MEM_free(buff);
-  OPENSSL_free(section);
-  if (out_error_line != NULL) {
+  Delete(section);
+  if (out_error_line != nullptr) {
     *out_error_line = eline;
   }
   ERR_add_error_dataf("line %ld", eline);
@@ -564,7 +567,7 @@ int NCONF_load(CONF *conf, const char *filename, long *out_error_line) {
   BIO *in = BIO_new_file(filename, "rb");
   int ret;
 
-  if (in == NULL) {
+  if (in == nullptr) {
     OPENSSL_PUT_ERROR(CONF, ERR_R_SYS_LIB);
     return 0;
   }
@@ -575,13 +578,14 @@ int NCONF_load(CONF *conf, const char *filename, long *out_error_line) {
   return ret;
 }
 
-int CONF_parse_list(const char *list, char sep, int remove_whitespace,
-                    int (*list_cb)(const char *elem, size_t len, void *usr),
-                    void *arg) {
+int bssl::CONF_parse_list(const char *list, char sep, int remove_whitespace,
+                          int (*list_cb)(const char *elem, size_t len,
+                                         void *usr),
+                          void *arg) {
   int ret;
   const char *lstart, *tmpend, *p;
 
-  if (list == NULL) {
+  if (list == nullptr) {
     OPENSSL_PUT_ERROR(CONF, CONF_R_LIST_CANNOT_BE_NULL);
     return 0;
   }
@@ -595,7 +599,7 @@ int CONF_parse_list(const char *list, char sep, int remove_whitespace,
     }
     p = strchr(lstart, sep);
     if (p == lstart || !*lstart) {
-      ret = list_cb(NULL, 0, arg);
+      ret = list_cb(nullptr, 0, arg);
     } else {
       if (p) {
         tmpend = p - 1;
@@ -612,7 +616,7 @@ int CONF_parse_list(const char *list, char sep, int remove_whitespace,
     if (ret <= 0) {
       return ret;
     }
-    if (p == NULL) {
+    if (p == nullptr) {
       return 1;
     }
     lstart = p + 1;
@@ -624,8 +628,10 @@ int CONF_modules_load_file(const char *filename, const char *appname,
   return 1;
 }
 
-void CONF_modules_free(void) {}
+void CONF_modules_unload(int all) {}
+
+void CONF_modules_free() {}
 
 void OPENSSL_config(const char *config_name) {}
 
-void OPENSSL_no_config(void) {}
+void OPENSSL_no_config() {}

data/third_party/boringssl-with-bazel/crypto/conf/internal.h

@@ -19,37 +19,36 @@
 
 #include "../lhash/internal.h"
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
 
+BSSL_NAMESPACE_BEGIN
 
 typedef struct conf_section_st CONF_SECTION;
 
 DEFINE_LHASH_OF(CONF_SECTION)
 DEFINE_LHASH_OF(CONF_VALUE)
 
+BSSL_NAMESPACE_END
+
 struct conf_st {
   LHASH_OF(CONF_VALUE) *values;
   LHASH_OF(CONF_SECTION) *sections;
 };
 
-// CONF_VALUE_new returns a freshly allocated and zeroed |CONF_VALUE|.
-CONF_VALUE *CONF_VALUE_new(void);
+BSSL_NAMESPACE_BEGIN
+
+// CONF_VALUE_new returns a freshly allocated and zeroed `CONF_VALUE`.
+CONF_VALUE *CONF_VALUE_new();
 
-// CONF_parse_list takes a list separated by 'sep' and calls |list_cb| giving
+// CONF_parse_list takes a list separated by 'sep' and calls `list_cb` giving
 // the start and length of each member, optionally stripping leading and
 // trailing whitespace. This can be used to parse comma separated lists for
-// example. If |list_cb| returns <= 0, then the iteration is halted and that
-// value is returned immediately. Otherwise it returns one. Note that |list_cb|
+// example. If `list_cb` returns <= 0, then the iteration is halted and that
+// value is returned immediately. Otherwise it returns one. Note that `list_cb`
 // may be called on an empty member.
 OPENSSL_EXPORT int CONF_parse_list(
     const char *list, char sep, int remove_whitespace,
     int (*list_cb)(const char *elem, size_t len, void *usr), void *arg);
 
-
-#if defined(__cplusplus)
-}  // extern C
-#endif
+BSSL_NAMESPACE_END
 
 #endif  // OPENSSL_HEADER_CRYPTO_CONF_INTERNAL_H

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

@@ -21,10 +21,12 @@
 #include <sys/types.h>
 
 
+using namespace bssl;
+
 static int has_hw_feature(const char *name) {
   int value;
   size_t len = sizeof(value);
-  if (sysctlbyname(name, &value, &len, NULL, 0) != 0) {
+  if (sysctlbyname(name, &value, &len, nullptr, 0) != 0) {
     return 0;
   }
   if (len != sizeof(int)) {
@@ -43,7 +45,7 @@ static int has_hw_feature(const char *name) {
   return value != 0;
 }
 
-void OPENSSL_cpuid_setup(void) {
+void bssl::OPENSSL_cpuid_setup() {
   // Apple ARM64 platforms have NEON and cryptography extensions available
   // statically, so we do not need to query them. In particular, there sometimes
   // are no sysctls corresponding to such features. See below.
@@ -61,13 +63,14 @@ void OPENSSL_cpuid_setup(void) {
   // available in macOS 12. For compatibility with macOS 11, we also support
   // the old names. The old names don't have values for features like FEAT_AES,
   // so instead we detect them statically above.
-  //
-  // If querying new sysctls, update the Chromium sandbox definition. See
-  // https://crrev.com/c/4415225.
   if (has_hw_feature("hw.optional.arm.FEAT_SHA512") ||
       has_hw_feature("hw.optional.armv8_2_sha512")) {
     OPENSSL_armcap_P |= ARMV8_SHA512;
   }
+  if (has_hw_feature("hw.optional.arm.FEAT_SHA3") ||
+      has_hw_feature("hw.optional.armv8_2_sha3")) {
+    OPENSSL_armcap_P |= ARMV8_SHA3;
+  }
 }
 
 #endif  // OPENSSL_AARCH64 && OPENSSL_APPLE && !OPENSSL_STATIC_ARMCAP

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

@@ -22,7 +22,9 @@
 #include <zircon/types.h>
 
 
-void OPENSSL_cpuid_setup(void) {
+using namespace bssl;
+
+void bssl::OPENSSL_cpuid_setup() {
   uint32_t hwcap;
   zx_status_t rc = zx_system_get_features(ZX_FEATURE_KIND_CPU, &hwcap);
   if (rc != ZX_OK || (hwcap & ZX_ARM64_FEATURE_ISA_ASIMD) == 0) {
@@ -48,6 +50,9 @@ void OPENSSL_cpuid_setup(void) {
   if (hwcap & ZX_ARM64_FEATURE_ISA_SHA512) {
     OPENSSL_armcap_P |= ARMV8_SHA512;
   }
+  if (hwcap & ZX_ARM64_FEATURE_ISA_SHA3) {
+    OPENSSL_armcap_P |= ARMV8_SHA3;
+  }
 }
 
 #endif  // OPENSSL_AARCH64 && OPENSSL_FUCHSIA && !OPENSSL_STATIC_ARMCAP

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

@@ -20,7 +20,9 @@
 #include <sys/auxv.h>
 
 
-void OPENSSL_cpuid_setup(void) {
+using namespace bssl;
+
+void bssl::OPENSSL_cpuid_setup() {
   unsigned long hwcap = getauxval(AT_HWCAP);
 
   // See /usr/include/asm/hwcap.h on an aarch64 installation for the source of
@@ -30,6 +32,7 @@ void OPENSSL_cpuid_setup(void) {
   static const unsigned long kPMULL = 1 << 4;
   static const unsigned long kSHA1 = 1 << 5;
   static const unsigned long kSHA256 = 1 << 6;
+  static const unsigned long kSHA3 = 1 << 17;
   static const unsigned long kSHA512 = 1 << 21;
 
   if ((hwcap & kNEON) == 0) {
@@ -55,6 +58,9 @@ void OPENSSL_cpuid_setup(void) {
   if (hwcap & kSHA512) {
     OPENSSL_armcap_P |= ARMV8_SHA512;
   }
+  if (hwcap & kSHA3) {
+    OPENSSL_armcap_P |= ARMV8_SHA3;
+  }
 }
 
 #endif  // OPENSSL_AARCH64 && OPENSSL_LINUX && !OPENSSL_STATIC_ARMCAP

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

@@ -21,39 +21,25 @@
 #include <machine/cpu.h>
 #include <sys/sysctl.h>
 
+#include "armv8_feature_parsing.h"
 #include "internal.h"
 
 
-void OPENSSL_cpuid_setup(void) {
+using namespace bssl;
+
+void bssl::OPENSSL_cpuid_setup() {
   int isar0_mib[] = {CTL_MACHDEP, CPU_ID_AA64ISAR0};
   uint64_t cpu_id = 0;
   size_t len = sizeof(cpu_id);
 
-  if (sysctl(isar0_mib, 2, &cpu_id, &len, NULL, 0) < 0) {
+  if (sysctl(isar0_mib, 2, &cpu_id, &len, nullptr, 0) < 0) {
     return;
   }
 
   OPENSSL_armcap_P |= ARMV7_NEON;
 
-  if (ID_AA64ISAR0_AES(cpu_id) >= ID_AA64ISAR0_AES_BASE) {
-    OPENSSL_armcap_P |= ARMV8_AES;
-  }
-
-  if (ID_AA64ISAR0_AES(cpu_id) >= ID_AA64ISAR0_AES_PMULL) {
-    OPENSSL_armcap_P |= ARMV8_PMULL;
-  }
-
-  if (ID_AA64ISAR0_SHA1(cpu_id) >= ID_AA64ISAR0_SHA1_BASE) {
-    OPENSSL_armcap_P |= ARMV8_SHA1;
-  }
-
-  if (ID_AA64ISAR0_SHA2(cpu_id) >= ID_AA64ISAR0_SHA2_BASE) {
-    OPENSSL_armcap_P |= ARMV8_SHA256;
-  }
-
-  if (ID_AA64ISAR0_SHA2(cpu_id) >= ID_AA64ISAR0_SHA2_512) {
-    OPENSSL_armcap_P |= ARMV8_SHA512;
-  }
+  // Use the common parsing function to check other features.
+  OPENSSL_armcap_P |= armcap::ParseISAR0Flags(cpu_id);
 }
 
 #endif  // OPENSSL_AARCH64 && OPENSSL_OPENBSD && !OPENSSL_STATIC_ARMCAP

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

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <openssl/cpu.h>
+
 #include "internal.h"
 
 // While Arm system registers are normally not available to userspace, FreeBSD
@@ -21,13 +23,11 @@
     (defined(ANDROID_BAREMETAL) || defined(OPENSSL_FREEBSD)) &&    \
     !defined(OPENSSL_NO_ASM)
 
-#define ID_AA64PFR0_EL1_ADVSIMD 5
+#include "./armv8_feature_parsing.h"
 
-#define ID_AA64ISAR0_EL1_AES 1
-#define ID_AA64ISAR0_EL1_SHA1 2
-#define ID_AA64ISAR0_EL1_SHA2 3
+BSSL_NAMESPACE_BEGIN
 
-#define NBITS_ID_FIELD 4
+#define ID_AA64PFR0_EL1_ADVSIMD 5
 
 #define READ_SYSREG(name)                \
   ({                                     \
@@ -36,12 +36,10 @@
     _r;                                  \
   })
 
-static unsigned get_id_field(uint64_t reg, unsigned field) {
-  return (reg >> (field * NBITS_ID_FIELD)) & ((1 << NBITS_ID_FIELD) - 1);
-}
-
-static int get_signed_id_field(uint64_t reg, unsigned field) {
-  unsigned value = get_id_field(reg, field);
+// We use the common GetIDField helper now, but need a signed variant
+// for the NEON check using ID_AA64PFR0_EL1.
+static int GetSignedIDField(uint64_t reg, unsigned field) {
+  unsigned value = armcap::GetIDField(reg, field);
   if (value & (1 << (NBITS_ID_FIELD - 1))) {
     return (int)(value | (UINT64_MAX << NBITS_ID_FIELD));
   } else {
@@ -49,44 +47,20 @@ static int get_signed_id_field(uint64_t reg, unsigned field) {
   }
 }
 
-static uint32_t read_armcap(void) {
-  uint32_t armcap = ARMV7_NEON;
-
+void OPENSSL_cpuid_setup() {
   uint64_t id_aa64pfr0_el1 = READ_SYSREG("id_aa64pfr0_el1");
-
-  if (get_signed_id_field(id_aa64pfr0_el1, ID_AA64PFR0_EL1_ADVSIMD) < 0) {
+  if (GetSignedIDField(id_aa64pfr0_el1, ID_AA64PFR0_EL1_ADVSIMD) < 0) {
     // If AdvSIMD ("NEON") is missing, don't report other features either.
     // This matches OpenSSL.
-    return 0;
+    return;
   }
 
+  // Use the common parsing function to check all cryptographic features.
   uint64_t id_aa64isar0_el1 = READ_SYSREG("id_aa64isar0_el1");
-
-  unsigned aes = get_id_field(id_aa64isar0_el1, ID_AA64ISAR0_EL1_AES);
-  if (aes > 0) {
-    armcap |= ARMV8_AES;
-  }
-  if (aes > 1) {
-    armcap |= ARMV8_PMULL;
-  }
-
-  unsigned sha1 = get_id_field(id_aa64isar0_el1, ID_AA64ISAR0_EL1_SHA1);
-  if (sha1 > 0) {
-    armcap |= ARMV8_SHA1;
-  }
-
-  unsigned sha2 = get_id_field(id_aa64isar0_el1, ID_AA64ISAR0_EL1_SHA2);
-  if (sha2 > 0) {
-    armcap |= ARMV8_SHA256;
-  }
-  if (sha2 > 1) {
-    armcap |= ARMV8_SHA512;
-  }
-
-  return armcap;
+  OPENSSL_armcap_P |= ARMV7_NEON | armcap::ParseISAR0Flags(id_aa64isar0_el1);
 }
 
-void OPENSSL_cpuid_setup(void) { OPENSSL_armcap_P |= read_armcap(); }
+BSSL_NAMESPACE_END
 
 #endif  // OPENSSL_AARCH64 && !OPENSSL_STATIC_ARMCAP &&
         // (ANDROID_BAREMETAL || OPENSSL_FREEBSD)

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

@@ -21,7 +21,16 @@
 #include <windows.h>
 
 
-void OPENSSL_cpuid_setup(void) {
+#if !defined(PF_ARM_SHA3_INSTRUCTIONS_AVAILABLE)
+#define PF_ARM_SHA3_INSTRUCTIONS_AVAILABLE 64
+#endif
+#if !defined(PF_ARM_SHA512_INSTRUCTIONS_AVAILABLE)
+#define PF_ARM_SHA512_INSTRUCTIONS_AVAILABLE 65
+#endif
+
+using namespace bssl;
+
+void bssl::OPENSSL_cpuid_setup() {
   // We do not need to check for the presence of NEON, as Armv8-A always has it
   OPENSSL_armcap_P |= ARMV7_NEON;
 
@@ -32,8 +41,12 @@ void OPENSSL_cpuid_setup(void) {
     OPENSSL_armcap_P |= ARMV8_SHA1;
     OPENSSL_armcap_P |= ARMV8_SHA256;
   }
-  // As of writing, Windows does not have a |PF_*| value for ARMv8.2 SHA-512
-  // extensions. When it does, add it here.
+  if (IsProcessorFeaturePresent(PF_ARM_SHA512_INSTRUCTIONS_AVAILABLE)) {
+    OPENSSL_armcap_P |= ARMV8_SHA512;
+  }
+  if (IsProcessorFeaturePresent(PF_ARM_SHA3_INSTRUCTIONS_AVAILABLE)) {
+    OPENSSL_armcap_P |= ARMV8_SHA3;
+  }
 }
 
 #endif  // OPENSSL_AARCH64 && OPENSSL_WINDOWS && !OPENSSL_STATIC_ARMCAP