Reduce code size of ABSL_ASSIGN_OR_RETURN by avoiding dead StatusOr cleanup. When the right-hand side of ABSL_ASSIGN_OR_RETURN returns a StatusOr via an indirect return slot, its stack address escapes. As a result, callers previously emitted full StatusOr destructor cleanup (an ok reload and Status::Unref) at scope exit and on every later early return. Store the StatusOr in a union with a no-op destructor instead: * On error, move the Status out and return without running StatusOr cleanup. * On OK, arm a small guard that destroys only the contained value at scope exit (or nothing when the value is trivially destructible), preserving value and view lifetimes. Types derived from absl::StatusOr do not match the specialization and continue to run the full StatusOr destructor via the primary template. PiperOrigin-RevId: 1008379647
diff --git a/absl/status/BUILD.bazel b/absl/status/BUILD.bazel index 3508b11..09060ff 100644 --- a/absl/status/BUILD.bazel +++ b/absl/status/BUILD.bazel
@@ -227,6 +227,7 @@ ":statusor", "//absl/base:config", "//absl/base:core_headers", + "//absl/meta:type_traits", "//absl/types:source_location", ], )
diff --git a/absl/status/CMakeLists.txt b/absl/status/CMakeLists.txt index 13ff4a6..5efa33b 100644 --- a/absl/status/CMakeLists.txt +++ b/absl/status/CMakeLists.txt
@@ -180,6 +180,7 @@ absl::status absl::status_builder absl::statusor + absl::type_traits PUBLIC )
diff --git a/absl/status/status_macros.h b/absl/status/status_macros.h index 965ea8e..4b1cc2b 100644 --- a/absl/status/status_macros.h +++ b/absl/status/status_macros.h
@@ -22,6 +22,7 @@ #define ABSL_STATUS_STATUS_MACROS_H_ #include <cstddef> +#include <memory> #include <string> #include <type_traits> #include <utility> @@ -29,6 +30,7 @@ #include "absl/base/attributes.h" #include "absl/base/config.h" #include "absl/base/optimization.h" +#include "absl/meta/type_traits.h" #include "absl/status/status.h" #include "absl/status/status_builder.h" // IWYU pragma: export #include "absl/status/statusor.h" @@ -201,6 +203,61 @@ T*, typename absl::StatusOr<typename T::value_type>*>>> : std::true_type {}; +template <typename T> +class IndirectNonvirtualDestructor { + public: + ABSL_ATTRIBUTE_ALWAYS_INLINE explicit IndirectNonvirtualDestructor(T* value) + : value_(value) {} + IndirectNonvirtualDestructor(const IndirectNonvirtualDestructor&) = delete; + IndirectNonvirtualDestructor& operator=(const IndirectNonvirtualDestructor&) = + delete; + ABSL_ATTRIBUTE_ALWAYS_INLINE ~IndirectNonvirtualDestructor() { + // Qualified call suppresses virtual dispatch when `T` is polymorphic. + value_->T::~T(); + } + + private: + T* value_; +}; + +struct EmptySentinelType {}; + +// Fallback for types derived from `absl::StatusOr`. +template <typename StatusOrType> +union AssignOrReturnStorage { + static_assert(!std::is_reference_v<StatusOrType>); + StatusOrType v; + ABSL_ATTRIBUTE_ALWAYS_INLINE ~AssignOrReturnStorage() { v.~StatusOrType(); } + [[nodiscard]] ABSL_ATTRIBUTE_ALWAYS_INLINE auto DestroyValueOnExit() { + return EmptySentinelType(); + } +}; + +// Holds `absl::StatusOr<T>` in a union with a no-op destructor to suppress +// `~StatusOr()` at scope exit. On error, the caller must move the status out of +// `v` before returning. On OK, `DestroyValueOnExit()` destroys only `T` at +// scope exit. +// +// Not a `struct` with an anonymous `union`: that would break aggregate +// initialization for nontrivial `T`. +template <typename T> +union AssignOrReturnStorage<absl::StatusOr<T>> { + absl::StatusOr<T> v; + // Not `= default`, as that would delete the destructor for nontrivial `T`. + ABSL_ATTRIBUTE_ALWAYS_INLINE ~AssignOrReturnStorage() {} + + [[nodiscard]] ABSL_ATTRIBUTE_ALWAYS_INLINE auto DestroyValueOnExit() { + if constexpr (std::is_trivially_destructible_v<T>) { + return EmptySentinelType(); + } else { + return IndirectNonvirtualDestructor<T>(std::addressof(*v)); + } + } +}; + +template <typename T> +AssignOrReturnStorage(T&&) -> AssignOrReturnStorage<absl::remove_cvref_t<T>>; + } // namespace status_macro_internal ABSL_NAMESPACE_END } // namespace absl @@ -221,7 +278,8 @@ lhs, rexpr, \ return_keyword absl::Status( \ std::move(ABSL_INTERNAL_STATUS_MACROS_IMPL_CONCAT_(_status_or_value, \ - __LINE__)) \ + __LINE__) \ + .v) \ .status(), \ absl::SourceLocation::current())) @@ -232,18 +290,29 @@ lhs, rexpr, /* NOLINTNEXTLINE(misc-const-correctness) */ \ absl::StatusBuilder _( \ std::move(ABSL_INTERNAL_STATUS_MACROS_IMPL_CONCAT_(_status_or_value, \ - __LINE__)) \ + __LINE__) \ + .v) \ .status(), \ absl::SourceLocation::current()); \ (void)_; /* error_expression is allowed to not use this variable */ \ return_keyword(error_expression)) +// REQUIRES: `error_expression` must move the status out of `statusor_union.v` +// and must not fall through, since `~StatusOr()` is suppressed. #define ABSL_INTERNAL_STATUS_MACROS_IMPL_ASSIGN_OR_RETURN_( \ - statusor, lhs, rexpr, error_expression) \ - auto statusor = (rexpr); \ - if (ABSL_PREDICT_FALSE(!statusor.ok())) { \ + statusor_union, lhs, rexpr, error_expression) \ + absl::status_macro_internal::AssignOrReturnStorage statusor_union = { \ + (rexpr)}; \ + static_assert( \ + !std::is_const_v<decltype(statusor_union)>, \ + "Do not const-qualify ABSL_ASSIGN_OR_RETURN; put const on the lhs"); \ + if (ABSL_PREDICT_FALSE(!statusor_union.v.ok())) { \ error_expression; \ } \ + /* Declared before `lhs` so `statusor_union.v`'s value outlives `lhs` \ + * (e.g. when `lhs` is a view into the contained value). */ \ + [[maybe_unused]] const auto ABSL_INTERNAL_STATUS_MACROS_IMPL_CONCAT_( \ + statusor_union, _destroyer) = statusor_union.DestroyValueOnExit(); \ { \ static_assert(!HasPotentialConditionalOperator(#lhs, sizeof(#lhs) - 1), \ "Identified potential conditional operator, consider not " \ @@ -252,11 +321,11 @@ { \ static_assert( \ absl::status_macro_internal::IsAllowedStatusOrMacroType< \ - std::remove_const_t<decltype(statusor)>>(), \ + decltype(statusor_union.v)>(), \ "ABSL_ASSIGN_OR_RETURN should only be used with absl::StatusOr<>"); \ } \ ABSL_INTERNAL_STATUS_MACROS_IMPL_UNPARENTHESIZE_IF_PARENTHESIZED(lhs) = \ - (*std::move(statusor)) + (*std::move(statusor_union.v)) // Internal helpers for macro expansion. #define ABSL_INTERNAL_STATUS_MACROS_IMPL_EAT(...)
diff --git a/absl/status/status_macros_test.cc b/absl/status/status_macros_test.cc index 7b5751d..e5578b4 100644 --- a/absl/status/status_macros_test.cc +++ b/absl/status/status_macros_test.cc
@@ -400,6 +400,71 @@ CheckSourceLocation(result.status(), {func3_line, func4_line}); } +TEST(AssignOrReturn, DestroysValueOnlyOnOkAtScopeExit) { + int live = 0; + struct Counted { + int* live; + explicit Counted(int* l) : live(l) { ++*live; } + Counted(const Counted& o) : live(o.live) { ++*live; } + Counted(Counted&& o) : live(o.live) { ++*live; } + Counted& operator=(const Counted&) = delete; + Counted& operator=(Counted&&) = delete; + ~Counted() { --*live; } + }; + + const std::string kLong(64, 'x'); + auto ok_fn = [&]() -> absl::Status { + ABSL_ASSIGN_OR_RETURN(Counted c [[maybe_unused]], + absl::StatusOr<Counted>(Counted(&live))); + // Both `c` and the moved-from value in the macro's hidden `StatusOr` stay + // alive until scope exit (so views like `view` below remain valid). + EXPECT_EQ(live, 2); + ABSL_ASSIGN_OR_RETURN(absl::string_view view, + absl::StatusOr<std::string>(kLong)); + EXPECT_EQ(view, kLong); + ABSL_ASSIGN_OR_RETURN(std::string const_str, + absl::StatusOr<const std::string>(kLong)); + EXPECT_EQ(const_str, kLong); + return absl::OkStatus(); + }; + EXPECT_EQ(ok_fn(), absl::OkStatus()); + EXPECT_EQ(live, 0); + + auto err_fn = [&]() -> absl::Status { + ABSL_ASSIGN_OR_RETURN(Counted c [[maybe_unused]], + absl::StatusOr<Counted>(ReturnError("EXPECTED"))); + return absl::OkStatus(); + }; + EXPECT_THAT(err_fn().message(), Eq("EXPECTED")); + EXPECT_EQ(live, 0); +} + +TEST(AssignOrReturn, WorksWithStatusOrSubclass) { + struct DerivedStatusOr : absl::StatusOr<std::string> { + using absl::StatusOr<std::string>::StatusOr; + }; + const std::string kLong(64, 'y'); + auto fn = [&]() -> absl::Status { + ABSL_ASSIGN_OR_RETURN(std::string s, DerivedStatusOr(kLong)); + EXPECT_EQ(s, kLong); + ABSL_ASSIGN_OR_RETURN(s, DerivedStatusOr(ReturnError("EXPECTED"))); + return absl::OkStatus(); + }; + EXPECT_THAT(fn().message(), Eq("EXPECTED")); +} + +TEST(AssignOrReturn, WorksWithArrayReference) { + int arr[2] = {10, 20}; + auto fn = [&]() -> absl::Status { + ABSL_ASSIGN_OR_RETURN(auto& ref, absl::StatusOr<int(&)[2]>(arr)); + static_assert(std::is_same_v<decltype(ref), int(&)[2]>); + EXPECT_EQ(ref[0], 10); + EXPECT_EQ(ref[1], 20); + return absl::OkStatus(); + }; + EXPECT_EQ(fn(), absl::OkStatus()); +} + TEST(ReturnIfError, Works) { auto func = []() -> absl::Status { ABSL_RETURN_IF_ERROR(ReturnOk());