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_; } }; ///////////////////////////////////////////////////////////////////////////////