Export of internal Abseil changes

--
d447fdcb801036cf08197eece193a5a706661120 by Gennadiy Rozental <rogeeff@google.com>:

Eliminate the need for static function holding help message. This decreases the cost of ABSL_FLAG abstraction by 120 bytes under clang.

PiperOrigin-RevId: 281107806

--
0aa6b91189f0e8b2381438c33465673a7ae02487 by Derek Mauro <dmauro@google.com>:

Disable the weak symbol CCTZ extension in the time test_util
on MinGW, which does not support it.

PiperOrigin-RevId: 280719769

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

Tune PeriodicSampler implementation (for internal-use only)

PiperOrigin-RevId: 280708943

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

Clean up public headers not to have warnings for "-Wcomma"

PiperOrigin-RevId: 280695373

--
981acd1ef3b13a83a84f04f11c8931f4ed4451c9 by Matthew Brown <matthewbr@google.com>:

Release absl::int128.

PiperOrigin-RevId: 280690817

--
d30fae9d2ec30b81322d2eb5afe7e13e45b4b422 by Derek Mauro <dmauro@google.com>:

Fix -Wundef warnings in random platform detection

PiperOrigin-RevId: 280669598
GitOrigin-RevId: d447fdcb801036cf08197eece193a5a706661120
Change-Id: Ie5e10e567c54b7de211833607689f233d4ddf734

1 files changed, 79 insertions, 10 deletions

diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h
index ce0ccf2d31d2..d79902543a22 100644
--- a/absl/flags/internal/flag.h
+++ b/absl/flags/internal/flag.h
@@ -61,6 +61,68 @@ class FlagState : public flags_internal::FlagStateInterface {
   int64_t counter_;
 };
 
+// This is help argument for absl::Flag encapsulating the string literal pointer
+// or pointer to function generating it as well as enum descriminating two
+// cases.
+using HelpGenFunc = std::string (*)();
+
+union FlagHelpSrc {
+  constexpr explicit FlagHelpSrc(const char* help_msg) : literal(help_msg) {}
+  constexpr explicit FlagHelpSrc(HelpGenFunc help_gen) : gen_func(help_gen) {}
+
+  const char* literal;
+  HelpGenFunc gen_func;
+};
+
+enum class FlagHelpSrcKind : int8_t { kLiteral, kGenFunc };
+
+struct HelpInitArg {
+  FlagHelpSrc source;
+  FlagHelpSrcKind kind;
+};
+
+// HelpConstexprWrap is used by struct AbslFlagHelpGenFor##name generated by
+// ABSL_FLAG macro. It is only used to silence the compiler in the case where
+// help message expression is not constexpr and does not have type const char*.
+// If help message expression is indeed constexpr const char* HelpConstexprWrap
+// is just a trivial identity function.
+template <typename T>
+const char* HelpConstexprWrap(const T&) {
+  return nullptr;
+}
+constexpr const char* HelpConstexprWrap(const char* p) { return p; }
+constexpr const char* HelpConstexprWrap(char* p) { return p; }
+
+// These two HelpArg overloads allows us to select at compile time one of two
+// way to pass Help argument to absl::Flag. We'll be passing
+// AbslFlagHelpGenFor##name as T and integer 0 as a single argument to prefer
+// first overload if possible. If T::Const is evaluatable on constexpr
+// context (see non template int parameter below) we'll choose first overload.
+// In this case the help message expression is immediately evaluated and is used
+// to construct the absl::Flag. No additionl code is generated by ABSL_FLAG.
+// Otherwise SFINAE kicks in and first overload is dropped from the
+// consideration, in which case the second overload will be used. The second
+// overload does not attempt to evaluate the help message expression
+// immediately and instead delays the evaluation by returing the function
+// pointer (&T::NonConst) genering the help message when necessary. This is
+// evaluatable in constexpr context, but the cost is an extra function being
+// generated in the ABSL_FLAG code.
+template <typename T, int = (T::Const(), 1)>
+constexpr flags_internal::HelpInitArg HelpArg(int) {
+  return {flags_internal::FlagHelpSrc(T::Const()),
+          flags_internal::FlagHelpSrcKind::kLiteral};
+}
+
+template <typename T>
+constexpr flags_internal::HelpInitArg HelpArg(char) {
+  return {flags_internal::FlagHelpSrc(&T::NonConst),
+          flags_internal::FlagHelpSrcKind::kGenFunc};
+}
+
+// Signature for the function generating the initial flag value based (usually
+// based on default value supplied in flag's definition)
+using InitialValGenFunc = void* (*)();
+
 // Signature for the mutation callback used by watched Flags
 // The callback is noexcept.
 // TODO(rogeeff): add noexcept after C++17 support is added.
