PR libstdc++/85494 use rdseed and rand_s in std::random_device

Add support for additional sources of randomness to std::random_device,
to allow using RDSEED for Intel CPUs and rand_s for Windows. When
supported these can be selected using the tokens "rdseed" and "rand_s".
For *-w64-mingw32 targets the "default" token will now use rand_s, and
for other i?86-*-* and x86_64-*-* targets it will try to use "rdseed"
first, then "rdrand", and finally "/dev/urandom".

To simplify the declaration of std::random_device in <bits/random.h> the
constructors now unconditionally call _M_init instead of _M_init_pretr1,
and the function call operator now unconditionally calls _M_getval. The
library code now decides whether _M_init and _M_getval should use a real
source of randomness or the mt19937 engine.

Existing code compiled against old libstdc++ headers will still call
_M_init_pretr1 and _M_getval_pretr1, but those functions now forward to
_M_init and _M_getval if a real source of randomness is available. This
means existing code compiled for mingw-w64 will start to use rand_s just
by linking to a new libstdc++.dll.

	* acinclude.m4 (GLIBCXX_CHECK_X86_RDSEED): Define macro to check if
	the assembler supports rdseed.
	* config.h.in: Regenerate.
	* configure: Regenerate.
	* configure.ac: Use GLIBCXX_CHECK_X86_RDSEED.
	* config/os/mingw32-w64/os_defines.h (_GLIBCXX_USE_CRT_RAND_S): Define.
	* doc/html/*: Regenerate.
	* doc/xml/manual/status_cxx2011.xml: Document new tokens.
	* include/bits/random.h (random_device::random_device()): Always call
	_M_init rather than _M_init_pretr1.
	(random_device::random_device(const string&)): Likewise.
	(random_device::operator()()): Always call _M_getval().
	(random_device::_M_file): Replace first member of union with an
	anonymous struct, with _M_file as its first member.
	* src/c++11/random.cc [_GLIBCXX_X86_RDRAND] (USE_RDRAND): Define.
	[_GLIBCXX_X86_RDSEED] (USE_RDSEED): Define.
	(USE_MT19937): Define if none of the above are defined.
	(USE_POSIX_FILE_IO): Define.
	(_M_strtoul): Remove.
	[USE_RDSEED] (__x86_rdseed): Define new function.
	[_GLIBCXX_USE_CRT_RAND_S] (__winxp_rand_s): Define new function.
	(random_device::_M_init(const string&)): Initialize new union members.
	Add support for "rdseed" and "rand_s" tokens. Decide what the
	"default" token does according to which USE_* macros are defined.
	[USE_POSIX_FILE_IO]: Store a file descriptor.
	[USE_MT19937]: Forward to _M_init_pretr1 instead.
	(random_device::_M_init_pretr1(const string&)) [USE_MT19937]: Inline
	code from _M_strtoul.
	[!USE_MT19937]: Call _M_init, transforming the old default token or
	numeric tokens to "default".
	(random_device::_M_fini()) [USE_POSIX_FILE_IO]: Use close not fclose.
	(random_device::_M_getval()): Use new union members to obtain a
	random number from the stored function pointer or file descriptor.
	[USE_MT19937]: Obtain a value from the mt19937 engine.
	(random_device::_M_getval_pretr1()): Call _M_getval().
	(random_device::_M_getentropy()) [USE_POSIX_FILE_IO]: Use _M_fd
	instead of fileno.
	[!USE_MT19937] (mersenne_twister): Do not instantiate when not needed.
	* testsuite/26_numerics/random/random_device/85494.cc: New test.

From-SVN: r271740

1 files changed, 244 insertions, 57 deletions

diff --git a/libstdc++-v3/src/c++11/random.cc b/libstdc++-v3/src/c++11/random.cc
index 1146d21c3f9..85cb2df4287 100644
--- a/libstdc++-v3/src/c++11/random.cc
+++ b/libstdc++-v3/src/c++11/random.cc
@@ -23,19 +23,30 @@
 // <http://www.gnu.org/licenses/>.
 
 #define _GLIBCXX_USE_CXX11_ABI 1
+#define _CRT_RAND_S // define this before including <stdlib.h> to get rand_s
+
 #include <random>
 
 #ifdef  _GLIBCXX_USE_C99_STDINT_TR1
 
 #if defined __i386__ || defined __x86_64__
 # include <cpuid.h>
+# ifdef _GLIBCXX_X86_RDRAND
+#  define USE_RDRAND 1
+# endif
+# ifdef _GLIBCXX_X86_RDSEED
+#  define USE_RDSEED 1
+# endif
 #endif
 
 #include <cerrno>
 #include <cstdio>
 
-#ifdef _GLIBCXX_HAVE_UNISTD_H
+#if defined _GLIBCXX_HAVE_UNISTD_H && defined _GLIBCXX_HAVE_FCNTL_H
 # include <unistd.h>
+# include <fcntl.h>
+// Use POSIX open, close, read etc. instead of ISO fopen, fclose, fread
+# define USE_POSIX_FILE_IO
 #endif
 
 #ifdef _GLIBCXX_HAVE_SYS_IOCTL_H
@@ -50,105 +61,273 @@
 # include <linux/random.h>
 #endif
 
+#ifdef _GLIBCXX_USE_CRT_RAND_S
+# include <stdlib.h>
+#endif
+
+#if defined USE_RDRAND || defined USE_RDSEED \
+  || defined _GLIBCXX_USE_CRT_RAND_S || defined _GLIBCXX_USE_DEV_RANDOM
+# pragma GCC poison _M_mt
+#else
+// Use the mt19937 member of the union, as in previous GCC releases.
+# define USE_MT19937 1
+#endif
+
 namespace std _GLIBCXX_VISIBILITY(default)
 {
   namespace
   {
-    static unsigned long
-    _M_strtoul(const std::string& __str)
-    {
-      unsigned long __ret = 5489UL;
-      if (__str != "mt19937")
-	{
-	  const char* __nptr = __str.c_str();
-	  char* __endptr;
-	  __ret = std::strtoul(__nptr, &__endptr, 0);
-	  if (*__nptr == '\0' || *__endptr != '\0')
-	    std::__throw_runtime_error(__N("random_device::_M_strtoul"
-					   "(const std::string&)"));
-	}
-      return __ret;
-    }
-
-#if (defined __i386__ || defined __x86_64__) && defined _GLIBCXX_X86_RDRAND
+#if USE_RDRAND
     unsigned int
     __attribute__ ((target("rdrnd")))
-    __x86_rdrand(void)
+    __x86_rdrand(void*)
     {
       unsigned int retries = 100;
       unsigned int val;
 
       while (__builtin_ia32_rdrand32_step(&val) == 0)
 	if (--retries == 0)
-	  std::__throw_runtime_error(__N("random_device::__x86_rdrand(void)"));
+	  std::__throw_runtime_error(__N("random_device: rdrand failed"));
 
       return val;
     }
 #endif
+
+#if USE_RDSEED
+    unsigned int
+    __attribute__ ((target("rdseed")))
+    __x86_rdseed(void*)
+    {
+      unsigned int retries = 100;
+      unsigned int val;
+
+      while (__builtin_ia32_rdseed_si_step(&val) == 0)
+	{
+	  if (--retries == 0)
+	    std::__throw_runtime_error(__N("random_device: rdseed failed"));
+	  __builtin_ia32_pause();
+	}
+
+      return val;
+    }
+#endif
+
+#ifdef _GLIBCXX_USE_CRT_RAND_S
+    unsigned int
+    __winxp_rand_s(void*)
+    {
+      unsigned int val;
+      if (::rand_s(&val) != 0)
+	std::__throw_runtime_error(__N("random_device: rand_s failed"));
+      return val;
+    }
+#endif
   }
 
   void
   random_device::_M_init(const std::string& token)
   {
-    const char *fname = token.c_str();
+#ifdef USE_MT19937
+    // If no real random device is supported then use the mt19937 engine.
+    _M_init_pretr1(token);
+    return;
+#else
+
+    _M_file = nullptr;
+    _M_func = nullptr;
+    _M_fd = -1;
+
+    const char* fname [[gnu::unused]] = nullptr;
+    bool default_token [[gnu::unused]] = false;
+
+    enum { rand_s, rdseed, rdrand, device_file } which;
 
     if (token == "default")
       {
-#if (defined __i386__ || defined __x86_64__) && defined _GLIBCXX_X86_RDRAND
+	default_token = true;
+	fname = "/dev/urandom";
+#if defined _GLIBCXX_USE_CRT_RAND_S
+	which = rand_s;
+#elif defined USE_RDSEED
+	which = rdseed;
+#elif defined USE_RDRAND
+	which = rdrand;
+#elif defined _GLIBCXX_USE_DEV_RANDOM
+	which = device_file;
+#else
+# error "either define USE_MT19937 above or set the default device here"
+#endif
+      }
+#ifdef USE_RDSEED
+    else if (token == "rdseed")
+      which = rdseed;
+#endif // USE_RDSEED
+#ifdef USE_RDRAND
+    else if (token == "rdrand" || token == "rdrnd")
+      which = rdrand;
+#endif // USE_RDRAND
+#ifdef _GLIBCXX_USE_CRT_RAND_S
+    else if (token == "rand_s")
+      which = rand_s;
+#endif // _GLIBCXX_USE_CRT_RAND_S
+#ifdef _GLIBCXX_USE_DEV_RANDOM
+    else if (token == "/dev/urandom" || token == "/dev/random")
+      {
+	fname = token.c_str();
+	which = device_file;
+      }
+#endif // _GLIBCXX_USE_DEV_RANDOM
+    else
+      std::__throw_runtime_error(
+	  __N("random_device::random_device(const std::string&):"
+	      " unsupported token"));
+
+    switch (which)
+    {
+#ifdef _GLIBCXX_USE_CRT_RAND_S
+      case rand_s:
+      {
+	_M_func = &__winxp_rand_s;
+	return;
+      }
+#endif // _GLIBCXX_USE_CRT_RAND_S
+#ifdef USE_RDSEED
+      case rdseed:
+      {
+	unsigned int eax, ebx, ecx, edx;
+	// Check availability of cpuid and, for now at least, also the
+	// CPU signature for Intel and AMD.
+	if (__get_cpuid_max(0, &ebx) > 0
+	    && (ebx == signature_INTEL_ebx || ebx == signature_AMD_ebx))
+	  {
+	    // CPUID.(EAX=07H, ECX=0H):EBX.RDSEED[bit 18]
+	    __cpuid_count(7, 0, eax, ebx, ecx, edx);
+	    if (ebx & bit_RDSEED)
+	      {
+		_M_func = &__x86_rdseed;
+		return;
+	      }
+	  }
+	// If rdseed was explicitly requested then we're done here.
+	if (!default_token)
+	  break;
+	// Otherwise fall through to try the next available option.
+	[[gnu::fallthrough]];
+      }
+#endif // USE_RDSEED
+#ifdef USE_RDRAND
+      case rdrand:
+      {
 	unsigned int eax, ebx, ecx, edx;
 	// Check availability of cpuid and, for now at least, also the
-	// CPU signature for Intel's
-	if (__get_cpuid_max(0, &ebx) > 0 && ebx == signature_INTEL_ebx)
+	// CPU signature for Intel and AMD.
+	if (__get_cpuid_max(0, &ebx) > 0
+	    && (ebx == signature_INTEL_ebx || ebx == signature_AMD_ebx))
 	  {
+	    // CPUID.01H:ECX.RDRAND[bit 30]
 	    __cpuid(1, eax, ebx, ecx, edx);
 	    if (ecx & bit_RDRND)
 	      {
-		_M_file = nullptr;
+		_M_func = &__x86_rdrand;
 		return;
 	      }
 	  }
-#endif
-
-	fname = "/dev/urandom";
+	// If rdrand was explicitly requested then we're done here.
+	if (!default_token)
+	  break;
+	// Otherwise fall through to try the next available option.
+	[[gnu::fallthrough]];
       }
-    else if (token != "/dev/urandom" && token != "/dev/random")
-    fail:
-      std::__throw_runtime_error(__N("random_device::"
-				     "random_device(const std::string&)"));
-
-    _M_file = static_cast<void*>(std::fopen(fname, "rb"));
-    if (!_M_file)
-      goto fail;
+#endif // USE_RDRAND
+#ifdef _GLIBCXX_USE_DEV_RANDOM
+      case device_file:
+      {
+#ifdef USE_POSIX_FILE_IO
+	_M_fd = ::open(fname, O_RDONLY);
+	if (_M_fd != -1)
+	  {
+	    // Set _M_file to non-null so that _M_fini() will do clean up.
+	    _M_file = &_M_fd;
+	    return;
+	  }
+#else // USE_POSIX_FILE_IO
+	_M_file = static_cast<void*>(std::fopen(fname, "rb"));
+	if (_M_file)
+	  return;
+#endif // USE_POSIX_FILE_IO
+	[[gnu::fallthrough]];
+      }
+#endif // _GLIBCXX_USE_DEV_RANDOM
+      default:
+      { }
+    }
+    std::__throw_runtime_error(
+	__N("random_device::random_device(const std::string&):"
+	    " device not available"));
+#endif // USE_MT19937
   }
 
+  // This function is called by _M_init for targets that use mt19937 for
+  // randomness, and by code compiled against old releases of libstdc++.
   void
   random_device::_M_init_pretr1(const std::string& token)
   {
-    _M_mt.seed(_M_strtoul(token));
+#ifdef USE_MT19937
+    unsigned long seed = 5489UL;
+    if (token != "default" && token != "mt19937")
+      {
+	const char* nptr = token.c_str();
+	char* endptr;
+	seed = std::strtoul(nptr, &endptr, 0);
+	if (*nptr == '\0' || *endptr != '\0')
+	  std::__throw_runtime_error(__N("random_device::_M_init_pretr1"
+					 "(const std::string&)"));
+      }
+    _M_mt.seed(seed);
+#else
+    // Convert old default token "mt19937" or numeric seed tokens to "default".
+    if (token == "mt19937" || isdigit((unsigned char)token[0]))
+      _M_init("default");
+    else
+      _M_init(token);
+#endif
   }
 
   void
   random_device::_M_fini()
   {
-    if (_M_file)
-      std::fclose(static_cast<FILE*>(_M_file));
+    // _M_file == nullptr means no resources to free.
+    if (!_M_file)
+      return;
+
+#ifdef USE_POSIX_FILE_IO
+    ::close(_M_fd);
+    _M_fd = -1;
+#else
+    std::fclose(static_cast<FILE*>(_M_file));
+#endif
+    _M_file = nullptr;
   }
 
   random_device::result_type
   random_device::_M_getval()
   {
-#if (defined __i386__ || defined __x86_64__) && defined _GLIBCXX_X86_RDRAND
-    if (!_M_file)
-      return __x86_rdrand();
+#ifdef USE_MT19937
+    return _M_mt();
+#else
+
+#if defined USE_RDRAND || defined USE_RDSEED || defined _GLIBCXX_USE_CRT_RAND_S
+    if (_M_func)
+      return _M_func(nullptr);
 #endif
 
-    result_type __ret;
-    void* p = &__ret;
+    result_type ret;
+    void* p = &ret;
     size_t n = sizeof(result_type);
-#ifdef _GLIBCXX_HAVE_UNISTD_H
+#ifdef USE_POSIX_FILE_IO
     do
       {
-	const int e = read(fileno(static_cast<FILE*>(_M_file)), p, n);
+	const int e = ::read(_M_fd, p, n);
 	if (e > 0)
 	  {
 	    n -= e;
@@ -158,34 +337,40 @@ namespace std _GLIBCXX_VISIBILITY(default)
 	  __throw_runtime_error(__N("random_device could not be read"));
       }
     while (n > 0);
-#else
+#else // USE_POSIX_FILE_IO
     const size_t e = std::fread(p, n, 1, static_cast<FILE*>(_M_file));
     if (e != 1)
       __throw_runtime_error(__N("random_device could not be read"));
-#endif
+#endif // USE_POSIX_FILE_IO
 
-    return __ret;
+    return ret;
+#endif // USE_MT19937
   }
 
+  // Only called by code compiled against old releases of libstdc++.
+  // Forward the call to _M_getval() and let it decide what to do.
   random_device::result_type
   random_device::_M_getval_pretr1()
-  {
-    return _M_mt();
-  }
+  { return _M_getval(); }
 
   double
   random_device::_M_getentropy() const noexcept
   {
-#if defined _GLIBCXX_HAVE_SYS_IOCTL_H && defined RNDGETENTCNT
+#if defined _GLIBCXX_USE_DEV_RANDOM \
+    && defined _GLIBCXX_HAVE_SYS_IOCTL_H && defined RNDGETENTCNT
     if (!_M_file)
       return 0.0;
 
-    const int fd = fileno(static_cast<FILE*>(_M_file));
+#ifdef USE_POSIX_FILE_IO
+    const int fd = _M_fd;
+#else
+    const int fd = ::fileno(static_cast<FILE*>(_M_file));
+#endif
     if (fd < 0)
       return 0.0;
 
     int ent;
-    if (ioctl(fd, RNDGETENTCNT, &ent) < 0)
+    if (::ioctl(fd, RNDGETENTCNT, &ent) < 0)
       return 0.0;
 
     if (ent < 0)
@@ -198,9 +383,10 @@ namespace std _GLIBCXX_VISIBILITY(default)
     return static_cast<double>(ent);
 #else
     return 0.0;
-#endif
+#endif // _GLIBCXX_USE_DEV_RANDOM && _GLIBCXX_HAVE_SYS_IOCTL_H && RNDGETENTCNT
   }
 
+#ifdef USE_MT19937
   template class mersenne_twister_engine<
     uint_fast32_t,
     32, 624, 397, 31,
@@ -208,5 +394,6 @@ namespace std _GLIBCXX_VISIBILITY(default)
     0xffffffffUL, 7,
     0x9d2c5680UL, 15,
     0xefc60000UL, 18, 1812433253UL>;
+#endif // USE_MT19937
 }
-#endif
+#endif // _GLIBCXX_USE_C99_STDINT_TR1