Split immutable flag metadata out of mutable FlagImpl state.

Nearly half of each 56-byte `absl::flags_internal::FlagImpl` in writable data consists of compile-time metadata that never changes at runtime, including the flag name, type operation handler, help source, and initial default value. Keeping those immutable fields inside each `absl::Flag` instance forces every process that mutates nearby variables on the same page to fault private copies of static metadata.

Extract the immutable metadata into a `FlagMeta` descriptor and leave only the descriptor pointer, mutex storage, initialization control, interned file ID, and atomic state byte in writable data. Separating constant metadata shrinks `FlagImpl` from 56 bytes to 32 bytes and scalar flags from 64 bytes to 40 bytes in writable data, preparing the descriptor layout for pointer-free read-only encodings in follow-up changes.

PiperOrigin-RevId: 1006216333
diff --git a/absl/flags/commandlineflag_test.cc b/absl/flags/commandlineflag_test.cc
index 35ce567..7faec3e 100644
--- a/absl/flags/commandlineflag_test.cc
+++ b/absl/flags/commandlineflag_test.cc
@@ -256,15 +256,20 @@
                                             flags::FlagHelpKind::kLiteral};
 constexpr flags::FlagDefaultArg kCompatStringDefaultArg{
     flags::FlagDefaultSrc(&MakeEmptyString), flags::FlagDefaultKind::kGenFunc};
-constexpr absl::Flag<std::string> kCompat4ArgFlag{"compat4", "file",
-                                                  kCompatHelpArg,
-                                                  kCompatStringDefaultArg};
-constexpr absl::Flag<std::string> kCompat5ArgCommonFlag{
-    "compat5_common", "std::string", "file", kCompatHelpArg,
-    kCompatStringDefaultArg};
-constexpr absl::Flag<std::string> kCompat5ArgCustomFlag{
-    "compat5_custom", "UnlistedStringAlias", "file", kCompatHelpArg,
-    kCompatStringDefaultArg};
+constexpr flags::FlagMeta kCompatMeta = flags::MakeFlagMeta<std::string>(
+    "compat_meta", kCompatHelpArg, kCompatStringDefaultArg);
+constexpr absl::Flag<std::string> kCompatMetaFlag{&kCompatMeta.hdr};
+constexpr flags::FlagMeta kCompatCommonMeta = flags::MakeFlagMeta<std::string>(
+    flags::FlagNameArg{"compat_common_meta",
+                       flags::LookupCommonOrEmptyFlagTypeId("std::string")},
+    kCompatHelpArg, kCompatStringDefaultArg);
+constexpr absl::Flag<std::string> kCompatCommonMetaFlag{&kCompatCommonMeta.hdr};
+constexpr flags::FlagMeta kCompatCustomMeta = flags::MakeFlagMeta<std::string>(
+    flags::FlagNameArg{
+        "compat_custom_meta",
+        flags::LookupCommonOrEmptyFlagTypeId("UnlistedStringAlias")},
+    kCompatHelpArg, kCompatStringDefaultArg);
+constexpr absl::Flag<std::string> kCompatCustomMetaFlag{&kCompatCustomMeta.hdr};
 
 TEST_F(CommandLineFlagTest, TestTypeName) {
   EXPECT_EQ(flags::PrivateHandleAccessor::TypeName(
@@ -290,13 +295,13 @@
             "CustomFlagUDT");
 
   EXPECT_EQ(flags::PrivateHandleAccessor::TypeName(
-                absl::GetFlagReflectionHandle(kCompat4ArgFlag)),
+                absl::GetFlagReflectionHandle(kCompatMetaFlag)),
             "");
   EXPECT_EQ(flags::PrivateHandleAccessor::TypeName(
-                absl::GetFlagReflectionHandle(kCompat5ArgCommonFlag)),
+                absl::GetFlagReflectionHandle(kCompatCommonMetaFlag)),
             "std::string");
   EXPECT_EQ(flags::PrivateHandleAccessor::TypeName(
-                absl::GetFlagReflectionHandle(kCompat5ArgCustomFlag)),
+                absl::GetFlagReflectionHandle(kCompatCustomMetaFlag)),
             "");
 }
 
diff --git a/absl/flags/flag.h b/absl/flags/flag.h
index 7c789f8..66940e6 100644
--- a/absl/flags/flag.h
+++ b/absl/flags/flag.h
@@ -197,19 +197,20 @@
 
 // ABSL_FLAG_IMPL macro definition conditional on ABSL_FLAGS_STRIP_NAMES
 #define ABSL_FLAG_IMPL_FLAG_PTR(flag) flag
-#define ABSL_FLAG_IMPL_HELP_ARG(name)                      \
-  absl::flags_internal::HelpArg<AbslFlagHelpGenFor##name>( \
+#define ABSL_FLAG_IMPL_HELP_ARG(name)                        \
+  ::absl::flags_internal::HelpArg<AbslFlagHelpGenFor##name>( \
       FLAGS_help_storage_##name)
 #define ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name) \