@@ -74,15 +136,19 @@ class FlagImpl {
  public:
   constexpr FlagImpl(const flags_internal::FlagOpFn op,
                      const flags_internal::FlagMarshallingOpFn marshalling_op,
-                     const flags_internal::InitialValGenFunc initial_value_gen)
+                     const flags_internal::InitialValGenFunc initial_value_gen,
+                     const HelpInitArg help)
       : op_(op),
         marshalling_op_(marshalling_op),
-        initial_value_gen_(initial_value_gen) {}
+        initial_value_gen_(initial_value_gen),
+        help_(help.source),
+        help_source_kind_(help.kind) {}
 
   // Forces destruction of the Flag's data.
   void Destroy() const;
 
   // Constant access methods
+  std::string Help() const;
   bool IsModified() const ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
   bool IsSpecifiedOnCommandLine() const ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
   std::string DefaultValue() const ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
@@ -149,9 +215,12 @@ class FlagImpl {
   absl::Mutex* DataGuard() const ABSL_LOCK_RETURNED(locks_->primary_mu);
 
   // Immutable Flag's data.
-  const FlagOpFn op_;                          // Type-specific handler
-  const FlagMarshallingOpFn marshalling_op_;   // Marshalling ops handler
-  const InitialValGenFunc initial_value_gen_;  // Makes flag's initial value
+  const FlagOpFn op_;                          // Type-specific handler.
+  const FlagMarshallingOpFn marshalling_op_;   // Marshalling ops handler.
+  const InitialValGenFunc initial_value_gen_;  // Makes flag's initial value.
+  const FlagHelpSrc help_;  // Help message literal or function to generate it.
+  // Indicates if help message was supplied as literal or generator func.
+  const FlagHelpSrcKind help_source_kind_;
 
   // Mutable Flag's data. (guarded by locks_->primary_mu).
   // Indicates that locks_, cur_ and def_ fields have been lazily initialized.
@@ -191,14 +260,13 @@ class FlagImpl {
 template <typename T>
 class Flag final : public flags_internal::CommandLineFlag {
  public:
-  constexpr Flag(const char* name, const flags_internal::HelpGenFunc help_gen,
+  constexpr Flag(const char* name, const flags_internal::HelpInitArg help,
                  const char* filename,
                  const flags_internal::FlagMarshallingOpFn marshalling_op,
                  const flags_internal::InitialValGenFunc initial_value_gen)
-      : flags_internal::CommandLineFlag(
-            name, flags_internal::HelpText::FromFunctionPointer(help_gen),
-            filename),
-        impl_(&flags_internal::FlagOps<T>, marshalling_op, initial_value_gen) {}
+      : flags_internal::CommandLineFlag(name, filename),
+        impl_(&flags_internal::FlagOps<T>, marshalling_op, initial_value_gen,
+              help) {}
 
   T Get() const {
     // See implementation notes in CommandLineFlag::Get().
@@ -222,6 +290,7 @@ class Flag final : public flags_internal::CommandLineFlag {
   }
 
   // CommandLineFlag interface
+  std::string Help() const override { return impl_.Help(); }
   bool IsModified() const override { return impl_.IsModified(); }
   bool IsSpecifiedOnCommandLine() const override {
     return impl_.IsSpecifiedOnCommandLine();