Export of internal Abseil changes

--
e54b9c7bbb0c58475676c268e2e19c69f4bce48a by Jorg Brown <jorg@google.com>:

Tweak ABSL_PREDICT_TRUE slightly, for better code on some platforms and/or
optimization levels.  "false || (x)" is more verbose than "!!(x)", but
ultimately more efficient.

For example, given this code:

void InitIfNecessary() {
  if (ABSL_PREDICT_TRUE(NeedsInit())) {
    SlowInitIfNecessary();
  }
}

Clang with default optimization level will produce:

Before this CL              After this CL
InitIfNecessary:            InitIfNecessary:
  push rbp                    push rbp
  mov  rbp, rsp               mov  rbp, rsp
  call NeedsInit              call NeedsInit
  xor  al, -1
  xor  al, -1
  test al, 1                  test al, 1
  jne  .LBB2_1                jne  .LBB3_1
  jmp  .LBB2_2                jmp  .LBB3_2
.LBB2_1:                    .LBB3_1:
  call SlowInitIfNecessary    call SlowInitIfNecessary
.LBB2_2:                    .LBB3_2:
  pop  rbp                    pop  rbp
  ret                         ret
PiperOrigin-RevId: 276401386

--
0a3c4dfd8342bf2b1b11a87f1c662c883f73cab7 by Abseil Team <absl-team@google.com>:

Fix comment nit: sem_open => sem_init.

The code calls sem_init, not sem_open, to initialize an unnamed semaphore.
(sem_open creates or opens a named semaphore.)

PiperOrigin-RevId: 276344072

--
b36a664e9459057509a90e83d3482e1d3a4c44c7 by Abseil Team <absl-team@google.com>:

Fix typo in flat_hash_map.h: exchaged -> exchanged

PiperOrigin-RevId: 276295792

--
7bbd8d18276eb110c8335743e35fceb662ddf3d6 by Samuel Benzaquen <sbenza@google.com>:

Add assertions to verify use of iterators.

PiperOrigin-RevId: 276283300

--
677398a8ffcb1f59182cffe57a4fe7ff147a0404 by Laramie Leavitt <lar@google.com>:

Migrate distribution_impl.h/cc to generate_real.h/cc.

Combine the methods RandU64To<Float,Double> into a single method:
GenerateRealFromBits().

Remove rejection sampling from absl::uniform_real_distribution.

PiperOrigin-RevId: 276158675

--
c60c9d11d24b0c546329d998e78e15a84b3153f5 by Abseil Team <absl-team@google.com>:

Internal change

PiperOrigin-RevId: 276126962

--
4c840cab6a8d86efa29b397cafaf7520eece68cc by Andy Soffer <asoffer@google.com>:

Update CMakeLists.txt to address https://github.com/abseil/abseil-cpp/issues/365.
This does not cover every platform, but it does at least address the
first-order issue of assuming gcc implies x86.

PiperOrigin-RevId: 276116253

--
98da366e6b5d51afe5d7ac6722126aca23d85ee6 by Abseil Team <absl-team@google.com>:

Internal change

PiperOrigin-RevId: 276097452
GitOrigin-RevId: e54b9c7bbb0c58475676c268e2e19c69f4bce48a
Change-Id: I02d84454bb71ab21ad3d39650acf6cc6e36f58d7

14 files changed, 304 insertions, 287 deletions