-  absl::flags_internal::DefaultArg<Type, AbslFlagDefaultGenFor##name>(0)
+  (&AbslFlagLegacyMetaFor##name<Type, AbslFlagDefaultGenFor##name>::kMeta.hdr)
 
 #if ABSL_FLAGS_STRIP_NAMES
 #define ABSL_FLAG_IMPL_FLAGNAME(txt) ""
 #define ABSL_FLAG_IMPL_TYPENAME(txt) ""
 #define ABSL_FLAG_IMPL_FILENAME() ""
-#define ABSL_FLAG_IMPL_NAME_ARG(name) \
-  absl::flags_internal::FlagNameArg{"", absl::flags_internal::kEmptyFlagTypeId}
-#define ABSL_FLAG_IMPL_DECLARE_NAME_METHODS(name, Type)
+#define ABSL_FLAG_IMPL_DECLARE_NAME_METHODS(name, Type)                  \
+  static constexpr const char* AbslFlagName() { return ""; }             \
+  static constexpr ::absl::string_view AbslFlagTypeName() { return ""; } \
+  static constexpr const char* AbslFlagPackedNameAndType() { return "\0"; }
 #define ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                      \
   absl::flags_internal::FlagRegistrar<T, false>(ABSL_FLAG_IMPL_FLAG_PTR(flag), \
                                                 nullptr)
@@ -217,17 +218,13 @@
 #define ABSL_FLAG_IMPL_FLAGNAME(txt) txt
 #define ABSL_FLAG_IMPL_TYPENAME(txt) txt
 #define ABSL_FLAG_IMPL_FILENAME() __FILE__
-#define ABSL_FLAG_IMPL_NAME_ARG(name) \
-  absl::flags_internal::MakeFlagNameArg<AbslFlagDefaultGenFor##name>()
-#define ABSL_FLAG_IMPL_DECLARE_NAME_METHODS(name, Type)      \
-  static constexpr const char* AbslFlagName() {              \
-    return #name;                                            \
-  }                                                          \
-  static constexpr absl::string_view AbslFlagTypeName() {    \
-    return absl::string_view(#Type, sizeof(#Type) - 1);      \
-  }                                                          \
-  static constexpr const char* AbslFlagPackedNameAndType() { \
-    return #name "\0" #Type;                                 \
+#define ABSL_FLAG_IMPL_DECLARE_NAME_METHODS(name, Type)         \
+  static constexpr const char* AbslFlagName() { return #name; } \
+  static constexpr ::absl::string_view AbslFlagTypeName() {     \
+    return ::absl::string_view(#Type, sizeof(#Type) - 1);       \
+  }                                                             \
+  static constexpr const char* AbslFlagPackedNameAndType() {    \
+    return #name "\0" #Type;                                    \
   }
 #define ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                     \
   absl::flags_internal::FlagRegistrar<T, true>(ABSL_FLAG_IMPL_FLAG_PTR(flag), \
@@ -264,7 +261,16 @@
   };                                                                           \
   ABSL_ATTRIBUTE_SECTION_VARIABLE(flags_help_cold)                             \
   constexpr auto FLAGS_help_storage_##name ABSL_INTERNAL_UNIQUE_SMALL_NAME() = \
-      absl::flags_internal::HelpStringAsArray<AbslFlagHelpGenFor##name>(0);
+      absl::flags_internal::HelpStringAsArray<AbslFlagHelpGenFor##name>(0);    \
+  template <typename AbslFlagType, typename AbslFlagDefaultGen>                \
+  struct AbslFlagLegacyMetaFor##name {                                         \
+    static constexpr ::absl::flags_internal::FlagMeta kMeta =                  \
+        ::absl::flags_internal::MakeFlagMeta<AbslFlagType>(                    \
+            ::absl::flags_internal::MakeFlagNameArg<AbslFlagDefaultGen>(),     \
+            ABSL_FLAG_IMPL_HELP_ARG(name),                                     \
+            ::absl::flags_internal::DefaultArg<AbslFlagType,                   \
+                                               AbslFlagDefaultGen>(0));        \
+  };
 
 #define ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)     \
   struct AbslFlagDefaultGenFor##name {                                        \
@@ -275,21 +281,30 @@
     ABSL_FLAG_IMPL_DECLARE_NAME_METHODS(name, Type)                           \
   };
 
+#define ABSL_FLAG_IMPL_DECLARE_META_WRAPPER(name)                            \
+  template <typename AbslFlagType>                                           \
+  struct AbslFlagMetaFor##name {                                             \
+    static constexpr auto kMeta = ::absl::flags_internal::SelectFlagMeta<    \
+        AbslFlagType, AbslFlagDefaultGenFor##name, AbslFlagHelpGenFor##name, \
+        sizeof(ABSL_FLAG_IMPL_FLAGNAME(#name))>(                             \
+        ABSL_FLAG_IMPL_FLAGNAME(#name), FLAGS_help_storage_##name, 0);       \
+  };
+
 // ABSL_FLAG_IMPL
 //
 // Note: Name of registrar object is not arbitrary. It is used to "grab"
 // global name for FLAGS_no<flag_name> symbol, thus preventing the possibility
 // of defining two flags with names foo and nofoo.
-#define ABSL_FLAG_IMPL(Type, name, default_value, help)              \
-  extern ::absl::Flag<Type> FLAGS_##name;                            \
-  namespace absl /* block flags in namespaces */ {}                  \
-  ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)  \
-  ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help)                    \
-  ABSL_CONST_INIT absl::Flag<Type> FLAGS_##name{                     \
-      ABSL_FLAG_IMPL_NAME_ARG(name), ABSL_FLAG_IMPL_HELP_ARG(name),  \
-      ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name)};                       \
-  extern absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name;    \
-  absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name =          \
+#define ABSL_FLAG_IMPL(Type, name, default_value, help)             \
+  extern ::absl::Flag<Type> FLAGS_##name;                           \
+  namespace absl /* block flags in namespaces */ {}                 \
+  ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value) \
+  ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help)                   \
+  ABSL_FLAG_IMPL_DECLARE_META_WRAPPER(name)                         \
+  ABSL_CONST_INIT absl::Flag<Type> FLAGS_##name{                    \
+      &AbslFlagMetaFor##name<Type>::kMeta.hdr};                     \
+  extern absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name;   \
+  absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name =         \
       ABSL_FLAG_IMPL_REGISTRAR(Type, FLAGS_##name)
 
 // ABSL_RETIRED_FLAG
diff --git a/absl/flags/flag_test.cc b/absl/flags/flag_test.cc
index 199577e..851c541 100644
--- a/absl/flags/flag_test.cc
+++ b/absl/flags/flag_test.cc
@@ -142,11 +142,13 @@
   // small as possible because production binaries may define thousands of
   // flags.
   if (sizeof(void*) == 8) {
-    EXPECT_EQ(sizeof(flags::FlagImpl), 56);
-    EXPECT_EQ(sizeof(absl::Flag<bool>), 64);
-    EXPECT_EQ(sizeof(absl::Flag<int>), 64);
-    EXPECT_EQ(sizeof(absl::Flag<int64_t>), 64);
-    EXPECT_EQ(sizeof(absl::Flag<double>), 64);
+    EXPECT_EQ(sizeof(flags::FlagImpl), 32);
+    EXPECT_EQ(sizeof(flags::FlagMetaHeader), 2);
+    EXPECT_EQ(sizeof(flags::FlagMeta), 40);
+    EXPECT_EQ(sizeof(absl::Flag<bool>), 40);
+    EXPECT_EQ(sizeof(absl::Flag<int>), 40);
+    EXPECT_EQ(sizeof(absl::Flag<int64_t>), 40);
+    EXPECT_EQ(sizeof(absl::Flag<double>), 40);
   }
 }
 
@@ -159,17 +161,17 @@
 using int128 = absl::int128;
 using uint128 = absl::uint128;
 
