Reduce the per-flag code size of ABSL_FLAG default value generators.
Previously, every non-arithmetic `ABSL_FLAG` emitted its own `AbslFlagDefaultGenFor<name>::Gen` function. Because its address is stored in the flag, identical code folding could not merge duplicate generators, and each body materialized a temporary wrapper struct, copy- or move-constructed the flag value from its member, and destroyed the temporary.
`absl::flags_internal::DefaultArg` now selects the cheapest representation for a flag's default value:
* Arithmetic `constexpr` defaults continue to be stored inline (`kOneWord`).
* Empty defaults (`{}`, `std::nullopt`, and empty `std::string` literals or views) share a single `GenDefaultValue<T>` function per type, with `std::string` and `std::vector<std::string>` explicitly instantiated in `flag.cc`.
* Remaining per-flag `Gen` functions construct `Type` directly in place via `InitDefaultValue`, avoiding intermediate temporaries and exception landing pads when converting class types from literals or `const char*`.
Placing the generated `AbslFlagHelpGenFor<name>` and `AbslFlagDefaultGenFor<name>` structs in an unnamed namespace also allows applying `ABSL_INTERNAL_UNIQUE_SMALL_NAME()` to the remaining per-flag helper functions.
PiperOrigin-RevId: 1008379642
diff --git a/absl/flags/flag.h b/absl/flags/flag.h
index 2e9a9e6..d5f40a0 100644
--- a/absl/flags/flag.h
+++ b/absl/flags/flag.h
@@ -232,33 +232,52 @@
// between the two via the call to HelpArg in absl::Flag instantiation below.
// If help message expression is constexpr evaluable compiler will optimize
// away this whole struct.
-// TODO(rogeeff): place these generated structs into local namespace and apply
-// ABSL_INTERNAL_UNIQUE_SHORT_NAME.
// TODO(rogeeff): Apply __attribute__((nodebug)) to FLAGS_help_storage_##name
#define ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, txt) \
+ namespace { \
struct AbslFlagHelpGenFor##name { \
/* The expression is run in the caller as part of the */ \
/* default value argument. That keeps temporaries alive */ \
/* long enough for NonConst to work correctly. */ \
static constexpr absl::string_view Value( \
- absl::string_view absl_flag_help ABSL_ATTRIBUTE_LIFETIME_BOUND = \
+ absl::string_view absl_flag_help ABSL_ATTRIBUTE_LIFETIME_BOUND = \
ABSL_FLAG_IMPL_FLAGHELP(txt)) { \
return absl_flag_help; \
} \
- static std::string NonConst() { return std::string(Value()); } \
+ static std::string NonConst() ABSL_INTERNAL_UNIQUE_SMALL_NAME() { \
+ return std::string(Value()); \
+ } \
}; \
+ } \
constexpr auto FLAGS_help_storage_##name ABSL_INTERNAL_UNIQUE_SMALL_NAME() \
ABSL_ATTRIBUTE_SECTION_VARIABLE(flags_help_cold) = \
absl::flags_internal::HelpStringAsArray<AbslFlagHelpGenFor##name>( \
0);
-#define ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value) \
- struct AbslFlagDefaultGenFor##name { \
- Type value = absl::flags_internal::InitDefaultValue<Type>(default_value); \
- static void Gen(void* absl_flag_default_loc) { \
- new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \
- } \
- };
+// Wraps default_value for compile-time inspection and in-place construction.
+#define ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value) \
+ namespace { \
+ struct AbslFlagDefaultGenFor##name { \
+ template <typename U = Type> \
+ static constexpr U MakeDefault() { \
+ return absl::flags_internal::InitDefaultValue<U>(default_value); \
+ } \
+ Type value = MakeDefault(); \
+ template <typename U = Type> \
+ static constexpr bool IsEmpty() { \
+ return absl::flags_internal::IsEmptyDefault<U>(default_value, 0); \
+ } \
+ static void Gen(void* absl_flag_default_loc) \
+ ABSL_INTERNAL_UNIQUE_SMALL_NAME() { \
+ if constexpr (std::is_move_constructible_v<Type>) { \
+ new (absl_flag_default_loc) Type(MakeDefault()); \
+ } else { \
+ new (absl_flag_default_loc) \
+ Type(AbslFlagDefaultGenFor##name{}.value); \
+ } \
+ } \
+ }; \
+ }
// ABSL_FLAG_IMPL
//
diff --git a/absl/flags/flag_test.cc b/absl/flags/flag_test.cc
index 5cacf64..d9466e1 100644
--- a/absl/flags/flag_test.cc
+++ b/absl/flags/flag_test.cc
@@ -1397,3 +1397,107 @@
#endif
} // namespace
+
+// --------------------------------------------------------------------
+
+namespace {
+
+constexpr char kLongLiteral[] = "a string longer than the small string buffer";
+const char* RuntimeCString() { return "runtime c string"; }
+
+struct AggregateUDT {
+ int value = 0;
+};
+bool AbslParseFlag(absl::string_view text, AggregateUDT* f, std::string*) {
+ return absl::SimpleAtoi(text, &f->value);
+}
+std::string AbslUnparseFlag(const AggregateUDT& f) {
+ return absl::StrCat(f.value);
+}
+
+} // namespace
+
+ABSL_FLAG(std::string, test_dflt_string_literal, kLongLiteral, "");
+ABSL_FLAG(std::string, test_dflt_embedded_nul, "ab\0cd", "");
+ABSL_FLAG(std::string, test_dflt_runtime_cstring, RuntimeCString(), "");
+ABSL_FLAG(std::vector<std::string>, test_dflt_empty_vector, {}, "");
+ABSL_FLAG(std::vector<std::string>, test_dflt_nonempty_vector,
+ std::vector<std::string>({"a", "b"}), "");
+ABSL_FLAG(AggregateUDT, test_dflt_aggregate_braces, {7}, "");
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
+ABSL_FLAG(AggregateUDT, test_dflt_designated_init, {.value = 9}, "");
+#endif
+
+namespace {
+
+TEST_F(FlagTest, TestConvertedAndAggregateDefaultValues) {
+ // Converting InitDefaultValue preserves NUL-termination and DefaultValue().
+ EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_string_literal), kLongLiteral);
+ EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_embedded_nul), "ab");
+ EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_runtime_cstring), "runtime c string");
+
+ absl::SetFlag(&FLAGS_test_dflt_string_literal, "changed");
+ EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_string_literal), "changed");
+ EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_dflt_string_literal)
+ .DefaultValue(),
+ kLongLiteral);
+
+ // Non-empty braced and designated initializers are not treated as empty.
+ EXPECT_TRUE(absl::GetFlag(FLAGS_test_dflt_empty_vector).empty());
+ EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_nonempty_vector),
+ std::vector<std::string>({"a", "b"}));
+ EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_aggregate_braces).value, 7);
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
+ EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_designated_init).value, 9);
+#endif
+}
+
+template <typename Gen, typename T = decltype(Gen::value)>
+constexpr bool UsesOneWordDefault() {
+ return flags::DefaultArg<T, Gen>(0).kind == flags::FlagDefaultKind::kOneWord;
+}
+
+template <typename Gen, typename T = decltype(Gen::value)>
+constexpr bool UsesSharedDefaultGen() {
+ constexpr flags::FlagDefaultArg arg = flags::DefaultArg<T, Gen>(0);
+ return arg.kind == flags::FlagDefaultKind::kGenFunc &&
+ arg.source.gen_func == &flags::GenDefaultValue<T>;
+}
+
+template <typename Gen, typename T = decltype(Gen::value)>
+constexpr bool UsesPerFlagDefaultGen() {
+ constexpr flags::FlagDefaultArg arg = flags::DefaultArg<T, Gen>(0);
+ return arg.kind == flags::FlagDefaultKind::kGenFunc &&
+ arg.source.gen_func == &Gen::Gen;
+}
+
+TEST_F(FlagTest, TestDefaultArgSelection) {
+ // Constexpr arithmetic -> kOneWord; runtime arithmetic -> per-flag Gen.
+ EXPECT_TRUE(UsesOneWordDefault<AbslFlagDefaultGenFortest_flag_02>());
+ EXPECT_TRUE(UsesPerFlagDefaultGen<
+ AbslFlagDefaultGenFortest_int_flag_with_non_const_default>());
+
+ // Empty defaults ("", {}, std::nullopt) -> shared GenDefaultValue<T>.
+ EXPECT_TRUE(UsesSharedDefaultGen<AbslFlagDefaultGenFortest_flag_11>());
+ EXPECT_TRUE(UsesSharedDefaultGen<AbslFlagDefaultGenFortest_flag_eb_05>());
+ EXPECT_TRUE(
+ UsesSharedDefaultGen<AbslFlagDefaultGenFortest_dflt_empty_vector>());
+ EXPECT_TRUE(UsesSharedDefaultGen<AbslFlagDefaultGenFortest_flag_eb_06>());
+ EXPECT_TRUE(UsesSharedDefaultGen<AbslFlagDefaultGenForoptional_int>());
+ EXPECT_TRUE(UsesSharedDefaultGen<AbslFlagDefaultGenForoptional_string>());
+
+ // Non-empty or runtime defaults -> per-flag Gen.
+ EXPECT_TRUE(
+ UsesPerFlagDefaultGen<AbslFlagDefaultGenFortest_dflt_string_literal>());
+ EXPECT_TRUE(
+ UsesPerFlagDefaultGen<AbslFlagDefaultGenFortest_dflt_runtime_cstring>());
+ EXPECT_TRUE(UsesPerFlagDefaultGen<
+ AbslFlagDefaultGenFortest_string_flag_with_non_const_default>());
+ EXPECT_TRUE(
+ UsesPerFlagDefaultGen<AbslFlagDefaultGenFortest_dflt_nonempty_vector>());
+ EXPECT_TRUE(
+ UsesPerFlagDefaultGen<AbslFlagDefaultGenFortest_dflt_aggregate_braces>());
+ EXPECT_TRUE(UsesPerFlagDefaultGen<AbslFlagDefaultGenForoptional_double>());
+}
+
+} // namespace
diff --git a/absl/flags/internal/flag.cc b/absl/flags/internal/flag.cc
index 662b342..32861f7 100644
--- a/absl/flags/internal/flag.cc
+++ b/absl/flags/internal/flag.cc
@@ -56,6 +56,9 @@
// if ABSL_FLAGS_STRIP_HELP is set to 1 before including absl/flags/flag.h
const char kStrippedFlagHelp[] = "\001\002\003\004 (unknown) \004\003\002\001";
+template void GenDefaultValue<std::string>(void*);
+template void GenDefaultValue<std::vector<std::string>>(void*);
+
namespace {
// Currently we only validate flag values for user-defined flag types.
diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h
index 8baff43..d400fb3 100644
--- a/absl/flags/internal/flag.h
+++ b/absl/flags/internal/flag.h
@@ -21,11 +21,14 @@
#include <atomic>
#include <cstring>
+#include <initializer_list>
#include <memory>
+#include <optional>
#include <string>
#include <type_traits>
#include <typeinfo>
#include <utility>
+#include <vector>
#include "absl/base/attributes.h"
#include "absl/base/call_once.h"
@@ -283,6 +286,80 @@
return T{};
}
+// True if class T is implicitly constructible from U (other than T itself).
+template <typename T, typename U>
+constexpr bool CanConvertToClassDefault() {
+ return std::is_class_v<T> && !std::is_same_v<std::decay_t<U>, T> &&
+ std::is_convertible_v<const U&, T>;
+}
+
+// Constructs class T directly from U via copy elision.
+template <typename T, typename U,
+ std::enable_if_t<CanConvertToClassDefault<T, U>(), int> = 0>
+constexpr T InitDefaultValue(const U& value) {
+ return value;
+}
+
+template <typename T>
+struct IsOptional : std::false_type {};
+template <typename T>
+struct IsOptional<std::optional<T>> : std::true_type {};
+
+template <typename T, typename U>
+constexpr bool IsStringWithStringViewDefault() {
+ return std::is_same_v<T, std::string> &&
+ std::is_convertible_v<const U&, absl::string_view>;
+}
+
+template <typename T, typename U>
+constexpr bool IsOptionalWithNulloptDefault() {
+ return IsOptional<T>::value &&
+ std::is_same_v<std::decay_t<U>, std::nullopt_t>;
+}
+
+// True if the default value expression is statically known to equal T{}.
+template <typename T>
+constexpr bool IsEmptyDefault(EmptyBraces, int) {
+ return true;
+}
+
+template <typename T, typename U>
+constexpr bool IsEmptyDefault(std::initializer_list<U>, int) {
+ return false;
+}
+
+template <typename T, typename U>
+constexpr bool IsEmptyDefault([[maybe_unused]] const U& v, int) {
+ if constexpr (IsStringWithStringViewDefault<T, U>()) {
+ return absl::string_view(v).empty();
+ } else {
+ return IsOptionalWithNulloptDefault<T, U>();
+ }
+}
+
+// Fallback for C++20 designated initializers like {.a = 1}.
+template <typename T, std::enable_if_t<std::is_class_v<T>, int> = 0>
+constexpr bool IsEmptyDefault(const T&, char) {
+ return false;
+}
+
+// Shared placement-new generator for flags with default T{}.
+template <typename T>
+void GenDefaultValue(void* dst) {
+ new (dst) T{};
+}
+
+extern template void GenDefaultValue<std::string>(void*);
+extern template void GenDefaultValue<std::vector<std::string>>(void*);
+
+// Requires copyability so non-copyable types still fail in GenT::Gen.
+template <typename ValueT, typename GenT>
+constexpr bool CanUseSharedDefaultGen() {
+ return std::is_default_constructible_v<ValueT> &&
+ std::is_copy_constructible_v<ValueT> && GenT::IsEmpty();
+}
+
+// Ranked int -> char -> ...: inline kOneWord, shared GenDefaultValue, or Gen.
template <typename ValueT, typename GenT,
std::enable_if_t<std::is_arithmetic_v<ValueT>, int> = ((void)GenT{},
0)>
@@ -290,8 +367,14 @@
return {FlagDefaultSrc(GenT{}.value), FlagDefaultKind::kOneWord};
}
-template <typename ValueT, typename GenT>
+template <typename ValueT, typename GenT,
+ std::enable_if_t<CanUseSharedDefaultGen<ValueT, GenT>(), int> = 0>
constexpr FlagDefaultArg DefaultArg(char) {
+ return {FlagDefaultSrc(&GenDefaultValue<ValueT>), FlagDefaultKind::kGenFunc};
+}
+
+template <typename ValueT, typename GenT>
+constexpr FlagDefaultArg DefaultArg(...) {
return {FlagDefaultSrc(&GenT::Gen), FlagDefaultKind::kGenFunc};
}