diff --git a/absl/random/BUILD.bazel b/absl/random/BUILD.bazel
index 828f134..c3520df 100644
--- a/absl/random/BUILD.bazel
+++ b/absl/random/BUILD.bazel
@@ -69,10 +69,10 @@ cc_library(
         "//absl/base:base_internal",
         "//absl/base:core_headers",
         "//absl/meta:type_traits",
-        "//absl/random/internal:distribution_impl",
         "//absl/random/internal:distributions",
         "//absl/random/internal:fast_uniform_bits",
         "//absl/random/internal:fastmath",
+        "//absl/random/internal:generate_real",
         "//absl/random/internal:iostream_state_saver",
         "//absl/random/internal:traits",
         "//absl/random/internal:uniform_helper",
diff --git a/absl/random/CMakeLists.txt b/absl/random/CMakeLists.txt
index 19dd2ca..289854f 100644
--- a/absl/random/CMakeLists.txt
+++ b/absl/random/CMakeLists.txt
@@ -58,7 +58,7 @@ absl_cc_library(
   DEPS
     absl::base_internal
     absl::core_headers
-    absl::random_internal_distribution_impl
+    absl::random_internal_generate_real
     absl::random_internal_distributions
     absl::random_internal_fast_uniform_bits
     absl::random_internal_fastmath
@@ -543,19 +543,18 @@ absl_cc_library(
 # Internal-only target, do not depend on directly.
 absl_cc_library(
   NAME
-    random_internal_distribution_impl
+    random_internal_generate_real
   HDRS
-    "internal/distribution_impl.h"
+    "internal/generate_real.h"
   COPTS
     ${ABSL_DEFAULT_COPTS}
   LINKOPTS
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
     absl::bits
-    absl::config
-    absl::int128
     absl::random_internal_fastmath
     absl::random_internal_traits
+    absl::type_traits
 )
 
 # Internal-only target, do not depend on directly.
@@ -767,9 +766,9 @@ absl_cc_test(
 # Internal-only target, do not depend on directly.
 absl_cc_test(
   NAME
-    random_internal_distribution_impl_test
+    random_internal_generate_real_test
   SRCS
-    "internal/distribution_impl_test.cc"
+    "internal/generate_real_test.cc"
   COPTS
     ${ABSL_TEST_COPTS}
   LINKOPTS
@@ -777,8 +776,7 @@ absl_cc_test(
   DEPS
     absl::bits
     absl::flags
-    absl::int128
-    absl::random_internal_distribution_impl
+    absl::random_internal_generate_real
     gtest_main
 )
 
@@ -1029,7 +1027,6 @@ absl_cc_library(
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
     absl::core_headers
-    absl::random_internal_distribution_impl
     absl::random_internal_fast_uniform_bits
     absl::random_internal_iostream_state_saver
     absl::random_internal_traits
diff --git a/absl/random/beta_distribution.h b/absl/random/beta_distribution.h
index e29894f..b09b02f 100644
--- a/absl/random/beta_distribution.h
+++ b/absl/random/beta_distribution.h
@@ -22,9 +22,10 @@
 #include <ostream>
 #include <type_traits>
 
-#include "absl/random/internal/distribution_impl.h"
+#include "absl/meta/type_traits.h"
 #include "absl/random/internal/fast_uniform_bits.h"
 #include "absl/random/internal/fastmath.h"
+#include "absl/random/internal/generate_real.h"
 #include "absl/random/internal/iostream_state_saver.h"
 
 namespace absl {
@@ -275,15 +276,21 @@ typename beta_distribution<RealType>::result_type
 beta_distribution<RealType>::AlgorithmJoehnk(
     URBG& g,  // NOLINT(runtime/references)
     const param_type& p) {
+  using random_internal::GeneratePositiveTag;
+  using random_internal::GenerateRealFromBits;
+  using real_type =
+      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+
   // Based on Joehnk, M. D. Erzeugung von betaverteilten und gammaverteilten
   // Zufallszahlen. Metrika 8.1 (1964): 5-15.
   // This method is described in Knuth, Vol 2 (Third Edition), pp 134.
-  using RandU64ToReal = typename random_internal::RandU64ToReal<result_type>;
-  using random_internal::PositiveValueT;
+
   result_type u, v, x, y, z;
   for (;;) {
-    u = RandU64ToReal::template Value<PositiveValueT, false>(fast_u64_(g));
-    v = RandU64ToReal::template Value<PositiveValueT, false>(fast_u64_(g));
+    u = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
+        fast_u64_(g));
+    v = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
+        fast_u64_(g));
 
     // Direct method. std::pow is slow for float, so rely on the optimizer to
     // remove the std::pow() path for that case.
@@ -327,12 +334,14 @@ typename beta_distribution<RealType>::result_type
 beta_distribution<RealType>::AlgorithmCheng(
     URBG& g,  // NOLINT(runtime/references)
     const param_type& p) {
+  using random_internal::GeneratePositiveTag;
+  using random_internal::GenerateRealFromBits;
+  using real_type =
+      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+
   // Based on Cheng, Russell CH. Generating beta variates with nonintegral
   // shape parameters. Communications of the ACM 21.4 (1978): 317-322.
   // (https://dl.acm.org/citation.cfm?id=359482).
-  using RandU64ToReal = typename random_internal::RandU64ToReal<result_type>;
-  using random_internal::PositiveValueT;
-
   static constexpr result_type kLogFour =
       result_type(1.3862943611198906188344642429163531361);  // log(4)
   static constexpr result_type kS =
@@ -341,8 +350,10 @@ beta_distribution<RealType>::AlgorithmCheng(
   const bool use_algorithm_ba = (p.method_ == param_type::CHENG_BA);
   result_type u1, u2, v, w, z, r, s, t, bw_inv, lhs;
   for (;;) {
-    u1 = RandU64ToReal::template Value<PositiveValueT, false>(fast_u64_(g));
-    u2 = RandU64ToReal::template Value<PositiveValueT, false>(fast_u64_(g));
+    u1 = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
+        fast_u64_(g));
+    u2 = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
+        fast_u64_(g));
     v = p.y_ * std::log(u1 / (1 - u1));
     w = p.a_ * std::exp(v);
     bw_inv = result_type(1) / (p.b_ + w);
diff --git a/absl/random/beta_distribution_test.cc b/absl/random/beta_distribution_test.cc
index 966ad08..d0111b3 100644
--- a/absl/random/beta_distribution_test.cc
+++ b/absl/random/beta_distribution_test.cc
@@ -92,7 +92,7 @@ TYPED_TEST(BetaDistributionInterfaceTest, SerializeTest) {
   for (TypeParam alpha : kValues) {
     for (TypeParam beta : kValues) {
       ABSL_INTERNAL_LOG(
-          INFO, absl::StrFormat("Smoke test for Beta(%f, %f)", alpha, beta));
+          INFO, absl::StrFormat("Smoke test for Beta(%a, %a)", alpha, beta));
 
       param_type param(alpha, beta);
       absl::beta_distribution<TypeParam> before(alpha, beta);
diff --git a/absl/random/exponential_distribution.h b/absl/random/exponential_distribution.h
index c8af197..24abf57 100644
--- a/absl/random/exponential_distribution.h
+++ b/absl/random/exponential_distribution.h
@@ -21,8 +21,9 @@
 #include <limits>
 #include <type_traits>
 
-#include "absl/random/internal/distribution_impl.h"
+#include "absl/meta/type_traits.h"
 #include "absl/random/internal/fast_uniform_bits.h"
+#include "absl/random/internal/generate_real.h"
 #include "absl/random/internal/iostream_state_saver.h"
 
 namespace absl {
@@ -118,9 +119,14 @@ typename exponential_distribution<RealType>::result_type
 exponential_distribution<RealType>::operator()(
     URBG& g,  // NOLINT(runtime/references)
     const param_type& p) {
-  using random_internal::NegativeValueT;
-  const result_type u = random_internal::RandU64ToReal<
-      result_type>::template Value<NegativeValueT, false>(fast_u64_(g));
+  using random_internal::GenerateNegativeTag;
+  using random_internal::GenerateRealFromBits;
+  using real_type =
+      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+
+  const result_type u = GenerateRealFromBits<real_type, GenerateNegativeTag,
+                                             false>(fast_u64_(g));  // U(-1, 0)
+
   // log1p(-x) is mathematically equivalent to log(1 - x) but has more
   // accuracy for x near zero.
   return p.neg_inv_lambda_ * std::log1p(u);
diff --git a/absl/random/gaussian_distribution.h b/absl/random/gaussian_distribution.h
index 1d1347b..c299e94 100644
--- a/absl/random/gaussian_distribution.h
+++ b/absl/random/gaussian_distribution.h
@@ -28,8 +28,8 @@
 #include <limits>
 #include <type_traits>
 
-#include "absl/random/internal/distribution_impl.h"
 #include "absl/random/internal/fast_uniform_bits.h"
+#include "absl/random/internal/generate_real.h"
 #include "absl/random/internal/iostream_state_saver.h"
 
 namespace absl {
@@ -207,12 +207,18 @@ namespace random_internal {
 
 template <typename URBG>
 inline double gaussian_distribution_base::zignor_fallback(URBG& g, bool neg) {
+  using random_internal::GeneratePositiveTag;
+  using random_internal::GenerateRealFromBits;
+
   // This fallback path happens approximately 0.05% of the time.
   double x, y;
   do {
     // kRInv = 1/r, U(0, 1)
-    x = kRInv * std::log(RandU64ToDouble<PositiveValueT, false>(fast_u64_(g)));
-    y = -std::log(RandU64ToDouble<PositiveValueT, false>(fast_u64_(g)));
+    x = kRInv *
+        std::log(GenerateRealFromBits<double, GeneratePositiveTag, false>(
+            fast_u64_(g)));
+    y = -std::log(
+        GenerateRealFromBits<double, GeneratePositiveTag, false>(fast_u64_(g)));
   } while ((y + y) < (x * x));
   return neg ? (x - kR) : (kR - x);
 }
@@ -220,6 +226,10 @@ inline double gaussian_distribution_base::zignor_fallback(URBG& g, bool neg) {
 template <typename URBG>
 inline double gaussian_distribution_base::zignor(
     URBG& g) {  // NOLINT(runtime/references)
+  using random_internal::GeneratePositiveTag;
+  using random_internal::GenerateRealFromBits;
+  using random_internal::GenerateSignedTag;
+
   while (true) {
     // We use a single uint64_t to generate both a double and a strip.
     // These bits are unused when the generated double is > 1/2^5.
@@ -227,7 +237,8 @@ inline double gaussian_distribution_base::zignor(
     // values (those smaller than 1/2^5, which all end up on the left tail).
     uint64_t bits = fast_u64_(g);
     int i = static_cast<int>(bits & kMask);  // pick a random strip
-    double j = RandU64ToDouble<SignedValueT, false>(bits);  // U(-1, 1)
+    double j = GenerateRealFromBits<double, GenerateSignedTag, false>(
+        bits);  // U(-1, 1)
     const double x = j * zg_.x[i];
 
     // Retangular box. Handles >97% of all cases.
@@ -244,7 +255,8 @@ inline double gaussian_distribution_base::zignor(
     }
 
     // i > 0: Wedge samples using precomputed values.
-    double v = RandU64ToDouble<PositiveValueT, false>(fast_u64_(g));  // U(0, 1)
+    double v = GenerateRealFromBits<double, GeneratePositiveTag, false>(
+        fast_u64_(g));  // U(0, 1)
     if ((zg_.f[i + 1] + v * (zg_.f[i] - zg_.f[i + 1])) <
         std::exp(-0.5 * x * x)) {
       return x;
diff --git a/absl/random/internal/BUILD.bazel b/absl/random/internal/BUILD.bazel
index ec58cec..91388d1 100644
--- a/absl/random/internal/BUILD.bazel
+++ b/absl/random/internal/BUILD.bazel
@@ -175,9 +175,9 @@ cc_library(
 )
 
 cc_library(
-    name = "distribution_impl",
+    name = "generate_real",
     hdrs = [
-        "distribution_impl.h",
+        "generate_real.h",
     ],
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
@@ -185,8 +185,7 @@ cc_library(
         ":fastmath",
         ":traits",
         "//absl/base:bits",
-        "//absl/base:config",
-        "//absl/numeric:int128",
+        "//absl/meta:type_traits",
     ],
 )
 
@@ -398,16 +397,17 @@ cc_test(
 )
 
 cc_test(
-    name = "distribution_impl_test",
+    name = "generate_real_test",
     size = "small",
-    srcs = ["distribution_impl_test.cc"],
+    srcs = [
+        "generate_real_test.cc",
+    ],
     copts = ABSL_TEST_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
-        ":distribution_impl",
+        ":generate_real",
         "//absl/base:bits",
         "//absl/flags:flag",
-        "//absl/numeric:int128",
         "@com_google_googletest//:gtest_main",
     ],
 )
diff --git a/absl/random/internal/distribution_impl.h b/absl/random/internal/distribution_impl.h
deleted file mode 100644
index 49b3e1a..0000000
--- a/absl/random/internal/distribution_impl.h
+++ /dev/null
@@ -1,194 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_RANDOM_INTERNAL_DISTRIBUTION_IMPL_H_
-#define ABSL_RANDOM_INTERNAL_DISTRIBUTION_IMPL_H_
-
-// This file contains some implementation details which are used by one or more
-// of the absl random number distributions.
-
-#include <cfloat>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <limits>
-#include <type_traits>
-
-#if (defined(_WIN32) || defined(_WIN64)) && defined(_M_IA64)
-#include <intrin.h>  // NOLINT(build/include_order)
-#pragma intrinsic(_umul128)
-#define ABSL_INTERNAL_USE_UMUL128 1
-#endif
-
-#include "absl/base/config.h"
-#include "absl/base/internal/bits.h"
-#include "absl/numeric/int128.h"
-#include "absl/random/internal/fastmath.h"
-#include "absl/random/internal/traits.h"
-
-namespace absl {
-namespace random_internal {
-
-// Creates a double from `bits`, with the template fields controlling the
-// output.
-//
-// RandU64To is both more efficient and generates more unique values in the
-// result interval than known implementations of std::generate_canonical().
-//
-// The `Signed` parameter controls whether positive, negative, or both are
-// returned (thus affecting the output interval).
-//   When Signed == SignedValueT, range is U(-1, 1)
-//   When Signed == NegativeValueT, range is U(-1, 0)
-//   When Signed == PositiveValueT, range is U(0, 1)
-//
-// When the `IncludeZero` parameter is true, the function may return 0 for some
-// inputs, otherwise it never returns 0.
-//
-// The `ExponentBias` parameter determines the scale of the output range by
-// adjusting the exponent.
-//
-// When a value in U(0,1) is required, use:
-//   RandU64ToDouble<PositiveValueT, true, 0>();
-//
-// When a value in U(-1,1) is required, use:
-//   RandU64ToDouble<SignedValueT, false, 0>() => U(-1, 1)
-// This generates more distinct values than the mathematically equivalent
-// expression `U(0, 1) * 2.0 - 1.0`, and is preferable.
-//
-// Scaling the result by powers of 2 (and avoiding a multiply) is also possible:
-//   RandU64ToDouble<PositiveValueT, false, 1>();  => U(0, 2)
-//   RandU64ToDouble<PositiveValueT, false, -1>();  => U(0, 0.5)
-//
-
-// Tristate types controlling the output.
-struct PositiveValueT {};
-struct NegativeValueT {};
-struct SignedValueT {};
-
-// RandU64ToDouble is the double-result variant of RandU64To, described above.
-template <typename Signed, bool IncludeZero, int ExponentBias = 0>
-inline double RandU64ToDouble(uint64_t bits) {
-  static_assert(std::is_same<Signed, PositiveValueT>::value ||
-                    std::is_same<Signed, NegativeValueT>::value ||
-                    std::is_same<Signed, SignedValueT>::value,
-                "");
-
-  // Maybe use the left-most bit for a sign bit.
-  uint64_t sign = std::is_same<Signed, NegativeValueT>::value
-                      ? 0x8000000000000000ull
-                      : 0;  // Sign bits.
-
-  if (std::is_same<Signed, SignedValueT>::value) {
-    sign = bits & 0x8000000000000000ull;
-    bits = bits & 0x7FFFFFFFFFFFFFFFull;
-  }
-  if (IncludeZero) {
-    if (bits == 0u) return 0;
-  }
-
-  // Number of leading zeros is mapped to the exponent: 2^-clz
-  int clz = base_internal::CountLeadingZeros64(bits);
-  // Shift number left to erase leading zeros.
-  bits <<= IncludeZero ? clz : (clz & 63);
-
-  // Shift number right to remove bits that overflow double mantissa.  The
-  // direction of the shift depends on `clz`.
-  bits >>= (64 - DBL_MANT_DIG);
-
-  // Compute IEEE 754 double exponent.
-  // In the Signed case, bits is a 63-bit number with a 0 msb.  Adjust the
-  // exponent to account for that.
-  const uint64_t exp =
-      (std::is_same<Signed, SignedValueT>::value ? 1023U : 1022U) +
-      static_cast<uint64_t>(ExponentBias - clz);
-  constexpr int kExp = DBL_MANT_DIG - 1;
-  // Construct IEEE 754 double from exponent and mantissa.
-  const uint64_t val = sign | (exp << kExp) | (bits & ((1ULL << kExp) - 1U));
-
-  double res;
-  static_assert(sizeof(res) == sizeof(val), "double is not 64 bit");
-  // Memcpy value from "val" to "res" to avoid aliasing problems.  Assumes that
-  // endian-ness is same for double and uint64_t.
-  std::memcpy(&res, &val, sizeof(res));
-
-  return res;
-}
-
-// RandU64ToFloat is the float-result variant of RandU64To, described above.
-template <typename Signed, bool IncludeZero, int ExponentBias = 0>
-inline float RandU64ToFloat(uint64_t bits) {
-  static_assert(std::is_same<Signed, PositiveValueT>::value ||
-                    std::is_same<Signed, NegativeValueT>::value ||
-                    std::is_same<Signed, SignedValueT>::value,
-                "");
-
-  // Maybe use the left-most bit for a sign bit.
-  uint64_t sign = std::is_same<Signed, NegativeValueT>::value
-                      ? 0x80000000ul
-                      : 0;  // Sign bits.
-
-  if (std::is_same<Signed, SignedValueT>::value) {
-    uint64_t a = bits & 0x8000000000000000ull;
-    sign = static_cast<uint32_t>(a >> 32);
-    bits = bits & 0x7FFFFFFFFFFFFFFFull;
-  }
-  if (IncludeZero) {
-    if (bits == 0u) return 0;
-  }
-
-  // Number of leading zeros is mapped to the exponent: 2^-clz
-  int clz = base_internal::CountLeadingZeros64(bits);
-  // Shift number left to erase leading zeros.
-  bits <<= IncludeZero ? clz : (clz & 63);
-  // Shift number right to remove bits that overflow double mantissa.  The
-  // direction of the shift depends on `clz`.
-  bits >>= (64 - FLT_MANT_DIG);
-
-  // Construct IEEE 754 float exponent.
-  // In the Signed case, bits is a 63-bit number with a 0 msb.  Adjust the
-  // exponent to account for that.
-  const uint32_t exp =
-      (std::is_same<Signed, SignedValueT>::value ? 127U : 126U) +
-      static_cast<uint32_t>(ExponentBias - clz);
-  constexpr int kExp = FLT_MANT_DIG - 1;
-  const uint32_t val = sign | (exp << kExp) | (bits & ((1U << kExp) - 1U));
-
-  float res;
-  static_assert(sizeof(res) == sizeof(val), "float is not 32 bit");
-  // Assumes that endian-ness is same for float and uint32_t.
-  std::memcpy(&res, &val, sizeof(res));
-
-  return res;
-}
-
-template <typename Result>
-struct RandU64ToReal {
-  template <typename Signed, bool IncludeZero, int ExponentBias = 0>
-  static inline Result Value(uint64_t bits) {
-    return RandU64ToDouble<Signed, IncludeZero, ExponentBias>(bits);
-  }
-};
-
-template <>
-struct RandU64ToReal<float> {
-  template <typename Signed, bool IncludeZero, int ExponentBias = 0>
-  static inline float Value(uint64_t bits) {
-    return RandU64ToFloat<Signed, IncludeZero, ExponentBias>(bits);
-  }
-};
-
-}  // namespace random_internal
-}  // namespace absl
-
-#endif  // ABSL_RANDOM_INTERNAL_DISTRIBUTION_IMPL_H_
diff --git a/absl/random/internal/generate_real.h b/absl/random/internal/generate_real.h
new file mode 100644
index 0000000..246d863
--- /dev/null
+++ b/absl/random/internal/generate_real.h
@@ -0,0 +1,144 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_RANDOM_INTERNAL_GENERATE_REAL_H_
+#define ABSL_RANDOM_INTERNAL_GENERATE_REAL_H_
+
+// This file contains some implementation details which are used by one or more
+// of the absl random number distributions.
+
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <type_traits>
+
+#include "absl/base/internal/bits.h"
+#include "absl/meta/type_traits.h"
+#include "absl/random/internal/fastmath.h"
+#include "absl/random/internal/traits.h"
+
+namespace absl {
+namespace random_internal {
+
+// Tristate tag types controlling the output of GenerateRealFromBits.
+struct GeneratePositiveTag {};
+struct GenerateNegativeTag {};
+struct GenerateSignedTag {};
+
+// GenerateRealFromBits generates a single real value from a single 64-bit
+// `bits` with template fields controlling the output.
+//
+// The `SignedTag` parameter controls whether positive, negative,
+// or either signed/unsigned may be returned.
+//   When SignedTag == GeneratePositiveTag, range is U(0, 1)
+//   When SignedTag == GenerateNegativeTag, range is U(-1, 0)
+//   When SignedTag == GenerateSignedTag, range is U(-1, 1)
+//
+// When the `IncludeZero` parameter is true, the function may return 0 for some
+// inputs, otherwise it never returns 0.
+//
+// When a value in U(0,1) is required, use:
+//   Uniform64ToReal<double, PositiveValueT, true>;
+//
+// When a value in U(-1,1) is required, use:
+//   Uniform64ToReal<double, SignedValueT, false>;
+//
+//   This generates more distinct values than the mathematical equivalent
+//   `U(0, 1) * 2.0 - 1.0`.
+//
+// Scaling the result by powers of 2 (and avoiding a multiply) is also possible:
+//   GenerateRealFromBits<double>(..., -1);  => U(0, 0.5)
+//   GenerateRealFromBits<double>(..., 1);   => U(0, 2)
+//
+template <typename RealType,  // Real type, either float or double.
+          typename SignedTag = GeneratePositiveTag,  // Whether a positive,
+                                                     // negative, or signed
+                                                     // value is generated.
+          bool IncludeZero = true>
+inline RealType GenerateRealFromBits(uint64_t bits, int exp_bias = 0) {
+  using real_type = RealType;
+  using uint_type = absl::conditional_t<std::is_same<real_type, float>::value,
+                                        uint32_t, uint64_t>;
+
+  static_assert(
+      (std::is_same<double, real_type>::value ||
+       std::is_same<float, real_type>::value),
+      "GenerateRealFromBits must be parameterized by either float or double.");
+
+  static_assert(sizeof(uint_type) == sizeof(real_type),
+                "Mismatched unsinged and real types.");
+
+  static_assert((std::numeric_limits<real_type>::is_iec559 &&
+                 std::numeric_limits<real_type>::radix == 2),
+                "RealType representation is not IEEE 754 binary.");
+
+  static_assert((std::is_same<SignedTag, GeneratePositiveTag>::value ||
+                 std::is_same<SignedTag, GenerateNegativeTag>::value ||
+                 std::is_same<SignedTag, GenerateSignedTag>::value),
+                "");
+
+  static constexpr int kExp = std::numeric_limits<real_type>::digits - 1;
+  static constexpr uint_type kMask = (static_cast<uint_type>(1) << kExp) - 1u;
+  static constexpr int kUintBits = sizeof(uint_type) * 8;
+
+  int exp = exp_bias + int{std::numeric_limits<real_type>::max_exponent - 2};
+
+  // Determine the sign bit.
+  // Depending on the SignedTag, this may use the left-most bit
+  // or it may be a constant value.
+  uint_type sign = std::is_same<SignedTag, GenerateNegativeTag>::value
+                       ? (static_cast<uint_type>(1) << (kUintBits - 1))
+                       : 0;
+  if (std::is_same<SignedTag, GenerateSignedTag>::value) {
+    if (std::is_same<uint_type, uint64_t>::value) {
+      sign = bits & uint64_t{0x8000000000000000};
+    }
+    if (std::is_same<uint_type, uint32_t>::value) {
+      const uint64_t tmp = bits & uint64_t{0x8000000000000000};
+      sign = static_cast<uint32_t>(tmp >> 32);
+    }
+    // adjust the bits and the exponent to account for removing
+    // the leading bit.
+    bits = bits & uint64_t{0x7FFFFFFFFFFFFFFF};
+    exp++;
+  }
+  if (IncludeZero) {
+    if (bits == 0u) return 0;
+  }
+
+  // Number of leading zeros is mapped to the exponent: 2^-clz
+  // bits is 0..01xxxxxx. After shifting, we're left with 1xxx...0..0
+  int clz = base_internal::CountLeadingZeros64(bits);
+  bits <<= (IncludeZero ? clz : (clz & 63));  // remove 0-bits.
+  exp -= clz;                                 // set the exponent.
+  bits >>= (63 - kExp);
+
+  // Construct the 32-bit or 64-bit IEEE 754 floating-point value from
+  // the individual fields: sign, exp, mantissa(bits).
+  uint_type val =
+      (std::is_same<SignedTag, GeneratePositiveTag>::value ? 0u : sign) |
+      (static_cast<uint_type>(exp) << kExp) |
+      (static_cast<uint_type>(bits) & kMask);
+
+  // bit_cast to the output-type
+  real_type result;
+  memcpy(static_cast<void*>(&result), static_cast<const void*>(&val),
+         sizeof(result));
+  return result;
+}
+
+}  // namespace random_internal
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_GENERATE_REAL_H_
diff --git a/absl/random/internal/distribution_impl_test.cc b/absl/random/internal/generate_real_test.cc
index fcc1690..aa02f0c 100644
--- a/absl/random/internal/distribution_impl_test.cc
+++ b/absl/random/internal/generate_real_test.cc
@@ -12,57 +12,74 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "absl/random/internal/distribution_impl.h"
+#include "absl/random/internal/generate_real.h"
+
+#include <cfloat>
+#include <cstddef>
+#include <cstdint>
+#include <string>
 
 #include "gtest/gtest.h"
 #include "absl/base/internal/bits.h"
 #include "absl/flags/flag.h"
-#include "absl/numeric/int128.h"
 
 ABSL_FLAG(int64_t, absl_random_test_trials, 50000,
           "Number of trials for the probability tests.");
 
-using absl::random_internal::NegativeValueT;
-using absl::random_internal::PositiveValueT;
-using absl::random_internal::RandU64ToDouble;
-using absl::random_internal::RandU64ToFloat;
-using absl::random_internal::SignedValueT;
+using absl::random_internal::GenerateNegativeTag;
+using absl::random_internal::GeneratePositiveTag;
+using absl::random_internal::GenerateRealFromBits;
+using absl::random_internal::GenerateSignedTag;
 
 namespace {
 
-TEST(DistributionImplTest, U64ToFloat_Positive_NoZero_Test) {
+TEST(GenerateRealTest, U64ToFloat_Positive_NoZero_Test) {
   auto ToFloat = [](uint64_t a) {
-    return RandU64ToFloat<PositiveValueT, false>(a);
+    return GenerateRealFromBits<float, GeneratePositiveTag, false>(a);
   };
   EXPECT_EQ(ToFloat(0x0000000000000000), 2.710505431e-20f);
   EXPECT_EQ(ToFloat(0x0000000000000001), 5.421010862e-20f);
   EXPECT_EQ(ToFloat(0x8000000000000000), 0.5);
+  EXPECT_EQ(ToFloat(0x8000000000000001), 0.5);
   EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), 0.9999999404f);
 }
 
-TEST(DistributionImplTest, U64ToFloat_Positive_Zero_Test) {
+TEST(GenerateRealTest, U64ToFloat_Positive_Zero_Test) {
   auto ToFloat = [](uint64_t a) {
-    return RandU64ToFloat<PositiveValueT, true>(a);
+    return GenerateRealFromBits<float, GeneratePositiveTag, true>(a);
   };
   EXPECT_EQ(ToFloat(0x0000000000000000), 0.0);
   EXPECT_EQ(ToFloat(0x0000000000000001), 5.421010862e-20f);
   EXPECT_EQ(ToFloat(0x8000000000000000), 0.5);
+  EXPECT_EQ(ToFloat(0x8000000000000001), 0.5);
   EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), 0.9999999404f);
 }
 
-TEST(DistributionImplTest, U64ToFloat_Negative_NoZero_Test) {
+TEST(GenerateRealTest, U64ToFloat_Negative_NoZero_Test) {
   auto ToFloat = [](uint64_t a) {
-    return RandU64ToFloat<NegativeValueT, false>(a);
+    return GenerateRealFromBits<float, GenerateNegativeTag, false>(a);
   };
   EXPECT_EQ(ToFloat(0x0000000000000000), -2.710505431e-20f);
   EXPECT_EQ(ToFloat(0x0000000000000001), -5.421010862e-20f);
   EXPECT_EQ(ToFloat(0x8000000000000000), -0.5);
+  EXPECT_EQ(ToFloat(0x8000000000000001), -0.5);
   EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), -0.9999999404f);
 }
 
-TEST(DistributionImplTest, U64ToFloat_Signed_NoZero_Test) {
+TEST(GenerateRealTest, U64ToFloat_Negative_Zero_Test) {
   auto ToFloat = [](uint64_t a) {
-    return RandU64ToFloat<SignedValueT, false>(a);
+    return GenerateRealFromBits<float, GenerateNegativeTag, true>(a);
+  };
+  EXPECT_EQ(ToFloat(0x0000000000000000), 0.0);
+  EXPECT_EQ(ToFloat(0x0000000000000001), -5.421010862e-20f);
+  EXPECT_EQ(ToFloat(0x8000000000000000), -0.5);
+  EXPECT_EQ(ToFloat(0x8000000000000001), -0.5);
+  EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), -0.9999999404f);
+}
+
+TEST(GenerateRealTest, U64ToFloat_Signed_NoZero_Test) {
+  auto ToFloat = [](uint64_t a) {
+    return GenerateRealFromBits<float, GenerateSignedTag, false>(a);
   };
   EXPECT_EQ(ToFloat(0x0000000000000000), 5.421010862e-20f);
   EXPECT_EQ(ToFloat(0x0000000000000001), 1.084202172e-19f);
@@ -72,9 +89,9 @@ TEST(DistributionImplTest, U64ToFloat_Signed_NoZero_Test) {
   EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), -0.9999999404f);
 }
 
-TEST(DistributionImplTest, U64ToFloat_Signed_Zero_Test) {
+TEST(GenerateRealTest, U64ToFloat_Signed_Zero_Test) {
   auto ToFloat = [](uint64_t a) {
-    return RandU64ToFloat<SignedValueT, true>(a);
+    return GenerateRealFromBits<float, GenerateSignedTag, true>(a);
   };
   EXPECT_EQ(ToFloat(0x0000000000000000), 0);
   EXPECT_EQ(ToFloat(0x0000000000000001), 1.084202172e-19f);
@@ -84,9 +101,9 @@ TEST(DistributionImplTest, U64ToFloat_Signed_Zero_Test) {
   EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), -0.9999999404f);
 }
 
-TEST(DistributionImplTest, U64ToFloat_Signed_Bias_Test) {
+TEST(GenerateRealTest, U64ToFloat_Signed_Bias_Test) {
   auto ToFloat = [](uint64_t a) {
-    return RandU64ToFloat<SignedValueT, true, 1>(a);
+    return GenerateRealFromBits<float, GenerateSignedTag, true>(a, 1);
   };
   EXPECT_EQ(ToFloat(0x0000000000000000), 0);
   EXPECT_EQ(ToFloat(0x0000000000000001), 2 * 1.084202172e-19f);
@@ -96,9 +113,9 @@ TEST(DistributionImplTest, U64ToFloat_Signed_Bias_Test) {
   EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), 2 * -0.9999999404f);
 }
 
-TEST(DistributionImplTest, U64ToFloatTest) {
+TEST(GenerateRealTest, U64ToFloatTest) {
   auto ToFloat = [](uint64_t a) -> float {
-    return RandU64ToFloat<PositiveValueT, true>(a);
+    return GenerateRealFromBits<float, GeneratePositiveTag, true>(a);
   };
 
   EXPECT_EQ(ToFloat(0x0000000000000000), 0.0f);
@@ -150,44 +167,60 @@ TEST(DistributionImplTest, U64ToFloatTest) {
   }
 }
 
-TEST(DistributionImplTest, U64ToDouble_Positive_NoZero_Test) {
+TEST(GenerateRealTest, U64ToDouble_Positive_NoZero_Test) {
   auto ToDouble = [](uint64_t a) {
-    return RandU64ToDouble<PositiveValueT, false>(a);
+    return GenerateRealFromBits<double, GeneratePositiveTag, false>(a);
   };
 
   EXPECT_EQ(ToDouble(0x0000000000000000), 2.710505431213761085e-20);
   EXPECT_EQ(ToDouble(0x0000000000000001), 5.42101086242752217004e-20);
   EXPECT_EQ(ToDouble(0x0000000000000002), 1.084202172485504434e-19);
   EXPECT_EQ(ToDouble(0x8000000000000000), 0.5);
+  EXPECT_EQ(ToDouble(0x8000000000000001), 0.5);
   EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), 0.999999999999999888978);
 }
 
-TEST(DistributionImplTest, U64ToDouble_Positive_Zero_Test) {
+TEST(GenerateRealTest, U64ToDouble_Positive_Zero_Test) {
   auto ToDouble = [](uint64_t a) {
-    return RandU64ToDouble<PositiveValueT, true>(a);
+    return GenerateRealFromBits<double, GeneratePositiveTag, true>(a);
   };
 
   EXPECT_EQ(ToDouble(0x0000000000000000), 0.0);
   EXPECT_EQ(ToDouble(0x0000000000000001), 5.42101086242752217004e-20);
   EXPECT_EQ(ToDouble(0x8000000000000000), 0.5);
+  EXPECT_EQ(ToDouble(0x8000000000000001), 0.5);
   EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), 0.999999999999999888978);
 }
 
-TEST(DistributionImplTest, U64ToDouble_Negative_NoZero_Test) {
+TEST(GenerateRealTest, U64ToDouble_Negative_NoZero_Test) {
   auto ToDouble = [](uint64_t a) {
-    return RandU64ToDouble<NegativeValueT, false>(a);
+    return GenerateRealFromBits<double, GenerateNegativeTag, false>(a);
   };
 
   EXPECT_EQ(ToDouble(0x0000000000000000), -2.710505431213761085e-20);
   EXPECT_EQ(ToDouble(0x0000000000000001), -5.42101086242752217004e-20);
   EXPECT_EQ(ToDouble(0x0000000000000002), -1.084202172485504434e-19);
   EXPECT_EQ(ToDouble(0x8000000000000000), -0.5);
+  EXPECT_EQ(ToDouble(0x8000000000000001), -0.5);
+  EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), -0.999999999999999888978);
+}
+
+TEST(GenerateRealTest, U64ToDouble_Negative_Zero_Test) {
+  auto ToDouble = [](uint64_t a) {
+    return GenerateRealFromBits<double, GenerateNegativeTag, true>(a);
+  };
+
+  EXPECT_EQ(ToDouble(0x0000000000000000), 0.0);
+  EXPECT_EQ(ToDouble(0x0000000000000001), -5.42101086242752217004e-20);
+  EXPECT_EQ(ToDouble(0x0000000000000002), -1.084202172485504434e-19);
+  EXPECT_EQ(ToDouble(0x8000000000000000), -0.5);
+  EXPECT_EQ(ToDouble(0x8000000000000001), -0.5);
   EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), -0.999999999999999888978);
 }
 
-TEST(DistributionImplTest, U64ToDouble_Signed_NoZero_Test) {
+TEST(GenerateRealTest, U64ToDouble_Signed_NoZero_Test) {
   auto ToDouble = [](uint64_t a) {
-    return RandU64ToDouble<SignedValueT, false>(a);
+    return GenerateRealFromBits<double, GenerateSignedTag, false>(a);
   };
 
   EXPECT_EQ(ToDouble(0x0000000000000000), 5.42101086242752217004e-20);
@@ -198,9 +231,9 @@ TEST(DistributionImplTest, U64ToDouble_Signed_NoZero_Test) {
   EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), -0.999999999999999888978);
 }
 
-TEST(DistributionImplTest, U64ToDouble_Signed_Zero_Test) {
+TEST(GenerateRealTest, U64ToDouble_Signed_Zero_Test) {
   auto ToDouble = [](uint64_t a) {
-    return RandU64ToDouble<SignedValueT, true>(a);
+    return GenerateRealFromBits<double, GenerateSignedTag, true>(a);
   };
   EXPECT_EQ(ToDouble(0x0000000000000000), 0);
   EXPECT_EQ(ToDouble(0x0000000000000001), 1.084202172485504434e-19);
@@ -210,9 +243,9 @@ TEST(DistributionImplTest, U64ToDouble_Signed_Zero_Test) {
   EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), -0.999999999999999888978);
 }
 
-TEST(DistributionImplTest, U64ToDouble_Signed_Bias_Test) {
+TEST(GenerateRealTest, U64ToDouble_GenerateSignedTag_Bias_Test) {
   auto ToDouble = [](uint64_t a) {
-    return RandU64ToDouble<SignedValueT, true, -1>(a);
+    return GenerateRealFromBits<double, GenerateSignedTag, true>(a, -1);
   };
   EXPECT_EQ(ToDouble(0x0000000000000000), 0);
   EXPECT_EQ(ToDouble(0x0000000000000001), 1.084202172485504434e-19 / 2);
@@ -222,9 +255,9 @@ TEST(DistributionImplTest, U64ToDouble_Signed_Bias_Test) {
   EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), -0.999999999999999888978 / 2);
 }
 
-TEST(DistributionImplTest, U64ToDoubleTest) {
+TEST(GenerateRealTest, U64ToDoubleTest) {
   auto ToDouble = [](uint64_t a) {
-    return RandU64ToDouble<PositiveValueT, true>(a);
+    return GenerateRealFromBits<double, GeneratePositiveTag, true>(a);
   };
 
   EXPECT_EQ(ToDouble(0x0000000000000000), 0.0);
@@ -296,9 +329,9 @@ TEST(DistributionImplTest, U64ToDoubleTest) {
   }
 }
 
-TEST(DistributionImplTest, U64ToDoubleSignedTest) {
+TEST(GenerateRealTest, U64ToDoubleSignedTest) {
   auto ToDouble = [](uint64_t a) {
-    return RandU64ToDouble<SignedValueT, false>(a);
+    return GenerateRealFromBits<double, GenerateSignedTag, false>(a);
   };
 
   EXPECT_EQ(ToDouble(0x0000000000000000), 5.42101086242752217004e-20);
@@ -379,10 +412,10 @@ TEST(DistributionImplTest, U64ToDoubleSignedTest) {
   }
 }
 
-TEST(DistributionImplTest, ExhaustiveFloat) {
+TEST(GenerateRealTest, ExhaustiveFloat) {
   using absl::base_internal::CountLeadingZeros64;
   auto ToFloat = [](uint64_t a) {
-    return RandU64ToFloat<PositiveValueT, true>(a);
+    return GenerateRealFromBits<float, GeneratePositiveTag, true>(a);
   };
 
   // Rely on RandU64ToFloat generating values from greatest to least when
diff --git a/absl/random/log_uniform_int_distribution.h b/absl/random/log_uniform_int_distribution.h
index ac43416..956a690 100644
--- a/absl/random/log_uniform_int_distribution.h
+++ b/absl/random/log_uniform_int_distribution.h
@@ -23,8 +23,8 @@
 #include <ostream>
 #include <type_traits>
 
-#include "absl/random/internal/distribution_impl.h"
 #include "absl/random/internal/fastmath.h"
+#include "absl/random/internal/generate_real.h"
 #include "absl/random/internal/iostream_state_saver.h"
 #include "absl/random/internal/traits.h"
 #include "absl/random/uniform_int_distribution.h"
diff --git a/absl/random/poisson_distribution.h b/absl/random/poisson_distribution.h
index 7750b1c..23a953f 100644
--- a/absl/random/poisson_distribution.h
+++ b/absl/random/poisson_distribution.h
@@ -22,9 +22,9 @@
 #include <ostream>
 #include <type_traits>
 
-#include "absl/random/internal/distribution_impl.h"
 #include "absl/random/internal/fast_uniform_bits.h"
 #include "absl/random/internal/fastmath.h"
+#include "absl/random/internal/generate_real.h"
 #include "absl/random/internal/iostream_state_saver.h"
 
 namespace absl {
@@ -164,9 +164,9 @@ typename poisson_distribution<IntType>::result_type
 poisson_distribution<IntType>::operator()(
     URBG& g,  // NOLINT(runtime/references)
     const param_type& p) {
-  using random_internal::PositiveValueT;
-  using random_internal::RandU64ToDouble;
-  using random_internal::SignedValueT;
+  using random_internal::GeneratePositiveTag;
+  using random_internal::GenerateRealFromBits;
+  using random_internal::GenerateSignedTag;
 
   if (p.split_ != 0) {
     // Use Knuth's algorithm with range splitting to avoid floating-point
@@ -186,7 +186,8 @@ poisson_distribution<IntType>::operator()(
     for (int split = p.split_; split > 0; --split) {
       double r = 1.0;
       do {
-        r *= RandU64ToDouble<PositiveValueT, true>(fast_u64_(g));
+        r *= GenerateRealFromBits<double, GeneratePositiveTag, true>(
+            fast_u64_(g));  // U(-1, 0)
         ++n;
       } while (r > p.emu_);
       --n;
@@ -205,10 +206,11 @@ poisson_distribution<IntType>::operator()(
   // and k = max(f).
   const double a = p.mean_ + 0.5;
   for (;;) {
-    const double u =
-        RandU64ToDouble<PositiveValueT, false>(fast_u64_(g));  // (0, 1)
-    const double v =
-        RandU64ToDouble<SignedValueT, false>(fast_u64_(g));  // (-1, 1)
+    const double u = GenerateRealFromBits<double, GeneratePositiveTag, false>(
+        fast_u64_(g));  // U(0, 1)
+    const double v = GenerateRealFromBits<double, GenerateSignedTag, false>(
+        fast_u64_(g));  // U(-1, 1)
+
     const double x = std::floor(p.s_ * v / u + a);
     if (x < 0) continue;  // f(negative) = 0
     const double rhs = x * p.lmu_;
diff --git a/absl/random/uniform_int_distribution.h b/absl/random/uniform_int_distribution.h
index 02aa376..dc8ba8c 100644
--- a/absl/random/uniform_int_distribution.h
+++ b/absl/random/uniform_int_distribution.h
@@ -34,7 +34,6 @@
 #include <type_traits>
 
 #include "absl/base/optimization.h"
-#include "absl/random/internal/distribution_impl.h"
 #include "absl/random/internal/fast_uniform_bits.h"
 #include "absl/random/internal/iostream_state_saver.h"
 #include "absl/random/internal/traits.h"
diff --git a/absl/random/uniform_real_distribution.h b/absl/random/uniform_real_distribution.h
index 336abb3..bf2ed2c 100644
--- a/absl/random/uniform_real_distribution.h
+++ b/absl/random/uniform_real_distribution.h
@@ -39,8 +39,9 @@
 #include <limits>
 #include <type_traits>
 
-#include "absl/random/internal/distribution_impl.h"
+#include "absl/meta/type_traits.h"
 #include "absl/random/internal/fast_uniform_bits.h"
+#include "absl/random/internal/generate_real.h"
 #include "absl/random/internal/iostream_state_saver.h"
 
 namespace absl {
@@ -76,6 +77,7 @@ class uniform_real_distribution {
       // is not possible, so value generation cannot use the full range of the
       // real type.
       assert(range_ <= (std::numeric_limits<result_type>::max)());
+      assert(std::isfinite(range_));
     }
 
     result_type a() const { return lo_; }
@@ -151,10 +153,15 @@ template <typename URBG>
 typename uniform_real_distribution<RealType>::result_type
 uniform_real_distribution<RealType>::operator()(
     URBG& gen, const param_type& p) {  // NOLINT(runtime/references)
-  using random_internal::PositiveValueT;
+  using random_internal::GeneratePositiveTag;
+  using random_internal::GenerateRealFromBits;
+  using real_type =
+      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+
   while (true) {
-    const result_type sample = random_internal::RandU64ToReal<
-        result_type>::template Value<PositiveValueT, true>(fast_u64_(gen));
+    const result_type sample =
+        GenerateRealFromBits<real_type, GeneratePositiveTag, true>(
+            fast_u64_(gen));
     const result_type res = p.a() + (sample * p.range_);
     if (res < p.b() || p.range_ <= 0 || !std::isfinite(p.range_)) {
       return res;