-#define DEFINE_CONSTRUCTED_FLAG(T, dflt, dflt_kind)                          \
-  constexpr flags::FlagDefaultArg f1default##T{                              \
-      flags::FlagDefaultSrc{dflt}, flags::FlagDefaultKind::dflt_kind};       \
-  constexpr absl::Flag<T> f1##T{"f1", help_arg, f1default##T};               \
-  ABSL_CONST_INIT absl::Flag<T> f2##T {                                      \
-    "f2", {flags::FlagHelpMsg(&TestHelpMsg), flags::FlagHelpKind::kGenFunc}, \
-        flags::FlagDefaultArg {                                              \
-      flags::FlagDefaultSrc(&TestMakeDflt<T>),                               \
-          flags::FlagDefaultKind::kGenFunc                                   \
-    }                                                                        \
-  }
+#define DEFINE_CONSTRUCTED_FLAG(T, dflt, dflt_kind)                            \
+  constexpr flags::FlagDefaultArg f1default##T{                                \
+      flags::FlagDefaultSrc{dflt}, flags::FlagDefaultKind::dflt_kind};         \
+  constexpr flags::FlagMeta f1meta##T =                                        \
+      flags::MakeFlagMeta<T>("f1", help_arg, f1default##T);                    \
+  constexpr absl::Flag<T> f1##T{&f1meta##T.hdr};                               \
+  constexpr flags::FlagMeta f2meta##T = flags::MakeFlagMeta<T>(                \
+      "f2", {flags::FlagHelpMsg(&TestHelpMsg), flags::FlagHelpKind::kGenFunc}, \
+      flags::FlagDefaultArg{flags::FlagDefaultSrc(&TestMakeDflt<T>),           \
+                            flags::FlagDefaultKind::kGenFunc});                \
+  ABSL_CONST_INIT absl::Flag<T> f2##T { &f2meta##T.hdr }
 
 DEFINE_CONSTRUCTED_FLAG(bool, true, kOneWord);
 DEFINE_CONSTRUCTED_FLAG(int16_t, 1, kOneWord);
@@ -185,11 +187,6 @@
 DEFINE_CONSTRUCTED_FLAG(int128, 13, kGenFunc);
 DEFINE_CONSTRUCTED_FLAG(uint128, 14, kGenFunc);
 
-constexpr absl::Flag<String> f_compat_5arg{
-    "f_compat", "std::string", "file", help_arg,
-    flags::FlagDefaultArg{flags::FlagDefaultSrc(&TestMakeDflt<String>),
-                          flags::FlagDefaultKind::kGenFunc}};
-
 template <typename T>
 bool TestConstructionFor(const absl::Flag<T>& f1, absl::Flag<T>& f2) {
   EXPECT_EQ(absl::GetFlagReflectionHandle(f1).Name(), "f1");
@@ -222,10 +219,6 @@
   TEST_CONSTRUCTED_FLAG(UDT);
   TEST_CONSTRUCTED_FLAG(int128);
   TEST_CONSTRUCTED_FLAG(uint128);
-  EXPECT_EQ(absl::GetFlagReflectionHandle(f_compat_5arg).Name(), "f_compat");
-  EXPECT_EQ(absl::GetFlagReflectionHandle(f_compat_5arg).Help(),
-            "literal help");
-  EXPECT_EQ(absl::GetFlagReflectionHandle(f_compat_5arg).Filename(), "");
 }
 
 // --------------------------------------------------------------------
@@ -1449,9 +1442,9 @@
   constexpr const char* kFileA = "dir/intern_test_a.cc";
   constexpr const char* kFileB = "dir/intern_test_b.cc";
 
-  absl::Flag<int32_t> f_a1{"fa1", help_arg, f1defaultint32_t};
-  absl::Flag<int32_t> f_a2{"fa2", help_arg, f1defaultint32_t};
-  absl::Flag<int32_t> f_b{"fb", help_arg, f1defaultint32_t};
+  absl::Flag<int32_t> f_a1{&f1metaint32_t.hdr};
+  absl::Flag<int32_t> f_a2{&f1metaint32_t.hdr};
+  absl::Flag<int32_t> f_b{&f1metaint32_t.hdr};
 
   flags::FlagRegistrar<int32_t, false>(ABSL_FLAG_IMPL_FLAG_PTR(f_a1), kFileA);
   flags::FlagRegistrar<int32_t, false>(ABSL_FLAG_IMPL_FLAG_PTR(f_a2), kFileA);
@@ -1464,4 +1457,27 @@
   EXPECT_EQ(f_b.Filename(), "dir/intern_test_b.cc");
 }
 
+ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(legacy_macro_expanded_flag, std::string,
+                                       "legacy_default")
+ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(legacy_macro_expanded_flag,
+                                    "Legacy 5-arg constructor help.")
+ABSL_CONST_INIT absl::Flag<std::string> FLAGS_legacy_macro_expanded_flag{
+    ABSL_FLAG_IMPL_FLAGNAME("legacy_macro_expanded_flag"),
+    ABSL_FLAG_IMPL_TYPENAME("std::string"), ABSL_FLAG_IMPL_FILENAME(),
+    ABSL_FLAG_IMPL_HELP_ARG(legacy_macro_expanded_flag),
+    ABSL_FLAG_IMPL_DEFAULT_ARG(std::string, legacy_macro_expanded_flag)};
+absl::flags_internal::FlagRegistrarEmpty
+    FLAGS_no_legacy_macro_expanded_flag_alias =
+        ABSL_FLAG_IMPL_REGISTRAR(std::string, FLAGS_legacy_macro_expanded_flag);
+
+TEST_F(FlagTest, LegacyFiveArgConstructorCompatibility) {
+  EXPECT_EQ(absl::GetFlag(FLAGS_legacy_macro_expanded_flag), "legacy_default");
+  EXPECT_EQ(FLAGS_legacy_macro_expanded_flag.Name(),
+            "legacy_macro_expanded_flag");
+  EXPECT_EQ(FLAGS_legacy_macro_expanded_flag.Help(),
+            "Legacy 5-arg constructor help.");
+  absl::SetFlag(&FLAGS_legacy_macro_expanded_flag, "updated");
+  EXPECT_EQ(absl::GetFlag(FLAGS_legacy_macro_expanded_flag), "updated");
+}
+
 }  // namespace
diff --git a/absl/flags/internal/flag.cc b/absl/flags/internal/flag.cc
index 4c70b7b..6b9014a 100644
--- a/absl/flags/internal/flag.cc
+++ b/absl/flags/internal/flag.cc
@@ -219,9 +219,9 @@
         on_command_line_(on_command_line),
         counter_(counter) {}
 
-  FlagState(FlagImpl& flag_impl, FlagDefaultSrc default_value)
+  explicit FlagState(FlagImpl& flag_impl)
       : flag_impl_(flag_impl),
-        value_(default_value),
+        value_(int64_t{0}),
         modified_(false),
         on_command_line_(false),
         counter_(-1) {}
@@ -231,7 +231,7 @@
     if (flag_impl_.ValueStorageKind() != FlagValueStorageKind::kHeapAllocated &&
         flag_impl_.ValueStorageKind() != FlagValueStorageKind::kSequenceLocked)
       return;
-    flags_internal::Delete(flag_impl_.op_, value_.heap_allocated);
+    flags_internal::Delete(flag_impl_.op(), value_.heap_allocated);
   }
 
  private:
