Move the call to CRYPTO_set_NEON_capable up.

crypto/openssl_util.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "crypto/openssl_util.h"
 
 #include <openssl/err.h>
 #include <openssl/ssl.h>
 #include <openssl/cpu.h>
 
@@ skipping 30 matching lines @@
     //      context) who's cleanup depends on the global environment here, but
     //      we can't control the order the AtExit handlers will run in so
     //      allowing the global environment to leak at least ensures it is
     //      available for those other singletons to reliably cleanup.
     return Singleton<OpenSSLInitSingleton,
                LeakySingletonTraits<OpenSSLInitSingleton> >::get();
   }
  private:
   friend struct DefaultSingletonTraits<OpenSSLInitSingleton>;
   OpenSSLInitSingleton() {
+#if defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
+    const bool has_neon =
+        (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
+    // CRYPTO_set_NEON_capable is called before |SSL_library_init| because this
+    // stops BoringSSL from probing for NEON support via SIGILL in the case
+    // that getauxval isn't present.

[davidben, 2015/02/02 19:47:16]

Fun fact: this also avoids a deadlock were CRYPTO_set_NEON_functional to take a
lock. I tried to reorder the locking callback functions and we actually assume
that nothing in this ctor calls the locking callbacks, because those go back and
query the singleton. (We should probably fix this at some point...)

+    CRYPTO_set_NEON_capable(has_neon);
+    // See https://code.google.com/p/chromium/issues/detail?id=341598
+    base::CPU cpu;
+    CRYPTO_set_NEON_functional(!cpu.has_broken_neon());
+#endif
+
     SSL_load_error_strings();
     SSL_library_init();
     int num_locks = CRYPTO_num_locks();
     locks_.reserve(num_locks);
     for (int i = 0; i < num_locks; ++i)
       locks_.push_back(new base::Lock());
     CRYPTO_set_locking_callback(LockingCallback);
     CRYPTO_THREADID_set_callback(CurrentThreadId);
-
-#if defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
-    const bool has_neon =
-        (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
-    if (has_neon)
-      CRYPTO_set_NEON_capable(1);
-    // See https://code.google.com/p/chromium/issues/detail?id=341598
-    base::CPU cpu;
-    CRYPTO_set_NEON_functional(!cpu.has_broken_neon());
-#endif
   }
 
   ~OpenSSLInitSingleton() {
     CRYPTO_set_locking_callback(NULL);
     EVP_cleanup();
     ERR_free_strings();
   }
 
   static void LockingCallback(int mode, int n, const char* file, int line) {
     OpenSSLInitSingleton::GetInstance()->OnLockingCallback(mode, n, file, line);
@@ skipping 42 matching lines @@
     std::string message;
     location.Write(true, true, &message);
     DVLOG(1) << "OpenSSL ERR_get_error stack from " << message;
     ERR_print_errors_cb(&OpenSSLErrorCallback, NULL);
   } else {
     ERR_clear_error();
   }
 }
 
 }  // namespace crypto