gcc13.1 warning: possibly dangling reference to a temporary w/ostream operator

[mcharneyamp]

Hi. Using current to of tree (02cae7e), I see this warning with aarch64 gcc 13.1 -Wall. On godbolt, I used "arm64 gcc trunk" to compile and got this error (They don't have an arm64 gcc 13.1 listed yet). Oddly, I don't see the error with x86-64 gcc13.1. No error with gcc 11.3 or 12.2 on aarch64.

/opt/compiler-explorer/libs/fmt/trunk/include/fmt/core.h:1674:15: warning: possibly dangling reference to a temporary [-Wdangling-reference]
 1674 |   const auto& arg = arg_mapper<Context>().map(FMT_FORWARD(val));
      |               ^~~
/opt/compiler-explorer/libs/fmt/trunk/include/fmt/core.h:1674:46: note: the temporary was destroyed at the end of the full expression 'fmt::v9::detail::arg_mapper<fmt::v9::basic_format_context<fmt::v9::appender, char> >().fmt::v9::detail::arg_mapper<fmt::v9::basic_format_context<fmt::v9::appender, char> >::map<foo&>((* & val))'
 1674 |   const auto& arg = arg_mapper<Context>().map(FMT_FORWARD(val));
      |                     ~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~
Compiler returned: 0

Here is a godbolt repro link:

https://godbolt.org/z/ajsGKe4nE

#include <cstdint>
#include <ostream>
#include <string>
#include <fmt/core.h>
#include <fmt/ranges.h>
#include <fmt/ostream.h>

class foo {
public:
    int a;
    std::string b;

    foo(int aa, std::string bb) : a(aa), b(bb) {}

    friend std::ostream& operator<< (std::ostream& os, const foo& obj);
};

template <> struct fmt::formatter<foo> : ostream_formatter {};
std::ostream& operator<< (std::ostream& os, const foo& obj) {
    os << obj.a << " " << obj.b;
    return os;
}



int main(int argc, char** argv) {
    foo f(5,"hello");
    fmt::print("{}\n", f);
}

[pattop]

Also happens when a specialisation of fmt::formatter is added, e.g https://godbolt.org/z/r657Yhc9Y

enum class foo { a, b };

template<>
struct fmt::formatter<foo> {
	constexpr auto parse(fmt::format_parse_context &ctx)
	{
		return ctx.begin();
	}

	auto format(const foo &f, fmt::format_context &ctx)
	{
		switch (f) {
		case foo::a:
			return fmt::format_to(ctx.out(), "a");
		case foo::b:
			return fmt::format_to(ctx.out(), "b");
		default:
			return fmt::format_to(ctx.out(), "wtf");
		}
	}
};

int main(int argc, const char** argv) {
	fmt::print("{}\n", foo::a);
	return 0;
}

[vitaut]

This is clearly a false positive because T is foo& and the chain of calls is

fmt/include/fmt/core.h

Lines 1453 to 1462 in 192df93

	template <typename T, typename U = remove_cvref_t<T>,
	FMT_ENABLE_IF((std::is_class<U>::value || std::is_enum<U>::value ||
	std::is_union<U>::value) &&
	!is_string<U>::value && !is_char<U>::value &&
	!is_named_arg<U>::value &&
	!std::is_arithmetic<format_as_t<U>>::value)>
	FMT_CONSTEXPR FMT_INLINE auto map(T&& val)
	-> decltype(this->do_map(std::forward<T>(val))) {
	return do_map(std::forward<T>(val));
	}

fmt/include/fmt/core.h

Lines 1444 to 1447 in 192df93

	template <typename T, FMT_ENABLE_IF(formattable<T>::value)>
	FMT_CONSTEXPR FMT_INLINE auto do_map(T&& val) -> T& {
	return val;
	}

which passes the reference through without any temporaries involved.

f61f15c implements a workaround but please report a bug to gcc.

[sunmy2019]

GCC will temporarily move the warning to -Wextra
https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=6b927b1297e66e26e62e722bf15c921dcbbd25b9

Currently it's producing many false positives.

[vitaut]

Thanks for the link!

[mcharneyamp]

Thanks everyone!