@@ -251,11 +251,9 @@
   union SavedValue {
     explicit SavedValue(void* v) : heap_allocated(v) {}
     explicit SavedValue(int64_t v) : one_word(v) {}
-    explicit SavedValue(FlagDefaultSrc v) : default_value(v) {}
 
     void* heap_allocated;
     int64_t one_word;
-    FlagDefaultSrc default_value;
   } value_;
   bool modified_;
   bool on_command_line_;
@@ -326,6 +324,8 @@
   file_id_ = static_cast<uint16_t>(table.files.size());
 }
 
+FlagOpFn FlagImpl::op() const { return PtrMeta()->op; }
+
 void FlagImpl::Init() {
   new (&data_guard_) absl::Mutex;
 
@@ -337,15 +337,15 @@
     case FlagValueStorageKind::kOneWordAtomic: {
       alignas(int64_t) std::array<char, sizeof(int64_t)> buf{};
       if (def_kind == FlagDefaultKind::kGenFunc) {
-        (*default_value_.gen_func)(buf.data());
+        (*PtrMeta()->default_value.gen_func)(buf.data());
       } else {
-        assert(def_kind != FlagDefaultKind::kDynamicValue);
-        std::memcpy(buf.data(), &default_value_, Sizeof(op_));
+        assert(def_kind == FlagDefaultKind::kOneWord);
+        std::memcpy(buf.data(), &PtrMeta()->default_value, Sizeof(op()));
       }
       if (ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit) {
         // We presume here the memory layout of FlagValueAndInitBit struct.
         uint8_t initialized = 1;
-        std::memcpy(buf.data() + Sizeof(op_), &initialized,
+        std::memcpy(buf.data() + Sizeof(op()), &initialized,
                     sizeof(initialized));
       }
       // Type can contain valid uninitialized bits, e.g. padding.
@@ -358,7 +358,7 @@
       // For this storage kind the default_value_ always points to gen_func
       // during initialization.
       assert(def_kind == FlagDefaultKind::kGenFunc);
-      (*default_value_.gen_func)(AtomicBufferValue());
+      (*PtrMeta()->default_value.gen_func)(AtomicBufferValue());
       SeqLock().MarkInitialized();
       break;
     }
@@ -368,7 +368,7 @@
       assert(def_kind == FlagDefaultKind::kGenFunc);
       // Flag value initially points to the internal buffer.
       MaskedPointer ptr_value = PtrStorage().load(std::memory_order_acquire);
-      (*default_value_.gen_func)(ptr_value.Ptr());
+      (*PtrMeta()->default_value.gen_func)(ptr_value.Ptr());
       // Default value is a candidate for an unprotected read.
       PtrStorage().store(MaskedPointer(ptr_value.Ptr(), true),
                          std::memory_order_release);
@@ -386,7 +386,7 @@
 
 void FlagImpl::AssertValidType(FlagFastTypeId rhs_type_id,
                                const std::type_info* (*gen_rtti)()) const {
-  FlagFastTypeId lhs_type_id = flags_internal::FastTypeId(op_);
+  FlagFastTypeId lhs_type_id = flags_internal::FastTypeId(op());
 
   // `rhs_type_id` is the fast type id corresponding to the declaration
   // visible at the call site. `lhs_type_id` is the fast type id
@@ -395,7 +395,7 @@
   if (ABSL_PREDICT_TRUE(lhs_type_id == rhs_type_id)) return;
 
   const std::type_info* lhs_runtime_type_id =
-      flags_internal::RuntimeTypeId(op_);
+      flags_internal::RuntimeTypeId(op());
   const std::type_info* rhs_runtime_type_id = (*gen_rtti)();
 
   if (lhs_runtime_type_id == rhs_runtime_type_id) return;
@@ -413,17 +413,18 @@
   void* res = nullptr;
   switch (mu_state_.load(std::memory_order_relaxed).DefaultKind()) {
     case FlagDefaultKind::kDynamicValue:
-      res = flags_internal::Clone(op_, GetDynamicDefault(this));
+      res = flags_internal::Clone(op(), GetDynamicDefault(this));
       break;
     case FlagDefaultKind::kGenFunc:
-      res = flags_internal::Alloc(op_);
-      (*default_value_.gen_func)(res);
+      res = flags_internal::Alloc(op());
+      (*PtrMeta()->default_value.gen_func)(res);
       break;
-    default:
-      res = flags_internal::Clone(op_, &default_value_);
+    case FlagDefaultKind::kOneWord:
+      res = flags_internal::Alloc(op());
+      std::memcpy(res, &PtrMeta()->default_value, Sizeof(op()));
       break;
   }
-  return {res, DynValueDeleter{op_}};
+  return {res, DynValueDeleter{op()}};
 }
 
 void FlagImpl::RecordMutation() {
@@ -443,12 +444,12 @@
     case FlagValueStorageKind::kOneWordAtomic: {
       // Load the current value to avoid setting 'init' bit manually.
       int64_t one_word_val = OneWordValue().load(std::memory_order_acquire);
-      std::memcpy(&one_word_val, src, Sizeof(op_));
+      std::memcpy(&one_word_val, src, Sizeof(op()));
       OneWordValue().store(one_word_val, std::memory_order_release);
       break;
     }
     case FlagValueStorageKind::kSequenceLocked: {
-      SeqLock().Write(AtomicBufferValue(), src, Sizeof(op_));
+      SeqLock().Write(AtomicBufferValue(), src, Sizeof(op()));
       break;
     }
     case FlagValueStorageKind::kHeapAllocated:
@@ -462,13 +463,13 @@
         // instead we move the memory to a freelist so it can still be safely
         // accessed, and allocate a new one for the new value.
         AddToFreelist(ptr_value.Ptr());
-        ptr_value = MaskedPointer(Clone(op_, src), source == kCommandLine);
+        ptr_value = MaskedPointer(Clone(op(), src), source == kCommandLine);
       } else {
         // Current value either was set programmatically or was never read.
         // We can reuse the memory since all accesses to this value (if any)
         // were protected by mutex. That said, if a new value comes from command
         // line it now becomes a candidate for an unprotected read.
-        ptr_value.Set(op_, src, source == kCommandLine);
+        ptr_value.Set(op(), src, source == kCommandLine);
       }
 
       PtrStorage().store(ptr_value, std::memory_order_release);
@@ -478,13 +479,14 @@
   InvokeCallback();
 }
 
-absl::string_view FlagImpl::Name() const { return name_; }
+absl::string_view FlagImpl::Name() const { return PtrMeta()->name; }
 
 absl::string_view FlagImpl::TypeName() const {
-  if (ABSL_PREDICT_TRUE(type_id_ != kCustomFlagTypeId)) {
-    return kCommonFlagTypeNames[type_id_];
+  if (ABSL_PREDICT_TRUE(meta_->type_id != kCustomFlagTypeId)) {
+    return kCommonFlagTypeNames[meta_->type_id];
   }
-  return name_ + std::strlen(name_) + 1;
+  const absl::string_view name = Name();
+  return name.data() + name.size() + 1;
 }
 
 std::string FlagImpl::Filename() const {
@@ -493,12 +495,13 @@
 }
 
 std::string FlagImpl::Help() const {
-  return HelpSourceKind() == FlagHelpKind::kLiteral ? help_.literal
-                                                    : help_.gen_func();
+  return HelpSourceKind() == FlagHelpKind::kLiteral
+             ? PtrMeta()->help.literal
+             : PtrMeta()->help.gen_func();
 }
 
 FlagFastTypeId FlagImpl::TypeId() const {
-  return flags_internal::FastTypeId(op_);
+  return flags_internal::FastTypeId(op());
 }
 
 int64_t FlagImpl::ModificationCount() const {
@@ -517,7 +520,7 @@
   absl::MutexLock l(DataGuard());
 
   auto obj = MakeInitValue();
-  return flags_internal::Unparse(op_, obj.get());
+  return flags_internal::Unparse(op(), obj.get());
 }
 
 std::string FlagImpl::CurrentValue() const {
@@ -528,18 +531,18 @@
       const auto one_word_val =
           absl::bit_cast<std::array<char, sizeof(int64_t)>>(
               OneWordValue().load(std::memory_order_acquire));
-      return flags_internal::Unparse(op_, one_word_val.data());
+      return flags_internal::Unparse(op(), one_word_val.data());
     }
     case FlagValueStorageKind::kSequenceLocked: {
-      std::unique_ptr<void, DynValueDeleter> cloned(flags_internal::Alloc(op_),
-                                                    DynValueDeleter{op_});
+      std::unique_ptr<void, DynValueDeleter> cloned(flags_internal::Alloc(op()),
+                                                    DynValueDeleter{op()});
       ReadSequenceLockedData(cloned.get());
-      return flags_internal::Unparse(op_, cloned.get());
+      return flags_internal::Unparse(op(), cloned.get());
     }
     case FlagValueStorageKind::kHeapAllocated: {
       absl::MutexLock l(guard);
       return flags_internal::Unparse(
-          op_, PtrStorage().load(std::memory_order_acquire).Ptr());
+          op(), PtrStorage().load(std::memory_order_acquire).Ptr());
     }
   }
 
