Export of internal Abseil changes

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

absl::random compiles (at least for some cases) with -Wconversion -Wsign-compare

PiperOrigin-RevId: 419595521

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

Annotate FlagImpl storage buffer

Flag type can contain legit uninitialized bits, e.g. padding.
When the code calls bit_cast as int64_t, it will contain those bits as well.
Then when we pass the int into the store it's UB for C++ and will be
reported by the new msan.

PiperOrigin-RevId: 418666492
GitOrigin-RevId: 620668e56950d7cfc39db2cd321adf265199ad77
Change-Id: Idd1190f5c98a0a13c4019f3d92cec0313822084c

absl/flags/BUILD.bazel

diff --git a/absl/flags/BUILD.bazel b/absl/flags/BUILD.bazel
index d20deab..020b791 100644
--- a/absl/flags/BUILD.bazel
+++ b/absl/flags/BUILD.bazel
@@ -204,6 +204,7 @@
         "//absl/base",
         "//absl/base:config",
         "//absl/base:core_headers",
+        "//absl/base:dynamic_annotations",
         "//absl/memory",
         "//absl/meta:type_traits",
         "//absl/strings",

absl/flags/CMakeLists.txt

diff --git a/absl/flags/CMakeLists.txt b/absl/flags/CMakeLists.txt
index 7f3298e..29c85ad 100644
--- a/absl/flags/CMakeLists.txt
+++ b/absl/flags/CMakeLists.txt
@@ -105,6 +105,7 @@
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
     absl::config
+    absl::dynamic_annotations
     absl::fast_type_id
 )
 

absl/flags/internal/flag.cc

diff --git a/absl/flags/internal/flag.cc b/absl/flags/internal/flag.cc
index 7102559..55892d7 100644
--- a/absl/flags/internal/flag.cc
+++ b/absl/flags/internal/flag.cc
@@ -30,6 +30,7 @@
 #include "absl/base/call_once.h"
 #include "absl/base/casts.h"
 #include "absl/base/config.h"
+#include "absl/base/dynamic_annotations.h"
 #include "absl/base/optimization.h"
 #include "absl/flags/config.h"
 #include "absl/flags/internal/commandlineflag.h"
@@ -160,6 +161,8 @@
         std::memcpy(buf.data() + Sizeof(op_), &initialized,
                     sizeof(initialized));
       }
+      // Type can contain valid uninitialized bits, e.g. padding.
+      ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buf.data(), buf.size());
       OneWordValue().store(absl::bit_cast<int64_t>(buf),
                            std::memory_order_release);
       break;

absl/random/bernoulli_distribution.h

diff --git a/absl/random/bernoulli_distribution.h b/absl/random/bernoulli_distribution.h
index 25bd0d5..d81b6ae 100644
--- a/absl/random/bernoulli_distribution.h
+++ b/absl/random/bernoulli_distribution.h
@@ -138,16 +138,16 @@
     // 64 bits.
     //
     // Second, `c` is constructed by first casting explicitly to a signed
-    // integer and then converting implicitly to an unsigned integer of the same
+    // integer and then casting explicitly to an unsigned integer of the same
     // size.  This is done because the hardware conversion instructions produce
     // signed integers from double; if taken as a uint64_t the conversion would
     // be wrong for doubles greater than 2^63 (not relevant in this use-case).
     // If converted directly to an unsigned integer, the compiler would end up
     // emitting code to handle such large values that are not relevant due to
     // the known bounds on `c`.  To avoid these extra instructions this
-    // implementation converts first to the signed type and then use the
-    // implicit conversion to unsigned (which is a no-op).
-    const uint64_t c = static_cast<int64_t>(p * kP32);
+    // implementation converts first to the signed type and then convert to
+    // unsigned (which is a no-op).
+    const uint64_t c = static_cast<uint64_t>(static_cast<int64_t>(p * kP32));
     const uint32_t v = fast_u32(g);
     // FAST PATH: this path fails with probability 1/2^32.  Note that simply
     // returning v <= c would approximate P very well (up to an absolute error