[Bug c++/114220] New: False positive warning: possibly dangling reference to a temporary [-Wdangling-reference]

[Bug c++/114220] New: False positive warning: possibly dangling reference to a temporary [-Wdangling-reference]

[dilyan.palauzov at aegee dot org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114220

            Bug ID: 114220
           Summary: False positive warning: possibly dangling reference to
                    a temporary [-Wdangling-reference]
           Product: gcc
           Version: 13.2.1
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: dilyan.palauzov at aegee dot org
  Target Milestone: ---

Created attachment 57598
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=57598&action=edit
The inlined programme

This code

#include <string>
#include <unordered_map>

static const std::unordered_map<int, std::string> hashTable1 = {{2, "u"}};
static const std::unordered_map<std::string, std::string> hashTable2 = {{"u",
"u"}};

const std::string& z1(int m);
const std::string& z1(int m) { return hashTable1.at(m); }
const std::string& z2(const std::string& m);
const std::string& z2(const std::string& m) { return hashTable2.at(m); }
const std::string& z3();
const std::string& z3() { return hashTable2.at("u"); }

int main() {
  const std::string& b1 { z1(2) };
  const std::string& b2 { z2("u") };
  const std::string& b3 { z3() };
  const std::string& f1 = hashTable1.at(2);
  const std::string& f2 = hashTable2.at("u");
  printf("%s %s %s %s %s\n", b1.c_str(), b2.c_str(), f1.c_str(), f2.c_str(),
b3.c_str());
}

produces with g++ (GCC) 13.2.1 20240302:

$ g++ -Wall -Wextra -o a a.cpp
a.c: In function ‘int main()’:
a.c:16:22: warning: possibly dangling reference to a temporary
[-Wdangling-reference]
   16 |   const std::string& b2 { z2("u") };
      |                      ^~
a.c:16:29: note: the temporary was destroyed at the end of the full expression
‘z2(std::__cxx11::basic_string<char>(((const char*)"u"),
std::allocator<char>()))’
   16 |   const std::string& b2 { z2("u") };
      |                           ~~^~~~~

So std::string as first template parameter is problematic (b2), when only the
second template parameter is relevant (b3), but int as first template parameter
is fine (b1).

I think this is a bug.

[Bug c++/114220] False positive warning: possibly dangling reference to a temporary [-Wdangling-reference]

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114220

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|---                         |INVALID

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
const std::string& z2(const std::string& m);

const std::string& z2(const std::string& m) { return hashTable2.at(m); }


  const std::string& b2 { z2("u") };


The warning is designed this way explictly because you are returning a
reference and taking a reference as an argument and in the case of b2, the
tempory is `std::string("u")` .

In GCC 14+ (since r14-9263-gc7607c4cf18986), you can add [[gnu::no_dangling]]
to the z2 function definition to mark it as not returning a dangling reference
(from the arguments). and the warning goes away.

[Bug c++/114220] False positive warning: possibly dangling reference to a temporary [-Wdangling-reference]

[dilyan.palauzov at aegee dot org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114220

--- Comment #2 from Дилян Палаузов <dilyan.palauzov at aegee dot org> ---
Is my reading correct, that the warning is triggered, when a function receives
as parameter a reference to a temporary and returns a reference?  If this is
the only criterion, then it is a wrong assumption, that both references are
somehow related.

[Bug c++/114220] False positive warning: possibly dangling reference to a temporary [-Wdangling-reference]

[dilyan.palauzov at aegee dot org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114220

--- Comment #3 from Дилян Палаузов <dilyan.palauzov at aegee dot org> ---
> The warning is designed this way explictly because you are returning a reference and taking a reference as an argument and in the case of b2, the tempory is `std::string("u")` .

> In GCC 14+ (since r14-9263-gc7607c4cf18986), you can add [[gnu::no_dangling]] to the z2 function definition to mark it as not returning a dangling reference (from the arguments). and the warning goes away.

If the declaration and definitions are in different files, do I have to add
[[gnu::no_dangling]] only to the function declaration ?

That said, is the warning triggered only based on the function declaration
(accepting as parameter a reference to temporary and returning a reference),
when on the function invocation the parameter is indeed a reference to a
temporary?

[Bug c++/114220] False positive warning: possibly dangling reference to a temporary [-Wdangling-reference]

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114220

--- Comment #4 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to Дилян Палаузов from comment #3)
> > The warning is designed this way explictly because you are returning a reference and taking a reference as an argument and in the case of b2, the tempory is `std::string("u")` .
> 
> > In GCC 14+ (since r14-9263-gc7607c4cf18986), you can add [[gnu::no_dangling]] to the z2 function definition to mark it as not returning a dangling reference (from the arguments). and the warning goes away.
> 
> If the declaration and definitions are in different files, do I have to add
> [[gnu::no_dangling]] only to the function declaration ?

Yes only on the declaration is needed.

> 
> That said, is the warning triggered only based on the function declaration
> (accepting as parameter a reference to temporary and returning a reference),
> when on the function invocation the parameter is indeed a reference to a
> temporary?

Yes that is correct, it is based on the function declaration only and the
warning does not look into the function to see it does not return the a
referenced based on the reference being passed.

[Bug c++/114220] False positive warning: possibly dangling reference to a temporary [-Wdangling-reference]

[xry111 at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114220

Xi Ruoyao <xry111 at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |asharafutdinov at adalisk dot com

--- Comment #5 from Xi Ruoyao <xry111 at gcc dot gnu.org> ---
*** Bug 114225 has been marked as a duplicate of this bug. ***