@@ -602,14 +605,14 @@
       // Built-in types have side-effect-free defaults; user-defined types may
       // have custom construction or validation side effects.
       return def_kind == FlagDefaultKind::kGenFunc &&
-             !ShouldValidateFlagValue(flags_internal::FastTypeId(op_));
+             !ShouldValidateFlagValue(flags_internal::FastTypeId(op()));
   }
   return false;
 }
 
 std::unique_ptr<FlagStateInterface> FlagImpl::SaveState() {
   if (ABSL_PREDICT_TRUE(CanSkipInitOnSave())) {
-    return std::make_unique<FlagState>(*this, default_value_);
+    return std::make_unique<FlagState>(*this);
   }
 
   absl::MutexLock l(DataGuard());
@@ -625,10 +628,10 @@
           on_command_line, ModificationCount());
     }
     case FlagValueStorageKind::kSequenceLocked: {
-      void* cloned = flags_internal::Alloc(op_);
+      void* cloned = flags_internal::Alloc(op());
       // Read is guaranteed to be successful because we hold the lock.
       bool success =
-          SeqLock().TryRead(cloned, AtomicBufferValue(), Sizeof(op_));
+          SeqLock().TryRead(cloned, AtomicBufferValue(), Sizeof(op()));
       assert(success);
       static_cast<void>(success);
       return std::make_unique<FlagState>(*this, cloned, modified,
@@ -638,7 +641,7 @@
       return std::make_unique<FlagState>(
           *this,
           flags_internal::Clone(
-              op_, PtrStorage().load(std::memory_order_acquire).Ptr()),
+              op(), PtrStorage().load(std::memory_order_acquire).Ptr()),
           modified, on_command_line, ModificationCount());
     }
   }
@@ -655,26 +658,20 @@
     return false;
   }
 
