It is possible for compilers to remove duplicate lambdas with the same definitions?

Full code available here: https://godbolt.org/z/7sbxeM3WP

I was curious if it would be possible for a compiler to optimize

constexpr auto lambda = [](){return 5;};
constexpr auto lambda_same_definition = [](){return 5;};

such that there would only be one generated functor. I am aware of how lambda expressions work under the hood, creating anonymous functors for each expression. But at least here it looks pretty obvious since the expressions are literally the same, char for char, plus they're stored as constexpr, that it doesn't seem out of the question that the compiler could fold the two functors into one. Of course I doubt this type of reasoning is doable in the general case, determining if two functions are the same sounds would probably be undecidable in the general case I'm guessing.

Unfortunately, it doesn't look like that's the case from my Godbolt snippet, it seems to have info for both under the type names*NL6lambdaMUlvE_E1 and NL22lambda_same_definitionMUlvE_E.

So my question is, is this a quality of implementation issue? Or is there something in the Standard that forbids this optimization?

Each lambda is a unique anonymous class. This is going to be the starting point.

The C++ standard allows a compiler to implement any optimization that has no observable effects. If the compiler can prove that using a single instance of the anonymous class will have no observable effects than the compiler is allowed to implement it.

So if someone is wondering "if it would be possible" to do that, the answer is: yes, it's possible.

Whether or not your compiler successfully implements this optimization can only be determined by inspecting the actual code produced by your compiler.