Why is the return type of C++ function template instantiations included in the mangled function name?

Question

The Itanium ABI specifies that, with a couple uninteresting exceptions, the return type is included in the mangled names of template instantions but not non-templates.

Why is this? In what case could you have two function template instantiations where the linker needs to distinguish them because it is not indicative of a one-definition-rule violation or similar?

As an example of what I mean:

class ReturnType {};
class ParamType {};

template <typename T>
ReturnType foo(T p)  {
    return ReturnType();
};
template ReturnType foo<ParamType>(ParamType);

ReturnType bar(ParamType p) {
    return ReturnType();
}

Then the resulting object file has manglings:

ReturnType foo<ParamType>(ParamType)
   => _Z3fooI9ParamTypeE10ReturnTypeT_
                        ^^^^^^^^^^^^

ReturnType bar(ParamType)
   => _Z3bar9ParamType

Why does foo need ReturnType mangled but bar doesn't?

(I am presuming there is a reason and it's not just an arbitrary choice.)

Answer 1

Maybe because, as opposed to normal functions, a function templates signature contains the return type? §1.3:

1.3.17 signature <function> name, parameter type list (8.3.5), and enclosing namespace (if any)
[ Note: Signatures are used as a basis for name mangling and linking. — end note ]

---

1.3.18 signature <function template> name, parameter type list (8.3.5), enclosing namespace (if any), return type, and template parameter list

Consider that we can have two entirely distinct function template overloads that only differ in their return type, if written thusly:

template <int>
char foo();

template <int>
int foo();

If name mangling wouldn't consider the return type, linking those templates would prove difficult, since foo<0> does not uniquely name one specialization. Still, one specialization can be addressed using overload resolution (without arguments):

int (*funptr)() = foo<0>;   

On the other hand, including the return type is not necessary for ordinary functions, as these cannot be overloaded on their return type - i.e. their signature does not include the return type.