-  switch (ValueStorageKind()) {
-    case FlagValueStorageKind::kValueAndInitBit:
-    case FlagValueStorageKind::kOneWordAtomic:
-      StoreValue(
-          flag_state.counter_ < 0
-              ? static_cast<const void*>(&flag_state.value_.default_value)
-              : static_cast<const void*>(&flag_state.value_.one_word),
-          kProgrammaticChange);
-      break;
-    case FlagValueStorageKind::kSequenceLocked:
-    case FlagValueStorageKind::kHeapAllocated:
-      if (flag_state.counter_ < 0) {
-        std::unique_ptr<void, DynValueDeleter> init_value(
-            flags_internal::Alloc(op_), DynValueDeleter{op_});
-        (*flag_state.value_.default_value.gen_func)(init_value.get());
-        StoreValue(init_value.get(), kProgrammaticChange);
-      } else {
+  if (flag_state.counter_ < 0) {
+    auto init_value = MakeInitValue();
+    StoreValue(init_value.get(), kProgrammaticChange);
+  } else {
+    switch (ValueStorageKind()) {
+      case FlagValueStorageKind::kValueAndInitBit:
+      case FlagValueStorageKind::kOneWordAtomic:
+        StoreValue(&flag_state.value_.one_word, kProgrammaticChange);
+        break;
+      case FlagValueStorageKind::kSequenceLocked:
+      case FlagValueStorageKind::kHeapAllocated:
         StoreValue(flag_state.value_.heap_allocated, kProgrammaticChange);
-      }
-      break;
+        break;
+    }
   }
 
   MuState s = mu_state_.load(std::memory_order_relaxed);
@@ -689,7 +686,7 @@
 StorageT* FlagImpl::OffsetValue() const {
   char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
   // The offset is deduced via Flag value type specific op_.
-  ptrdiff_t offset = flags_internal::ValueOffset(op_);
+  ptrdiff_t offset = flags_internal::ValueOffset(op());
 
   return reinterpret_cast<StorageT*>(p + offset);
 }
@@ -701,8 +698,8 @@
 
 flags_internal::SequenceLock& FlagImpl::SeqLock() const {
   assert(ValueStorageKind() == FlagValueStorageKind::kSequenceLocked);
-  size_t num_words =
-      flags_internal::AlignUp(Sizeof(op_), sizeof(uint64_t)) / sizeof(uint64_t);
+  size_t num_words = flags_internal::AlignUp(Sizeof(op()), sizeof(uint64_t)) /
+                     sizeof(uint64_t);
   return *reinterpret_cast<flags_internal::SequenceLock*>(AtomicBufferValue() +
                                                           num_words);
 }
@@ -727,7 +724,7 @@
   std::unique_ptr<void, DynValueDeleter> tentative_value = MakeInitValue();
 
   std::string parse_err;
-  if (!flags_internal::Parse(op_, value, tentative_value.get(), &parse_err)) {
+  if (!flags_internal::Parse(op(), value, tentative_value.get(), &parse_err)) {
     absl::string_view err_sep = parse_err.empty() ? "" : "; ";
     err = absl::StrCat("Illegal value '", value, "' specified for flag '",
                        Name(), "'", err_sep, parse_err);
@@ -744,7 +741,7 @@
     case FlagValueStorageKind::kOneWordAtomic: {
       const int64_t one_word_val =
           OneWordValue().load(std::memory_order_acquire);
-      std::memcpy(dst, &one_word_val, Sizeof(op_));
+      std::memcpy(dst, &one_word_val, Sizeof(op()));
       break;
     }
     case FlagValueStorageKind::kSequenceLocked: {
@@ -755,7 +752,7 @@
       absl::MutexLock l(guard);
       MaskedPointer ptr_value = PtrStorage().load(std::memory_order_acquire);
 
-      flags_internal::CopyConstruct(op_, ptr_value.Ptr(), dst);
+      flags_internal::CopyConstruct(op(), ptr_value.Ptr(), dst);
 
       // For unprotected read candidates, mark that the value as has been read.
       if (ptr_value.IsUnprotectedReadCandidate() && !ptr_value.HasBeenRead()) {
@@ -785,7 +782,7 @@
 }
 
 void FlagImpl::ReadSequenceLockedData(void* dst) const {
-  size_t size = Sizeof(op_);
+  size_t size = Sizeof(op());
   // Attempt to read using the sequence lock.
   if (ABSL_PREDICT_TRUE(SeqLock().TryRead(dst, AtomicBufferValue(), size))) {
     return;
@@ -801,12 +798,12 @@
 void FlagImpl::Write(const void* src) {
   absl::MutexLock l(DataGuard());
 
-  if (ShouldValidateFlagValue(flags_internal::FastTypeId(op_))) {
-    std::unique_ptr<void, DynValueDeleter> obj{flags_internal::Clone(op_, src),
-                                               DynValueDeleter{op_}};
+  if (ShouldValidateFlagValue(flags_internal::FastTypeId(op()))) {
+    std::unique_ptr<void, DynValueDeleter> obj{flags_internal::Clone(op(), src),
+                                               DynValueDeleter{op()}};
     std::string ignored_error;
-    std::string src_as_str = flags_internal::Unparse(op_, src);
-    if (!flags_internal::Parse(op_, src_as_str, obj.get(), &ignored_error)) {
+    std::string src_as_str = flags_internal::Unparse(op(), src);
+    if (!flags_internal::Parse(op(), src_as_str, obj.get(), &ignored_error)) {
       ABSL_INTERNAL_LOG(ERROR, absl::StrCat("Attempt to set flag '", Name(),
                                             "' to invalid value ", src_as_str));
     }
@@ -895,7 +892,7 @@
 
   auto dst = MakeInitValue();
   std::string error;
-  if (!flags_internal::Parse(op_, v, dst.get(), &error)) {
+  if (!flags_internal::Parse(op(), v, dst.get(), &error)) {
     ABSL_INTERNAL_LOG(
         FATAL,
         absl::StrCat("Flag ", Name(), " (from ", Filename(),
@@ -912,7 +909,7 @@
 
   auto obj = MakeInitValue();
   std::string ignored_error;
-  return flags_internal::Parse(op_, value, obj.get(), &ignored_error);
+  return flags_internal::Parse(op(), value, obj.get(), &ignored_error);
 }
 
 }  // namespace flags_internal
diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h
index b565aaf..ff5df92 100644
--- a/absl/flags/internal/flag.h
+++ b/absl/flags/internal/flag.h
@@ -156,6 +156,7 @@
   return static_cast<ptrdiff_t>(reinterpret_cast<intptr_t>(
       op(FlagOp::kValueOffset, nullptr, nullptr, nullptr)));
 }
+
 // Returns an address of RTTI's typeid(T).
 template <typename T>
 inline const std::type_info* GenRuntimeTypeId() {
@@ -167,7 +168,7 @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// Flag help and name/type-name auxiliary structs.
+// Flag help auxiliary structs.
 
 // This is help argument for absl::Flag encapsulating the string literal pointer
 // or pointer to function generating it as well as enum discriminating two
@@ -188,10 +189,11 @@
 inline constexpr uint8_t kEmptyFlagTypeId = 0;
 inline constexpr uint8_t kCustomFlagTypeId = 31;
 
-// Common macro-stringified `#Type` spellings stored as a 5-bit ID in `FlagImpl`
-// so common flags avoid emitting a per-flag type-name string. Entry 0 (`""`) is
-// used when flag names are stripped or omitted; ID 31 (`kCustomFlagTypeId`)
-// indicates that `name_` points to a packed `"<name>\0<type_name>\0"` array.
+// Common macro-stringified `#Type` spellings stored as a compact ID in
+// `FlagMetaHeader` so common flags avoid emitting a per-flag type-name string.
+// Entry 0 (`""`) is used when flag names are stripped or omitted; ID 31
+// (`kCustomFlagTypeId`) indicates that `FlagMeta::name` points to a packed
+// `"<name>\0<type_name>\0"` array.
 inline constexpr absl::string_view kCommonFlagTypeNames[] = {
     "",
     "bool",
@@ -250,9 +252,9 @@
   uint8_t type_id;
 };
 
-template <typename Gen>
-constexpr FlagNameArg MakeFlagNameArg() {
-  constexpr uint8_t kTypeId = LookupCommonFlagTypeId(Gen::AbslFlagTypeName());
+template <typename Gen,
+          uint8_t kTypeId = LookupCommonFlagTypeId(Gen::AbslFlagTypeName())>
+constexpr FlagNameArg MakeFlagNameArgImpl(int) {
   if constexpr (kTypeId != kCustomFlagTypeId) {
     return {Gen::AbslFlagName(), kTypeId};
   } else {
@@ -260,6 +262,16 @@
   }
 }
 
+template <typename Gen>
+constexpr FlagNameArg MakeFlagNameArgImpl(char) {
+  return {"", kEmptyFlagTypeId};
+}
+
+template <typename Gen>
+constexpr FlagNameArg MakeFlagNameArg() {
+  return MakeFlagNameArgImpl<Gen>(0);
+}
+
 template <typename Gen, size_t N = Gen::Value().size()>
 constexpr FixedCharArray<N + 1> HelpStringAsArray(int) {
   return FixedCharArray<N + 1>::FromLiteralString(
@@ -336,7 +348,7 @@
 enum class FlagDefaultKind : uint8_t {
   kDynamicValue = 0,
   kGenFunc = 1,
-  kOneWord = 2  // for default values UP to one word in size
+  kOneWord = 2,  // inline default value in descriptor
 };
 
 struct FlagDefaultArg {
@@ -660,6 +672,66 @@
   FlagOpFn op;
 };
 
+struct FlagMetaHeader {
+  constexpr static uint8_t PackKinds(FlagValueStorageKind vk, FlagHelpKind hk,
+                                     FlagDefaultKind dk) {
+    return static_cast<uint8_t>((static_cast<uint8_t>(vk) & 0x7) |
+                                ((static_cast<uint8_t>(hk) & 0x1) << 3) |
+                                ((static_cast<uint8_t>(dk) & 0x3) << 4));
+  }
+
+  uint8_t kinds;
+  uint8_t type_id;
+};
+
+// Pointer-based descriptor for flag metadata (40 B).
+struct FlagMeta {
+  constexpr FlagMeta(FlagMetaHeader hdr_arg, const char* name_arg,
+                     FlagHelpMsg help_arg, FlagDefaultSrc default_value_arg,
+                     FlagOpFn op_arg)
+      : hdr(hdr_arg),
+        name(name_arg),
+        help(help_arg),
+        default_value(default_value_arg),
+        op(op_arg) {}
+
+  FlagMetaHeader hdr;
+  // Flag's name passed to ABSL_FLAG as second arg.
+  const char* const name;
+  // Help message literal or function to generate it.
+  const FlagHelpMsg help;
+  // Initial default value source specified in ABSL_FLAG.
+  const FlagDefaultSrc default_value;
+  // Type-specific operations vtable.
+  const FlagOpFn op;
+};
+
+template <typename T>
+constexpr FlagMeta MakeFlagMeta(FlagNameArg name, FlagHelpArg help,
+                                FlagDefaultArg default_arg) {
+  return FlagMeta(
+      FlagMetaHeader{FlagMetaHeader::PackKinds(flags_internal::StorageKind<T>(),
+                                               help.kind, default_arg.kind),
+                     name.type_id},
+      name.name, help.source, default_arg.source, &FlagOps<T>);
+}
+
+template <typename T>
+constexpr FlagMeta MakeFlagMeta(const char* name, FlagHelpArg help,
+                                FlagDefaultArg default_arg) {
+  return MakeFlagMeta<T>(FlagNameArg{name, kEmptyFlagTypeId}, help,
+                         default_arg);
+}
+
+template <typename ValueT, typename GenT, typename HelpGenT, size_t NameLen,
+          typename HelpStorageT>
+constexpr FlagMeta SelectFlagMeta(const char* name [[maybe_unused]],
+                                  const HelpStorageT& help_storage, int) {
+  return MakeFlagMeta<ValueT>(MakeFlagNameArg<GenT>(),
+                              HelpArg<HelpGenT>(help_storage),
+                              DefaultArg<ValueT, GenT>(0));
+}
+
 class FlagState;
 
 // These are only used as constexpr global objects.
@@ -689,19 +761,12 @@
   static_assert(std::atomic<MuState>::is_always_lock_free);
 
  public:
-  constexpr FlagImpl(FlagNameArg name, FlagOpFn op, FlagHelpArg help,
-                     FlagValueStorageKind value_kind,
-                     FlagDefaultArg default_arg)
-      : name_(name.name),
-        op_(op),
-        help_(help.source),
-        help_source_kind_(static_cast<uint8_t>(help.kind)),
-        value_storage_kind_(static_cast<uint8_t>(value_kind)),
-        type_id_(name.type_id),
-        mu_state_(MuState{static_cast<uint8_t>(default_arg.kind), false, false,
-                          false, 0}),
+  constexpr explicit FlagImpl(const FlagMetaHeader* meta)
+      : meta_(meta),
+        mu_state_(MuState{static_cast<uint8_t>((meta->kinds >> 4) & 0x3), false,
+                          false, false, 0}),
         file_id_(0),
-        default_value_(default_arg.source),
+        init_control_{},
         data_guard_{} {}
 
   // Constant access methods
@@ -750,6 +815,11 @@
   friend class Flag;
   friend class FlagState;
 
+  FlagOpFn op() const;
+  const FlagMeta* PtrMeta() const {
+    return reinterpret_cast<const FlagMeta*>(meta_);
+  }
+
   // Ensures that `data_guard_` is initialized and returns it.
   absl::Mutex& DataGuard() const
       ABSL_LOCK_RETURNED(reinterpret_cast<absl::Mutex*>(data_guard_));
@@ -763,7 +833,7 @@
   // respect const correctness, so be very careful using them.
 
   // This is a shared helper routine which encapsulates most of the magic. Since
-  // it is only used inside the three routines below, which are defined in
+  // it is only used inside the routines below, which are defined in
   // flag.cc, we can define it in that file as well.
   template <typename StorageT>
   StorageT* OffsetValue() const;
@@ -789,16 +859,16 @@
   void StoreValue(const void* src, ValueSource source)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(DataGuard());
 
-  // Copy the flag data, protected by `seq_lock_` into `dst`.
+  // Copy the flag data, protected by `SeqLock()` into `dst`.
   //
   // REQUIRES: ValueStorageKind() == kSequenceLocked.
   void ReadSequenceLockedData(void* dst) const ABSL_LOCKS_EXCLUDED(DataGuard());
 
   FlagHelpKind HelpSourceKind() const {
-    return static_cast<FlagHelpKind>(help_source_kind_);
+    return static_cast<FlagHelpKind>((meta_->kinds >> 3) & 0x1);
   }
   FlagValueStorageKind ValueStorageKind() const {
-    return static_cast<FlagValueStorageKind>(value_storage_kind_);
+    return static_cast<FlagValueStorageKind>(meta_->kinds & 0x7);
   }
 
   // CommandLineFlag interface implementation
@@ -841,36 +911,19 @@
                  ValueSource source, std::string& error) override
       ABSL_LOCKS_EXCLUDED(DataGuard());
 
-  // Immutable flag's state.
+  // Pointer to immutable flag descriptor in .rodata / .data.rel.ro.
+  const FlagMetaHeader* const meta_;
 
-  // Flags name passed to ABSL_FLAG as second arg (followed by NUL-terminated
-  // type name when `type_id_ == kCustomFlagTypeId`).
-  const char* const name_;
-  // Type-specific operations vtable.
-  const FlagOpFn op_;
-  // Help message literal or function to generate it.
-  const FlagHelpMsg help_;
-  // Indicates if help message was supplied as literal or generator func.
-  const uint8_t help_source_kind_ : 1;
-  // Kind of storage this flag is using for the flag's value.
-  const uint8_t value_storage_kind_ : 2;
-  // Index into `kCommonFlagTypeNames`, or `kCustomFlagTypeId` when `name_`
-  // stores `"<name>\0<type_name>\0"`.
-  const uint8_t type_id_ : 5;
-
-  // Mutable state updated under DataGuard() and read with relaxed atomic loads.
+  // Mutable state updated under DataGuard() and read with lock-free relaxed
+  // atomic loads (cannot use ABSL_GUARDED_BY(DataGuard()), which also requires
+  // holding the mutex on reads).
   std::atomic<MuState> mu_state_;
 
   // Deduplicated filename index assigned on registration (0 = unset).
   uint16_t file_id_;
 
-  // Unique tag for absl::call_once call to initialize this flag.
   absl::once_flag init_control_;
 
-  // Initial default value source specified in ABSL_FLAG. Dynamic default
-  // overrides set via SET_FLAGS_DEFAULT are stored in a side table.
-  const FlagDefaultSrc default_value_;
-
   // This is reserved space for an absl::Mutex to guard flag data. It will be
   // initialized in FlagImpl::Init via placement new.
   // We can't use "absl::Mutex data_guard_", since this class is not literal.
@@ -896,37 +949,42 @@
 ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(ABSL_FLAGS_INTERNAL_IS_SUPPORTED_TYPE)
 #undef ABSL_FLAGS_INTERNAL_IS_SUPPORTED_TYPE
 
+template <typename T,
+          FlagValueStorageKind Kind = flags_internal::StorageKind<T>()>
+struct FlagStorage {
+  constexpr explicit FlagStorage(const FlagMetaHeader* meta)
+      : impl_(meta), value_() {}
+
+  // The implementation depends on value_ field to be placed exactly after the
+  // impl_ field, so that impl_ can figure out the offset to the value and
+  // access it.
+  FlagImpl impl_;
+  FlagValue<T, Kind> value_;
+};
+
 template <typename T>
-class Flag {
+class Flag : private FlagStorage<T> {
  public:
-  constexpr Flag(FlagNameArg name, FlagHelpArg help,
-                 const FlagDefaultArg default_arg)
-      : impl_(name, &FlagOps<T>, help, flags_internal::StorageKind<T>(),
-              default_arg),
-        value_() {}
-  constexpr Flag(const char* name, FlagHelpArg help,
-                 const FlagDefaultArg default_arg)
-      : Flag(FlagNameArg{name, kEmptyFlagTypeId}, help, default_arg) {}
-  constexpr Flag(const char* name, const char* /*filename*/, FlagHelpArg help,
-                 const FlagDefaultArg default_arg)
-      : Flag(FlagNameArg{name, kEmptyFlagTypeId}, help, default_arg) {}
-  // Kept for backwards compatibility.
-  constexpr Flag(const char* name, const char* type_name,
-                 const char* /*filename*/, FlagHelpArg help,
-                 const FlagDefaultArg default_arg)
-      : Flag(FlagNameArg{name, LookupCommonOrEmptyFlagTypeId(type_name)}, help,
-             default_arg) {}
+  constexpr explicit Flag(const FlagMetaHeader* meta) : FlagStorage<T>(meta) {}
+
+  // Compatibility constructor for callers that expand ABSL_FLAG_IMPL_* macros
+  // directly instead of using ABSL_FLAG().
+  constexpr Flag(const char* name [[maybe_unused]],
+                 const char* type_name [[maybe_unused]],
+                 const char* filename [[maybe_unused]],
+                 FlagHelpArg help [[maybe_unused]], const FlagMetaHeader* meta)
+      : FlagStorage<T>(meta) {}
 
   // CommandLineFlag interface
-  absl::string_view Name() const { return impl_.Name(); }
-  std::string Filename() const { return impl_.Filename(); }
-  std::string Help() const { return impl_.Help(); }
+  absl::string_view Name() const { return this->impl_.Name(); }
+  std::string Filename() const { return this->impl_.Filename(); }
+  std::string Help() const { return this->impl_.Help(); }
   // Do not use. To be removed.
   bool IsSpecifiedOnCommandLine() const {
-    return impl_.IsSpecifiedOnCommandLine();
+    return this->impl_.IsSpecifiedOnCommandLine();
   }
-  std::string DefaultValue() const { return impl_.DefaultValue(); }
-  std::string CurrentValue() const { return impl_.CurrentValue(); }
+  std::string DefaultValue() const { return this->impl_.DefaultValue(); }
+  std::string CurrentValue() const { return this->impl_.CurrentValue(); }
 
  private:
   template <typename, bool>
@@ -944,39 +1002,34 @@
 
 #if !defined(NDEBUG)
     if constexpr (IsSupportedFlagType<T>::value) {
-      if (ABSL_PREDICT_FALSE(impl_.op_ != &FlagOps<T>)) {
-        impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
+      if (ABSL_PREDICT_FALSE(this->impl_.op() != &FlagOps<T>)) {
+        this->impl_.AssertValidType(absl::FastTypeId<T>(),
+                                    &GenRuntimeTypeId<T>);
       }
     } else {
-      impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
+      this->impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
     }
 #endif
 
-    if (ABSL_PREDICT_FALSE(!value_.Get(u.value))) {
-      impl_.Read(&u.value);
+    if (ABSL_PREDICT_FALSE(!this->value_.Get(u.value))) {
+      this->impl_.Read(&u.value);
     }
     return std::move(u.value);
   }
   void Set(const T& v) {
     if constexpr (IsSupportedFlagType<T>::value) {
-      if (ABSL_PREDICT_FALSE(impl_.op_ != &FlagOps<T>)) {
-        impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
+      if (ABSL_PREDICT_FALSE(this->impl_.op() != &FlagOps<T>)) {
+        this->impl_.AssertValidType(absl::FastTypeId<T>(),
+                                    &GenRuntimeTypeId<T>);
       }
     } else {
-      impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
+      this->impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
     }
-    impl_.Write(&v);
+    this->impl_.Write(&v);
   }
 
   // Access to the reflection.
-  const CommandLineFlag& Reflect() const { return impl_; }
-
-  // Flag's data
-  // The implementation depends on value_ field to be placed exactly after the
-  // impl_ field, so that impl_ can figure out the offset to the value and
-  // access it.
-  FlagImpl impl_;
-  FlagValue<T> value_;
+  const CommandLineFlag& Reflect() const { return this->impl_; }
 };
 
 ///////////////////////////////////////////////////////////////////////////////